@timurproko/a1 0.2.7-dev.1245 → 0.2.7-dev.1252

package/docs/ci-release-runbook.md

@@ -103,6 +103,8 @@ The real three-release `update-predecessor` scenario is exhaustive because its f
 
 Development outcomes report each owner/scope invocation separately while sharing authenticated build/package preparation. The aggregate reports setup, scope, job, aggregate-processing, total runner, and runner-critical-path durations. The acceptance targets are at most eight minutes of runner critical path and five minutes for one PR-required scope; an over-target result remains unmet without retries, timeout increases, workload reduction, or mutable installation caches. Hosted queue time is reported separately when available and is not counted as test execution.
 
+Candidate-packing Development lanes build the pure-JavaScript product once per lane with `npm run build` and record the build receipt; there is no native artifact to build, cache, restore, or certify.
+
 Inspect local committed and worktree impact without running tests:
 
 ```sh
@@ -125,7 +127,7 @@ Rendering evidence captures each selected producer/mode/workload matrix once and
 
 ## Resource-sensitive fast validation
 
-The authoritative fast-tier declaration identifies tests that repeatedly create temporary repositories, launch child processes, mutate storage, or coordinate release cohorts. The planner removes those files from the parallel remainder and runs them exactly once in one serial `vitest-fast-resource-sensitive` process with file parallelism disabled, on an isolated runner that no other partition shares. One process instead of one per file removes about twenty cold starts from the partition; each file still gets a fresh module context. Pull-request, development-package, and complete release plans use the same partition on every platform.
+The authoritative fast-tier declaration identifies tests that repeatedly create temporary repositories, launch child processes, or mutate release and update state. The planner removes those files from the parallel remainder and runs them exactly once in one serial `vitest-fast-resource-sensitive` process with file parallelism disabled, on an isolated runner that no other partition shares. One process instead of one per file removes about twenty cold starts from the partition; each file still gets a fresh module context. Pull-request, development-package, and complete release plans use the same partition on every platform.
 
 The partition runs under an explicit `--testTimeout=30000`, the same hang bound the other explicit fast-tier invocations use. That bound is a hang detector, not a performance gate: shared Windows runners vary by a factor of two or more for identical work, and a fixed five-second wall-clock limit failed passing suites on runner noise. Per-test durations remain in the reporter evidence; `scripts/release/report-resource-sensitive-validation.mjs` records repeated executions and lists every test body above five seconds under `slowTests` so a real slowdown is visible without failing the pull request. A failure is still not retried or converted to success, and the bound is not raised to create margin.
 
@@ -152,7 +154,7 @@ For applicable code changes, it requires the dedicated Defender-enabled exact-pa
 | Windows Node 22 | Required for applicable changes | Not scheduled | Retained | Retained |
 | Windows Node 24 | Not scheduled | Retained | Retained | Retained |
 
-Each selected startup lane runs the package-install scenarios once: a failed budget remains failed and is never retried to obtain a warmed result. The budgets are the ones the `a1-shell` capability declares (2 seconds after an update and on a warm launch, 2.5 seconds with no live supervisor); development validation, development previews, nightly publication, and Full regression record an overrun as a warning and are judged by the three-run persistent-overrun verdict, while stable candidate validation fails on it (see `STARTUP_BUDGET_ENFORCEMENT` in [validation](validation.md)). The publication lane set comes from `scripts/release/publication-validation-matrix.mjs`: a numbered preview validates on the Windows, Linux, and macOS Node 24 lanes, and nightly covers the same head on Windows Node 22 within a day. Node 24 runtime support, other PR jobs, Defender, and publication gates are unchanged. Full validation retains every deferred startup, image, and history test through its existing suite owners.
+Each selected startup lane runs the package-install scenarios once: a failed budget remains failed and is never retried to obtain a warmed result. The budgets are the ones the `a1-shell` capability declares (2 seconds after an update and on a warm launch, 2.5 seconds on a restart-equivalent launch); development validation, development previews, nightly publication, and Full regression record an overrun as a warning and are judged by the three-run persistent-overrun verdict, while stable candidate validation fails on it (see `STARTUP_BUDGET_ENFORCEMENT` in [validation](validation.md)). The publication lane set comes from `scripts/release/publication-validation-matrix.mjs`: a numbered preview validates on the Windows, Linux, and macOS Node 24 lanes, and nightly covers the same head on Windows Node 22 within a day. Node 24 runtime support, other PR jobs, Defender, and publication gates are unchanged. Full validation retains every deferred startup, image, and history test through its existing suite owners.
 
 The trade-off is delayed detection: a Node-24-specific regression can reach `develop` before nightly catches it, and the same is true for a real published-predecessor regression. A green bounded PR check does not certify Node 24 or real historical predecessor execution, and nightly failure still blocks its publication. For an unselected candidate or diagnosis, explicitly request the non-publishing standalone Full regression workflow for the desired branch or tag:
 
@@ -331,10 +333,10 @@ extra-path, wrong-body, or ambiguous work is refused. An existing reopening bran
 without that exact PR is preserved rather than overwritten. The local preparation
 checkout is never committed, reset, or used to publish package bytes.
 
-Candidate validation builds the process guardian on all supported platforms, stamps
+Candidate validation builds the product, stamps
 the version, packs each package once, runs the complete stable suite against those
 bytes on Windows, Linux, and macOS, and retains the pair for 30 days as
-`release-package-<version>`. Stable publication skips the guardian builds and
+`release-package-<version>`. Stable publication skips the build and
 validation lanes, adopts that retained pair, publishes both to npm `latest` with
 provenance from the `npm-publish` environment, and exercises the exact published
 installer/application pair in isolated prefixes on every release lane. Only after

package/docs/features/launch-profiles.md

@@ -4,17 +4,13 @@
 
 | Command | Purpose | Pi user profile |
 |---|---|---|
-| `a1` | A1 | `~/.a1/agent` |
+| `a1` | A1, one agent in this terminal | `~/.a1/agent` |
 | `a1 --session <path\|id>` | Resume a persisted A1 session | `~/.a1/agent` (or explicitly selected storage) |
-| `a1 solo` | Fresh A1 direct single-agent mode | `~/.a1/agent` |
-| `a1 solo --session <path\|id>` | Resume a persisted A1 session in direct single-agent mode | `~/.a1/agent` (or explicitly selected storage) |
 | `a1 pi` | Pi-compatible direct comparison surface using the ordinary Pi profile | ordinary `~/.pi/agent` |
 
-`a1 solo` is available in release and prerelease builds. Without arguments it starts a fresh single-agent session; with `--session` and optional `--session-dir` it resumes a saved session. Both forms omit the tab strip and the Tabs settings section.
-
 `a1 pi` is a development instrument for comparing A1 against pinned Pi. Prerelease builds — what `a1 update --develop` or `a1 update --develop <number>` installs — expose it. A release build does not recognize the launch form. Repository development can run the comparison directly with `npm start:pi`.
 
-There is no `a1 agent` command. The former `a1 ui` subcommand is removed. Unsupported commands return quietly without selecting another runtime. Bare `a1` is the normal A1 product surface.
+There is no `a1 agent` command. The former `a1 ui` subcommand, the `a1 solo` launch word, and the `a1 tabs …` maintenance commands are removed; like any other unsupported command they return quietly without selecting another runtime. Bare `a1` is the normal A1 product surface.
 
 ## First launch
 
@@ -37,20 +33,18 @@ Run Pi’s normal `/login` independently in each profile that needs stored authe
 
 ## Resume a session
 
-After a conversation has been persisted, exit A1 and run the command it prints from the original project directory. Exited solo sessions print the solo form; tabbed A1 sessions keep the tabbed form:
+After a conversation has been persisted, exit A1 and run the command it prints from the original project directory:
 
 ```sh
 a1 --session <id>
 a1 --session-dir '/path/to/session store' --session <id>
-a1 solo --session <id>
-a1 solo --session-dir '/path/to/session store' --session <id>
 ```
 
 `--session` also accepts a `.jsonl` file path; `--session-dir` may come before or after it. Explicit storage overrides `PI_CODING_AGENT_SESSION_DIR`, which overrides default storage. IDs are searched in the current project before other projects within the A1 store. A cross-project ID match asks before creating a fork with a new identity; an explicit file resumes directly using its stored working directory. Missing or invalid targets fail rather than create an empty replacement.
 
-Resume uses the shipped Pi's public restoration behavior, including the compaction format it writes. It sends no model prompt by itself and does not recover, convert, or modify an unrelated conversation. A tabbed selection opens in a new A1 tab or focuses the tab already holding it; a solo selection opens in the direct strip-free UI without starting the resident host. A live session remains protected by its single-writer lease. Pi picker/continue CLI aliases and `a1 pi --session` are not supported; in-UI `/resume` is unchanged.
+Resume uses the shipped Pi's public restoration behavior, including the compaction format it writes. It sends no model prompt by itself and does not recover, convert, or modify an unrelated conversation. A session already open in another A1 process stays protected by the session writer guard, so A1 offers a fork instead of attaching to it. Pi picker/continue CLI aliases and `a1 pi --session` are not supported; in-UI `/resume` is unchanged.
 
-Regression evidence creates disposable sessions through Pi 0.84.2, then executes the emitted command through the packed public entry, bootstrap, guardian, and owned UI. Default/custom storage, Windows Git Bash quoting, supervisor restart, failure cleanup, and simultaneous distinct selections are covered in `test/foundation/release/session-resume.integration.test.ts`. CI runs it in the resource-sensitive `package-smoke` scope, not the fast remainder. Unsupported synthetic retained-tail certification is separate deferred work.
+Regression evidence creates disposable sessions through the pinned Pi, then executes the emitted command through the packed public entry, bootstrap, and owned UI. Default/custom storage, Windows Git Bash quoting, an occupied session, failure cleanup, and simultaneous distinct selections are covered in `test/foundation/release/session-resume.integration.test.ts`. CI runs it in the resource-sensitive `package-smoke` scope, not the fast remainder. Unsupported synthetic retained-tail certification is separate deferred work.
 
 ## Pi comparison profile
 
@@ -58,14 +52,14 @@ Regression evidence creates disposable sessions through Pi 0.84.2, then executes
 
 ## Terminal behavior
 
-All interactive launch forms run the A1-owned full-viewport TUI over pinned Pi engine, component, and terminal APIs. Bare `a1` attaches to the native resident host; each tab runs the owned UI in a holder-owned pseudoterminal, while Node never relays or renders terminal bytes. `a1 solo` uses the direct owned path without resident infrastructure. `a1 pi` uses that same direct pipeline with A1-specific screens withheld.
+All interactive launch forms run the A1-owned full-viewport TUI over pinned Pi engine, component, and terminal APIs. The installed `a1` command selects the approved active release and runs its UI as one directly attached child process with the terminal inherited; nothing relays or renders terminal bytes in between. `a1 pi` uses that same pipeline with A1-specific screens withheld.
 
-## Concurrent instance lifecycle
+## Concurrent launches
 
-Each `a1 solo` or `a1 pi` invocation receives a unique non-detachable launch instance. Normal A1 clients instead attach to the profile's tab set, which can be viewed from concurrent terminals with explicit input-controller transfer. Profile files remain shared according to the selected profile root.
+Every `a1` or `a1 pi` invocation is an independent process. Any number can run at once in different terminals; profile files remain shared according to the selected profile root, and the session writer guard keeps each session file to one writer.
 
-Normal exit or terminal closure tears down a solo/comparison launch instance within bounded graceful and forced deadlines. Closing or detaching a normal A1 client leaves its tabs running; a tab and its process tree stop only when the user explicitly closes that tab.
+Quitting with `/quit` or `Ctrl+C` twice ends the agent and returns to the shell. Closing the terminal ends the agent too, as it does for upstream Pi. If the UI exits uncleanly, the launcher restores the terminal and prints the resume command.
 
-## Recovery and comparison
+## Comparison and reporting
 
-If A1's normal mode cannot start, bare `a1` falls back to the direct path with one notice. To start single agent mode explicitly, run `a1 solo` from the same working directory. To compare against the pinned Pi profile, run `a1 pi`; its profile data is intentionally separate, so authentication or settings may need independent configuration. Use `a1 --version` to record the installed A1 release before reporting a difference.
+To compare against the pinned Pi profile, run `a1 pi`; its profile data is intentionally separate, so authentication or settings may need independent configuration. Use `a1 --version` to record the installed A1 release before reporting a difference.

package/docs/features/prompt-history.md

@@ -44,11 +44,11 @@ imported automatically.
 The default uses A1's effective profile home: `A1_PROFILE_HOME` when set, otherwise
 the operating-system home. A custom agent-profile directory changes the history
 identity, not this default root. `A1_DATA_DIR` takes precedence for storage;
-`XDG_DATA_HOME` does not redirect default history. Control metadata, settings,
+`XDG_DATA_HOME` does not redirect default history. Release state, settings,
 agent resources, releases, logs, runtime files, and caches keep their existing
 locations. For repository-local `./scripts/dev` launches, history uses a stable
-checkout-wide data root so two independent solo instances share the selected
-Shared database, while control and runtime data remain isolated per launch.
+checkout-wide data root so two independent instances share the selected
+Shared database, while release and runtime data remain isolated per launch.
 The development-only `A1_DEV_HISTORY_DATA_DIR` selects that root; an explicit
 `A1_DATA_DIR` still overrides its launcher default. Existing histories in old
 per-instance development roots are not moved or combined.
@@ -62,14 +62,14 @@ Old and new releases using different roots do not synchronize history.
 In Shared mode the filename is the original `a1-` SHA-256 profile identity,
 independent of project, session, checkout, and release. In Unique mode (the
 default), a domain-separated digest also includes the stable conversation session
-ID; two solo launches or resident tabs therefore use different databases and
+ID; two concurrent launches therefore use different databases and
 image sidecars. Resuming the same session reuses its store; starting or forking a
 session selects a different one. Windows ordinary case and separator variants
 normalize together. Moving a profile, unresolved symlink aliases, or selecting a
 different data root can select a different history; A1 never silently merges or
 imports it.
 
-The database is separate from `control.sqlite3`, agent resources, and disposable
+The database is separate from release state, agent resources, and disposable
 caches. Upgrades, ordinary npm uninstall/reinstall, release rollback, cache cleanup,
 and conversation deletion do not clear it. Reusing saved history requires the
 same profile and history root; explicitly deleting user data still removes it.
@@ -91,9 +91,9 @@ The History section in `/settings` provides:
   storage and durable recall for subsequent launches, not current-session
   recovery. Existing enabled instances keep running until closed.
 - **History scope:** Unique (default) keeps each agent session's durable prompts
-  separate across solo launches and resident tabs. Shared restores the former
-  profile-wide store. Switching applies to running agents, including other solo
-  processes and resident tabs, when their shared settings update arrives. New
+  separate across concurrent launches. Shared restores the former
+  profile-wide store. Switching applies to running agents, including other A1
+  processes, when their shared settings update arrives. New
   prompts use the newly selected store; already-submitted writes finish in their
   original store. Switching never transfers or deletes records, and it preserves
   unsent drafts. Existing profiles without this setting default to Unique, so
@@ -145,9 +145,8 @@ Build the checkout, then launch it through `./scripts/dev`. Use an isolated
 `A1_DATA_DIR` for disposable history checks; keep that same directory on each
 restart and in both concurrent terminals. The development launcher always sets
 an isolated `A1_DATA_DIR`; to try the home-based location in that launcher,
-explicitly select `A1_DATA_DIR=<effective-home>/.a1/data` and keep
-`A1_DATABASE_PATH` in a separate disposable directory so control metadata is not
-placed beside history. For a history-only review, `NODE_DISABLE_COMPILE_CACHE=1`
+explicitly select `A1_DATA_DIR=<effective-home>/.a1/data` in a disposable
+profile home. For a history-only review, `NODE_DISABLE_COMPILE_CACHE=1`
 also avoids creating compile-cache files under that explicitly overridden root.
 The focused path/composition tests cover normal no-override selection. Test:
 

package/docs/local-worktree-cleanup.md

@@ -99,6 +99,32 @@ node scripts/governance/local-worktree-cleanup.mjs discard \
 
 An open, merged, reopened, forked, protected, reserved, advanced, dirty, active, linked, nested, replaced, current, or unverifiable candidate remains blocking. Remote deletion followed by a Windows lock or later local blocker is reported as `partial`; the journal preserves the remaining worktree/local ref for the same exact confirmed command to inspect and resume. The command never scans by age or name, adopts another session's checkout, enables queue/watch, or turns PR close events into automatic discard authority.
 
+### Closed-unmerged branch without a checkout
+
+Use the same explicitly confirmed `discard` operation with `--branch` instead of `--path` when the checkout is already gone and no live cleanup registration owns the ref. The selectors are mutually exclusive:
+
+```bash
+cd /d/Git/a1 && node scripts/governance/local-worktree-cleanup.mjs discard --repo D:/Git/a1 --branch feature/rejected-example --change rejected-example --pr 123 --confirm-closed-unmerged
+```
+
+Branch mode verifies the named same-repository PR is still closed-unmerged into `develop`, its implementation association matches the requested change, no other open PR uses the branch, no Git worktree has it checked out, and no nonterminal registration owns the ref. Protected/reserved refs, advanced local or remote tips, malformed evidence, conflicting journals, and scoped lock contention block. It never creates a checkout, invents a filesystem identity, deletes a directory, or adopts a worktree.
+
+A branch-scoped `branch-discard-<ref-digest>.json` journal beside the ordinary cleanup state pins the repository, exact ref, change, PR, expected head, and deletion step without changing existing worktree records. After local preflight, the command journals intent, revalidates live evidence, expected-head deletes only the remote ref, verifies remote absence, and compare-and-deletes the unchanged local ref. Absent refs support resumption. Repeated completed requests report `already-discarded` only while both refs remain absent; a recreated ref is retained as `discard-ref-recreated`. Command reports, not the worktree-only registration list, describe this branch-scoped state. Sweep and queue never invoke branch-only discard.
+
+## Explicit disposable-link remediation
+
+Ordinary completion and sweep still refuse external descendant links. For one released, eligible merged candidate, a separately confirmed `unlink-disposable-link` operation can remove one explicitly named ignored descendant link beneath a central disposable root without admitting its external target into purge:
+
+```bash
+cd /d/Git/a1 && node scripts/governance/local-worktree-cleanup.mjs unlink-disposable-link --repo D:/Git/a1 --path D:/Git/a1/.worktrees/example-task --change example-task --pr 123 --link .artifacts/agent/shared-node-modules --confirm-link-only
+```
+
+The command requires the existing released registration, exact candidate/change/PR, accepted HEAD ancestry, eligible merged/archive evidence, absent remote topic ref, and clean local content except for that one named link. Invoke it from primary, with no known conflicting editor, using integrated repository policy. Owned, current, replaced, dirty, ineligible, unregistered, or resource-busy candidates remain blocked. Other unsafe links remain blockers; no wildcard or bulk-link option exists.
+
+Only a relative slash-separated path strictly below a central disposable root is accepted. The path must be ignored and untracked, its parents must be real non-link directories inside the canonical worktree, and its final entry must be a resolvable symlink or junction with a target outside that worktree. Internally targeted links remain on the ordinary generated-content path and are rejected by this no-target-enumeration operation. Escapes, root substitutions, ordinary files/directories, cycles, Git-metadata targets, identity/target/parent drift, and locked links block. The command revalidates candidate authority, full local content, ancestor identities, link fingerprint, and target before every bounded non-recursive unlink attempt, including Windows junction fallback. It never enumerates, traverses, modifies, or removes the target.
+
+An `unlinked` report records the candidate and removed link identity without target contents. The worktree and its released registration remain intact; a later ordinary `complete` or sweep must independently repeat every normal gate. The operation enables nothing, deletes no ref, does not grant ongoing link-removal authority, and cannot repair locked leftover directories. A missing selected link reports a named blocker rather than fabricating prior success.
+
 ## Explicit redundant no-PR retirement
 
 A non-empty unregistered checkout is never adopted by sweep, preview, queue/watch, branch pruning, age, or ancestry. After the maintainer explicitly authorizes one exact redundant checkout, use the repository-owned operation from the primary checkout:
@@ -170,7 +196,7 @@ Registration binds the repository, exact directory/filesystem identity, candidat
 
 A CI/base/older-ancestor checkout does not qualify automatically. Version 3 has no local acceptance/archive checkout to register. No local archive checkout is required when a legacy archive was generated entirely on GitHub. Legacy version-1/version-2 linkage remains supported, but individually reviewing and registering a legacy checkout is explicit adoption, not a bulk sweep.
 
-Low-level `register` keeps an explicit disposable allowlist for legacy and diagnostic use. The standard `complete` command supplies the central repository policy automatically; agents do not choose flags for normal completed-delivery cleanup. Neither route permits discarding tracked, staged, unstaged, untracked, unknown ignored, unapproved linked, special, or actual nested repository/submodule content. The sole link exception is the guarded exact-root or contained descendant behavior above. Declaring or centrally recognizing a generated directory does not bypass ignored-path, identity, type, or traversal checks.
+Low-level `register` keeps an explicit disposable allowlist for legacy and diagnostic use. The standard `complete` command supplies the central repository policy automatically; agents do not choose flags for normal completed-delivery cleanup. Neither route permits discarding tracked, staged, unstaged, untracked, unknown ignored, unapproved linked, special, or actual nested repository/submodule content. Automatic purge admits only the guarded exact-root or contained descendant behavior above. Separately confirmed named-link remediation removes only its exact link entry and never widens purge authority. Declaring or centrally recognizing a generated directory does not bypass ignored-path, identity, type, or traversal checks.
 
 Before handing a completed checkout to cleanup, stop its development processes, leave its directory, and release it using the returned ID and current generation:
 
@@ -184,6 +210,10 @@ After a low-level release, request a pass from the stable checkout if queue clea
 
 ## Resume or recover ownership
 
+This protocol works for external agents without an A1 installation, runtime, or session link. First verify the exact delivery branch, change, and PR plus continuing editing ownership or explicit handoff under the [worktree protocol](architecture/project-structure.md#development-worktrees). Inspect Git locks and this tool's `status` from the primary checkout. A familiar path, clean status, or missing A1 runtime is not evidence of another editor's absence. Known live editing claims, foreign cleanup ownership, Git locks, and unverifiable handoffs block reuse.
+
+For a worktree with no cleanup registration, this tool supplies no ownership claim: a fresh checkout created by this session or verified continuing ownership/explicit handoff establishes editing provenance. Do not register with fabricated PR identities or create a cleanup claim solely to simulate an A1 link. For a released registration, the atomic claim below is mandatory before editing; an already-owned registration requires matching owner authority. A failed claim never authorizes recovery or takeover. A successful cleanup claim prevents cleanup but does not prove exclusive editing ownership, and an A1 runtime link does not claim the cleanup journal. Both remain cooperative, independent safeguards.
+
 Before resuming a released worktree, acquire it:
 
 ```bash
@@ -210,6 +240,7 @@ State, journals, stop controls, and execution reports live in `<git-common-dir>/
 - `blocked`: ownership, content, path, provenance, authentication, or identity needs attention.
 - `unmanaged`: no local registration; no automatic adoption. Reason `empty-directory-recent` marks an all-empty folder still inside its ten-minute grace, and in preview `empty-directory` marks one an execution pass would remove.
 - `removed`: worktree and eligible local-ref operations were verified.
+- `unlinked`: only the explicitly named disposable link entry was removed; its target, worktree, and released registration were preserved.
 - `already-absent`: a completed journal's path/ref are still absent.
 - `retired`: either evidence was unverifiable but nothing remained to delete and the merged PR registration completed with `retired-nothing-left`, or an exact confirmed `retire-redundant` operation safely removed its no-PR checkout and local ref.
 - `forgotten`: the maintainer explicitly closed an all-absent entry with `forget`.

package/docs/manual-owned-ui-checkpoint.md

@@ -22,7 +22,6 @@ $manualRoot = (Resolve-Path ".artifacts/manual-owned-ui").Path
 $env:A1_CONFIG_DIR = "$manualRoot\state\config"
 $env:A1_DATA_DIR = "$manualRoot\state\data"
 $env:A1_RUNTIME_DIR = "$manualRoot\state\runtime"
-$env:A1_DATABASE_PATH = "$manualRoot\state\data\control.sqlite3"
 ```
 
 Run each installed launch form yourself:

package/docs/openspec-archive-automation.md

@@ -6,6 +6,14 @@ Unrelated standalone documentation remains separate: a non-draft unassociated PR
 
 Version-1 and version-2 deliveries and their existing comments, acceptance PRs, archive PRs, receipts, retries, and bounded catch-up remain supported under [Legacy delivery](#legacy-delivery). Do not silently convert an in-flight legacy delivery.
 
+## Worktree context across agent environments
+
+External agents use ordinary Git worktrees without an A1 installation, runtime, or session link. Follow the [development worktree protocol](architecture/project-structure.md#development-worktrees): keep primary on `develop`, run the cleanup sweep, inspect Git inventory, and verify the exact task root, common repository, branch, and state before edits. A fresh worktree created by the session establishes its provenance. An existing delivery needs continuing ownership or explicit handoff plus the exact branch, change, and PR; inventory and a clean checkout alone grant nothing.
+
+Use A1 inventory/linking only inside an active A1 shell-tool session, and Claude Code's established worktree hooks in that environment. Missing A1 integration alone does not block an external agent. A known live owner, Git lock, conflicting cleanup owner, or unverifiable handoff still blocks reuse. Claim any released cleanup registration through the [cleanup ownership protocol](local-worktree-cleanup.md#resume-or-recover-ownership) before editing. Neither a runtime link nor a cleanup claim proves the absence of arbitrary external editors; coordination remains cooperative.
+
+Repeat context and ownership verification on resume or stream changes, preserve the delivery's branch/history/PR, and keep every command explicitly scoped to its worktree. Handoffs name the absolute worktree path, branch, change, PR, and whether editing ownership is being handed over. An editing handoff does not register, release, or authorize cleanup and grants no integration authority. The lifecycle below applies equally to all agent environments.
+
 ## Version-3 lifecycle
 
 1. **Draft plan:** create one normally named branch/PR such as `feature/...`, `fix/...`, or `chore/...`. Start the body with `## Proposal`, use it for one or two sentences of intent, and follow it with one or more unchecked, outcome-sized task items under `## Implementation`, with no fixed maximum. Each item names a delivered code outcome. Omit generic process tasks; run, verify, validate, evidence, or manual-test items; quoted phase lines; and routine validation command lists, and keep machine linkage under final collapsed `Automation`. Keep it draft and include only planning artifacts until the maintainer approves the plan and explicitly requests implementation.
@@ -94,11 +102,11 @@ Keep acceptance absent during proposal review so unfinished intent is not mistak
 
 ## Agent scratch files
 
-When an agent chooses a path for a transient repository-delivery file—such as a PR/comment body, command payload, captured output, temporary patch/diff, or ad hoc log—it must use a purpose-specific descendant of the exact `.artifacts/` root in the worktree that owns the operation. A linked delivery uses its linked task worktree, not the primary checkout, another worktree, the operating-system temporary directory, home/desktop, or a sibling path. Address the worktree path explicitly because session linking does not change tool cwd.
+When an agent chooses a path for a transient repository-delivery file—such as a PR/comment body, command payload, captured output, temporary patch/diff, or ad hoc log—it must use a purpose-specific descendant of the exact `.artifacts/` root in the worktree that owns the operation. Use the verified task worktree, not the primary checkout, another worktree, the operating-system temporary directory, home/desktop, or a sibling path. Address the worktree path explicitly; context verification and optional runtime association do not change tool cwd.
 
 Keep these files ignored, unstaged, uncommitted, disposable, non-authoritative, and free of credentials or other prohibited sensitive data. Required durable evidence belongs in its declared tracked OpenSpec location. This rule governs paths selected by the agent; it does not relocate temporary storage internally selected by Git, GitHub CLI, OpenSpec, language/package tooling, product runtime code, test frameworks, or hermetic fixtures.
 
-For example, create `.artifacts/agent/pr-body.md` in the linked worktree before passing it to `gh pr create --body-file` or `gh pr edit --body-file`. The exact `.artifacts/` root remains subject to the existing guarded generated-content cleanup policy; this guidance does not authorize deletion outside that root or through unsafe filesystem boundaries.
+For example, create `.artifacts/agent/pr-body.md` in the verified task worktree before passing it to `gh pr create --body-file` or `gh pr edit --body-file`. The exact `.artifacts/` root remains subject to the existing guarded generated-content cleanup policy; this guidance does not authorize deletion outside that root or through unsafe filesystem boundaries.
 
 ## Version-3 implementation metadata
 
@@ -190,7 +198,7 @@ If an unassociated implementation has already integrated, do not edit its merged
 
 ## Finalization command
 
-The local command remains available for inspection or when a developer prefers to finalize before the automatic ready transition; the workflow then verifies the head and pushes nothing. It has inspection mode by default and an explicit `--write` mode. It never commits, pushes, edits GitHub, marks a PR ready, or merges. Run from the linked worktree and use an ignored artifact body file so the operation can update exact version-3 paths without mutating remote PR state:
+The local command remains available for inspection or when a developer prefers to finalize before the automatic ready transition; the workflow then verifies the head and pushes nothing. It has inspection mode by default and an explicit `--write` mode. It never commits, pushes, edits GitHub, marks a PR ready, or merges. Run from the verified task worktree and use an ignored artifact body file so the operation can update exact version-3 paths without mutating remote PR state:
 
 ```bash
 git fetch origin develop

package/docs/validation.md

@@ -6,7 +6,7 @@ Development validation computes one exact base/head selection with:
 npm run select:validation-impact -- --base <full-base-sha> --head <full-head-sha> --output .artifacts/validation/impact.json
 ```
 
-The versioned `config/validation-ownership.json` registry maps stable product and test path groups to a mandatory PR core, an explicit critical floor per owner, changed and bounded transitive consumers, resource-sensitive tests, and integration owners. The coarse owners are UI/rendering, launch/startup, release/package/update, Pi, native containment, image/history, governance, and shared product inputs. Each integration owner in `config/integration-owners.json` declares `pull-request`, `direct-impact`, or `exhaustive` cadence. A changed pull-request test selects its owner; a changed exhaustive test selects focused deterministic contracts and records the exhaustive owner as cadence-deferred. Shared support selects every declared PR consumer and records affected exhaustive consumers; copies, renames, and deletions inspect both identities. Reasons and changed paths are recorded in `impact.json`.
+The versioned `config/validation-ownership.json` registry maps stable product and test path groups to a mandatory PR core, an explicit critical floor per owner, changed and bounded transitive consumers, resource-sensitive tests, and integration owners. The coarse owners are UI/rendering, launch/startup, release/package/update, Pi, image/history, governance, and shared product inputs. Each integration owner in `config/integration-owners.json` declares `pull-request`, `direct-impact`, or `exhaustive` cadence. A changed pull-request test selects its owner; a changed exhaustive test selects focused deterministic contracts and records the exhaustive owner as cadence-deferred. Shared support selects every declared PR consumer and records affected exhaustive consumers; copies, renames, and deletions inspect both identities. Reasons and changed paths are recorded in `impact.json`.
 
 Reviewed `refinements` can narrow a coarse owner's tests and integration links for known subareas: scrollbar/settings, clipboard/editor/repository commands, documentation/cleanup/delivery governance, and development-environment tooling. Each rule keeps an explicit minimum test set; a bounded relative-import graph across `test/`, `src/`, `scripts/`, and `bin/` adds at most 24 sorted transitive consumers per changed path, including consumers outside the coarse owner, and integration owners of those retained consumers. The graph is supplemental, not sole coverage authority. Unreviewed or absent source identities and an unavailable graph retain the coarse owner. Changed tests, shared support, and mixed source/support changes retain their coarse contracts; rename and deletion classification still includes both identities. Some UI changes deliberately select more tests than before because the graph exposes formerly missed shell consumers.
 
@@ -40,7 +40,7 @@ Do not run preflight, `test:fast`, `test:full`, `test:release`, or directory-wid
 npm run preflight                  # pull-request validation's fast gates on the committed head
 ```
 
-Preflight selects the committed merge-base diff with `origin/develop` exactly as validation does (uncommitted paths are reported, not checked), writes it to `.artifacts/validation/local-impact.json`, and stops at the first failure. It runs the core job's install build and receipt, `typecheck`, `check:architecture`, changed-file code documentation, release documentation, changed-file naming, docs governance, strict OpenSpec validation with the workflow's pinned validator, the delivery-guidance test, and the core job's `pr-core-tests` and `pr-selected-tests` scopes. Each step invokes the script and arguments its workflow job runs, so a failure reports the same rule identifier and path. It never builds the native host, does not run resource-sensitive or integration owners, and CI remains the authority.
+Preflight selects the committed merge-base diff with `origin/develop` exactly as validation does (uncommitted paths are reported, not checked), writes it to `.artifacts/validation/local-impact.json`, and stops at the first failure. It runs the core job's install build and receipt, `typecheck`, `check:architecture`, changed-file code documentation, release documentation, changed-file naming, docs governance, strict OpenSpec validation with the workflow's pinned validator, the delivery-guidance test, and the core job's `pr-core-tests` and `pr-selected-tests` scopes. Each step invokes the script and arguments its workflow job runs, so a failure reports the same rule identifier and path. It does not run resource-sensitive or integration owners, and CI remains the authority.
 
 `test:pr-core` is not a replacement for `test:fast`: CI combines it with directly changed and coarse-owner tests from the exact impact selection. Selected resource-sensitive tests run independently on an isolated Windows runner. Selected package, startup, rendering, Pi, compatibility, and platform owners also run independently after their actual prerequisites.
 
@@ -50,11 +50,7 @@ Conservative Development retains every critical owner floor and the small set of
 node scripts/release/generate-validation-ownership-ledger.mjs --output .artifacts/validation/ownership-ledger.json
 ```
 
-Containment-selected modular jobs build and test the debug `process-guardian.node` addon for their exact platform, export `A1_PROCESS_GUARDIAN_PATH` to that file, and run the launch-owner integration fixtures as Node processes. The tests exercise the real addon-held Windows job or Unix process group, addon-backed identity and terminal operations, and the Node exit watcher; no fixture invokes a process-guardian executable. The Windows startup lane keeps Defender real-time protection enabled while packaged startup loads the release addon.
-
-The `terminal-host` owner is CI-only. A change under `native/terminal-host/` or to its run scripts selects, per platform (Windows x64, Linux x64, macOS arm64), one **Native terminal host** job and three **Native terminal host tests** partition jobs. The partition jobs each build the test profile and run one third of the serialized `role_integration` suite (`run-terminal-host-probe.mjs --partition <i>/3`, partitioned by sorted test name read from the suite's source); the feature-gated `role-host` binary stands in only for the fixed role grammar inside Rust integration tests and is never packaged. The build-and-probe job runs `npm run test:terminal-host` with the role suite skipped (`TERMINAL_HOST_PARTITION=none`), building `terminal-host.node` with Rust, Node-API 9, and Zig 0.15.2 for the lane's exact target and baseline CPU model. It loads the addon for its version and non-interactive probes, verifies the shared session-writer lock export, and uploads the debug addon and frozen protocol manifest; Linux also runs bounded decoder fuzzing.
-
-The protected aggregate requires every partition of every selected platform, keyed by `partition` in the outcome authority and job envelope. Because the role suite no longer warms the resident launch paths in the build-and-probe job, its certification step runs one unmeasured `measure-resident-tabs.mjs` pass before the measured pass whose budgets are unchanged. Fidelity, latency, chaos, and certification start roles as `process.execPath dist/foundation/resident-tabs/host-entry.js` with `A1_TERMINAL_HOST_PATH` naming the addon. Windows cleanup identifies those Node-hosted residents by command line; it never kills every `node.exe` by image name. Locally, `npm run test:terminal-host` without a partition is unchanged and runs everything in one process. Local Windows builds fail in `build.rs` unless `TERMINAL_HOST_LOCAL_BUILD=1` is set, because Zig's package fetch unpacks test data that workstation antivirus quarantines. Native lanes also publish the terminal library they linked; a local build can link it instead of running Zig (see Local native iteration in [`architecture/resident-tabs.md`](architecture/resident-tabs.md)), which is development evidence only and never replaces selected CI. `TERMINAL_HOST_CONTRACTS_ONLY=1` is a library-only diagnostic and cannot substitute for selected CI. See [`native/terminal-host/README.md`](../native/terminal-host/README.md).
+The repository has no native code, so no validation lane builds, caches, or certifies a native artifact; every lane builds the TypeScript product with `npm run build` and tests it as JavaScript. The Windows startup lane keeps Defender real-time protection enabled while it measures packaged startup.
 
 ## Coverage-preserving efficiency
 
@@ -94,7 +90,7 @@ For GitHub's explicit **re-run failed jobs** action, a successful job that GitHu
 
 Checkout-bound type, architecture, governance, unit, and smoke outcomes bind head/run/selection/scope authority without inventing package identity. Build and package receipts remain mandatory wherever validation consumes emitted or packed bytes: package, startup, update, compatibility, preview, release, and publication boundaries.
 
-A build receipt binds checkout head, complete build inputs, toolchain, emitted files, and native artifacts. A package receipt additionally binds exact tarball bytes, packed entries, manifest/bin identity, producer, and verified build/source authority. `VALIDATION_BUILD_READY` and `VALIDATION_CANDIDATE_TARBALL` only locate prerequisites; stale or tampered receipts cause fresh preparation or failure.
+A build receipt binds checkout head, complete build inputs, toolchain, and emitted files. A package receipt additionally binds exact tarball bytes, packed entries, manifest/bin identity, producer, and verified build/source authority. `VALIDATION_BUILD_READY` and `VALIDATION_CANDIDATE_TARBALL` only locate prerequisites; stale or tampered receipts cause fresh preparation or failure.
 
 Npm download bytes may be reused with integrity checks and `--prefer-offline`, with normal network fallback. Every installation prefix remains fresh. Installed package trees, dependency certification, startup/profile state, mutable fixture repositories, passing outcomes, and publication evidence are never restored from caches.
 
@@ -141,7 +137,7 @@ Download these artifacts from the exact workflow run:
 - `development-validation-impact`: base/head, global selection identity, PR-core tests, selected pull-request owners, cadence-deferred exhaustive owners, exclusions, and bounded reasons.
 - `development-validation-outcome-<job>-<platform>-node<node>-attempt-<attempt>`: attempt-qualified outcome, content-free envelope, per-scope authority and duration, and applicable exact-artifact evidence.
 - `development-validation-aggregate-<head>-<run>-<attempt>`: selected/deferred owners, accepted/reused attempts, evidence count, runner critical path, total runner time, aggregate processing, setup/gate/scope time, cache state, and invocation count.
-- `pr-full-regression-selection-<run>-<attempt>` plus `complete-regression-aggregate-<run>-<attempt>`: current PR/head/base/metadata selection identity and all four exact-run native lane envelopes. Missing, mismatched, stale, failed, cancelled, or unexpected skip evidence blocks the protected aggregate. It reports the eight-minute critical-path and five-minute individual-scope targets as met or unmet; hosted queue delay is not test execution and remains separate.
+- `pr-full-regression-selection-<run>-<attempt>` plus `complete-regression-aggregate-<run>-<attempt>`: current PR/head/base/metadata selection identity and all four exact-run platform lane envelopes. Missing, mismatched, stale, failed, cancelled, or unexpected skip evidence blocks the protected aggregate. It reports the eight-minute critical-path and five-minute individual-scope targets as met or unmet; hosted queue delay is not test execution and remains separate.
 - startup/resume phase JSONL and performance JSON: first-attempt launch evidence and retained failed setup/readiness records.
 
 For selected implementation candidates, record focused and pre-finalization full observations before finalization. Keep final head/run/selection identity in Actions and handoff rather than adding a post-success commit that invalidates that evidence. A successful selected PR run replaces an additional mandatory dispatch; standalone runs remain diagnostic, and numbered-package nightly recovery remains independent.

package/docs/worktree-link-recovery.md

@@ -4,9 +4,9 @@ A1 coordinates worktree-claim mutations separately from the editing claims thems
 
 ## Automatic recovery
 
-Updated A1 holds an OS lock on the persistent `session-worktree-claims/mutation.authority` file. The OS releases it when the process exits, including a crash. `mutation.lock` is now a persistent directory that blocks older file-lock writers; its `owner.json` is only diagnostic metadata.
+Updated A1 holds a `proper-lockfile` gate, the `mutation.authority.gate` lock directory beside the persistent `session-worktree-claims/mutation.authority` file, for each mutation. The holder refreshes it while working; a gate left by a crashed or stalled process becomes stale after 10 seconds and the next mutation reclaims it. `mutation.lock` is a persistent directory that blocks older file-lock writers; its `owner.json` is only diagnostic metadata.
 
-The next mutation safely recovers abandoned owner/pending metadata after taking native authority. Empty, truncated, NUL-filled, or otherwise malformed metadata does not prevent this recovery. One bounded `recovery.json` records the recovery reason/time, not the original bytes or session contents. A live native holder remains protected. Acquisition waits at most two seconds by default and honors cancellation.
+The next mutation safely recovers abandoned owner/pending metadata after taking the gate. Empty, truncated, NUL-filled, or otherwise malformed metadata does not prevent this recovery. One bounded `recovery.json` records the recovery reason/time, not the original bytes or session contents. A live gate holder remains protected. Acquisition waits at most two seconds by default and honors cancellation.
 
 If startup registration fails temporarily, the running session retries on its 30-second refresh interval. Slow attempts are coalesced rather than queued indefinitely. Once registration succeeds, retry the explicit worktree link in the same session. Switching an agent's session replaces its publication identity, and disposal drains publication before releasing claims.
 
@@ -18,19 +18,19 @@ An existing regular-file `mutation.lock` belongs to the old protocol. Updated A1
 
 For this one-time legacy case, stop all older A1 processes normally, move only that exact regular lock file to a backup while they are stopped, then start updated A1. Keep sessions, runtime records, associations, editing claims, Git locks, and worktrees. Reinstalling/downgrading alone does not clear persisted legacy state. Never move the new directory or delete `mutation.authority` while A1 is running.
 
-When the old gate is absent, updated A1 initializes its compatibility barrier automatically. Older versions cannot mutate worktree claims after this point: all participating sessions must use the updated version. This intentionally prevents two incompatible mutation protocols from running concurrently. The installed native addon must support the new gate; there is no unsafe PID-file fallback if the addon is missing or outdated.
+When the old gate is absent, updated A1 initializes its compatibility barrier automatically. Older versions cannot mutate worktree claims after this point: all participating sessions must use the updated version. This intentionally prevents two incompatible mutation protocols from running concurrently.
 
 ## Diagnostics
 
 | Code | Meaning / next step |
 | --- | --- |
-| `worktree-claim-busy` | A mutation still holds native authority. Retry the link shortly; runtime registration retries automatically. |
+| `worktree-claim-busy` | A mutation still holds the gate. Retry the link shortly; runtime registration retries automatically. |
 | `worktree-legacy-recovery-required` | Retained old-format gate. Use the stopped-process legacy procedure above. |
-| `worktree-coordination-unavailable` | Missing or outdated native support. Repair/update the A1 installation. |
+| `worktree-coordination-unavailable` | The installation cannot coordinate worktree claims. Repair/update the A1 installation. |
 | `worktree-coordination-io` | Gate/metadata filesystem access failed. Check permissions and storage availability. |
 | `worktree-coordination-boundary` | Unexpected file type, link, or entry. Retain it for inspection; do not clear the store. |
 | `session-runtime-unavailable` | Runtime registration has not succeeded. Retry after the next refresh and address any specific coordination failure. |
-| `process-inspection-unavailable` / `session-runtime-unverifiable` | Exact process identity cannot be checked. Repair inspection support; no ownership takeover is authorized. |
+| `session-runtime-unverifiable` | The runtime's recorded process cannot be checked. Retry; no ownership takeover is authorized. |
 | `worktree-active-in-another-session` | Another live agent owns the target. Use a different worktree or have that owner release it. |
 | `worktree-owner-unverifiable` | The editing claim itself is uncertain. Gate recovery cannot make that claim available. |
 

package/package.json

@@ -1,16 +1,12 @@
 {
   "name": "@timurproko/a1",
-  "version": "0.2.7-dev.1245",
-  "description": "Standalone terminal workspace for supervised native and managed agents",
+  "version": "0.2.7-dev.1252",
+  "description": "Standalone single-agent terminal UI on pinned Pi",
   "type": "module",
   "privateLaunchContract": "neutral-launch-v1",
   "updateActivationContracts": [
     "activate-v1"
   ],
-  "residentControlContracts": [
-    "resident-control-v1",
-    "resident-workspace-v1"
-  ],
   "updateCommandContracts": [
     "update-release-v1"
   ],
@@ -32,12 +28,10 @@
     "clean": "node scripts/clean.mjs",
     "build": "node scripts/development/run-build.mjs",
     "build:core": "node scripts/development/run-build.mjs --core",
-    "build:managed": "npm run clean && tsc -p tsconfig.build.json && node scripts/release/generate-release-notes-resource.mjs && node scripts/pi/build-pi-settings-metadata.mjs && node scripts/pi/build-startup-public.mjs && node scripts/development/build-process-guardian.mjs",
-    "build:process-guardian": "node scripts/development/build-process-guardian.mjs",
-    "build:terminal-host": "node scripts/development/build-terminal-host.mjs",
+    "build:managed": "npm run clean && tsc -p tsconfig.build.json && node scripts/release/generate-release-notes-resource.mjs && node scripts/pi/build-pi-settings-metadata.mjs && node scripts/pi/build-startup-public.mjs",
     "typecheck": "tsgo -p tsconfig.json --noEmit && tsgo -p tsconfig.bin.json",
-    "check:local": "npm run typecheck && npm run check:architecture && npm run check:names && vitest run test/repository-governance/native-ci-workflows.test.ts",
-    "check:architecture": "node scripts/governance/check-architecture.mjs && node scripts/governance/check-session-writer-guard.mjs && node scripts/governance/check-product-identity-boundaries.mjs && node scripts/governance/check-package-identity.mjs && node scripts/governance/check-pinned-pi-source-ledger.mjs && node scripts/governance/check-terminal-host-provenance.mjs",
+    "check:local": "npm run typecheck && npm run check:architecture && npm run check:names",
+    "check:architecture": "node scripts/governance/check-architecture.mjs && node scripts/governance/check-session-writer-guard.mjs && node scripts/governance/check-product-identity-boundaries.mjs && node scripts/governance/check-package-identity.mjs && node scripts/governance/check-pinned-pi-source-ledger.mjs",
     "preflight": "node scripts/development/run-preflight.mjs",
     "check:names": "node scripts/governance/product-identifier-policy.mjs --check",
     "check:names:changed": "node scripts/governance/product-identifier-policy.mjs --check --selection .artifacts/validation/impact.json",
@@ -60,9 +54,6 @@
     "test:scope": "node scripts/release/run-validation-tier.mjs",
     "test:full": "node scripts/release/run-validation-tier.mjs full-release",
     "test:release": "node scripts/release/run-release-gates.mjs",
-    "test:terminal-host": "node scripts/development/run-terminal-host-probe.mjs",
-    "test:resident-parallel-progress": "node scripts/development/verify-resident-parallel-progress.mjs",
-    "test:resident-chaos": "node scripts/development/run-resident-chaos.mjs --build",
     "test:pi-engine-conformance": "vitest run test/integrations/pi/engine/conformance.test.ts test/integrations/pi/engine/runtime-integration.test.ts test/integrations/pi/engine/session-integration.test.ts",
     "report:pi-engine-conformance": "npm run build --silent && node scripts/pi/run-pi-engine-conformance.mjs",
     "report:rendering-stability": "tsx scripts/pi/report-rendering-stability.ts",
@@ -70,8 +61,6 @@
     "sync:pi-ui": "npm run update:pi-component-parity && npm run update:pi-event-frame-parity",
     "update:pi-component-parity": "tsx scripts/pi/update-pi-component-parity.ts",
     "update:pi-event-frame-parity": "tsx scripts/pi/update-pi-event-frame-parity.ts",
-    "proof:terminal-host": "node scripts/development/run-terminal-host.mjs",
-    "proof:terminal-host:ci": "node scripts/development/certify-ci-terminal-host.mjs",
     "start": "npm run build && node scripts/development/dev-launch.mjs",
     "start:pi": "npm run build && node scripts/development/dev-launch.mjs pi",
     "prepack": "node scripts/release/validate-packaged-release-note.mjs && node scripts/release/prepack-gate.mjs",
@@ -110,7 +99,6 @@
     "cli",
     "tui",
     "terminal",
-    "multiplexer",
     "agents"
   ],
   "author": "Timur Prokopiev",
@@ -126,7 +114,7 @@
     "@mariozechner/clipboard": "^0.3.9"
   },
   "publication": {
-    "source": "fc4a2588e22b6d90034465d80d7923c8fede91d8",
-    "pullRequest": 870
+    "source": "9f0307c00ea0b83cfd4aea196543ddb7738fc6ee",
+    "pullRequest": 878
   }
 }

package/bin/guardian.js

@@ -1,42 +0,0 @@
-#!/usr/bin/env node
-
-const startup = await import("../dist/foundation/startup/startup-runtime.js");
-startup.enableEnvironmentCompileCache(process.env);
-await startup.markStartupPhase(process.env, "guardian-start");
-const { resolve } = await import("node:path");
-const { parseSessionSelection } = await import("../dist/foundation/lifecycle/session-selection.js");
-const { runLaunchGuardian } = await import("../dist/foundation/launch-guardian/main.js");
-
-const { readLaunchContext } = await import("../dist/foundation/launch-context/index.js");
-const launchContext = readLaunchContext(process.env, "release");
-const releaseRoot = launchContext.releaseRoot;
-const profileId = readLaunchContext(process.env, "profile").launchProfile;
-// Invariant: the "release" and "profile" requirements above already refused an environment without
-// these values; the checks give the type checker the same certainty.
-if (releaseRoot === undefined || profileId === undefined) throw new Error("A1 launch context is incomplete");
-
-const sessionSelection = parseSessionSelection(process.argv.slice(2));
-const rootCommand = launchContext.residentRootExecutable === undefined ? undefined : {
-  executable: launchContext.residentRootExecutable,
-  arguments: JSON.parse(launchContext.residentRootArguments ?? "[]"),
-};
-Promise.resolve().then(() => runLaunchGuardian({
-  ...(sessionSelection === undefined ? {} : { sessionSelection }),
-  ...(rootCommand === undefined ? {} : { rootCommand }),
-  profileId,
-  releaseRoot,
-  uiEntry: resolve(releaseRoot, "bin", "ui.js"),
-  environment: process.env,
-  cwd: process.cwd(),
-})).then(
-  code => { process.exitCode = code; },
-  error => {
-    if (error instanceof Error && "code" in error && error.code === "release-superseded" && typeof process.send === "function") {
-      process.send({ type: "a1-release-reselection" });
-      process.exitCode = 1;
-      return;
-    }
-    console.error(error instanceof Error ? error.message : String(error));
-    process.exitCode = 1;
-  },
-);

package/bin/supervisor.js

@@ -1,7 +0,0 @@
-#!/usr/bin/env node
-import { runSupervisor } from "../dist/foundation/supervision/index.js";
-
-runSupervisor(process.argv.slice(2)).catch(error => {
-  console.error(error instanceof Error ? error.stack ?? error.message : String(error));
-  process.exitCode = 1;
-});

package/bin/tab-launch-context.d.ts

@@ -1,27 +0,0 @@
-export interface TabLaunchCredentials {
-  readonly tabId: string;
-  readonly token: string;
-  readonly endpoint: string;
-  readonly releaseId?: string;
-}
-
-export function formatResidentFallbackNotice(reason: string): string;
-
-export function assignFreshSessionRuntimeId(
-  environment: Record<string, string | undefined>,
-  name: string,
-  createId: () => string,
-): string;
-
-export function waitForStandbyPromotion(input: NodeJS.ReadStream, promotionFile?: string): Promise<void>;
-
-export function consumeTabLaunchContext(
-  arguments_: readonly string[],
-  environment: Record<string, string | undefined>,
-): {
-  readonly uiArguments: string[];
-  readonly tabCredentials: TabLaunchCredentials | undefined;
-  readonly tabDataDir?: string;
-  readonly tabIncarnation?: number;
-  readonly tabStandby: boolean;
-};