Skip to content

feat(crate)!: Converge the work since 11-03 into one change - #1389

Open
uael wants to merge 2260 commits into
mainfrom
w/converge
Open

uael wants to merge 2260 commits into
mainfrom
w/converge

Conversation

@uael

@uael uael commented Nov 6, 2026 •

Copy link
Copy Markdown
Owner

Written on 2026-11-14 at head c9366da92.

Why

The work since 11-03 stood in many open pull requests, and each one waited on its own red or slow CI. This branch converges that work into one change, so that one CI run proves the whole.

It keeps the label hold on, so that nothing merges by itself. It lands as one merge of one head that was proven.

Fixes #1230.
Fixes #1267.
Fixes #1268.

Outcome

Items (25 of 83 done)

Estimate of the end: the log of the rows holds no change in the last 24 hours, so the rate gives no estimate yet.

  • daemon-log: A slow window no longer makes the daemon copy the whole log of a life, and replaced events leave the log. (at 4a32d88: cargo test -p furb-host --test suite -- apart:: exits 0, and its children pass: memory::window_alone (a slow window on a life of 10320 facts: the daemon took 5082 KiB), memory::heap_alone and memory::rebirth_alone (two rebirths at 20209 facts: a birth added 13304 KiB); 26f44d1, d86a669)
  • resume-new-chain: A resumed life runs the rungs of a new chain and gathers its state. (at 4a32d88: pytest test/checkpoint passes in a run of 125 passed, cargo test -p furb --lib passes a_life_goes_on_from_a_checkpoint_with_the_names_the_module_and_the_open_prompt_of_each_chain, and bun run test tui/scenarios/birth passes a life born on a checkpoint keeps each value and life word, sets up a new chain, and goes on with its thread; 391c581)
  • replay-no-bound: A replay steps a recorded word with no bound of a turn. (at 4a32d88: cargo test -p furb --lib passes a_replay_takes_the_answer_of_each_question_that_the_record_holds_and_a_live_word_past_the_bound_is_refused and a_record_whose_word_never_yields_replays_to_the_same_facts; b4d401a)
  • protocol-follows-schema: The protocol version follows its schema, so a window never hangs on an older daemon. (at 4a32d88: the host suite (cargo test -p furb-host --test suite, 100 passed) passes protocol::each_change_of_the_schema_raises_the_protocol, protocol::the_schema_on_disk_is_the_schema_of_the_protocol and protocol::a_hello_of_another_version_is_refused_with_both_versions; PROTOCOL is 15 (host/src/protocol.rs:19); 335255e, e841832)
  • merge-hooks: The hooks of a merge check only its new content. (at 4a32d88: pytest test/outside/test_hook_script.py test/outside/test_hook_reach.py test/outside/test_hook_config.py test/outside/test_memwatch_script.py gives 61 passed and 2 skipped, among them the four tests of a merge of test_hook_script.py (a file that a merge takes whole from one parent is not checked; a file whose content differs from every parent is); e9db9d6)
  • push-hooks: A push runs the hooks of each commit that skipped them. (void: R268 and R269 of the rules of this session (a commit is instant and a push is not verified; the suite runs at an interval): 87b65bb made a push run no hook. at 4a32d88 script/hooks/pre-push only refuses a push to main, and AGENTS.md:406 says that a push checks no commit. The loop of the lead and the gates of CI run the checks; was 21270be)
  • memory-wait: No work waits on memory, and a watcher ends a test process when the memory is tight and the lane can be the cause. (at 4a32d88: script/memwatch.sh ends the largest test process only when the work can be the cause (a process of 4 GB, or 8 GB held by the work); pytest test/outside/test_memwatch_script.py passes (in 61 passed): the real script on a reading that the test gives; sh script/memwatch.sh --once exits 0; git grep -n -i -E 'memory_pressure|vm.swapusage' -- script .github finds no step that waits on memory. Not checked: a tight memory of this machine itself)
  • stopped-life-reopens: A life that a fault of the sandbox stopped opens again and goes on. (at 4a32d88: cargo test -p furb --lib passes a_life_that_a_fault_of_the_sandbox_stopped_opens_again_and_goes_on, and bun run test tui/scenarios/resume passes a life whose host is killed opens again to the same transcript, values and module, and goes on; 2a670e5)
  • daemon-idle-end: A daemon that its last window left, with no life, ends after its grace. (at 4a32d88: the host suite (cargo test -p furb-host --test suite, 100 passed) passes daemon::a_daemon_whose_last_window_left_ends_once_its_grace_passed; cb01465)
  • lost-image: A turn that names a lost image gets its answer and tells the loss once. (at 4a32d88: cargo test -p furb --lib passes a_turn_that_names_an_image_whose_file_is_lost_gets_its_answer_and_the_life_tells_the_loss_once; 800714e)
  • build-slots-gone: The build slots are gone, and no cap limits the builds that run at once. (at 4a32d88: git grep -n -E 'build-slot|FURB_BUILD_JOBS|CARGO_BUILD_JOBS|FURB_BUILD_SLOTS' -- script .github AGENTS.md CONTRIBUTING.md .cargo prints nothing, and script/ holds no build-slot.sh; a comment of script/deepswe.py:115 still names a slot of this machine. Note for the lead: the lane of this session runs each build through the build-slot.sh of the old checkout, which the request behind this row removed; 20d206e, 28769f4)
  • model-roster: A /model of a model that the roster lacks stands the life again with the roster, and no life ends. (at 4a32d88: the host suite (cargo test -p furb-host --test suite, 100 passed) passes life::a_change_of_the_roster_offers_its_models_at_the_next_stand_of_the_life, and bun run test tui/scenarios/roster passes a model of the catalog that the roster lacks joins the same life at a stand, and takes the next message (R165). In the new window the model and its effort change with ctrl+x m or a click (window-design.md, The keys); ce68d13, fix(tui)!: Offer a model that the roster lacks with no new life #1396)
  • windows-build: The Rust of the host, the cli and tests/promise.rs builds clean on Windows and Linux. (not checked on this machine, which builds for macOS alone: the run 43583934141 of the gates at 9de2016 shows the jobs the crate, the suite and the build green on ubuntu-latest, macos-latest and windows-latest; no run of the gates has ended on 4a32d88 or on aa6b234 yet; a5ffadd, 2c83065)
  • stable-numbering: A life names its acts the stable way only, and each of 32 records opens as it did before. (at 4a32d88: cargo test -p furb --lib passes each_record_of_the_replays_replays_on_its_own_engine_with_no_drift, cargo test -p furb --test suite -- promise:: passes promise::each_record_of_each_folder_of_the_corpus_opens_gives_back_its_modules_and_takes_one_more_turn, and pytest test/test_numbered.py passes; the count of 32 records is of the head of then and was not counted again; d345e1a, e5cf6d7)
  • seed-order: On a new chain, stand() and cd come before the memory reads. (at 4a32d88: pytest test/test_chain.py -k holds_first_the_setup passes on both engines: the first turn that furb crafts in the setup of a chain is stand() then cd('/w'), before each read of the setup. R112 now leaves the order of the setup to measures and to coherence (the subject S11 of the lead), so this order is the state of today and not a ruling)
  • builtin-skills-folder: The built-in skills stand in .agents/skills, and .claude/skills links to it. (at 4a32d88: ls -la .claude/skills shows the link to ../.agents/skills, and .agents/skills holds catchup, compaction, mcp, memory, naming, ouroboros, skills and web; 2fc9ceb)
  • ask-again-rule: After any word, a chain that holds a new fact since its last ask is asked again, and no thread is left asked no more in silence. (at 4a32d88: pytest test/test_chain.py -k 'asked_again or barren or due' passes on both engines (a thread is asked again exactly when a new fact for it came since its last ask; the third barren step in a row pauses the thread with a why), and bun run test tui/scenarios/steps gives 2 pass. Three behaviors of this rule come from a page of an agent and wait for a word of the owner (alignment.md, part 2))
  • close-on-operator-question: A thread whose word awaits a question to the operator closes with its value when the operator resolves it, and the desk no longer owes the next prompt. (at 4a32d88: pytest test/outside/test_defects.py passes test_the_operator_closes_a_thread_whose_word_awaits_a_question_to_the_operator; a probe on the harness of the suite shows the question to the operator not over before the close and over after it (engine.over), and the host suite (cargo test -p furb-host --test suite, 100 passed) passes view::the_desk_holds_the_questions_and_the_notices_the_oldest_first_and_drops_a_question_that_is_done. Not run: a resolve from a window; close (resolve) of a thread that awaits an operator question is refused with IndexError, after a stray closed tell #1262 is still open on GitHub)
  • born-window-windows: A window of a life born from its checkpoint hears each fact of the life once, on Windows too, where the test of the daemon passed on three runs of the gates in a row. (at 4a32d88 on macOS: the host suite (cargo test -p furb-host --test suite, 100 passed) passes daemon::a_window_of_a_life_born_from_its_checkpoint_hears_each_fact_of_the_life_once. Not checked: Windows, which this machine cannot run; the job the crate on windows-latest of the run 43583934141 at 9de2016 is green; 6a7ac41)
  • engine-wall: The engine stays under its wall of 8000 tokens. (at 4a32d88: .venv/bin/python script/tokens.py exits 0 and prints that the engine costs 7762 tokens, counted in the installed furb_monty, and that the doctrine costs 920; BUDGET of script/tokens.py is 7763, under the wall of 8000 (R098). The replay stands in src/furb/checkpoint.py and the gate is gone (R115); grant is still in the engine and goes to a kit later (R319))
  • dead-code-delete: The branch holds no code that nothing calls: a scan names each such part, and each one is wired and proven or deleted. The unused desk, roll up, news, PROFILE and walked_files code is deleted, each after a check. (at 4a32d88: python3 -I script/unused.py exits 0 and names nothing: it is the scan of each exported name of the TypeScript side and each public item of the crates that no file but a test names, and the hooks run it; clippy with warnings denied holds the private Rust, and the coverage of 100 the python. git grep -n -E 'roll_up|State::ALL|export function desk' -- bind tui src prints nothing. --tests lists 3 helpers that only tests reach, which the check does not hold yet)
  • stall-watch: A chain that holds a rung or a prompt with no act beside gets a notice from the daemon, and a thought of 5 minutes is caught. (at 4a32d88: cargo test -p furb-host --lib -- stall gives 11 passed (a_rung_with_a_word_that_nothing_lives_beside_on_its_chain_arms_the_watch, a_reply_that_writes_nothing_for_five_minutes_stalls_its_chain), and the host suite passes a_rung_that_waits_with_no_reply_is_told_to_its_chain_after_the_bound. For the lead: R123 replaced the rule behind the second clause (a long thought is no stall; the fault is that the window shows no progress); the watch only tells, and it still tells a reply that writes nothing for 5 minutes)
  • fork-keeps-prefix: A fork that goes on with the same work keeps its whole prefix. (at 4a32d88: git grep -c -E 'fork|filter|source=' -- DOCTRINE.md counts none, and pytest test/test_chain.py -k 'holds_the_entries_up_to_that_source_first or holds_whole_the_setup' passes on both engines (in a run of 26 passed): a chain with a source and no filter holds the whole transcript of its origin first)
  • roster-whole: The model fable is in the roster of a life. (at 4a32d88: bun run test bind/typescript/test/session gives 43 pass and 0 fail, among them a session offers the models its host names, and keeps the model and the effort chosen last as a preference, whose default roster lists claude-cli:fable (session.test.ts:148) and whose second session on the same record gives claude-cli:opus, claude-cli:fable and operator (:178); src/world/provider/claude/discover.rs:52 names fable with a window of 1000000)
  • text-replace-refusal: Text.replace on a text that is not there is refused with the rarest line of that text, and raises no AttributeError. (at 4a32d88: pytest test/test_text_replace.py passes on both engines, with test_a_replace_of_a_string_that_the_text_does_not_hold_is_refused)
  • gates-run-to-end, partly done: The gates of w/converge run to their end at each push. (a run of the gates that started goes to its end (gates.yml:39 cancels no run in progress of w/converge), but not at each push: gh run list --branch w/converge --workflow gates.yml --limit 40 shows 3 runs cancelled (43589594303, 43522862128, 43358204354): a group holds one run that waits, so a head that waits is replaced by the next push. Left: say the sentence as it is (the newest head gets a verdict), or push no head while a run waits)
  • file-picker, partly done: The file picker ranks with nucleo and walks its folder once per open. It picks a file outside of the current directory, it lists dot files, and typing stays fast: a key never waits for the walk. (the crate half is proven at 4a32d88: cargo test -p furb --lib passes the six tests of world::picker (a_picker_walks_its_folder_once_when_it_opens_and_never_at_a_key, a_walk_lists_each_dot_file_but_git_itself_and_each_file_that_gitignore_hides, a_query_that_leaves_the_directory_walks_from_the_folder_that_it_names), so nucleo, one walk for each open, the dot files and a file outside the directory hold. The window clause moved: R167, R200: a key that never waits is of the new window, where the file picker comes right after the twelve subjects, on a verb of the daemon (window-design.md, what comes right after, item 3). The old window held it at 17046d0, not run again)
  • pr-body-list, partly done: The body of this pull request lists each big change, done or left, as one list of boxes that are ticked or not, with an estimate of the end in the time of this Mac, made again at each landing. A script makes it again from one table at each landing. (the body is one list of boxes with the line of the estimate, made by tmp/lane/pr-body.py from this table. Left: the clause that it is made again at each landing: gh pr view 1389 --json body shows a body written on 2026-11-13 at head 6b31ebf, 55 commits behind 4a32d88, and tmp/lane/rows.log holds no line since 11-13 06:28; pr-body.py read its head from the stale tree furb-sm (fixed by this audit: it reads origin/w/converge of the tree that FURB_TREE names). The lead posts the new body; And the list in the pr body isn't updating #1394)
  • close-means-done, partly done: A close means done, and nothing else: no close comes before the work is verified and each question of the session is handled, and after a close nothing of the ask is left to do. The engine refuses a close of a prompt while an act that its word started still runs, and it names each act. A close in the wrong shape has a bound. A message on an open thread is a fact, prompt(None), that the model reads at its next step, even while its word awaits, so no message needs a close. A notice to the operator is a prompt to the operator, never a close, and each intermediate prompt is closed. This change of what a close means ships as a major. No second model checks a close for now: the promises with no act are measured for some days after the two changes. The design of the close lives in a GitHub issue, where the owner iterates on it. (at 4a32d88: pytest test/outside/test_defects.py test/test_close.py test/test_cancel.py gives 64 passed and 3 xfailed: a close by a word under the prompt is refused while an act under it runs (test_close.py:195), and a close in the wrong shape is a barren step with a bound (:180); the scenario messages passes a message on a thread gets its answer while a word of the thread awaits a command; DOCTRINE.md says the notice by a prompt to the operator and the close of each other prompt by its id. Left: a word that closes its own prompt drops the rest of its word in silence (H4b, strict xfail); a second close of a thread is dropped untold (H5, A message on a thread while its word awaits: the first word closes the thread, and the answer to the message is dropped untold #1273, strict xfail); w/close2 (a close by a word of another thread) is not on the carrier; no command shows that no close comes before the work is verified; the measure of the promises with no act is not made; the owner raises the major; A close means done: refuse it while its work runs, and make a message on a thread a fact #985 is open)
  • message-answered, partly done: Each message of the operator gets its answer at once, on the root or on a thread, whatever the chain awaits: a wait, a command or a prompt. A message on an open thread is a fact that the model reads at its next step, even while its word awaits, so no message needs a close. No chain stays on the state that waits for its turn with nothing else. He never opens a new thread to be heard, and a thread is as good to steer as it was before the change of A close means done: refuse it while its work runs, and make a message on a thread a fact #985. (at 4a32d88: the scenarios messages and steps pass a message of the operator gets the answer of the model, a message on a thread gets its answer while a word of the thread awaits a command, and again once a later word awaited a short one, a message of the operator never waits behind a prompt that came after it and a step that leaves a message unanswered is asked again, and the message gets its answer. Left: the reminder of an owed message is said at each quiet step (H3, strict xfail) and a second close of a thread is dropped untold (H5); no test of a message while a wait or a prompt is awaited; no proof that a thread is as good to steer as before A close means done: refuse it while its work runs, and make a message on a thread a fact #985 (R118, R191: the owner says). The window half moved: R167: subject 4 of window-design.md (a message reaches a thread that works, at once))
  • birth-goes-on-whole, partly done: A session never dies inside a build, and it crosses each new build with its chains and its module. A life that opens again, from its checkpoint or with none, returns to the exact state of its tip: each chain, its module, each prompt and thread, and a reply on its last thread works. A word that the checkpoint cut ends as interrupted, and the model starts it again in a turn that shows. A seed word that raises loses no later value and no life word, and a chain made after a birth binds each word of its setup. (at 4a32d88: test/checkpoint passes (in 125 passed); cargo test -p furb --lib passes a_life_goes_on_from_a_checkpoint_with_the_names_the_module_and_the_open_prompt_of_each_chain and a_large_value_and_an_exit_come_back_from_the_checkpoint_at_each_later_open_and_no_rung_of_the_seed_raises; the host suite passes the four tests of image:: and the test of a handover; the scenarios resume and birth pass (a life whose host is killed opens again to the same transcript, values and module; a life born on a checkpoint sets up a new chain and goes on with its thread). Left: a message on an open prompt is lost at the second birth (reproduced by a probe on the harness of the suite, tmp/lane/soak-probe/test_soak_two_births.py); a checkpoint of before schema 2 holds each act twice (not run again; tmp/lane/oldform.patch); an image loads only on the build that wrote it, so a change of build goes by the checkpoint; fix(engine): Keep each chain of a life in its checkpoint, not the root alone #1230, After a rebirth from its checkpoint, the root chain comes back paused though no prompt was open, and new messages hang #1267 and A rebirth from a checkpoint retells each module value whole: a 10 KB turn comes back as 1.1 MB #1268 are open)
  • birth-says-only-what-changed, partly done: A birth on a checkpoint tells only what changed since the last one, so the memory of the daemon grows in a line with the life. (at 4a32d88, at the small sizes: cargo test -p furb-host --test suite -- apart:: passes memory::rebirth_alone (a birth added 13304 KiB at 20209 facts) and heap::alone (43180 KiB before the rebirth, 29512 KiB after). Not checked: the bound of the heap on a large record, which needs more than the 3 GB that this audit may hold; the lead measured a daemon of a long life at 7 to 43 GB (LEAD.md, part 8), so the clause that the memory grows in a line with the life is not proven)
  • replay-no-drift, partly done: No record drifts on its own engine: a drift is a defect that is fixed at its root, with a test. Each record of tests/replay and tests/corpus, and each record of the owner, replays word by word to the exact state of its tip, with its checkpoint and with none, since the replay is the truth and a checkpoint only makes it fast. Several proofs that a machine runs hold it. (at 4a32d88: cargo test -p furb --lib passes each_record_of_the_replays_replays_on_its_own_engine_with_no_drift and each_run_of_a_chain_of_the_replays_has_a_turn_that_shows_its_word; cargo test -p furb --test suite -- promise:: gives 11 passed, among them a_life_killed_at_a_random_fact_opens_at_its_tip_with_a_checkpoint_and_without_one_and_goes_on and a_life_that_a_replay_opens_with_no_checkpoint_holds_the_transcript_that_it_held_live; the scenario resume passes a life that quits opens again, and after its end replays from its first entry to the same turns, values and module. Left: a replay tells no drift when a word of the record changes in its text, its answer or its close value (LEAD.md, part 8; its fix costs tokens of the engine); docs/promise.md lists what no machine proves yet; no record of the owner was replayed by this audit; the ten soak runs were not made)
  • stable-release-promise, partly done: Until the next major, each life made on a stable release resumes, reopens, is read and is shared on each build of that major, with no drift. Within the major no patch of the engine makes a record drift, and adapters for old engines are allowed. A record of a later build of the major opens on an earlier one too. A default of the contract, as TIMEOUT, is a policy that a minor may change. The promise is written, and the promise job of publish.yml refuses a release that breaks it. (at 4a32d88: docs/promise.md is written (what is frozen, what a minor and a major may change, each proof by its name); engine.pyi:159 marks the policies WINDOW, TIMEOUT, LARGEST, HEAD and TAIL, which a minor may change; pytest test/test_drift.py test/checkpoint test/outside/test_promise_script.py test/outside/test_contract_diff.py test/outside/test_promise_rollback.py gives 125 passed and 2 skipped; the job promise of publish.yml:344 runs script/promise.py before each job that publishes. Left: a record of a later build that opens on an earlier one has no proof (test_promise_rollback.py skips until a release holds a corpus); no proof across the builds of the major; the promise binds only from 1.0.0; script/contract.py names 19 breaks since v0.4.2, each listed in the page; Promise that each life opens on each build of its major #988 is open)
  • doctrine-program, partly done: DOCTRINE.md says what a program is and teaches to lower a prompt into code. (at 4a32d88: .venv/bin/python script/tokens.py gives 920 tokens of the 1000 of the wall (R321), so 80 tokens of room stand; DOCTRINE.md teaches control flow, a fan-out, an async def for a step that repeats, a loop that converges, and a prompt as an oracle inside a loop. Left: no line says that the one non-determinism of a program is the call of prompt (R080), and none teaches to lower a prompt into code until it cannot be lowered (R082, R134); no command can prove a doctrine, so the proof is a read of the owner and a bench (R247))
  • cost-regression, partly done: The same unattended loop spends about what it spent before the regression, and no reply repeats a pass loop. A measure names the spend of each kind of ask. The model of a chain chooses what its compaction keeps, so the cache of its prefix holds. (at 4a32d88: compaction.py:97 asks the model that wrote the last reply of the chain what its compaction keeps, and the third barren step in a row pauses a thread (test/test_chain.py), so no loop of pass spends with no end (R122). Left: no measure shows the spend back to what it was before the regression (it needs the same loop on a real model); the view sums the spend of the answers (src/view/act.rs:231), but no measure names the spend of each kind of ask)
  • tui-no-fact-copy, partly done: The TUI is a thin view, a client of the one daemon of the machine over one protocol: the shared core, in idiomatic async Rust, holds all the logic and the meaning of a life, and the TUI holds the layout alone, with no logic and no copy of the facts beside the crate. Each concern stands at the lowest layer where it makes sense: the engine, the host, then the window. Once the core stands, the TypeScript is cleaned. (the Rust half stands at 4a32d88: the fold of the crate (src/view) gives the state of each act, the desk, the threads and the spend, and the host suite passes its 24 tests of view::. The window half moved: R167, R163: the new window links that fold and holds the layout alone (subject 0 of window-design.md, on the carrier since e34e21b), so the copies of tui/src (states.ts, ladder.ts, acts.ts, session.ts, asks.ts) are not cleaned: they leave with the old window when the twelve subjects stand)
  • ts-jobs-green, partly done: The jobs of the bindings and the TUI pass on ubuntu, macOS and Windows with no test left out. (the run 43583934141 of the gates at 9de2016 shows the bindings and the TUI green on ubuntu, macOS and Windows; the run at 5399050 failed on the speed of the TUI on ubuntu alone, and no run has ended on 4a32d88. Left: tests are left out on Windows: tui/scenarios/harness.ts:14 skips each scenario there, and session.test.ts:884 and children.test.ts:31 skip one test each. Moved in part: R167: the jobs of the TUI stop when the old window leaves; R328 keeps those of the TypeScript door)
  • marks-concern-operator, partly done: A message that an operator did not acknowledge shows a mark of its own, and what he acknowledged shows too. The marks show him where a new element waits for him: a question anywhere, and unread, failed or paused work on the threads that he started alone. Having seen a message is a fact of the record for each person, so each login sees its own marks. (the Rust half stands at 4a32d88: the host suite passes the_seen_of_each_operator_is_said_under_his_login_and_a_reopen_keeps_each (the seen of each login is wired) and view::a_question_concerns_the_operator_in_any_thread_and_a_failure_or_a_pause_only_in_his_own. The window half moved: R167: subject 1 of window-design.md (the part Needs you at the top of the list, a word with its mark, the dot of a thread that he did not read) and subject 8 (the asks counted for the member of the view). To settle there: the design names a file of the cards that the window saw, which must not be a second home of the seen that the record holds; 81cb1e9 to bce521e)
  • threads-state-names, partly done: The sidebar tells the threads that the operator started from the threads of agents, which nest under the thread that made them, folded to a count. Only a real conversation shows as a thread, closed threads stand at the top and open ones last, a click on a thread goes to its end, and the threads after a fork render right. The name of a session is never lost, across each version of furb. (the Rust half stands at 4a32d88: the host suite passes view::the_threads_that_the_ladder_of_a_thread_made_nest_under_it_and_a_question_in_an_agent_rolls_up and view::the_closed_threads_stand_first_and_the_open_ones_last_each_group_by_its_last_message. Not run: the tests of the name of a session. The window half moved: R167, R326: a card is a thread that he started, and a thread of an agent is a row of the dock of its maker and a count on its card (subjects 1 and 3 of window-design.md); the four parts of the list (Needs you, Working, Resting, Resolved) replace the order of the feed of the old window; a click on a card opens its thread (subject 2))
  • many-windows, partly done: Any number of windows open one life at the same time, and the life is one, shared by all. A window opens read-write by default, and can open read-only. Each read-write window speaks as an actor of its own. No window ends another, the daemon has no takeover at all, whatever the build of each window, and a read-only window cannot send. /end detaches the window that says it, and the life ends with its last holder, when no window and no pin holds it for 30 seconds: a pin keeps detached work and each job of the product, and running work holds no life. The work starts from the issue that the owner opened on GitHub for many players. (the host half stands at 4a32d88: the host suite (cargo test -p furb-host --test suite, 100 passed) passes two_windows_on_one_life_both_stay_and_hear_it, the_detach_of_one_window_leaves_the_other, a_second_daemon_of_the_machine_refuses_to_start, a_handover_keeps_each_life_its_pins_and_each_window and net::a_reader_of_the_tailnet_is_refused_each_write; the scenario windows passes two windows on one life both read and write it, and neither ends the other. Changed by a later rule: R327 replaces the end of a life 30 seconds after its last holder, which the host still does: the last view asks whether the life goes on, pauses or stops. Left and moved: R160, R161, R322, R327: subjects 8 and 9 of window-design.md (many operators; to leave and the background, with detach and its then). No test holds more than two windows. Open for the owner: an actor for each person or for each window (the host gives one member for each login); One daemon on each machine holds every life: many windows, many operators, many machines #983)
  • operators-members, partly done: Any number of users speak on one life, on a remote machine too, each with an identifier of its own, and each one reads and writes or reads only. An operator is operator/: a member of the session in the roster, whom a model asks by name, and each request of a person is said at that site. A window that joins or leaves makes no stand: the roster holds the members, and presence is a view of the daemon. /end detaches the window that says it, and the life ends with its last holder. The design of the operators lives in a GitHub issue, where the owner iterates on it. (the host half stands at 4a32d88: the host suite passes the_roster_of_a_life_names_the_user_of_the_daemon_as_a_member_of_the_operator, the_roster_names_the_access_list_and_a_change_of_it_tells_each_life_to_stand, a_skill_says_each_act_under_its_name_and_a_window_under_its_operator, the_seen_of_each_operator_is_said_under_his_login_and_a_reopen_keeps_each and the tests of net:: on the login and the role; the contract names the site operator/id (engine.pyi:1007); the design lives in One daemon on each machine holds every life: many windows, many operators, many machines #983. Left: the design of many operators that R322 asks before the first screens is a page of tmp, not yet his ruling (N017; window-design.md, open points 1 and 2); the window half moved: R167: subject 8 of window-design.md (who is here, the verb here, the asks by member))
  • other-machines, partly done: furb manages several machines: from the TUI a user picks a machine and starts a session there, and several users connect to one session on it. The transport is a dialer and an identity, so that another network can take the place of Tailscale: Tailscale first, with its login as the identity, and TLS for the cloud. A delete of a session counts the windows of the daemon that holds it. (the host half stands at 4a32d88: the host suite passes the 12 tests of net:: (the daemon serves the tailnet by TCP and by WebSocket, a peer is the login that Tailscale gives for its address, a login with no entry is refused), and host/src/transport.rs:37 and :44 hold the traits Dialer and Identity. Left: git grep -n -i -E 'tls|rustls' -- host/src host/Cargo.toml finds nothing, so TLS for the cloud does not stand; several users on one session of a remote machine have no test from end to end. The window half moved: R167, R162: subject 1 of window-design.md (a file of the machines, the state of each machine at the top of the list, project@machine on a card). The old window held the lists and the delete at 17046d0 (tui/scenarios/machine), not run again)
  • kit-seed, partly done: It is clear which skill loads on which chain. The seed of a new chain is chain(), stand() and cd, the doctrine, the memory, the index, then the default skills: the cd comes before the memory loads, and the record serves each word with no copy. The skills on by default are catchup, memory and compaction, and each other skill loads through the index, skills://, with skill(name). A skill with code is a plain skill whose front matter holds the fields of furb (its word, its interface, its process, its view), in the same folders, so Claude Code reads it as an ordinary skill: its word runs in furb alone, and a script of its folder runs the same in both. (at 4a32d88: pytest .agents/skills/skills/test gives 50 passed: the index is skills://, skill(name) loads a skill on need, and skill() plays each skill whose manifest says furb-default; a skill with code is a plain skill whose front matter holds furb-word, furb-interface, furb-life and furb-view, which Claude Code reads through the link .claude/skills. Left: five skills are on by default (catchup, compaction, memory, naming, skills), where the sentence names three; the order of the seed is open again (R112: measures and coherence decide it, the subject S11 of the lead); not checked: that the record serves each word with no copy, and that a script of a skill runs the same in furb and in Claude Code; k/kit-seed is not on the carrier; Kits: skills and extensions as one concept, with an index, a seed in order and views #984 is open)
  • kit-defined, partly done: A chain sees the interface that a skill ships, from a .pyi that is optional, else its code, and skill(name) shows as a word, as an import does. read('skills://x', defined(name)) shows one definition as a Text, and the doctrine teaches to edit it by replace. write(text) edits a skill: an official skill gets a copy in the project, and the reload rebinds what changed in each chain that plays it. (at 4a32d88: pytest .agents/skills/skills/test gives 50 passed, and skills.pyi holds each clause but one: skill(name) answers with the interface of a skill, or with its word when its manifest names none; read('skills://x', defined(name)) tells one definition and gives the whole word; a write of skills:// copies an official skill into .furb/skills of the project, and each chain plays the new definitions (test_a_write_of_a_skill_that_the_life_runs_reloads_it). Left: no text teaches it: git grep -n 'defined(' -- DOCTRINE.md src/furb/AGENTS.md '.agents/skills/*/SKILL.md' prints nothing (R128, R220))
  • extension-word-gone, partly done: The word extension is gone from each place where a user or a model reads it, and skill takes its place. Kit is the name of a skill that carries code. The rename is one cut with no alias, once the live checkpoint stands, so that a live record crosses it at a handover. The prose that still says extension is parked in an issue. (at 4a32d88: git grep -i -c -e extension counts 982 lines outside the changelog and the records: docs/skills.md 70, src/furb/AGENTS.md 27, AGENTS.md 16, docs/tui.md 11, the contracts of the engine (10), ouroboros (7), skills (4) and compaction (1), src/skill.rs 82, tui/fixtures 272; engine.py holds none. R215 keeps both words, skill and kit. Left: the one cut of the rename in the docs, the contracts and the Rust, and the issue that parks the prose; the lines of tui/ leave with the old window (R167))
  • kits-not-rust, partly done: No built-in skill is written in Rust or needs an ear in Rust: a built-in uses only the interface that any skill has. The outside part of a skill uses the same verbs, and a skill that needs more has a process of its own, written in TypeScript, the one language of the process and of the views of a skill, which speaks the one protocol of the daemon as a window does: it hears the facts that it asks for, says acts, and serves the trees of its views. The World still speaks MCP to each MCP server that a user adds. The word of a skill is Python. (at 4a32d88: each built-in skill is a word in .agents/skills with its contract and its suite, and the World speaks MCP in src/world/mcp.rs. Left: the life gives the ears skills and mcp in Rust (src/life.rs:339 to 341), so a built-in still reaches more than the interface of any skill (R217); the views of compaction and mcp are tui.ts files, and R216 makes Python the one language of the process and of the views of a skill, so the clause that named TypeScript is reversed. Moved in part: R167: window-design.md leaves the parts that a skill adds out of the first window)
  • rust-audit, partly done: The skill rust holds the guidelines of Monty. The whole Rust is audited against it and cleaned, so that it reads as an expert writes it, async and idiomatic, with clippy -D warnings clean and no debt left. Lints of the workspace hold the bar: no sleep, block_on or try_wait, an expect with a reason on each module with debt, one enum of errors for each concern, and a width of 100. (at 4a32d88: Cargo.toml denies unsafe code, unwrap and allow attributes and warns the pedantic set; clippy.toml forbids sleep, block_on, park_timeout and try_wait; rustfmt.toml sets a width of 100; the skill rust holds the guidelines of Monty (SKILL.md:335); clippy ran with exit 0 at this head in the loop of the lead. Left: git grep -c -E '#!?\[expect\(' counts 177 expects in 93 files; the audit of the whole Rust against the skill and its cleaning (R051) are not made; one enum of errors for each concern is not checked)
  • ci-fast-no-flakes, partly done: The whole suite, the engine on both interpreters and the Rust tests, runs in less than one minute on a warm build, and it fails past a hard limit of time: it is the first priority. The gates build once for each target, and each later job runs on a copy of that build, so a run of the gates is as fast as it can be, and a remote run blocks no local work. The worktrees are used again, so no build starts cold, and the work comes in few and big pull requests. A watcher of memory ends the test processes past a threshold. (at 4a32d88: the gates build once for each target and each later job takes that build (system.yml: needs: build); script/budget.py fails a part past its limit of script/budgets.toml; the loop of the lead measured at this head pytest 25 s, clippy 15 s and cargo test 91 s on a warm build (tmp/lane/lead-verify.tsv). Left: the whole suite takes about 2 minutes and not one (R239: the limit of cargo test is 300 s, not 60); the gates took 11 to 25 minutes; script/memwatch.sh runs in gallery.yml alone, not in the gates; a flake stood: each_window_of_a_life_that_opens_hears_how_far_the_open_stands_then_its_events failed in the loop of the lead at aa6b234, and c9366da changes its wait (not run by this audit); no ten runs with no flake. Its parts for bun leave with the old window (R167))
  • gallery-pr, partly done: After a push to main that changes a path that a capture reads, one pull request on w/gallery keeps fresh captures, at a different rate or with no CI for it, so that it does not starve the runners, even when it merges on main. The captures of this branch are pushed where the owner reads them. (the pull request chore(tui): Show the gallery of w/converge at fda8967 #1392 of github-actions holds the captures of this branch where the owner reads them, but they are not fresh: it shows the head fda8967 of 11-08, 187 commits behind the carrier. Left: the cause that gallery.yml draws no new head; the clause that it starves no runner. Moved in part: R167: the gallery draws the old window; in the new window each subject lands with its capture, the text in git and the image in the pull request)
  • conductor-small, partly done: The code of the orchestration is small and stable, a way for the work and not the work. It is written again from a deep reasoning on the whole engine, and the result is shown to the owner. Its changes come together in few pull requests, so that they take no worker and no runner of CI from the work. (at 4a32d88: the conductor is gone and .furb/skills/lane holds the lane kit: lane.py has 319 lines, against more than 3000 before (a9cf867), and git log -3 -- .furb/skills/lane shows 3 changes, the last a change of the hooks. Left: this session orchestrates outside furb, by the scripts of tmp/lane (R297), so nothing uses the kit of the repository today: the lead decides whether it stays; the result of the rewrite was not shown to the owner; the issues Cut the round of the conductor to the work that it does #1069 and The record of the decisions of the coordinator #1084 are open)
  • stability-audit-1260, partly done: Stability and robustness come first. Each bug that a life met has a trace. Each defect that a life met has its root cause found and its fix landed on main, with a test: the 14 points of Stability audit of main on 11-05: 14 defects that a long unattended life can meet #1260, the points of the second stability audit (fix(host)!: Bound the wait of a handover for each life to end #1317 to fix(host): Keep a life until its record holds each fact #1322), and the defects of Defects of the repair of a long life on 11-04 that no PR addresses yet #1190, Promise that each life opens on each build of its major #988 and A close means done: refuse it while its work runs, and make a message on a thread a fact #985. (at 4a32d88, by the points of Stability audit of main on 11-05: 14 defects that a long unattended life can meet #1260: 4 holds (test_defects.py: a message of a model on its own thread asks it no step again), 3 holds at the small sizes (unkept::), 6 holds (the stall tests), 8 holds for a word under the prompt (test_close.py), 11 holds (a_drift_at_the_open_of_a_life_tells_its_window_why_and_leaves_the_daemon), 14 holds (fix(host)!: Bound the wait of a handover for each life to end #1317). Left: point 5: the reminder is said at each quiet step (H3, strict xfail); POINT 10 IS BACK: its fix stood in the gate, which R115 removed, and a probe on the harness of the suite shows that a word that calls an async def with no await runs nothing and that no turn tells its chain; points 2, 7 and 13 are not checked; the open defects of the daemon of LEAD.md part 8 (a life asked to be born again each second, a busy life that writes no checkpoint, no checkpoint at a termination signal, a daemon of 7 to 43 GB) have no fix; Stability audit of main on 11-05: 14 defects that a long unattended life can meet #1260, Promise that each life opens on each build of its major #988 and A close means done: refuse it while its work runs, and make a message on a thread a fact #985 are open)
  • only-fixes-loop, partly done: The big items land, the improvements of the use and of the look of the TUI among them: the work is not only small fixes. A loop that lands only small fixes is detected early, audits do not keep other items from closing, and each issue that the owner opens is seen and handled at once. (since 17046d0 the carrier gained 78 commits: 51 fix, 18 perf, 6 chore and 3 feat (git log --format=%s 17046d03c..origin/w/converge), and big items among them: the gate out of the engine, the engine under its wall (7762), the image that opens a life, the base of the new window. Left: the big items of the window are the twelve subjects of the design, of which the base alone is on the carrier; no check detects a loop of small fixes; the 17 open issues are not handled (the row issues-handled); Only fixes, the w/converge loop is stuck again #1393 is open)
  • scratch-leak, partly done: No test and no hook leaves a file in the caches of the machine: no scratch directory from cargo test or a plain bun test, and no copy of the furb-cli wheel. (at 4a32d88: ls ~/Library/Caches/furb/scratch | wc -l stayed at 26420 across each run that this audit measured: the host tests apart:: and image::, 45 outside tests of pytest and bun run test tui/scenarios/steps; pyproject.toml:55 sets no-cache for uv, and its cache holds no wheel of furb-cli; script/clean-caches.py removes what earlier runs left. Left: the 26420 directories of earlier runs still stand (R286); not measured: the whole suite, a plain bun test and the hooks; no test fails when a run leaves a directory; Tests and hooks leave scratch directories and furb-cli wheels in the caches of the machine #1395 is open)
  • rows-carry-words, partly done: Each row of this list names the requests that it carries. A check fails on a row that is done while a clause of its request has no proof, and on a request or a picked option that no row carries. No drift stays between the requests and the rows. (each row names the requests that it carries in its fifth field, and python3 -I tmp/lane/rows-words-check.py reads each ask, each later request and each picked option. Left: tmp/ground/rows-words.md was made on 11-12, before R115, R167, R215, R216, R318 and R319 to R329: its clauses name the old window and the gate, so the guard checks this table against stale clauses (3 faults today) until it is made again; a missed clause is still found only by a second read)
  • tui-kit-session, partly done: A skill adds rich views to the TUI, as a tree of a closed set of nodes that the TUI draws with OpenTUI, for one session alone or for the project: skill(name), or /skill in the TUI, turns it on by a fact of the record. The protocol of the views and its set of nodes only grow within a major. The skill ouroboros helps a user to build one: a request for a list of tasks with a view gives a view that lives in that session. (the host half stands at 4a32d88: the host suite passes a_kit_of_a_session_gives_its_view_to_each_window_in_each_life_of_its_record, a_skill_serves_a_tree_to_a_writer_and_a_reader_and_hears_the_writer_alone and a_mount_needs_a_skill_and_a_holder_and_a_view_ends_with_its_peer; the protocol holds the closed set of nodes. Left: the views of the skills are TypeScript (tui.ts), and R216 asks Python; no test shows that ouroboros builds a view of one session from a request (R219). The window half moved: R167, R218: window-design.md leaves the parts that a skill adds out of the first window, until the skills move to Python)
  • one-life-cut, partly done: An audit lists what the one-life work added beyond a stable session, and each part that serves only a dead record is deleted: the store of builds, the upgrade, the refusal of a version, carry, inherit, imported, the resume of feat(tui): Resume a record of an earlier engine from its turns #514, onelife.py and docs/one-life.md. (at 4a32d88: git ls-files | grep -i -E 'onelife|one-life' prints nothing; carry, inherit and imported are gone from the contract of compaction (docs/promise.md lists each as a break); the checkpoint stands outside engine.py. Left: the audit that lists what the one-life work added is not written (R154); not checked: the store of builds, the refusal of a version and the resume of feat(tui): Resume a record of an earlier engine from its turns #514; whether the checkpoint itself stays beside the image waits for the research and the word of the owner (R152, N018))
  • pasted-images, partly done: A pasted image is named image-N with its extension, and it stands in the text at the place of the caret. The model receives the text and the images in that order. (the crate half is proven at 4a32d88: cargo test -p furb --lib passes a_message_with_an_image_in_the_middle_goes_as_text_image_text_in_the_order_of_the_message, for the claude command line and for pi-ai. The window half moved: R167, R197: an image in a message, at its place in the text, as image-1.png, is the second addition after the twelve subjects of window-design.md, and it needs the image in the protocol, which names none today)
  • open-quote-streams, partly done: A string that stays open across the lines of a streamed word is not refused: the REPL of monty takes the open quote. The cause of the refusal that a life met is found. (at 4a32d88: cargo test -p furb --lib passes a_triple_quote_whose_paragraph_starts_at_the_left_edge_runs_once_its_word_is_whole and a_quote_that_the_model_writes_in_small_chunks_holds_until_its_close_mark_and_binds_whole, so a string and a quote that stay open across the lines of a streamed word are held until they close (R116). Left: the cause of the refusal that a life met is not found: no test plays that reply again, and the gate that read a word then is gone (R115), so the reply must be played again on this head before the row closes)
  • dump-one-definition, partly done: dump leaves the engine for ouroboros, where dump(name) gives the definition of that name alone and not the whole word that defined it, and literal moves to the code of the checkpoint. (at 4a32d88: dump left the engine for ouroboros and literal stands in the checkpointer (30884a7; .agents/skills/ouroboros/ouroboros.py:67, src/furb/checkpoint.py:272), and pytest .agents/skills/ouroboros/test/test_dump.py passes. Left: dump gives the last whole word of the program that defines a name (ouroboros.pyi:24), not the definition alone, and it refuses the name of a value, where R131 asks the function alone and the variables of a module as python that another life loads)
  • resume-in-15s, partly done: A resume of a session in the TUI takes 15 seconds at most, and the window shows a progress bar while it resumes. This is the one reason of the checkpoint. (at 4a32d88: an open tells its progress and a life opens from its image: the host suite passes a_window_of_a_life_that_opens_from_its_image_hears_its_stages_then_its_events, each_window_of_a_life_that_opens_hears_how_far_the_open_stands_then_its_events and the four tests of image::; PROTOCOL 15 holds the frame opening. Not checked by this audit, which may hold no process over 3 GB: the time on a large record. The lead measured (LEAD.md, part 5): the record of 19 chains shows by its image in 1.7 s, against 21.9 s; the large record of 204642 facts has no image yet, its first open shows at 88.9 s, and the daemon passes 8 GB. Left: the large record in 15 s with the daemon under 3 GB (tmp/lane/resume-accept.py); the first open after a change of build, which loads no image; the bar in a window (subject 2 of window-design.md, R167); the resume of the session bcbdf402 by the owner)
  • tui-in-rust, partly done: The whole TUI is written again in Rust, on the Rust package of OpenTUI, and Python is the only scripting language, for the engine, the skills and the parts of the TUI, so that TypeScript leaves furb. (at 4a32d88: the base of the new window is on the carrier (e34e21b, subject 0 of window-design.md): the package window/ on the Rust package of OpenTUI, pinned at 4d578d86, with its tokens, its spinner and its test harness; cargo test -p furb-window gives 9 passed on macOS. Left: subjects 1 to 11 (the list of cards is in work on a local branch), then the old window leaves: git ls-files tui bind | grep -c '[.]ts$' prints 308, and R328 keeps the TypeScript door, so the count that ends this row is of tui/ and of the tui.ts views of the skills, not of bind/typescript; Python as the language of the views of a skill is not started (R216); Design: the window of furb in Rust on OpenTUI, with Python as the one scripting language #1398)
  • one-loader, open: Each state has one animated loader, from one table of marks, in every view. The mark of a model that thinks differs from the mark of a command that a word awaits. In a code block the loader takes the place of the number of the line that runs, and that line is lit. (moved: R167 and the rule of the session that no fix lands on code that a ruled design replaces. New home: subject 3 of window-design.md (screen 3): the loader stands in the place of the number of the line that runs and the line is lit; a braille spinner is a model that writes and a quarter circle a command that runs (R209, R182, R183). The spinner of subject 0 is on the carrier (window/src/spinner.rs))
  • click-keeps-keys, open: A click on a list keeps the keys with the input. (moved: R167. The old window holds it (a799c12, tui/scenarios/focus and queue, not run again at this head). New home: the part The keys of window-design.md: the input has the focus, each key of the window is a chord or follows the leader, and a click on a card or on a control uses it; its tests are those of subject 1 (the list of cards) and subject 4 (the input))
  • long-life-open, open: The record of 1.2 GB opens in a window within the heap bound, and the photowroom session resumes on the merged build through a window. (not checked: the open of the record of 1.2 GB needs a daemon over the 3 GB that this audit may hold, and the session photowroom is a record of the owner. The lead measured the large record at 88.9 s for its first open, with the daemon over 8 GB (LEAD.md, part 5). The window half moved: R167: subjects 2 and 3 of window-design.md (the open; a thread read by page); the design names no test of a bound of memory. The clause of the time is the row resume-in-15s)
  • first-stable-release, open: The first stable release, 1.0.0, is tagged after the proof on one pinned head. (only the owner closes it: version 0.4.2 stands (Cargo.toml:49), the major is raised by hand with release.yml, and R281 says that no 1.0.0 is released while furb is not distributed and not advertised)
  • walk-stuck, open: The audit of the UX uses the real TUI on a real life, in depth: it drives each control, and it finds by itself the defects of use and of look, as a frontend designer does. (moved: R167, R173 and R323. The search for the cause of the stall of the walk in the old window stopped. New home: each subject of window-design.md lands with a test on the headless terminal of the Rust package against a real daemon, and with a capture that the owner judges (R003). The design names no walk of the whole window on a real life: it is a subject to add after the twelve; a7dc0bd, 1b848bc, d979df2)
  • window-memory, open: A window of the TUI does not hold too much memory. The cause is found in how the TypeScript uses OpenTUI, since the logic lives in Rust, and a test that the gates run holds the bound. (moved: R167 and R176. The clause on the cause in the TypeScript is void: that code leaves. New home: subject 3 of window-design.md, where a window reads a thread by page, the newest first, and the principle of the resume that a window attaches at the tip. The design names no test of a bound of memory of the window: it is a gap to close in subject 3. The old window held a bound on a small life (tui/test/window-heap.test.ts), and its heap passed 512 MB on the large record)
  • thread-collapse-scroll, open: In a long thread, scrolling never jumps and a collapse button is reachable at any scroll. (moved: R167. New home: subject 3 of window-design.md (screen 3): an older page keeps the row that he reads (it needs the anchor of the scroll box upstream in the Rust package of OpenTUI), the feed follows its end, and a row jumps to the latest. The design leaves the collapse button of a thread box out: the window shows one thread, and a thread is a card of the list (R326), so only a block and a thought fold, with ctrl+x t; fix(tui): Give each thread one toggle that stays in view #1292)
  • code-prose-render, open: A word and a code block of Markdown render the same way: background, theme, numbers near the left edge, and a header that names the model. The turns of the user render as Python, the prose has one soft shade, and the right gutter of facts is thought again. The count of the characters that a cut hides stands at the end of its line or in its trailer, and a link of Markdown takes a click. The line of thinking is thought again, and furb owns the gutter of its code blocks. A long text ends with the one-character ellipsis. A quote streams as a string binding from its opener on, and the transcript draws its content as text. (moved: R167. New home: subject 3 of window-design.md (screen 3): one block of code for each answer, drawn as a code block of the markdown with the model as its head (R180), a window of 7 rows that rolls (R181), the thought as one muted line (R183), a light grey text (R188), code never pastel (R185), a link that takes a click. The design does not name the one-character ellipsis with the count of what a cut hides (R186) nor a quote that streams as a string binding (R187): two clauses to add to subject 3)
  • tui-polish, open: Each interactive element of the TUI lights under the pointer, and the mark of a state stands apart from the numbers of the lines. (moved: R167. New home: the part The keys of window-design.md: each thing that takes a click rises by one step of background under the pointer (R199), with the token lifted of subject 0, which is on the carrier (window/src/tokens.rs); the loader stands in the place of the number of the line, so no mark of a state stands beside the numbers (subject 3). The old window held a part (8586d8c to b7bb54d))
  • context-panel, open: A click on the Context box opens a panel with its breakdown, as the image that the owner gave shows it. (moved: R167. New home: the frame of window-design.md holds the context box under the list, in line with the input (R207, R208). Gap: the design names no click on the box that opens its breakdown (the last clause of R208), and no builder has the image that the owner gave: to add to the subject that draws the box)
  • config-command, open: /config shows and sets the keys of config.json and of the schemas that skills add, the key gate among them, which turns the gate off. It can take ideas from the settings of VS Code, and its panel is good to use and to look at. (moved: R167 and R199. window-design.md leaves the panel of settings out of the first window: the first window changes the model and the effort alone, and a panel comes later (ux-research.md, part 11). The clause of the key gate is void: R115 removed the gate, and docs/config.md names no such key at this head. The old window holds /config (feat(crate)!: Add /config over a schema that skills extend #1360))
  • append-only-chain, open: No verb or ear drops, rewrites or reorders what a chain holds. (nothing new at 4a32d88: no list of the verbs and the ears against the rule stands (R084). To read in that audit: a write of the door of a prompt drops rungs of its ladder and makes the module again by a replay (src/furb/engine.pyi:581 to 585), which R128 names as an edit by versions; compact() of the skill compaction cuts a chain in place; ce68d13 fixed /model alone)
  • session-disposed-popup, open: A message to the session that the window shows always sends: no popup says that the session is disposed. (moved: R167, R166 and R161. New home: subject 4 of window-design.md (a message reaches a thread that works) and subject 2 (a message typed during an open is sent after it); a session is a name on a card, and a window attaches to the daemon, so no state disposed stands in the design. No scenario of the old window holds it; fix(bash): Read the login PATH from a file, not a pipe #1166, fix(engine)!: Advance first the rung that waits longest #1182)
  • bind-rename, open: The folder bind is named binding: bind/typescript and bind/python become binding/typescript and binding/python. (at 4a32d88 the folders are bind/typescript and bind/python. R328 keeps the TypeScript door, so the rename still holds for both folders. The pull request chore(binding): Move the folder of the doors from bind to binding #1385 (w/ask-a151-1) holds the move outside the carrier, in conflict and last updated on 11-06, against the one pull request of this session (R296): it lands here or it closes; Rename bind to binding #1208 is open)
  • issues-handled, open: Each open issue is closed with its proof or carried by name here, and only this pull request and the automatic ones stay open. (gh issue list --state open shows 17 issues (One daemon on each machine holds every life: many windows, many operators, many machines #983, Kits: skills and extensions as one concept, with an index, a seed in order and views #984, A close means done: refuse it while its work runs, and make a message on a thread a fact #985, Promise that each life opens on each build of its major #988, Cut the round of the conductor to the work that it does #1069, The record of the decisions of the coordinator #1084, Rename bind to binding #1208, fix(engine): Keep each chain of a life in its checkpoint, not the root alone #1230, Stability audit of main on 11-05: 14 defects that a long unattended life can meet #1260, close (resolve) of a thread that awaits an operator question is refused with IndexError, after a stray closed tell #1262, After a rebirth from its checkpoint, the root chain comes back paused though no prompt was open, and new messages hang #1267, A rebirth from a checkpoint retells each module value whole: a 10 KB turn comes back as 1.1 MB #1268, A message on a thread while its word awaits: the first word closes the thread, and the answer to the message is dropped untold #1273, Only fixes, the w/converge loop is stuck again #1393, Tests and hooks leave scratch directories and furb-cli wheels in the caches of the machine #1395, The engine at 8000 tokens: a design #1397, Design: the window of furb in Rust on OpenTUI, with Python as the one scripting language #1398), and gh pr list shows feat(crate)!: Converge the work since 11-03 into one change #1389, the automatic chore(tui): Show the gallery of w/converge at fda8967 #1392, chore(provider): Refresh the catalog of models #1382 and chore(main): Release 0.5.0 #982, and chore(binding): Move the folder of the doors from bind to binding #1385, which is neither this one nor automatic. close (resolve) of a thread that awaits an operator question is refused with IndexError, after a stray closed tell #1262 has its proof at this head (the row close-on-operator-question) and can close)
  • converge-ready-proof, open: The branch is ready to merge. On one pinned head every check passes, each request that this list carries is done and verified from end to end, the changes of the TUI on real captures of the screen, and the whole is reviewed and clean: the engine, the checkpoint, the replay and the provider line by line, the rest by slice. Each part is the least and the simplest code that says its meaning, and the checklist below is ticked. (not ready: 24 rows of 83 are proven at 4a32d88, the gates have no green run on this head (the last green run is 43583934141 at 9de2016; the runs at e34e21b and 5399050 failed), the label hold stands, and the new window is one subject of twelve. gh pr view 1389 --json mergeable says MERGEABLE)
  • workspace-opens-new, open: A click on a workspace opens it quickly, to start a new session there, and it selects no session that the user did not pick. (moved: R167, R205 and R318 (the word is project). New home: subject 1 of window-design.md (the list of cards: a project is a badge and a filter, and the list has no level of session, so a click opens only the card that he picks) and subject 4 (ctrl+n turns the input to a new thread). The old window holds it at this head: bun run test tui/scenarios/windows passes a click on a workspace opens a session that no other window holds, and never the session of another window)
  • reply-open-thread, open: By default, a reply in the window goes to the open thread, also when a close of the model closed that thread. (moved: R167 and R192. New home: subject 4 of window-design.md (the input speaks to the open thread, and one key turns it to a new thread) and subject 7 (a reply opens a resolved thread again). The old window holds it at this head: bun run test tui/scenarios/messages passes a message goes to the thread that the view shows by default, also once the model closed it, and a new thread only on its own key)
  • effort-click, open: A click on the effort beside the model in the input changes the effort. (moved: R167 and R199. New home: the part The keys of window-design.md: a click on the effort changes it, and ctrl+x m opens the model and its effort; its test goes with subject 4 (the input). Nothing of it stands in the old window)
  • ctrl-c-question, open: Ctrl+C in an answer to a question empties the input first. On an empty input it refuses the question, with no question back. (moved: R167 and R194. The old window holds it (0fd20d9, 54bbdde, 55d443d; tui/scenarios/ctrlc passed at 17046d0, not run again). New home: the part The keys of window-design.md: ctrl+c empties the input, and in a question it refuses; its test goes with subject 5 (the question, screen 6))
  • history-key-cancels-nothing, open: A key that travels the history of the input cancels no ask. (moved: R167 and R193. The old window holds it (24921ae, 0fd20d9; tui/scenarios/travel passed at 17046d0, not run again). New home: subject 4 of window-design.md (the input), whose test proves that the up arrow cancels nothing; the history of the project needs the verb history of the daemon)

Breaking changes

  • furb::world::config: the layer of an entry is now an Option. A key that a schema names and that no layer gives comes with its default and no layer.
  • furb::view: the threads view of a chain gives its runs of notes, and the verb threads of the protocol takes an optional place read.
  • The TUI reads each act and its meaning from the daemon, and a click or a key of the window closes no thread.
  • A handover waits for each life to end, with no bound.
  • Only the default skills play at the seed of a chain, and the others play when a word needs them.
  • furb.engine: boot takes the journal of a record in the place of the record, and the journal with the feed of a tail stand in the contract of the checkpointer. automatic is a definition of the skill naming, and no longer of the engine.
  • The end of a life of the daemon writes an image beside the record, and no checkpoint; a handover still writes a checkpoint.

  • I am accountable for this diff, whoever or whatever wrote it.
    Not yet: the diff grows with each cycle, and each topic is accountable for its commits until the final review.
  • It is one change. No part belongs in another PR. No part could be its own PR.
    Not yet: it is one PR, and it may split after CI is green.
  • Its comments obey AGENTS.md: none, or each one prevents a debugging session.
    Not yet: the review of the comments of each topic is still to do.
  • Its prose obeys AGENTS.md: Simplified Technical English, for a general non-technical audience.
    Not yet: the review of the prose of each topic is still to do.
  • Every flaw I know of is fixed in this diff or named in ## Outcome.
    Not yet: the failures of CI are not read yet.
  • I checked each statement above. I did not assume it.
    Not yet: each statement above stands on the merge and the checks of this cycle alone.

@uael uael added breaking-change A change that requires a caller to change its code hold The orchestrator reviews it before the lander merges it labels Nov 6, 2026
uael added a commit that referenced this pull request Nov 7, 2026
The concurrency of gates.yml cancelled the run in progress at each push on every branch but main. The gates of w/converge take 30 to 40 minutes and the aggregator pushes it every 15 to 25, so each run ended before it had a verdict: since the crash, the runs of 986f3fe, 930272d, 47c6816, 296fa4b , e42e4f5 and 653eb15 were all cancelled and #1389 got none.

A push on w/converge reaches the gates only as the pull_request of #1389, whose ref is refs/pull/<n>/merge, so the old test on the ref could not see the branch. The rule now reads github.head_ref, which names the branch of a pull request: on main and on the pull request of w/converge the run in progress goes to its end and one run waits behind it, which the next push replaces; on every other branch a push still ends the run before it. It stays the one concurrency of gates.yml, with no second workflow.

Proof: test/outside/test_gates_concurrency.py reads the expression of gates.yml and finds that main and the pull request of w/converge do not cancel while c/ci and the pull requests of other branches do. It fails on the old rule (2 failed) and passes now (5 passed).
QA: Push w/converge twice in a row, 20 minutes apart. On the pull request, the first run of the gates keeps running when the second push comes and ends with a conclusion, and the second run waits and starts after it. A push on another branch still ends its run in progress.
uael and others added 21 commits November 16, 2026 06:45
A let go of a life dropped the pages that the client had asked of it, so under load a window
whose life ended as it opened never took the page that it waited for, and showed its thread
empty. The thread now keeps what it asked, and asks its end again once that comes.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Each home now stands its guide just above the input, where the home with no thread already stood
it, and says how many answers are new beside what needs the operator, so the mark of a new answer
on a card has its words. A filtered list keeps its part heads, with the rows of each part together
and the part of the best match first, so a search in Go to reads by kind. The row of the model in
use says an effort that the arrows chose and the input does not use yet as a change, as high to
medium, and the arrows step from the effort of the row, not from its text. The card of the open
thread stands whole when the thread is resolved, so its session and its project stay in view.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01PHaEDPN8sNDePofW68EMSb
Each click of a view now has its keys. The leader and V, or /view, give the keys to the first
control of the views of the session: the arrows move among their buttons and inputs, Enter
presses a button or turns the input of the window to an input, and Escape gives the keys back.
The control that the keys reach stands in the accent, and a row under the views says the keys.
The client holds which control the keys reach, from the controls that the views draw. Walk 31
checks a task and adds one with the keys alone.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
The build on Windows failed at ddba3f4 after its programs were built: the copy of the DLL of OpenTUI beside each
program of the window found no line that starts with window in the table of the programs, whose folders the move
of the crates names crates/window now, and grep with no match ended the step under pipefail. On macOS the job of
the crate kept the tests of the window and the kills of the command line by the old names too, so after the move it
would have skipped them all with no failure. Each now names crates/window and crates/cli. That build ran 59 minutes
from nothing, since the hash of the build script of TypeScript, which the key of the cache holds, changed with the
move; it saves no cache when it fails, so its limit is 90 minutes, over that cold build.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01PHaEDPN8sNDePofW68EMSb
The test turned the wheel a fixed count of times, so each new command above the row that it
wants broke it. It now turns the wheel until the row shows, within the patience of the suite.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
One dot meant two things: a session whose life runs, white before the title of its card, in the
head of its thread and in the count of the home, and an answer that the operator did not read,
blue at the right of a card. A new answer now takes the small dot that marks an unread mail, and
the large dot means a live session alone.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01PHaEDPN8sNDePofW68EMSb
The job of the crate on macOS selected the test programs of the table by the names of their folders, and the move of
the crates renamed two of them, so it would have skipped the tests of the window and the kills of the command line
and passed. It also ran the suite of the command line with the filter kills::, which passes with no test when no test
matches it. The job now names the folders of its selection once, fails when a folder of it ran no program, and fails
when a filter ran no test, each with an error that names it. The test runs the step of the workflow in bash on a
table of fake programs: the selection on macOS, a table with the old folders, and a filter that selects no test. The
two last fail on the step before this change and pass after it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01PHaEDPN8sNDePofW68EMSb
The build of each system on Windows ran 59 minutes from nothing in run 43806453852, since the move of the crates
changed the build script of TypeScript, whose hash the setup put in a variable that the key of the cache of rust
holds beside the hash of the rust. rust-cache restores an older key only when the hash of the manifests and the lock
differs, and never across that part, so each of the 9 changes of that script in 14 days built every crate again on
each system. The hash was there so a script that selects a new crate saves a new cache, but the build of each system
now compiles every crate of the workspace for its tests, so its cache holds each dependency that a script can
select. The hash, its input and its variable are gone, from the gates and from the proof of the corpus, which
restores the same cache. A change of the lock or of a manifest still restores the older key and builds only what
changed. This change itself changes the key once.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01PHaEDPN8sNDePofW68EMSb
Each block of a long thread stood under the same model, as opus/high above each answer, so the
column at the right of the feed repeated one word down the whole thread. A block now names its model
where it differs from the block before it, as a chat names a sender once for his messages in a row,
and the row of the head stays as the blank row between the message and the box.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01PHaEDPN8sNDePofW68EMSb
A skill has one name in code, and the name of a test that said extension broke that rule, which
the test of the names of the skills holds.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
When the ear of a chain raised while it heard a fact, the life dropped the chain: the act of that fact
stayed open, and each later rung of the chain waited for ever. A word that read a path that is no str
did it, since the guard of the door of a prompt raised on the path, and so did a reply whose answer
holds no text, since the chain raised where it unquoted the word.

The ear of a chain now catches a raise of its own while it hears a fact. It says the done of the open
act of the chain that the fact names, with a refusal that names the chain and what it raised, and it
hears on. A replay raises in the same place and says the same refusal, so it does not drift.

The chain keeps the word of a rung only after it made the run of that word, so a word that did not
run never stands in the program that the door of a thread reads.

Drift is now a BaseException, so no except of an Exception holds a drift: the ear of a chain does not
take a drift for a raise of its own, and the life no longer needs a case for a drift where it hears.

Contract: one sentence of chain, "The ear of a chain that raises while it hears a fact says the done
of the open act of the chain that the fact names, with a refusal that names the chain and what it
raised, and hears on, so the chain stays and its later rungs run." Drift changes its base from
Exception to BaseException, a break that docs/promise.md lists. The engine costs 8851 tokens, so
BUDGET is 8852.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01PHaEDPN8sNDePofW68EMSb
An image cannot draw a part of itself, so a box that the edge of the feed cut stood as blank rows
of its band. The first row of the box now names the image under it, as it does while the bytes
come, so a cut box still says what it holds, and the image covers the name where it draws.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01PHaEDPN8sNDePofW68EMSb
On Windows the build of the tests still compiled the crate furb a second time, and each crate under windows-sys: the
colors of insta, a dev-dependency of the window, take console, which asks windows-sys 0.61 for the input of the
keyboard and the mouse, a feature that the build of TypeScript does not select. The test build on Windows took 24
minutes after a build of TypeScript of 22 in run 43806453852. insta now takes no default feature, so a snapshot that
differs shows its diff with no colors, and the features of each crate that the build of TypeScript compiles are the
same in the build of the tests on Windows, Linux and macOS, by cargo tree, but for simd-adler32, which only xtask
reads there. The 147 tests of the window pass.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01PHaEDPN8sNDePofW68EMSb
The ear of a chain that raised at a late point of a fact left a half step. A rung with an actor that
is no str raised where the chain advanced it: the chain had made it its step, so each later rung of
a thread waited behind it for ever. The ear now says the done of that rung too, when it has no reply
yet, as a Kernel that raises refuses each run that it held, so the thread takes its next rung.

The door of a thread takes a write only of a text whose content is a str. Before, the chain dropped
the word of the writer from the program of the door, then raised on the content, so the door lost a
word that ran.

The test of the sentence now holds three raises against a life where nothing raised: a rung with an
actor that is no str against one with an actor that the roster does not hold, and a reply whose text
is no str against a reply that the World refused. In each pair the facts after the refusal are the
same, so the chain goes on as an ear that never raised.

Contract: the sentence of chain says the rung that the ear advanced and that has no reply yet. The
engine costs 8859 tokens, so BUDGET is 8860.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01PHaEDPN8sNDePofW68EMSb
A box that the head of the feed cut kept its first row above the feed, so its rows in sight stood
blank as at the foot before. The last row of a box that holds its image names the image too, so a
box cut at either edge says what it holds, and the image covers both names where it draws.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01PHaEDPN8sNDePofW68EMSb
The ear of a chain moved its state before two raises could come. A standing that the chain could not
read raised after the chain took it as its standing: a later stand back to the old standing then made
a rung that a life with no such standing does not make, and a first standing of that kind left the
root with no setup at all. A jump whose word is no str made the new chain, then raised where it ran
that word, so the jump never ended and a word that awaited it waited for ever.

The chain now makes the word of a stand and the plan of its setup from the new standing before it
takes that standing, so a standing that it cannot read moves nothing. The chain takes a jump only of
a list of names and a word that is a str, so a jump of another kind is refused as no ear takes it.

The test of the sentence of chain adds two pairs of lives on a World that gives the standing as it
is: a standing with no directory against no such standing, and a first standing with extensions
that are no list against a first standing that holds them. In each pair the chain makes the same
turns, and the same facts at the later stand.

Contract: one sentence of jump, "A jump whose word is no str is refused, since no chain takes it, so
the chain does not jump." The engine costs 8887 tokens, so BUDGET is 8888.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01PHaEDPN8sNDePofW68EMSb
A list part took the width of the rows that passed its filter, so the settings shrank to the
middle of the window as he typed, and the part that writes a value stood in other columns again.
A part now measures its rows before a filter or a group takes some, and the part of a value
measures the settings that it came from, so the part keeps its columns from its open to its close,
as a palette does. A row that only a search shows and that is wider is cut.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01PHaEDPN8sNDePofW68EMSb
The test wheeled the feed while the third answer could still come, so once the image drew whole
before the answer pushed it up, the feed at its end held the image cut at its head and never whole.
The test now waits for the block of the third answer, then wheels back from the end of the feed.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01PHaEDPN8sNDePofW68EMSb
Before the first answer of a thread, the box of the context said that none came on its head row
and left its counts row blank, so the last row of the list stood empty beside the hints. The words
now stand on the counts row, in line with the hints, where the counts of the first answer replace
them, and the head holds the title alone until a share is known.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01PHaEDPN8sNDePofW68EMSb
A part of things that say what they do, the settings and the extensions, grew past the most width
of a part while the window had room, so at 200 columns the settings spanned the whole feed and each
value stood 120 columns from its name. Each part now stops at the one most width, the chosen row
still says what it does whole on its wrapped rows, and each other row keeps one row of it, as
before on a smaller window.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01PHaEDPN8sNDePofW68EMSb
The sentence of hearer said that the record keeps a fact not. It now says that the record does not
keep it, which is Simplified Technical English. The meaning and the test do not change.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01PHaEDPN8sNDePofW68EMSb
uael and others added 30 commits November 17, 2026 04:14
A handover waits for each command that a life runs at its ask. The life
told each act to its readers first, and changed the set of its commands
only once the step that told it ended. So a window could hear a command
start, a handover asked then could find no command, and the end of the
life cut the command. A test of the daemon failed this way under the
load of a whole run of the suites, the old daemon ending before the
command in flight.

Now the life changes the set of its commands as it takes the act of a
command, before any reader hears that act. A new test reads the start of
forty commands of one rung and finds each among the commands of the
life at once. It did not fail on the code before in 23 runs on a quiet
machine, and the test of the daemon did not fail again in 190 runs, 60
of them beside the whole suite: the order holds by construction, and
the flake was not reproduced on demand.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FHsycs2gr35oRcDVYxYVHq
w/rust brings the Rust work of the night: the window lays out only the
parts of the feed that a change reaches, the allocations counted, the
drift fix of the replay, the panic and RefCell passes, and the host
counts a command before a reader hears it start. w/converge brings the
seven commits of the life of the owner: the skills furb and furb-kit,
the hakari build, a handover without a still thread, each line of a
text whole, and the drop of the ear of an act at its done.

The fields of a life handle take the beat of w/converge and the names of
w/rust. The test of a handover without a still thread reads the event of
a frame through event_of, since a frame now shares its event. The
allocations for each fact rise from 1197 to 1227, and from 1207 to 1231
on the bench, since 799b6b2 reads whether an act is over at each hear;
budgets.toml says so, and one allocation more for each fact still fails.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FHsycs2gr35oRcDVYxYVHq
The build of each system made three artifacts one after the other on one runner: the engine of TypeScript, the test programs and the wheel of python. Each holds the crate furb with features of its own, so each was a compile of furb, and napi gives the build script of furb an environment that cargo test does not, so the tests compiled furb and furb-host a second time. On Windows the build took 1397 to 1813 s, and the suite waited for all of it.

Each artifact now has a build job of its own that starts at once, and each later job waits for the build of its artifact alone: the crate for the tests, the bindings for the addon, the suite for the wheel. The addon and the wheel restore the cache of the build of the tests and save none, so the store keeps one cache of rust for each system.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FHsycs2gr35oRcDVYxYVHq
Each job of the gates failed in its first cargo command after furb-hack came in: the gates deny each warning, and cargo warned that furb-hack inherits no lints, and that the dependency on furb-hack is unused in furb-hack itself, in furb-wire and in xtask, which load it through no other crate of the workspace. No local gate denies the warnings of cargo, so each passed.

furb-hack now inherits the lints of the workspace, and the workspace allows an unused dependency: cargo takes no lint for one dependency, and `cargo hakari publish` removes the dependency on furb-hack, so no line of code can name it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FHsycs2gr35oRcDVYxYVHq
CI denied each warning through CARGO_BUILD_WARNINGS, which only its setup set, so a warning of cargo, as one of the manifest of furb-hack, passed each local gate and failed every job of the gates in their first cargo command. The setting now stands in .cargo/config.toml, which every build of a tree and of CI reads. The variable left the environment of the jobs, so the key of each cache of rust changes once.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FHsycs2gr35oRcDVYxYVHq
799b6b2 dropped the ear of an act before it heard a fact once the act
was over, unless the ear lasts. So an ear never heard the done that the
World or the engine said for its act: a read, a write and a tell of a
text waited for ever, and four test files of the suite hung on both
engines until the workers crashed.

Now the ear hears each fact as before, and goes once it heard a fact
while its act is over, unless it lasts. An ear that says its own done
goes at once, as the contract says, and one whose act another ended
hears that end and goes, so an ear that asks again at each answer
stops at the end of its act.

The test of a life asserted that the ear of an act that says its own
done hears it, which the sentence of Act on the drop refuses: it now
asserts that such an ear hears nothing. The hook hakari of 2221a82
runs at a commit, so the test of the hooks of a commit names it. The
allocations for each fact are 1229, and 1233 on the bench, in each of
4 and 2 runs. The engine costs 8952 tokens of 8955. The Python suite
passes whole, 2619 tests, with a coverage of 100.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FHsycs2gr35oRcDVYxYVHq
The test of the commands that a reader hears start read its first events
from the log of the life, which the life gives only once the step that
told them ended. So it read the commands after the life changed them,
and it passed on the code before the fix of the order too.

The reader now reads the log up to a done rung first, and then hears the
start of each command as the life tells it. On the code before the fix,
it fails at the first command in each of 20 runs; on the fix, it passes
in each of 50 runs.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FHsycs2gr35oRcDVYxYVHq
A killed daemon leaves its socket. A daemon that starts then finds that
no one answers it, removes it and listens. Two daemons that start at
once each did that check and that removal, so the second removed the
socket of the first, and both listened: one served where no peer could
reach it, and its end later removed the socket of the other.

Now a daemon holds the lock of its folder from its look at the socket
to its listen, so the look, the removal and the listen are one step,
and the kernel ends the lock with its process. A daemon waits for the
lock only while another starts, so a daemon that ends lets the next one
listen at once. A new test starts sixteen daemons at once on a stale
socket and finds one that listens: it failed in 6 of 10 runs on the
code before, and passes in 30 of 30 runs now.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FHsycs2gr35oRcDVYxYVHq
A test that starts furb host runs the program at the path that cargo
gives. A build of the tree while the suite runs, as cargo build or the
wheel that uv sync builds, puts another program at that path, and the
daemon of the test follows a new program at its path: it starts it and
hands its lives over in the middle of the test. The window of the test
then closed, and the test failed with "the daemon stays", as in a run
of the gates where the suite of Python built the wheel.

Now each test runs a hard link of the program in its own folder, which
no build replaces. With a copy put at the path of the program every
2.2 s, the test of a kill after an image failed in 4 of 4 runs before,
and the whole suite of the command line passes in 6 of 6 runs now.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FHsycs2gr35oRcDVYxYVHq
The wheel of furb-cli dropped the symbols of the program in each build,
so a sync in a tree built the program again with other flags and put
it at the path of the program of cargo. A daemon of that tree follows
a new program at its path, so each sync and each later cargo build
moved the daemon of the tree to another program and back.

Now only the wheel of a release drops the symbols. A sync after a build
of cargo leaves the program as it was, with the same hash and the same
time of its last write.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FHsycs2gr35oRcDVYxYVHq
The helper turn of the provider tests reads furb::value::entry on each system, and its import stood under cfg(unix), so the suite did not compile on Windows. cargo xtask targets fails on it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FHsycs2gr35oRcDVYxYVHq
The check of the contract compares the contract with v0.4.2, and found the break of Entry, whose alias now holds a fourth number, listed in two steps and not as one. The page lists it once, with its fate.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FHsycs2gr35oRcDVYxYVHq
A daemon and a window each take a new program at their path as a new
build, and give it their place. A build of the workspace, as the tests
and the gates take, turns on the feature typescript of furb, which the
package of the addon names. A build of the programs alone, as cargo
build -p furb-cli -p furb-window and the wheel that uv builds, did not.
So the same sources made two programs at one path, each build put its
own there, and the daemon and the window of the tree moved to it, as if
it were a new build. Each change also built the crate furb twice.

Now the two programs name the feature too, but on Windows, where the
build of napi looks for the library of node, so there the two builds
still make two programs. cargo build -p furb-cli -p
furb-window, a build of the tests of the workspace and uv sync leave the
same program, with the same hash and the same time of its last write. A
new test compares the features of furb that cargo resolves for the two
programs alone and for the workspace, off Windows: it fails on the code before
("furb v0.4.2" against "furb v0.4.2 typescript") and passes now.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FHsycs2gr35oRcDVYxYVHq
The hooks of the gates refused three tests: ruff formats a long list of test_prompt.py, ty refuses an ear of test_act_shape.py typed as a generator of objects where act takes an ear, and warns that a truthy check of test_entry.py always holds, which now checks the kind and the name of the act.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FHsycs2gr35oRcDVYxYVHq
ruff (RUF021) refuses an and inside an or with no parentheses, in the ear that d00e6ef changed, so the hooks of the gates fail. The program is the same, and the minified engine too.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FHsycs2gr35oRcDVYxYVHq
The job of the crate ran each test program of the build with the runner of libtest, so the tests of one program ran as threads of one process, with no bound of time. A tree runs them with cargo-nextest, one process for each test. memory::a_window_holds_no_more_on_a_life_four_times_as_large measures the heap of its process, so in CI it read the other tests of the window and failed on Linux and on macOS (5365660 bytes past 4194304), and `cargo test -p furb-window --test suite` fails it the same way here, while nextest passes it.

The build of the tests now makes an archive with `cargo nextest archive`, with the examples that a test runs, and the job of the crate runs it with cargo-nextest, with no rust, under a profile ci whose bound of time fits a runner of 3 or 4 cores. The selection of macOS is a filter of nextest; a package that it names and the workspace lacks, or a filter that selects no test, fails the job. The whole archive passes from a fresh copy of the sources here (1251 tests).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FHsycs2gr35oRcDVYxYVHq
A life that keeps its record keeps the carry of its last crossing
beside it, so a later open replays no segment before that crossing.
Its key named the texts of the build that wrote it, so each new build
of furb refused it and replayed every old segment again: a copy of a
record of 480 MB took 274 s and 4.4 GB to open by its record after a
build, against seconds once its carry was kept.

The carry is a function of the entries up to the crossing, which name
the texts that each segment replays on, and of what the replay takes
from the build beside them: the opening of the sandbox, the rule of
the record, and the order and the checkpointer that the build gives an
older segment. The key now names those, as engine::replays gives them,
and not the texts that the build runs. A carry of the former key is
refused once, and the next open keeps one of the new key.

On a copy of that record, with no image, a build of other engine texts
now opens it in 12 s at a peak of 1.8 GB, where the first open, which
replays each old segment, took 274 s at 4.4 GB. The test of the carry
now finds no text of the build in its key: it fails on the former key.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FHsycs2gr35oRcDVYxYVHq
While a run runs, the facts that it says wait in the log, so the log
grows with the word. The engine walked that whole log at each fact
twice: to count the facts that wait, which each entry of the record
holds, and in a replay to find the entry of a fact that the record
answers. A word of 5200 asks thus took 11.3 s on monty and the open
of its record 3.3 s more, and each ask cost more than the one before;
the test of the host that runs it took 14.7 s alone and went past its
bound of 60 s under load.

The engine now counts the facts that wait as it places and lets go
of each, and finds the entry of a fact from the end of the log, where
it stands. On monty that word now runs in 2.0 s and the open of its
record in 1.7 s, and the test takes 3.7 s; 10400 asks run in 4.0 s,
against 31.6 s, and open in 4.0 s, against 8.1 s. On this interpreter
the replay of 16000 asks takes 0.49 s, against 4.8 s. The records
are the same: each test of the suite passes on both engines.

A test of the register of defects holds the time of a word and of
its replay to their length: it fails on the walks, with a ratio near
13 for a word 4 times longer, and passes at about 5. The engine
costs 8972 tokens, and BUDGET of tokens.py moves to 8973, under the
wall of 9000.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FHsycs2gr35oRcDVYxYVHq
AGENTS.md says that a life that keeps its record and opened on the
texts of another build crosses to this build before any word runs.
The daemon does so, and the doors do so through boot, but the
commands run and prompt of the command line, which keep their record,
opened the life and never moved it: the record took words on the old
engine, and a later build replayed them there.

Life::lived now takes the lease of the record first, opens, and when
the engine runs other texts crosses it and opens again under the same
lease, as the host does. A test of the command line makes the last
segment of its record run another engine and finds one fact made of
this build after the next command, and none more after the one after
it; it fails on the former code.

On a copy of a record of 480 MB whose last segment ran a build of
other engine texts, a run crossed in 14 s at a peak of 3.9 GB; the
next run opened by its image in 2 s, and one with the image removed
opened by its record in 8 s at 1.7 GB, with no second crossing.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FHsycs2gr35oRcDVYxYVHq
Point 5 of the stability audit #1260 found that the reminder of a
message of the operator that a thread owes came at each quiet step,
with no bound. Its test in the register of defects stood as a strict
expected failure, and it still failed, but for another reason: it
counted the reminders as prompts that the thread says on itself, a
form that the engine no longer has. The engine now tells the message
in the next turn of the chain, once, and a step that answers it with
no act asks the chain no more.

The test now holds that rule: the message stands in one turn of the
chain, and four quiet steps after it make no rung beyond the one that
it asked. It passes, so its mark goes. A reminder at each step would
make a rung at each step, which its second assertion refuses.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FHsycs2gr35oRcDVYxYVHq
The job of the crate extracted the archive of the tests to a temporary folder, and a test runs a program by the path that the build compiled into it, env!("CARGO_BIN_EXE_furb"), in the target of the checkout of the build. So each test that runs furb, xtask, furb-frames or an example failed at once with NotFound on each system (run 44019685107).

The archive now goes into the target of the checkout, which stands at the path of the build on each runner of a system. Proof here: an archive built in a copy of the sources, run in that copy with no target, fails the kills with NotFound at a temporary extraction, and passes 1251 of 1251 when it is extracted into the copy.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FHsycs2gr35oRcDVYxYVHq
A window that reads a record of 1.4 GB from before the stable cut
held a heap of 2.15 GB at its peak and settled at 540 MiB. The peak
came from two lines of the record, checkpoints of 418 MB and 500 MB,
which the host parsed whole into values of JSON, about three times
their size, though no view reads the turns and the module of a chain,
which hold about 450 MB of the larger one.

The host now tells a checkpoint with what a view reads of it: its
chains with no turns, no definitions and no values. The parse of a
line passes over those keys and makes no value of them, so a large
checkpoint costs what a view keeps. json_of gives the same fact for a
checkpoint that a life says, and the reader of the log digests a
checkpoint line as that fact, so a reader finds the facts that the
log let go. The protocol and its schema do not change; the fact of a
checkpoint that a window hears holds less.

On a copy of that record, with its file of what it tells, through
Life::spawn as the daemon opens it: with no reader, three runs each,
6.6 s, a heap of 2154 MiB at its peak and 2.40 to 2.50 GB of RSS
before, and 4.9 s, 1703 MiB and 1.82 GB after; with a reader of each
fact from the start, as a window that reads the past, one run before
and two after, 11.5 s, 2351
MiB and 3.71 GB before, and 8.7 s, 1703 MiB and 2.89 GB after. The
heap settles at 540 MiB in each. A test reads the checkpoint of a
record of the corpus as the life tells it and as a later reader reads
it again, and finds no turns and no module of a chain; it fails on the
former code.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FHsycs2gr35oRcDVYxYVHq
The test of the command line that compared the features of furb in a
build of furb-cli and furb-window alone with a build of the workspace
ran cargo tree with --offline. The job of the crate in CI runs the
tests from an archive on a runner that holds no dependency of cargo,
so cargo could not get the fork of monty and the test failed there, on
Linux and on macOS, at f7cd410.

The check reads the manifests and the lock, not a build, so it is a
hook beside the hook of hakari: it runs where cargo holds the
dependencies, on each change of a manifest or of the lock, and in the
job of the hooks. It passes on this tree, and it fails and names both
sets of features when the manifests of the two programs leave out the
feature typescript.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FHsycs2gr35oRcDVYxYVHq
The crate job runs the archive of the tests with no cargo. insta asks
cargo metadata for the root of the workspace, and with no cargo it
falls back to the folder of the package, finds no snapshot under it,
and fails each test of the window that draws a screen: 47 on macOS and
22 on Windows in run 44025412536. The job now names the root in
INSTA_WORKSPACE_ROOT. A test of the window run with CARGO set to false
fails the same way, and passes with the variable.

On Windows the two tests of a delete named the life with a slash
between the folder and the record, while the daemon names it with the
separator of the system, so the refusal and the file of the restore
named another string. They name the record with that separator now.
They pass on macOS; Windows runs them in the next run of the gates.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FHsycs2gr35oRcDVYxYVHq
The hook programs runs cargo tree over the whole workspace, so it reads
more than the staged files, as the hooks paths and unused do. A commit
skips it, and a run of the hooks by hand and the job of the hooks run
it. The test of the hook script, which holds the list of the hooks
that a commit runs, failed on each system at 3b3714d and passes now.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FHsycs2gr35oRcDVYxYVHq
The window test of a sub thread about a folder failed on Linux: its
own `git add` met `index.lock: File exists`. The daemon reads the
changes of the checkout of the project while the window shows it, and
`git status` and `git diff` refresh the index of the checkout and
write it under that lock when they can. So a git command that the
operator runs in his checkout at the same moment could fail the same
way. A loop of reads beside 1000 adds failed one add.

Each read now writes nothing in the checkout: git runs with
`--no-optional-locks`, and each diff is the plumbing `diff-index`,
with `-M` for the renames that the porcelain diff found by default,
since `git diff` writes the index even with that flag. A test of the
daemon touches a tracked file and holds the index of the checkout the
same across a read of the changes; it fails on the reads before.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FHsycs2gr35oRcDVYxYVHq
The guard of the linear engine failed on a loaded runner of Linux: it
compared the processor time of a word of 8000 asks with one of 2000,
and read 8.03 times more, past its bound of 8, on the engine that the
guard holds. A time of the processor still moves with the load of the
machine, as a time on the wall does.

The guard now counts the lines that the package furb runs for the word
and for its replay, which no load changes. A word of 2000 asks runs
1,423,417 lines and one of 8000 runs 5,683,417, 710 lines for each ask
and the same cost once; its replays run 1,105,657 and 4,405,657, 550
for each ask. So a word 4 times longer runs at most 4 times the lines.
On the engine before fb8a6af, which walked the log at each fact, the
replay of the long word runs 14.5 times the lines, and the guard fails.
It runs one word of each length, in 1.35 s against 1.73 s.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FHsycs2gr35oRcDVYxYVHq
The law of speed of the kits failed in 3 of the last 5 runs of the
crate on Linux: the hop to the process of a kit took 1.16 to 1.27 ms
against 0.37 to 0.60 ms for the start of the least program, as the
least of 50 runs, so no run of the 50 was free of the load. A likely
cause, not measured: on a runner whose cores the other tests keep
busy, each wake of a thread or a process waits for a core, and a hop
wakes four (the writer of the stdin, the kit, the reader of its
stdout, the life) where a start wakes two. On an idle machine the hop
costs about 40 us.

The law now counts the work that the code does, which no load
changes: five acts hop to the one process of the kit, which starts no
program, and each act after the first passes it the same count of
frames. A change that tells the kit more frames at each act fails it.
It stands in the suite beside the other tests of the kits, which a
life that a host opens runs, since a count does not depend on the ears
that stand before the kits; the test of the module goes.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FHsycs2gr35oRcDVYxYVHq
The test that walks a value of 19,900 levels on the engine of an
earlier build overflowed its stack on Windows in each run of the crate
there, since it came. The stack held 1,024 bytes a level, on a claim
of under a KiB. A probe that bisects the least stack of that walk in
child processes measured 1,054 bytes a level on Windows, 20,986,624
bytes in all against the 20,971,520 that the run grew, and 673 on
macOS, both in a build for development.

The run now grows 1,600 bytes a level, half again the most that was
measured, on each system: 32 MB of address space that the run touches
only as deep as its walk goes. The test passes on Windows, on the PC of
the owner, and on macOS; it stays the proof on each system, and the
probe does not land.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FHsycs2gr35oRcDVYxYVHq
The test of a take back read the first frame that showed the stop of the
message and asked that its text stand in the input there too. The text comes
back with the reply to the cancel, and the page that shows the stop comes from
the task that reads the thread. The protocol gives no order between the two,
so under load the stop drew first and the test failed. The test now waits for
the frame that shows both.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FHsycs2gr35oRcDVYxYVHq

This branch has not been deployed

No deployments
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

breaking-change A change that requires a caller to change its code hold The orchestrator reviews it before the lander merges it

Projects

None yet

1 participant