Autolith project adaptations

Purpose

This voluntary file records reusable ways Autolith adapts itself to this project. It supplements AGENTS.md and never overrides repository policy, user instructions, or capability boundaries. It contains documentation, not executable Lisp.

Project profile

Record project-specific tools, workflows, and recurring friction only when they matter to future work.

Active adaptations

For each adaptation, record its problem, behavior, scope and location, verification, and removal condition. State whether it is tracked project work, a user-local init.lisp change, or a private image commit.

Inspectable test-worker stalls

Problem: worker timeouts omitted the active case and blocked thread stacks.
Behavior: record RUN before each case. Set AUTOLITH_TEST_STACK_AFTER to collect live Lisp thread backtraces after the requested delay.
Scope and location: tracked project work in tests/test-runner.lisp and script/test-worker.lisp.
Verification: a controlled shard replay identified the pending subprocess case, its pipe reader, and its owner waiting for I/O completion.
Removal condition: retire the optional watchdog after equivalent thread capture is available automatically at worker timeouts.

Railed job completion summaries

Problem: completed and cancelled job notices rendered summary bodies as plain white text without the tool-output rail.
Behavior: wrap each summary row beneath a dim left rail and use subdued text.
Scope and location: private application--job-completion-entry definition, image commit 7fb799af-aa66-45cf-9ed1-64a7b8aaffe3, private Git c1df7a2517d18cb03a916b2194502b728c0dbcbe.
Verification: 90 rendering cases and 348 railed rows cover completion outcomes, compact display, terminal width, controls, Unicode, and bounded output. The completion-controller suite passed 10 cases and 83 checks. Active rendering assertions and clean-process private replay passed.
Removal condition: discard the override after installing equivalent tracked completion-summary presentation.

Authorized paths in explicit delimiter checks

Problem: lisp.paren-check authorized an external path, then supplied a separate workspace-root list to Parenchek and rejected the same path.
Behavior: authorize once through workspace-tool-path; derive the backend’s path-stability scope from that authorized path. Retain snapshot and requested directory traversal checks.
Scope and location: private tool-execute method for lisp-paren-check-tool, image commit c812075b-89aa-44dc-a2b4-14f17f5675f1, private Git 72d99b8e3bd2e62c40156eee6ed12b9d8aaa08c2.
Verification: the two failed scratchpad files and their 13-file source tree pass. External calls ask once; denied and sandbox-only decisions reject them, full access permits them, and workspace paths need no external approval. Clean-process private replay passed.
Removal condition: replace the override after installing equivalent tracked tool path handling.

Shell-log search result limit

Problem: resource.read advertised 50 search results but rejected requests above 20 for shell-log: resources.
Behavior: accept up to 50 bounded excerpts per shell-log search.
Scope and location: private *shell-log-resource-maximum-results* definition, image commit d7be1e92-d766-4913-8387-5bc5d3341843, private Git 3c4551024b63a5ce6c940ac769c0360f7a0797cd.
Verification: the previously rejected 25-result request succeeds; the validator accepts 50 and rejects 51. Clean-process private replay passed.
Removal condition: discard the override after installing an equivalent tracked search limit or scheme-specific tool description.

Isolated patches beside unrelated edits

Problem: isolated patch checks required an entirely clean integration target, blocking nonoverlapping patches in a workspace with preserved user edits.
Behavior: require cleanliness only for affected paths reported by Git; retain busy-operation checks and Git’s index/worktree applicability checks.
Scope and location: private cl-worktree:check-patch definition, image commit bc75abac-fc67-40b7-9148-cbfe76206c78, private Git 19b44556b18fb0a7f2fa1d56c25319a6464d3a5a.
Verification: actual task.worktree check/apply preserved unrelated edits and rejected changed patch paths. NUL-delimited rename and literal path checks passed, as did clean-process private replay.
Removal condition: replace the override after installing equivalent upstream cl-worktree integration behavior.

Native paths in file observations

Problem: scratchpad URIs did not identify the filesystem paths needed by compiler and shell commands.
Behavior: include the resolved native path from observation metadata in workspace and scratchpad read/edit results.
Scope and location: private workspace-file--read-result definition, image commit 3014c532-3f40-43c8-b03c-53ba49bf1501, private Git 310f0743410e9a50a858d2895c87ca77194c9e88.
Verification: missing/file/directory observations exposed their paths; 121 workspace/scratchpad checks passed. A C file with spaces in its name compiled and ran using the returned path. Clean-process private replay passed.
Removal condition: replace the override after installing equivalent tracked file-observation output.

Temporary shell capture quota

Problem: 1,918 closed or interrupted shell captures could not be pruned, exceeding the 256-artifact limit and preventing new shell executions.
Behavior: Raise the active-image artifact count allowance to 4096 while preserving protected captures and the 1 GiB total byte allowance.
Scope and location: exploratory *shell-log-retention-count-limit* setting. No private commit; papercut e6320f39-dd3a-4938-a2c8-5cc2957cfddd tracks receipt-backed pruning.
Verification: inspection measured 155,164,525 bytes and zero active captures; subsequent shell executions succeeded.
Removal condition: discard the override after repairing capture pruning.

Session worker executable

Problem: AUTOLITH_SBCL referred to a deleted Nix executable, so Lisp workers could not start.
Behavior: Read the valid executable from ~/.local/share/autolith/runtimes/command and set the process environment with platform-setenv. Check the recorded path before using it.
Scope and location: process-local environment only; no private image commit. Papercut e72224a4-7763-4581-9603-dc57af07ad65 also records the indexed search helper, whose initialized executable did not change with the environment.
Verification: a new Lisp worker started and parsed the public models.dev catalog.
Removal condition: start a fresh process with a valid worker executable and repair the stale indexed search helper configuration.

Active-image internal symbol reader

Problem: Single-colon autolith: references failed for internal symbols during active-image inspection.
Behavior: Read self-tool forms in AUTOLITH and invoke the reader’s continuation for internal AUTOLITH: references.
Scope and location: tracked src/self/tools.lisp. Live mutation 33dc0dd8-da5f-44ae-bbfd-8beaad4cceb4 is exploratory.
Verification: the self.eval boundary test and live reader exercise passed, including the internal prompt-cache accessor.
Removal condition: discard the exploratory override after booting the tracked definition.

Recent child coordination notes

Problem: Long live child output became an omitted-field descriptor in job.get, hiding the newest source-freeze and Git-index coordination notes.
Behavior: Retain a bounded newest-tail preview for :progress-output in native job records, including a count of omitted leading characters.
Scope and location: private task--artifact-field definition, image commit 1f767606-fbcc-4002-a141-06e220dc9ed6, private Git 0e8907b605e0db35a49d416ae4c054fd9df9943a.
Verification: assertions covered long, short, empty and zero-budget progress; a 7,000-character native job record retained its latest note within 1,024 characters. Clean-process private replay passed.
Removal condition: replace the override after installing equivalent tracked native job preview behavior.

Resumed-turn job ownership

Problem: The repeated restart notice did not distinguish new live jobs from pre-restart work during a long resumed turn.
Behavior: Identify pre-restart ownership loss explicitly and permit ordinary inspection, joining and cancellation of jobs created during the resumed turn.
Scope and location: private *resume-context-instruction* setting, image commit aae299c0-2394-4528-b4d8-e934f37a8bfc, private Git d1b92e8c61ddccb83363331e922da4173f13e017.
Verification: subsequent provider requests contain the corrected boundary; new RLM and command jobs completed and were collected. Private replay passed.
Removal condition: replace this override after installing an equivalent tracked restart notice.

NetBSD directory enumeration

Problem: The unversioned libc opendir=/=readdir bindings returned legacy NetBSD directory structures. directory-names decoded them with the current layout, truncating names and producing empty resource directory listings.
Behavior: Use __opendir30 and __readdir30 together, with the NetBSD x86-64 dirent layout, bounded iteration, errno checks and owned handle cleanup.
Scope and location: private override of ls-compat.posix:directory-names, image commit 47f3e7f6-1b0f-4ce0-95e0-3caba894aa2e, private Git 41637533d508c80becfd51d58346ac0c82ebc1eb. This is host-specific live state, not a tracked dependency fix.
Verification: worker and active-image assertions covered names, uniqueness, zero/one entry limits and missing directories. Resource directory reads now return complete names. The clean-process private replay probe passed.
Removal condition: replace this override after installing a dependency with correct NetBSD directory ABI bindings.

Child assignment scope

Problem: The child prompt prohibited work outside the initial workspace, overriding ordinary path authorization for explicitly assigned repositories.
Behavior: Identify the initial workspace and use the assignment’s scope; authorize other paths through the existing tool boundary.
Scope and location: tracked src/task/child.lisp. Live mutation 62d7eeae-e7ef-4129-bc2e-82865f84a720 is exploratory; private persistence is blocked by inherited replay protocol incompatibility, papercut 94df14e7-bdb7-4a04-a6d6-bfc567239fee.
Verification: lambda-debugger-authorized-3 and the core reviewer accessed the assigned sibling repository. Full checks passed: 604 cases and recovery probes.
Removal condition: remove the exploratory override after booting a runtime with the tracked definition.

Child execution job controls

Problem: Children could start asynchronous commands but could not collect their results because task-job-tool lacked the child-safe method.
Behavior: Allow job.* through child role grants, with the existing job-owner and ancestry checks. Bundled reviewer and librarian roles grant job access.
Scope and location: tracked src/task/tools.lisp, src/task/contracts.lisp, and src/task/agents.lisp. The live method and explicit-grant policy are retained in private image commit c3ec5281-3622-4c30-9bc9-a223fecccd47, private Git ef5e3ed06e3ee5129b27fe4eb29c0905c53b7b54.
Verification: active registry exercise passed. Child child-job-smoke-4 launched a 12-second asynchronous command, awaited exec:114 through job.wait, and returned its successful output. Private replay probe passed.
Removal condition: the installed runtime contains the tracked child-safe method, making its private override redundant.

Intentional foreign definitions

Problem: The replay ownership guard treated intentional foreign definitions as stale Autolith definitions moved into libraries. Installation and undo unlocked the reader package but not a separately qualified target’s package.
Behavior: Journal each new definition’s owning package and preserve it through replay entries and direct persistence. Unlock the reader and target packages around installation and undo, restoring both locks. Preserve stale-owner skips for historical definitions and skip uninterned replacement targets.
Scope and location: tracked src/self/tools.lisp, src/state/image-commits.lisp and src/state/durable-mutations.lisp. The live definitions are retained through private image commit fcc8b2e8-d411-4a1d-9886-d12d2d86c00d, private Git e05ecdef33b8ffc51e141e83ca12134b3c34950f. Tracked type declarations were refreshed with the live definitions.
Verification: focused lifecycle cases cover foreign functions, SETF functions, globals and methods, including discard, failure restoration, direct persistence and rendered replay. Active-image exercises verified foreign installation, discard, ownership checks, lock restoration and uninterned-target skips. Every private definition publication passed its clean-process replay probe.
Removal condition: the installed runtime includes these tracked definitions, making the private overrides redundant.

Independent page-retrieval namespace

Problem: The page-retrieval implementation and prompt used web_extra.gist, but the default registry still advertised web.gist. The prompt also contained an incomplete static namespace list.
Behavior: Register page retrieval as web_extra.gist and use the current request’s supplied tool names as the namespace authority.
Scope and location: tracked src/tools/defaults.lisp and docs/system-prompt.org; the live factory was persisted in private image commit 380c50d8-6c1d-4cf5-ae13-2dfac13f9a84, private Git 64d045c74e3450ff6617cdd6581d39860e676a43. The active registry was updated in place, retaining its runtime bindings.
Verification: live and fresh registry/schema assertions passed, a real web_extra.gist request returned the Example Domain page, and the private reconstruction passed its clean-process probe.
Removal condition: an installed build includes the corrected registration, making the private factory override redundant.

Lower-cost delegated inference

Problem: General task children and unqualified RLM calls inherited the primary model and reasoning effort, consuming the user’s subscription allowance on routine delegated work.
Behavior: Top-level RLM calls default to gpt-5.6-luna at low effort. Explicit model/effort arguments override those defaults; supplied Lisp configurations and nested runs retain their selected route. The user-level task role selects @smol at medium effort.
Scope and location: RLM routing is private image commit fc16f9e6-e071-4dcc-9360-039c7b3b1e4d, private Git commit 0ed468c50d3e825a2c52c586ee27aca47128980b. Task routing is declarative user configuration in ~/.config/autolith/agents/task.sexp; project role overrides take precedence. The other bundled roles are unchanged.
Verification: 31 routing cases passed, covering defaults, explicit routes, inherited configurations, rejected nested overrides and effective task configuration. Live inference trace y1bBiLs records gpt-5.6-luna at low effort and a successful response. The private commit passed its clean-process replay probe.
Removal condition: equivalent RLM defaults become configurable in tracked Autolith, or the user selects a different delegation policy.

GitHub workflow waiter

Problem: Waiting for GitHub Actions repeatedly required model-driven API polls, consuming turns and tokens for a simple blocking operation.
Behavior: github.wait-workflows polls Actions runs for one repository and commit through Dexador, optionally filters by workflow and event, uses GH_TOKEN or GITHUB_TOKEN when available, requires two stable completed observations, and returns one compact terminal summary. Its bounded timeout retries transport failures and explicitly transient HTTP statuses. Permanent API failures, including unauthenticated HTTP 401 and 403 responses, stop after the first request without exposing credentials.
Scope and location: private image commits 2dcb8218-a80b-4672-aa6e-b34dbeaf5086 and 823c003e-aa27-42b8-aa99-521606752548; private Git commits 6a4f8aba7233789473990582a51b6c1bae7463fe and 6225e8d8d86bb6609f13e4e01260c5ace7d6309f. The first commit also sanitizes multiline mutation targets in reconstruction-script comments.
Verification: both clean-process replays passed. Focused active-image exercises verified that HTTP 403 is non-retryable and one permanent failure produces exactly one workflow request.
Removal condition: tracked Autolith provides equivalent workflow waiting and safe multiline reconstruction comments, or GitHub workflow waits cease to be recurring work.

Persistent transient provider recovery

Problem: A transient USOCKET:NS-TRY-AGAIN-ERROR escaped retry handling when DNS failed during credential refresh or request construction, before response stream opening. The shared provider retry ladder also propagated retryable failures after the finite 1, 2, 4, 8, and 16 second waits, ending active goals and requiring manual resume operations.
Behavior: Provider transport normalization now wraps the complete logical attempt, including credential acquisition and request construction. DNS, socket, pre-response TLS syscall, and provider retryable conditions preserve the in-flight turn and retry indefinitely with exponential jitter. Delays begin near one second and cap in the 40 to 60 second range. Authentication and definitive TLS failures retain bounded or immediate failure behavior.
Scope and location: tracked project work in src/provider/client.lisp and tests/provider-tests.lisp, committed as 2dbdbad.
Verification: focused provider tests passed for successful continuation beyond the former retry bound, bounded jitter delays, cancellation during backoff, rolling retry presentation, and normalization of USOCKET:NS-TRY-AGAIN-ERROR into PROVIDER-RETRYABLE-ERROR.
Removal condition: a replacement provider recovery protocol preserves the same complete-attempt transport normalization, persistent transient retries, cancellation behavior, and capped jitter with less runtime complexity.

Lisp worker reader boundary

Problem: The worker protocol disabled *read-eval* while reading untrusted requests and accidentally kept it disabled during request execution. Standard dependency source containing #. syntax, including Colorlisp, then failed to compile through lisp.*.
Behavior: Protocol input is still read with *read-eval* disabled. Request execution uses normal Common Lisp reader semantics.
Scope and location: private image commit d5387bc4-9dd1-47a6-8788-a8cd59e7f0ce, private Git commit fbc458a9e19f894d7872d06af3f5e2c983f590b8. The durable downstream fix is lambda-symbolics/sbcl-workers commit 1f832d0, retained by the current 85bbab4 pin; Autolith first pinned it in tracked commit 536dc1f.
Verification: clean-process replay passed. A fresh pristine worker reports *read-eval* as true during request execution, and lisp.load-system successfully loads autolith.
Removal condition: a rebuilt active image loads the tracked sbcl-workers pin, making the private replay definition redundant.

Autolith Qlot worker image

Problem: The generic asdf-user-tree worker image resolved an incompatible sexp-store while loading autolith/tests, so focused tests failed before compiling the changed code.
Behavior: Start Autolith-focused workers from autolith-qlot. The image is pristine SBCL with the current checkout’s locked Qlot setup loaded and autolith.asd registered, giving project sources exact precedence.
Scope and location: saved Lisp worker image autolith-qlot, parent pristine; no active-image or tracked runtime behavior changes.
Verification: a fresh autolith-qlot worker loads autolith/tests successfully.
Removal condition: the generic worker image reliably reproduces this checkout’s Qlot source registry, or project-focused workers stop recurring.

Current-state self exercises

Problem: self.exercise required an effective pending mutation, so it could not journal final verification after self.discard restored tracked or previously committed behavior.
Behavior: An exercise still defaults to the newest effective mutation. When none is pending, it runs and journals evidence against the current active state. An explicitly named unknown mutation still fails.
Scope and location: tracked commit c0295d7 and private image commit 71bca135-ba7b-4139-b04d-a14428c105fd, private Git commit 766467d0904c22881b0194f59491b7334c9a38ef.
Verification: clean-process replay passed, the focused discard test passed, all 4,766 repository tests passed, and live self.exercise reported a pass against the current active state with no uncommitted mutations.
Removal condition: the private replay can be dropped after a rebuilt active image contains tracked commit c0295d7.

NetBSD amd64 source bootstrap

Problem: Autolith’s supported source targets were Linux x86-64 and macOS arm64. nbsd64 needs a host SBCL, BSD terminal ioctl, and two bootstrap workarounds before images will build.
Behavior: TIOCGWINSZ uses the BSD ioctl request. Building fff defines union semun for LMDB on NetBSD only. Active-image ASDF treats the SBCL CONTEXT-FLOAT-REGISTER stub warning as non-fatal. Runtime binary install remains Linux-only; set AUTOLITH_SBCL to a 2.6.6+ build.
Scope and location: tracked project work in src/terminal/stream.lisp, script/build-fff.lisp, and script/build-active.lisp. Guest install is local to nbsd64 (al@10.0.0.21, /home/al/autolith, /home/al/sbcl-2.6.6).
Verification: recovery probe returns NetBSD 10.1 x86-64 / SBCL 2.6.6. ./bin/autolith --version reports 0.32.2 from the active core.
Removal condition: SBCL implements NetBSD os_context_float_register_addr, LMDB builds without extra CFLAGS, and a NetBSD runtime path exists.

OpenBSD amd64 source bootstrap

Problem: OpenBSD 7.9 already provides union semun. The shared BSD LMDB flag redefined it and broke fff/lmdb-master-sys.
Behavior: _SEM_SEMUN_UNDEFINED is NetBSD-only. OpenBSD needs wxallowed on /home for SBCL cores, AUTOLITH_SBCL at 2.6.6, and a sha256sum wrapper around gsha256sum.
Scope and location: tracked script/build-fff.lisp. Guest install is local to obsd64 (al@10.0.0.22, /home/al/autolith, /home/al/sbcl-2.6.6).
Verification: recovery and active cores built. ./bin/autolith --version reports 0.32.2 on OpenBSD 7.9 amd64 / SBCL 2.6.6 after reboot.
Removal condition: a packaged OpenBSD runtime path exists.

Isolated sibling ASDF verification

Problem: Lisp workers start with Autolith’s Qlot source registry and loaded systems. Loading a sibling checkout’s ASDF file under the same system name can silently retain the pinned Qlot definition and produce a false-positive test result against old source.
Behavior: before claiming sibling dependency test results, launch a pristine host SBCL with CL_SOURCE_REGISTRY confined to the intended checkout and :ignore-inherited-configuration. Verify asdf:system-source-file names that checkout before running asdf:test-system; loading its ASDF file alone is not sufficient.
Scope and location: tracked project workflow note for sibling Common Lisp dependency development; no executable behavior changes.
Verification: a Lisp worker retained Qlot revision e9ad866 while Structlisp was at 66bbfbe. A pristine host process without source-registry isolation later resolved a different sibling checkout. Confining CL_SOURCE_REGISTRY to Structlisp revision 68c0322 selected its exact ASDF file and passed the complete suite.
Removal condition: sibling verification tools isolate the source registry and reject a resolved system outside the requested source root.

Modified Enter terminal compatibility

Problem: the active-turn cancellation change disabled Kitty CSI-u reporting to preserve plain Escape, leaving Alacritty unable to distinguish Shift-Enter or Ctrl-Enter from ordinary submission. Some Ctrl-Shift-V paste paths also arrive without bracketed-paste markers or a literal Ctrl-V byte, so embedded newlines were interpreted as submission. Enhanced Ctrl-D reports were ignored, while physical stream EOF was incorrectly collapsed into the Ctrl-D event.
Behavior: terminal startup enables Kitty CSI-u and xterm modifyOtherKeys. Pinned Clinedi de133d8 decodes enhanced reports for Escape, Enter, Tab, Shift-Tab, Backspace, and Ctrl-D and owns the exact bracketed-paste enable and disable controls. Autolith retains product-specific protocol lifecycle and rollback, physical EOF, literal Ctrl-V, and raw multiline burst policy. Literal and enhanced Ctrl-D produce :end-of-input; physical stream EOF remains :stream-end so modal and responsive readers cancel or exit without entering Ctrl-D-specific actions. The reader collects bounded literal Ctrl-V and raw multiline byte bursts as paste events. It coalesces each multi-character plain-text single-line burst into one insert event. Single-line bursts containing terminal controls remain buffered for normal decoding. Multiline paste classification keeps precedence over later controls so pasted text cannot submit or invoke editing commands. Partial protocol activation performs balanced best-effort cleanup. Terminal mode detection checks the input file descriptor’s POSIX TTY status before inspecting termios, so stopping and restarting the UI for line-oriented secret prompts remains interactive even when the Lisp stream wrapper reports noninteractive. During an active turn, Escape cancels and permits queued work to continue; Ctrl-C cancels and holds queued follow-ups plus unconsumed steering until explicit input resumes them, while retaining its second-press force-exit window.
Scope and location: tracked project work in src/terminal/input.lisp, src/terminal/protocol.lisp, src/terminal/stream.lisp, src/terminal/ui.lisp, src/terminal/responsive-input.lisp, src/localgroup/terminal.lisp, and src/localgroup/client.lisp.
Verification: Clinedi’s exhaustive enhanced key mapping and exact bracketed-paste control suites pass. Autolith’s representative Clinedi delegation, physical EOF, bracketed and literal Ctrl-V paste, raw string-stream and OS-pipe multiline paste, multiline control precedence, single-line paste batching, mixed buffered keys, protocol ordering and rollback, follow-up cycling, active-interrupt queue holding and resumption, descriptor-backed terminal restart, and cleanup regressions pass in focused checks. The complete repository check previously passed 3,734 tests.
Removal condition: terminals reliably bracket every paste path, so Autolith can remove its unbracketed Ctrl-V and raw-burst compatibility without losing multiline paste semantics.

Authenticated local session control

Problem: long-running Autolith processes exposed no reliable external view of session identity, strict idleness, queued work, cancellation, or live child jobs. Operators therefore could not safely inspect, message, attach to, pause, or stop another local session, and releasing a foreground terminal risked losing accepted input or conversation ownership.
Behavior: each process publishes a private authenticated loopback endpoint with strict idle-state reporting and bounded length-prefixed local control. Read-only and controlling terminal relays preserve ordered, bounded output and support observation and live take-over. Foreground detach and take-over use an atomic, supervised process handoff that preserves the localgroup identity, capability, durable conversation, permissions, and composer draft. Cancellation positively stops the replacement process group before the old process restores its conversation lease.
Scope and location: tracked project work in src/localgroup/, src/application/, src/startup/main.lisp, and the stable-launcher command dispatch in src/launcher/main.lisp.
Verification: protocol, privacy, status, command, relay, queue-admission, snapshot, lease-transfer, cancellation-interleaving, fresh-conversation, and supervised process-group regressions pass within the complete 3,227-test repository check.
Removal condition: the supported runtime gains an equivalent authenticated local process/session protocol and atomic foreground handoff with the same state, ownership, and rollback guarantees.

Revision-gated workspace, agenda, memory, and papercut resources

Problem: exact-text editing requires models to reproduce existing source, indentation, and line endings, causing avoidable retries and output token use. Independent file or agenda calls could also mutate content after inspection.
Behavior: resource.read establishes transient conversation-local observations. For workspace: files it retains an exact bounded snapshot and only lines fully shown to the model; resource.edit applies validated original-line operations, rejects unseen or stale content, serializes native filesystem mutations, preserves uniform line endings and final-newline state, and publishes through exact POSIX rename semantics so extensionless targets stay extensionless. It then re-observes the destination and reports success only when the published content is exactly the requested content, while keeping the temporary file eligible for cleanup until that postcondition passes. For agenda:current it returns the complete readable current agenda, retains an exact snapshot including empty state, and applies exactly one revision-gated add, update, or remove under the same recursive lock as legacy agenda tools. Agenda revisions address exact snapshots, so an alias is stale while content differs and valid again if the exact snapshot returns. Agenda URIs cannot resolve another workspace or the raw state file, task child agents cannot resolve them, and aliases cannot cross conversations or workspace changes. The agenda lock serializes same-process Autolith operations only and does not provide interprocess safety. memory: resources expose the relevant, workspace, and global collections plus exact active stable IDs through canonical memory:id/<percent-encoded-stable-id> URIs using existing scope rules. This namespace supports reserved collection names and arbitrary valid persisted IDs; direct item URIs remain compatible for non-reserved IDs. They return complete metadata, canonical item URIs, and excerpts or one full memory, retain exact snapshots including empty collections, deny task child agents, and never expose memories.sexp. Relevant and workspace snapshots include the canonical current workspace identity, while global snapshots remain workspace-independent. The relevant collection is read-only; workspace and global collection revisions each accept one complete create, while exact item revisions accept one complete replacement or tombstone. Every memory operation validates before persistence, rechecks the exact snapshot, attributes writes to the source conversation, and appends under the recursive process-local memory lock. This lock does not provide interprocess CAS. papercut: resources expose the active current-workspace collection and exact active reports through canonical papercut:id/<percent-encoded-stable-id> URIs. Collection observations retain compact ordered identifier snapshots and render canonical item URIs with bounded excerpts; exact observations return the complete immutable report. The current collection accepts one revision-gated report attributed to the source conversation, while exact items accept one revision-gated closure with a required complete resolution. Closed, missing, and other-workspace items are unavailable, task child agents cannot resolve the scheme, and append plus revision validation occur under the process-local papercut lock. Existing papercut.report and terminal commands, agenda.*, and memory.* tools stay available as convenience paths.
Scope and location: tracked project work in src/resource/, src/state/agendas.lisp, src/state/memories.lisp, src/state/papercuts.lisp, src/conversation/store.lisp, src/tools/defaults.lisp, and the resource schemas, prompt, guide, and regressions.
Verification: workspace URI confinement, observation isolation and expiry, visible-range gating, original-snapshot multi-operation edits, stale and protected paths, bounded UTF-8 snapshots, empty files, atomic publish failures, exact extensionless target publication without inherited temporary types, post-publication mismatch rejection and temporary cleanup, line endings, plus agenda empty and complete reads, revisions, confinement, add/update/remove, memory links, shared locking, and convenience tools pass. Memory collection scopes, exact IDs, empty and missing states, child denial, typed mixed observation retention, schemas, and existing memory tools pass within the complete 3,559-test repository check. Papercut collection and exact-item reads, canonical IDs, reporting, closure, stale revisions, conversation and workspace confinement, child denial, schemas, and existing interfaces pass in focused regressions.
Removal condition: a provider-native editing protocol supplies the same exact revision, visibility, authority, atomicity, and recovery guarantees with lower harness complexity.

Caller-selected shell runtimes and resilient output decoding

Problem: long deployment commands were silently capped at ten minutes even when the user requested more time, while arbitrary generated-file bytes in command output could raise a UTF-8 decoding error and discard the exit status.
Behavior: shell.run keeps its 60-second default but accepts any positive requested timeout without a product maximum. The sandbox still enforces the selected deadline and bounded output. Invalid encoded bytes are replaced at the command-sandbox boundary so status and surrounding diagnostics survive.
Scope and location: tracked project work in src/tools/workspace.lisp, the pinned cl-exec-sandbox integration, the shell schema, specification, guide, and workspace-tool regressions.
Verification: a requested 900-second timeout is retained, invalid UTF-8 shell output completes with replacement characters and its exit status, truncation remains bounded, and the complete 3,567-test repository check passes.
Removal condition: the command sandbox dependency natively captures bounded arbitrary-byte output with replacement decoding and exposes caller-selected deadlines without an Autolith compatibility layer.

Unlimited default child runtimes

Problem: child agents were terminated after a fixed 30-minute wall-clock cap, discarding their live context and often leaving useful repository work without a terminal handoff.
Behavior: task jobs have no runtime deadline by default. A positive AUTOLITH_TASK_MAX_RUNTIME_MS remains an operator opt-in to the existing shared deadline monitor. User, parent, descendant, shutdown, and active-turn cancellation continue to interrupt live work, while progress and terminal retention remain bounded.
Scope and location: tracked project work in src/task/state.lisp, task runtime tests, the specification, and the guide.
Verification: the default orchestrator has no deadline or monitor, a positive 1,000-millisecond override still aborts a real stalled tool call with one durable terminal result, and the complete repository check passes.
Removal condition: child providers support reliable resumable handoff at arbitrary forced deadlines without losing in-progress context or work.

Bounded child activity traces

Problem: during long programming tasks, child agents could remain on one tool such as lisp.eval for minutes while the one-line live strip exposed only that tool name. Operators could not distinguish active work from a stuck child, especially when the primary model was waiting for a blocking child.
Behavior: task progress retains eight completed tool milestones and the active tool’s elapsed duration. Detached children show the newest three milestones on their compact row, with older activity collapsed to an ellipsis. Blocking children are explicitly labelled and receive an indented row with up to six milestones plus the assignment when the terminal-height budget permits. Running blockers receive expansion priority, short terminals preserve a useful primary row and overflow summary, and only tool activity is shown, never hidden reasoning. The projection remains ephemeral and outside conversation history.
Scope and location: tracked project work in src/task/state.lisp, src/task/runtime.lisp, src/task/scheduler.lisp, src/terminal/ui.lisp, task, terminal, and application presentation tests, the specification, and the guide.
Verification: chronological ordering, eight-item retention, active-tool timing, injected clock isolation, sanitization, compact and expanded trace limits, blocking priority, short-terminal row budgets, overflow, animation, and terminal cleanup pass in focused checks. The complete repository check passes 3,841 tests.
Removal condition: a replacement task inspector provides equally immediate, bounded, viewport-aware child progress and blocking visibility without exposing hidden reasoning or adding durable transcript state.

Actionable public Nix smoke annotations

Problem: unauthenticated GitHub Actions logs were unavailable, and generic check annotations hid the persistent macOS first-run failure.
Behavior: the Nix smoke step emits bounded stderr, stdout, exit status, and specific missing-artifact or missing-marker failures as check annotations.
Scope and location: tracked project work in .github/workflows/nix.yml.
Verification: run 30700246262 exposed the Darwin terminal-mode failure and its complete first-run phase output through the public annotations API.
Removal condition: authenticated logs become reliably available or the Nix smoke path gains equivalent structured diagnostics elsewhere.

Bounded release-host container builds

Problem: repository checks inside release-builder containers repeatedly stopped producing output and remained alive indefinitely. The v0.23.2 container was still blocked in script/check.lisp after 40 minutes, preventing both v0.23.2 and v0.23.3 archive publication even though the updater and server had already activated v0.23.2.
Behavior: each managed release container has a unique name and a generous 30-minute deadline. Failure or timeout prints bounded process and log diagnostics, then force-removes the complete container before the polling loop retries. The deadline is configurable with AUTOLITH_RELEASE_CONTAINER_TIMEOUT_SECONDS.
Scope and location: tracked project work in server/release-builder.lisp and release-server regressions.
Verification: timeout command construction, managed naming, structured failure, diagnostics, and forced cleanup pass within the complete 3,251-test repository check. The stuck v0.23.2 container was manually stopped before deployment.
Removal condition: the release build moves to an execution boundary with native bounded runtime, complete descendant cleanup, and equivalent diagnostics.

Extracted runtime library boundaries

Problem: Autolith carried duplicate implementations for compact identifiers, restricted native configuration parsing, retained generations, child-job scheduling, named SBCL worker validation, and macOS command-policy translation.
Behavior: pinned idsmall, sexp-config, sbcl-generations, sbcl-workers, cl-jobpond, and cl-exec-sandbox now own those reusable mechanics. Autolith retains its product-specific migration, validation, provenance, atomic state, authority, cancellation, and output policies. Pinned sexp-config 408fa90 handles standard keyword-to-string reader boundaries directly; sbcl-workers 85bbab4 owns the shared worker-name predicate, prompt request cancellation, the reader-evaluation boundary between protocol input and request execution, and exact ASDF definition selection for loads and tests; sbcl-generations e65e27e owns the live-thread snapshot preflight, with hosts retaining exclusion across that check and fork; and cl-jobpond ee2e2eb owns atomic four-limit pool policy publication, immediate worker and monitor capacity refresh, and the locked default-runtime admission boundary. No pool-policy compatibility adapter remains in Autolith. Dependency lock materialization, exact Nix builds, and release builds validate the three pin surfaces; Autolith carries no dependency metadata shape tests.
Scope and location: tracked project work in src/conversation/, src/mcp/, src/skills/, src/state/generations.lisp, src/task/, src/tools/workspace.lisp, src/workers/lisp.lisp, dependency locks, Nix packaging, architecture documentation, and behavioral regressions.
Verification: cl-jobpond passes 408 assertions. Focused hurry-up admission, delayed-close refresh, asynchronous execution, and task scheduler tests pass. Exact Nix package builds, bootstrap image rebuilds, version and recovery probes, and final reviews validate the integrated dependency set.

Crash-safe recovery input vaults

Problem: accepted follow-ups, commands, and steering could exist only in the active controller when its Lisp image crashed. Recovery could then load a durable pending snapshot into executable queues, and active Ctrl-C allowed preserved queued work to resume as soon as cancellation completed.
Behavior: active Ctrl-C now holds queued follow-ups and unconsumed steering until explicit new input resumes them. Pending snapshots preserve active work, in-flight steering, stable identities, recovery provenance, and a durable steering-order prefix. Recovery imports pending input idempotently into a conversation-scoped vault before controller creation, starts with pending loading disabled, keeps crash diagnosis first, and never submits recovered input automatically. Startup warns while captures or storage failures remain. (vault) shows bounded chronological previews, (vault-restore) transactionally prepends captures in their exact active, restored-prefix, in-flight steering, queued steering, and remaining-work order, and (vault-discard) deletes only attributed current-conversation state. Corrupt bytes remain unchanged and ordinary ingress is blocked while persistence is unsafe; unattributed corrupt process-global legacy state remains preserved and ignored.
Scope and location: tracked project work in src/agent/runtime.lisp, src/application/runtime.lisp, src/conversation/store.lisp, src/terminal/responsive-input.lisp, src/configuration/settings.lisp, src/application/recovery-input-vault.lisp, src/startup/main.lisp, ASDF wiring, regressions, README, guide, and specification. The implementation commits are b9a63f0, 0c7a1e0, 4ec8398, feca0f2, 9d083c0, 7b482ee, and 34c9dc4.
Verification: vault import, legacy isolation, corruption preservation, unattributed legacy handling, ordered restore, active restored-work crashes, both rollback paths, scoped discard, disabled ordinary and recalled ingress, recovery and ordinary startup, pending persistence, steering promotion, quiescence, active interruption, command scheduling, diagnosis ordering and tool surface, resume guidance, and responsive model input pass one per fresh SBCL process under a 60-second timeout. Relevant parenthesis checks and git diff --check pass. The complete repository check was intentionally not run for this focused task.
Removal condition: a replacement input controller provides equivalent conversation-scoped atomic persistence, explicit crash recovery, exact ordering, corruption preservation, and transactional restore without this vault layer.

Async-first delegation and inspectable execution jobs

Problem: task.run made independent work block unless each caller opted into asynchronous execution. Long shell.run and Lisp execution calls also held the provider tool turn until completion, preventing useful concurrent work and inspectable cancellation; retrying after an apparent stall risked duplicate side effects.
Behavior: every non-blocking child role now detaches by default and blocking: true is the explicit wait policy; the inverse async argument remains a compatibility input. Authorized shell commands and execution-oriented Lisp calls are admitted to one shared session job runtime exactly once. async: true hands off immediately. An ordinary call waits for a reloadable ten-second grace and returns normally when already complete, otherwise it hands off the same live job without rerunning it. job.list, job.wait, and job.cancel expose bounded state and terminal results; zero-second waits inspect. Shell cancellation terminates and reaps the external process. Lisp cancellation stops the selected named worker; its next request restarts from the same base image and a clean protocol stream.
Scope and location: tracked project work in src/task/, src/tools/registry.lisp, src/tools/workspace.lisp, src/workers/lisp.lisp, src/workers/scratchpad.lisp, src/tools/defaults.lisp, the prompt, guide, dependency locks, Nix pins, and task, shell, and Lisp regressions. The pinned command sandbox fix is cl-exec-sandbox revision 0a5c7a2.
Verification: default and explicit blocking delegation, compatibility argument conflicts, mixed batches, exact job identities, session visibility, retention, fast results, grace-period handoff, exactly-once side effects, synchronous shell authorization, bounded captured policy, shell process cancellation, named REPL affinity, Lisp cancellation and restart, system loading, and scratchpad loading pass. The command sandbox passes 65 tests, and the complete Autolith repository check passes 3,835 tests.
Removal condition: a replacement execution protocol natively provides the same asynchronous default, explicit blocking, exactly-once handoff, session-scoped inspection, bounded retention, cancellation cleanup, and worker restart guarantees with less project-specific scheduling code.

Lisp-family delimiter checking

Problem: successful text edits could leave Common Lisp, Scheme, or Clojure source with unmatched or type-mismatched structural delimiters, while the model received only a success result. The repository’s separate copied Rust checker duplicated a weaker parenthesis-only implementation and was unavailable through the normal tool and canonical Lisp operation surfaces.
Behavior: successful workspace: and scratchpad: file resource.edit operations classify the resulting file by extension and run a language-aware lexical delimiter scan. Strings, supported comments, escaped symbols, character literals, script headers, and reader-specific escapes avoid structural false positives. The scan counts every issue while retaining bounded exact-location details, appends an advisory warning to the successful model-visible result, and never rolls back the edit. lisp.paren-check applies the same scanner explicitly to one file or a recursive directory tree with deterministic discovery, fixed canonical read authority, descriptor-bound repeated directory classification, repeated file snapshots, input and traversal budgets, bounded diagnostics, and failed results for issues, changes, or incomplete checks.
Scope and location: the generic scanner, bounded edit-warning composition, safe recursive checker, and 72 regression assertions live in the COLL-Attribution Parenchek library pinned at revision a7dc0a7. Autolith retains one shared resource-file edit integration, imports two public functions, and provides a 36-line tool adapter in src/tools/lisp-paren-check.lisp with exact ASDF, Qlot, and Nix pins. 451-line scanner, 854-line checker implementation, 647-line specialized test file, three test-entry calls, and the remaining dedicated registry assertion were removed.
Verification: Parenchek’s complete check passes 72 assertions. A fresh forced Autolith test-system load passes, and registry smoke covers balanced and broken explicit checks, Common Lisp, Scheme, and Clojure fs.write warnings, and a Clojure scratchpad warning. Workspace tools, workspace-file resources, and scratchpad tools pass focused checks. The exact Nix Autolith package builds with Parenchek. Autolith source falls by 1,266 lines, tests fall by 653 lines, and 48 local test-assert forms disappear. The complete repository check was intentionally not run under the release-only full-check policy.
Removal condition: a replacement dependency provides equivalent language-aware post-edit advice and explicit bounded tree checking with exact diagnostics, workspace authority, and honest incomplete-scan failures using less integration code.

Lisp-first unified interaction

Problem: chat messages, slash commands, local Lisp, and model tools were separate terminal languages. Startup tips exposed compatibility slash syntax, commands received fixed invocation objects instead of ordinary Lisp arguments, and local conditions had no integrated restart selector. Direct local side effects also disappeared from later model context because they correctly bypassed ordinary provider message history. Safe local work waited unnecessarily during active turns, activity rows appeared above the animated modeline, and terminal scrollback had no semantic prompt boundaries.
Behavior: parenthesized input is direct active-image Lisp with a red * prompt, ColorLisp draft highlighting, multiline reading, printed output, multiple values, conditions, and a styled selector for live restarts. Commands and tools project through one canonical Lisp operation surface with restricted completion and slash compatibility hints; startup tips render canonical Lisp calls. Callable commands declare ordinary Common Lisp lambda lists and explicit slash argument mappings. Noninteractive calls preserve ordinary arity errors, while interactive calls can supply replacement arguments through the restart debugger or abort safely to the prompt. Provider calls show parenthesized tool names above aligned keyword-labeled argument tables, followed directly by highlighted source rails. File changes number removed and added rows whenever exact original and resulting coordinates are known.
Explicit Lisp and resolved registered interactive commands attempt to append durable outcome records with bounded source and result fields outside ordinary provider history. Successful records reappear as untrusted request-local evidence on every normal provider request until count or character eviction, and never enter compaction side requests. Nested command calls inside one explicit Lisp form do not duplicate evidence. If an append fails, no record or later evidence exists. A completed Lisp result is presented before that attempt so the persistence failure cannot hide already-applied side effects.

Active-turn policy runs nonconflicting local operations immediately, keeps modal, authorized, or serialized work at safe boundaries, and provides (eval-now FORM) as a local-only scheduling override. The live region keeps the animated status row above local, child, provider, notice, queued, and prompt rows. Interactive terminals emit exactly one OSC 133 A=/=B=/=C=/=D;STATUS block per foreground interaction and none for repaint or internal work. Generic marker construction and exact sequence coverage live in pinned Clinedi f7c158e; Autolith retains interaction lifecycle, terminal gating, write, flush, and ordering policy.
Scope and location: tracked project work in src/application/command.lisp, src/application/commands.lisp, src/application/operation.lisp, src/application/lisp-machine.lisp, src/application/user-operation-context.lisp, src/conversation/store.lisp, src/terminal/protocol.lisp, src/terminal/syntax-highlighting.lisp, src/terminal/ui.lisp, src/terminal/responsive-input.lisp, src/startup/main.lisp, provider and tool presentation, focused regressions, the guide, architecture, and specification. Implementation commits are 2cb9e51 through 1910b1a.
Verification: direct evaluation, canonical startup tips, operation discovery and dispatch, ordinary noninteractive arity, interactive argument recovery, styled restart selection and abort, transcript equivalence, active-turn admission, live-row ordering, Clinedi marker construction, Autolith marker lifecycle and reader ordering, file-change numbering, and provider call rendering pass focused tests. User-operation persistence, forward-compatible replay, malformed and circular rejection, count and character eviction, request bounds, compaction exclusion, successful, aborted, failed, quit, responsive, conversation-switching, nested-suppression, and retention-failure paths also pass focused tests. Source and test delimiter checks and git diff --check pass. Reviews of the final capture slice found no findings. The complete repository check was intentionally not run. A known unrelated repeated Shift-Tab test race remains outside this adaptation.
Removal condition: a replacement interaction model provides the same direct Lisp semantics, ordinary callable command protocol, integrated restart debugger, bounded local-operation continuity, honest transcript, concurrent admission policy, ordered live presentation, and semantic prompt boundaries with less project-specific code.

Unified mutation change viewer

Problem: file mutations had numbered colored source changes, while agenda and memory mutations fell back to unrelated field or operation renderings. The divergent paths made equivalent state changes harder to scan and risked using current live state when a revision-gated resource call referred to an older exact observation.
Behavior: file, agenda, and memory mutation calls now use one bounded line change viewer whenever an exact semantic projection is available. Its single keyword-only API receives complete removed and added content, optional source coordinates, classification-only pathname metadata or an explicit syntax language, an explicit highlighting switch, and a line bound. It never reads the pathname, and mutation-domain projection remains outside the renderer. Removed rows are red with preimage line numbers, added rows are green with resulting line numbers, and retained context is dim. Recognized file content keeps ColorLisp syntax highlighting. Agenda items project stable status, text, and memory-ids documents; memories project stable title, scope, tags, and content documents. Revision-gated agenda and memory previews use only the retained observation matching both URI and revision. Invalid operation shapes, missing snapshots, and unavailable exact state fall back to structured semantic fields rather than displaying a speculative diff.
Scope and location: generic endpoint comparison, bounded numbered rows, semantic highlighting, and terminal-safe ANSI output live in pinned Colordiff revision 9294574. Autolith keeps only its terminal-span adapter, source preview, mutation-domain projection, exact-preimage lookup, and fallback policy in src/terminal/syntax-highlighting.lisp, src/application/change-viewer.lisp, src/application/change-presentation.lisp, and src/application/tool-presentation.lisp.
Verification: Colordiff’s 23 tests pass. Fresh-SBCL focused Autolith tests pass 43 assertions covering numbered and syntax-highlighted file changes, live Lisp highlighting, native and revision-gated agenda and memory changes, exact observed preimages, and structured fallback. The Nix Autolith package builds with the pinned library, git diff --check passes, and independent review found no defects. The extraction removes 247 Autolith source lines, 74 test lines, and five test-assert forms. The complete repository check was intentionally not run because this is not a release.
Removal condition: a replacement mutation-presentation dependency provides the same exact preimage discipline, stable semantic documents, numbered colored context, applicable syntax highlighting, bounded output, terminal safety, and honest structured fallback with less project-specific code.

Shared terminal Markdown renderer

Problem: Autolith carried a reusable line-oriented terminal Markdown parser, streaming renderer, semantic span model, table layout, syntax-highlighted code blocks, and their dedicated tests inside the application repository. This duplicated shelf-level behavior and made application tests own parser details.
Behavior: Markdown parsing and rendering now come from the COLL-Attribution cl-termdown library pinned at revision 340579a. Autolith uses the qualified renderer type, constructor, and incremental line, partial-line, and inline entry points. Termdown’s keyword-and-text semantic spans are directly compatible with the existing terminal style pipeline. Autolith retains transcript-width selection, input sanitization, stream orchestration, and application presentation policy.
Scope and location: exact ASDF, Qlot lock, and Nix pins select the library; src/terminal/markdown.lisp and tests/markdown-tests.lisp are removed. The generic terminal-row text helper now lives in tests/test-support.lisp. No Markdown rendering assertion remains in Autolith.
Verification: cl-termdown’s isolated check passes 62 assertions. Autolith bootstrap materializes the exact revision and rebuilds both installed images. Fresh focused terminal and application suites pass 379 and 775 assertions, respectively; the complete repository check passes 4,372 tests; and the exact Nix package builds with cl-termdown. The integration removes 578 net Autolith source lines, 331 net test lines, and 63 dynamically executed assertions.
Removal condition: a replacement terminal renderer provides equivalent bounded incremental Markdown behavior, semantic spans, code highlighting, tables, terminal-width correctness, and isolated tests with less dependency or adapter cost.

Callable PROMPT and child response promotion

Problem: the Lisp-first operation surface had no canonical way to submit exact computed text or image attachments to the primary agent, add context to an already running named child, or guarantee that ordinary terminal prose used the same operation. A child received its assignment only at admission, and its later verbal response remained in private task state rather than appearing where the user asked for the additional work.
Behavior: ordinary terminal prose and (prompt CONTENT) both invoke the canonical prompt operation. (prompt CONTENT) is exactly (prompt :to 'autolith CONTENT), while (prompt (read-file PATH)) supports exact computed UTF-8 prompts. :images accepts one local image pathname or a proper list, validates every image, adds matching [Image #N] labels, and preserves rich image input through primary admission or child steering. The case-insensitive target autolith is reserved exclusively for the primary. Every other (prompt :to TARGET CONTENT) resolves one child visible to the primary session by unique case-insensitive display name before visible job ID, accepts only a running job, and never spawns or revives one. Accepted child prompts enter a bounded FIFO steering mailbox and reserve one FIFO response-promotion token each. Tool calls, reasoning, blank assistant output, and failed persistence leave tokens pending. The first later durable nonblank verbal response consumes the oldest token exactly once and appears in the primary window below an unconditional timestamped ● autolith [child-name] YYYY-MM-DD HH:MM header. The child name uses xterm-256 color 78 with a green fallback. Exact listener identity and a single presentation transaction exclude stale reconnect events. Promotion does not append a primary conversation record or expose hidden reasoning.
Scope and location: tracked project work in src/application/operation.lisp, src/terminal/responsive-input.lisp, src/task/state.lisp, src/task/runtime.lisp, src/task/child.lisp, src/agent/runtime.lisp, src/application/runtime.lisp, src/terminal/style.lisp, focused agent, task, operation, application, recovery-vault, and terminal regressions, and the guide. Original implementation commits are 94bb2a2, 6aface1, abc34ed, 67dc694, 535b164, and 044e77c; current tracked source supersedes the original :to autolith child-routing rule.
Verification: fresh-SBCL focused tests cover primary routing, the explicit autolith alias, computed file prompts, validated primary and child images, circular image-list rejection, terminal prose delegation to canonical prompt with and without steering, visible-name and job-ID child resolution, rejection paths, FIFO steering, durable recovery ordering, observer ordering, blank and nonverbal exclusion, bounded and concurrent exact-once token consumption, terminal cleanup, canonical response presentation, stale and replaced listeners, overlapping reconnects, terminal color fallback, and application replacement and unwind safety. Source delimiter scans, git diff --check, and the full 4,341-test repository check pass. Final review of the unified implementation found no remaining defects.
Removal condition: a replacement local prompting and child-steering protocol provides the same exact primary admission, named running-child resolution, bounded FIFO delivery, durable one-response promotion, stale-listener safety, and history-neutral primary presentation with less project-specific code.

Candidates

Record only concrete improvements with evidence of recurring value. Remove discarded or obsolete candidates.

FilesExpand file tree

AUTOLITH.org

Latest commit

History