axstack 0.49.1 → 0.50.1

package/skills/axstack/references/routing.md

@@ -12,8 +12,7 @@ or use an explicit user selection in the run record. The legacy manifest
 manifest value does not create a contradiction. Missing or contradictory installed
 preset / explicit user selection: setup gap, hold. Never infer from live profiles, harness,
 tools, credentials, quota, subscription, or default to `mixed`.
-Only same-provider, same-model account selection among instances of one driver
-may use headroom under [Provider bindings](t3-runtime.md#preflight-and-binding);
+Follow [Provider bindings](t3-runtime.md#preflight-and-binding);
 provider/model substitution still requires the user's decision.
 
 At start, snapshot all role IDs from installed `skills/axstack/roles.json`,
@@ -30,9 +29,6 @@ using saved T3 capabilities JSON; missing or malformed capabilities holds.
 Claude exact IDs come from capabilities, replacing transcript read-back.
 Use an explicit model as given; for `model:null` without a class, grok uses the
 provider's first listed model from saved capabilities and records its exact ID.
-For `model:null` without a class, Antigravity must select the first listed model
-whose ID ends with `-<effort>` from saved capabilities and record its exact ID.
-Missing effort-suffix matches hold resolution for Antigravity.
 A Codex or Claude role with neither model nor class is an intentional absence
 and holds.
 Resume must reuse the saved capabilities and role snapshot with no re-resolution; changes require the user’s explicit decision.
@@ -40,8 +36,7 @@ An unavailable provider, model, role, mode or effort holds that role with no sub
 Preset changes apply to new runs only; an active run keeps its snapshot.
 Replacing a session needs an explicit user decision and revalidation.
 Timeout, quota, auth and rejection hold affected work.
-An exhausted account with no eligible sibling still holds; dispatched roles never fail over mid-thread.
-Follow [Provider bindings](t3-runtime.md#preflight-and-binding) for driver account re-selection at turn boundaries.
+Follow [Provider bindings](t3-runtime.md#preflight-and-binding).
 [Model discipline](contracts.md#model-discipline) governs optional seats,
 auditor preflight, and required holds; [Role roster](role-roster.md) governs
 single-provider absence, mixed research with at least two different providers,
@@ -148,4 +143,5 @@ not alone a formal spec trigger. Hold affected unsafe work while reassessing.
   author provenance — then use `axstack-review` and `axstack-watch` without
   repeated approval or new spec ceremony. Never infer the author from the
   orchestrator or assume an imported own PR's author.
+  Before pushing a stale or external PR, follow [adoption dispositions](../../axstack-watch/SKILL.md#stale-or-external-prs).
 - Direct later phase: start there and pass that phase's identity check.

package/skills/axstack/references/t3-runtime.md

@@ -29,73 +29,14 @@ preset and stable role IDs, requested provider/model/class/mode/effort, resolved
 ID, source and time once. Resume preserves that snapshot with no re-resolution;
 changes require the user's explicit decision. Bundled presets are setup inputs.
 
-Provider bindings must map grok→`grok` and antigravity→`antigravity`, with
-canonical error-exit fallbacks codex→`codex` and claude→`claudeAgent`.
-At each dispatch or launch, claude and codex must bind to the instanceId printed
-by `scripts/pick-instance.js --provider <provider>`.
-For dispatched roles, only error exit 1 permits fallback to the canonical instance after validating availability.
-Exit 2 (no eligible provider instances) must hold the work without fallback.
-Record the chosen instanceId and a pointer to saved `--json` output in the dispatch record.
-Only same-provider, same-model account selection among instances of one driver
-is permitted, with provider, model, class and effort rules required to remain unchanged.
-An exhausted account with no eligible sibling must hold.
-Dispatched roles never fail over mid-thread.
-
-When the driver starts or resumes a run and at the start of every run-watch wake,
-it runs `scripts/pick-instance.js --provider <its own provider> --json`.
-Read its current binding with `t3_thread_configuration` and save picker JSON in private run evidence.
-If the driver's own current instance is `excluded` for a usage limit and an eligible
-same-provider sibling exists, it must switch itself via `t3_thread_configure` to the
-chosen sibling instance, keeping the same provider, model and effort/options, then continue.
-The driver must record from/to instance, a pointer to saved picker JSON and UTC time in `progress.md`.
-If the driver's own current instance is eligible, it must stay despite headroom differences.
-On exit 2 (no eligible sibling), the driver must hold under the existing rule.
-On error exit 1, the driver must keep its current instance.
-Driver account re-selection must configure only the calling thread and only at a turn boundary.
-A turn already paused by a usage limit cannot self-recover.
-The next wake or user message runs this check.
-
-Driver self-switching is required from v0.25.1.
-T3 scheduled tasks retain the creation-time instanceId for wakes and fresh-thread
-passes regardless of the calling thread's current binding.
-The driver must arm a run watch only after picking its account: `pick-instance.js` before `schedule_task`.
-On a driver self-switch, delete and recreate its armed bound run watch with the
-same prompt, cadence and binding on the new instance.
-
-Every scheduled automation pass runs `scripts/pick-instance.js --provider <its own provider> --json`
-at pass start, including fresh-thread review-manager passes.
-Scheduled passes follow the driver's eligibility and stay rules: an eligible own instance stays,
-exit 1 keeps the current instance and exit 2 holds.
-If a scheduled pass's own current instance is `excluded` and an eligible same-provider sibling exists,
-it must switch itself via `t3_thread_configure` to the chosen sibling instance,
-keeping the same provider, model and effort/options.
-On a scheduled pass self-switch in a review-manager lane, only the owner-of-record, after lane reconciliation
-and the duplicate check, must delete and recreate its own schedule with the same
-prompt, cadence and binding on the chosen instance.
-On any other scheduled pass self-switch, delete and recreate its own schedule with
-the same prompt, cadence and binding on the chosen instance only after `list_scheduled_tasks`
-confirms no replacement for that schedule on the chosen instance already exists.
-If a replacement for that schedule on the chosen instance already exists, any other scheduled pass must skip recreation.
-For a review-manager self-switch, only the owner-of-record must update the recorded
-`axstack-owner` binding's instanceId to the chosen instance after verifying unchanged
-provider/model/effort/options with `t3_thread_configuration` and attaching the picker
-switch receipt, before the admission binding comparison.
-For each schedule replacement, read back old absence and new presence using `list_scheduled_tasks`.
-For each schedule replacement, record old/new scheduledTaskId, from/to instance,
-picker JSON pointer and UTC time in the `progress.md` or durable activation/continuity record.
-Retain the recorded schedule's title and enabled state and use a fresh stable creation `clientRequestId`.
-An uncertain replacement holds affected work: preserve its native receipts for reconciliation.
-A scheduled pass already running on an exhausted account cannot recover.
-Account switches must happen before exhaustion at the picker's near-limit cutoff.
+Provider bindings must map codex→`codex`, claude→`claudeAgent` and grok→`grok`.
+For every dispatch or launch, claude must bind to `claudeAgent` and codex must bind to `codex`.
+A usage-limited instance must hold the work without failover.
 
 For plan generation, run
-`scripts/dispatch-plan.js --role <id> --roles <roles.json> --capabilities <saved.json> --picker <picker.json> --kind task|launch`
+`scripts/dispatch-plan.js --role <id> --roles <roles.json> --capabilities <saved.json> --kind task|launch`
 using the recorded role snapshot and saved capabilities.
-Plan JSON carries `inputs`, which callers omit when copying `target`/`modelSelection` and `runtimeMode` into `delegate_task`/`t3_thread_launch`; large plan output requires `--out`.
-For claude/codex, the `--picker` JSON must come from saved
-`scripts/pick-instance.js --provider <role provider> --json` output.
-For grok/antigravity, or after a claude/codex picker exit-1 canonical fallback,
-pass `{"chosenInstanceId":"<canonical instance>"}`.
+Plan JSON carries `inputs`, which callers omit when copying `target`/`modelSelection` and `runtimeMode` plus `isolation` when present into `delegate_task`/`t3_thread_launch`; large plan output requires `--out`.
 For configuration verification, run `scripts/dispatch-plan.js --verify <configuration.json>`
 with the same plan inputs and saved `t3_thread_configuration` read-back.
 
@@ -105,17 +46,13 @@ A preset model must be used as given.
 
 A missing or malformed catalog holds resolution.
 
-For a null-model grok or antigravity role, record the exact model ID from the plan,
+For a null-model grok role, record the exact model ID from the plan,
 rather than an unresolved provider default.
-Antigravity must hold when saved capabilities advertise zero models.
-No matching effort suffix holds resolution for Antigravity.
 For codex or claude, a role lacking both model and class is an intentional
 absence and must hold; never use a provider default for that role.
 
 An unavailable provider, model, role, mode or effort must hold that role with
 no substitution. Auth, quota, timeout and rejection do not select an alternative.
-Here alternative means a provider or model substitution, excluding the bounded
-same-provider, same-model account selection above.
 Intentional absent seats remain recorded absences; availability is runtime proof.
 
 Grok's CLI requires ≥1.0.13.
@@ -138,9 +75,9 @@ configuration; unrelated configurations remain eligible.
 
 | Roles | Mechanism and permitted workspace | Completion |
 |---|---|---|
-| Advisers, research, read-only explorers, explainers, diligence, checker, auditor, monitor, arena prose candidates and judges, escalation | Must use async `delegate_task` in the driver worktree, title = dispatch key; tracked and untracked files stay untouched; writes only `<run>/evidence/<key>/` | Native notification followed by persisted `task_status` |
+| Advisers, research, read-only explorers, explainers, diligence, checker, auditor, arena prose candidates and judges, escalation | Must use async `delegate_task` in the driver worktree, title = dispatch key; tracked and untracked files stay untouched; writes only `<run>/evidence/<key>/` | Native notification followed by persisted `task_status` |
 | Reviewers (peer/authored), release checks, debug investigators, execution investigators (`axstack-explore-execution`), UI verifier candidate checks (`axstack-ui-verifier`) | Must use async `delegate_task`, title = dispatch key; driver makes a disposable detached checkout of candidate SHA and pinned base with `git worktree add --detach <run>/checkouts/<key> <sha>` (plus pinned debug patch); brief requires `cd` into it; only disposable probes write there, outputs go to `<run>/evidence/<key>/` | Same delegated terminal checks |
-| Author and repairs | Must use `t3_thread_launch` with `{type:worktree, baseRef:<SHA>, branch:<encoded branch>, startFromOrigin:false}` in their own worktree, kept until PR merges or closes | Writer sends a receipt to the driver; driver verifies terminal run and candidate |
+| Author and repairs | Fresh authors must use async `delegate_task` with `isolation:"worktree"`, title = dispatch key, stable `clientRequestId` in their own worktree, kept until PR merges or closes; repairs use `t3_thread_send` to the same child | Delegated terminal checks plus verified candidate |
 | Owner | Driver thread in Driver worktree; never writes tracked candidate source or tests; planning artifacts allowed only for repository Markdown; scope, integration, forge mutations and record | No worker launch |
 
 The UI verifier checkout row applies to candidate checks, while a page without
@@ -152,6 +89,13 @@ The driver may write planning artifacts (spec, ticket map) in its own worktree w
 Repairs return to that author. Missing or idle sessions grant no ownership transfer.
 The current chat/driver has no role row in any preset.
 
+At launch and rename, visible driver thread titles express a plain outcome of
+at most 30 characters.
+Visible driver thread titles use no repo, issue or size prefix.
+Hidden children keep dispatch-key titles.
+D9 applies to driver threads only, while flagged unbound pass threads retain the
+`Needs you: <kind> <repo>#<n>` (or `<lane>`) rename under Automations.
+
 The dispatch key must be `<run>:<role>:<task>:a<n>`, recorded before launch and
 used as the exact whole T3 title. Substring matches do not establish identity.
 Each dispatch binds the approved spec or small-change intent, brief, authority, role snapshot, base and candidate to its dispatch key.
@@ -162,12 +106,37 @@ The branch must be `axstack/<run>/<role>/<task>-a<n>`; lowercase each segment
 and replace every `[^a-z0-9-]` character with `-`. Keep the dispatch key in its
 original form and record both; normalization is never an identity substitute.
 
+Before dispatch, the driver must name its resolved worktree absolute path in the author brief.
+Before `git switch -c`, the delegated fresh author must verify `git rev-parse --show-toplevel` differs from the driver worktree named in the brief.
+The isolation proof also requires `git rev-parse --git-dir` differs from `git rev-parse --git-common-dir` (a linked worktree) and `git status --porcelain` is empty.
+The isolation proof must never depend on the starting branch name.
+T3 can rename the starting branch after start.
+On failed isolation proof, stop with `AXSTACK-FAILED` and change nothing.
+After dispatch, the driver must read back the child's `worktreePath` and hold if it is missing or equals the driver worktree.
+The delegated fresh author brief step 1 must verify the branch is absent before
+`git switch -c <encoded branch> <pinned base SHA>`, then verify HEAD equals the pinned base SHA.
+Immediately before `git switch -c`, record the current starting branch with `git symbolic-ref --short HEAD` and starting HEAD with `git rev-parse HEAD`.
+Never use `git switch -C`.
+Delete the T3-created starting branch under its current name only after the switch succeeds and HEAD is verified.
+If T3 renamed the recorded name between capture and switch, follow the worktree reflog rename to the final name.
+Delete only if no worktree has it checked out and its tip equals the recorded starting HEAD.
+If it cannot be identified safely, leave it and name it in the receipt for driver cleanup.
+At dispatch, record taskId, childThreadId, worktreePath and encoded branch.
+T3 worktree isolation starts from the parent HEAD and ignores workspaceStrategy,
+so the delegated fresh child must perform step 1 in its own checkout before writing.
+
+Keep `t3_thread_launch` for top-level drivers; use `t3_thread_launch` as a rare
+author fallback only when worktree isolation is unavailable and record each use in the run record.
+For a recorded author launch, use `{type:worktree, baseRef:<SHA>, branch:<encoded branch>, startFromOrigin:false}`.
+A launched fallback author starts on its encoded branch and skips step 1 and the isolation proof.
+The launch-only recovery and completion rules below cover that fallback.
+
 `baseRef` must always be a commit SHA, never a branch name; T3 renames its
 `t3code/*` branches. Pin base and candidate before dispatch.
-Fetch the pinned base commit into the launch repository before a writer launch.
-Before a writer launch, verify locally that the pinned base SHA resolves to a
+Fetch the pinned base commit into the dispatch repository before an author dispatch.
+Before an author dispatch, verify locally that the pinned base SHA resolves to a
 commit with that exact SHA.
-If fetch or verification fails, hold that launch.
+If fetch or verification fails, hold that dispatch.
 
 Workers must finish with exactly one final marker: `AXSTACK-DONE key=… head=…
 report=…`, `AXSTACK-FAILED key=… head=… report=…`, or `AXSTACK-QUESTION key=… q=…`.
@@ -185,6 +154,9 @@ Delegated completion must require terminal `completed`, `result_available`,
 `hasPendingChildRuns:false`, and final `AXSTACK-DONE`; a question stays
 incomplete even when native status says completed.
 
+Delegated author completion requires delegated terminal checks plus candidate checks:
+non-empty diff, clean tree and named red/green logs.
+
 Launched writer completion must require terminal `t3_thread_wait` on that run,
 then candidate checks: non-empty diff, clean tree and named red/green logs.
 A receipt message alone counts only as progress; it can precede terminal state.
@@ -207,7 +179,10 @@ including untracked entries. Any change is a hold before advancing that work.
 
 ## Launch recovery, repairs and questions
 
-For a lost launch response the driver must use fully paginated `t3_thread_list`
+For a lost delegated dispatch or repair response, retry with the same stable
+`clientRequestId` to recover task identity. Never start a second writer while the outcome is unknown.
+
+For a lost launch response on the recorded fallback route the driver must use fully paginated `t3_thread_list`
 with `titleContains=<key>`, filtered to exact whole-title equality, plus
 `git worktree list`. Keep the reserved branch through recovery. A branch or
 worktree without a reconciled thread prevents proof of absence.
@@ -222,16 +197,31 @@ failed is launch failure; timed-out with `t3_thread_read` showing both
 `activeRunId` and `worktreePath` is started; still preparing is a hold and
 re-read at the next wake. An unresolved state preserves the attempt.
 
-For `AXSTACK-QUESTION` the driver must answer once using `t3_thread_send` to
-the `childThreadId`, record the returned resumed runId, then
+For a delegated child, detect questions with `t3_pending_request_list(childThreadId)`.
+Never rely on `hasPendingQuestion` alone.
+Codex `request_user_input_async` does not set it.
+Use `t3_pending_request_read`, then confirm the request is still pending with
+`t3_pending_request_list(childThreadId)`, then answer once within existing authority
+using `t3_pending_request_respond`; a second ask holds.
+Independent review rounds require fresh `delegate_task` calls.
+Only author continuation and an answer to a child's own question use the same child.
+Providers without a question tool (grok) and launched writers keep
+the `AXSTACK-QUESTION` marker route.
+
+For a delegated marker question, answer once with `t3_thread_send(childThreadId, mode:queue)`,
+record the returned `taskId`, and consume the follow-up under delegated terminal checks.
+For a launched-writer `AXSTACK-QUESTION` marker the driver must answer once using
+`t3_thread_send` to the `childThreadId`, record the returned resumed runId, then
 `t3_thread_wait(childThreadId, runId, timeoutMs:600000)`, re-armed by the run
 watch. Persist status again and accept only `latestTerminal*` with
 `latestTerminalRunId` newer than the question run (recorded run ordering, not
 lexical ID order), terminal success and matching receipt key/SHA. The original
-summary stays stable; no notification is assumed for a resumed result.
+summary stays stable; no notification is assumed for a launched-writer resumed result.
 
-A repair must use `t3_thread_send(writerThreadId, mode:queue)` to the same
-author in the same attempt and worktree; pin the new candidate revision.
+A delegated repair must use a stable clientRequestId with `t3_thread_send(childThreadId, mode:queue, clientRequestId)` to the same author
+in the same attempt, worktree and branch, record the returned taskId and verify the existing candidate head.
+Repairs never repeat fresh checkout step 1. Pin the new candidate revision.
+For a launched fallback, retain the same author thread and use launched-run completion checks.
 
 A replacement after terminal failure must use `a<n+1>`, a new branch and title;
 the failed attempt's branch is kept until salvage. Unknown liveness holds
@@ -239,7 +229,7 @@ replacement; reconcile the old writer before admitting another.
 
 With an unsettled launched thread, the driver turn must end only while a bound
 `schedule_task` with `bindToCurrentThread:true` is armed at the default
-`everyMs:1800000` or for its 5-minute recovery cases in
+`everyMs:3600000` or for its 5-minute recovery cases in
 [Chat-run watch runtime](../../axstack-watch/references/watch-runtime.md#chat-run-watch),
 with its ID recorded. Each wake must reconcile all unsettled runs, including a
 writer that died without sending; failed runs hold incomplete work. The watch
@@ -269,17 +259,19 @@ Before finishing PR work, including watch end or Close-out, the driver calls
 `list_thread_pull_requests` and links every missing run PR.
 Never link unrelated PRs.
 
-After verified publication readback of an own PR, for every layer of an ordinary-chain or legacy `gh stack`,
-the driver also calls `t3_thread_update` with `action: link_pull_request`,
-`pullRequest` containing its number, repository and full PR URL, and `threadId`
-set to the author thread, then reads back the PR link with
-`list_thread_pull_requests` for that same author thread.
-A missing or failed author-link readback never triggers author repair: it holds
-only that PR's merge-ready and requires retrying the link.
+Authors are never PR-linked: the driver alone links and watches the PR.
+For delegated authors after accepted completion, in the same driver turn settle with
+`t3_thread_organize` using `action: settle`, read back `settled: true` with `t3_thread_read`
+and record `settle: manual` under the [Settlement](workspace-hygiene.md#settlement) guards.
+For delegated authors, archive and guarded manual worktree removal wait for PR merge or close.
+Never rely on automatic child cleanup.
 
 When the forge confirms a run PR merged or closed, in the same driver turn the
-driver settles its author thread with `t3_thread_organize` using `action: settle`
-and reads back `settled: true` with `t3_thread_read` for that thread.
+driver first reads its author thread with `t3_thread_read`.
+If the readback already shows `settled: true`, record `settle: native` only when
+no driver settle was issued for that thread; otherwise retain `settle: manual`.
+Otherwise settle with `t3_thread_organize` using `action: settle`, then read back
+`settled: true` with `t3_thread_read` before recording `settle: manual`.
 Apply the existing [Settlement](workspace-hygiene.md#settlement) guards:
 terminal run evidence is required and user-taken-over threads stay untouched.
 A missing or failed settle readback holds watch end and Close-out only for
@@ -288,22 +280,44 @@ that author thread until resolved.
 For every watched own PR in chat-run or standalone adopted maintenance, when
 available the driver calls `watch_pull_request` for T3 wakes on check completion,
 new comments from others, or branch conflicts, then ends the turn.
+Only the PR-owning driver calls `watch_pull_request`.
+Delegated children never call `watch_pull_request`.
+Before arming, handle existing checks and comments because only later comments wake the thread.
 Never poll or keep a model active between native PR wake events.
-A T3 "stopped watching" notice is itself a driver wake: in that same turn,
-re-check the PR and call `watch_pull_request` again.
-This includes a stop after T3 could not read the PR for 15 minutes.
+Native watch ends after 8 failed reads, or on settle, archive, user Stop, or PR merge/close.
+For parked holds, follow [Parked user-reply holds](contracts.md#parked-user-reply-holds).
+A parking unwatch never triggers native re-arm or the 5-minute recovery cadence.
+A non-user T3 "stopped watching" notice is itself a driver wake: in that same turn,
+re-check the PR.
+After a non-user stop while the PR stays open, the driver must re-arm in that
+same turn when GraphQL quota permits, using the recovery steps below.
+Record the stop reason T3 gives.
+Re-arm only after a stop not caused by the user.
+For a "could not read" stop, run `gh api rate_limit --jq .resources.graphql` as a diagnostic only.
+When GraphQL remaining is near 0, defer re-arming until reset: set the bound
+schedule to 5 minutes and re-arm on the next wake after reset.
+Record the GraphQL reset time in the run record.
+Never wait for a GraphQL reset inside a turn.
+Before re-arming, first unsettle the driver thread with `t3_thread_organize`
+using `action: unsettle`, then call `watch_pull_request` again.
+Never re-arm in a loop.
 Route native PR wake events through watch §4 and the unchanged §5 readiness predicate.
 
 If `watch_pull_request` is unavailable, fall back to the bound 5-minute schedule
 and `scripts/pr-digest.js` without a hold.
 If re-arming fails, restore the bound 5-minute schedule.
-When the run waits only on a user decision or a human-only step, including a
-user merge, with no unsettled worker and no PR needing watch events, change
-the run watch cadence to 60 minutes at once.
-When work restarts, restore the normal 30-minute cadence.
-Keep native PR watches.
+For forge-resolved human waits, including user merge, npm stage approval and
+human review, with no unsettled worker and no PR needing watch events, set the run watch cadence to 60 minutes
+at once.
+When work restarts, re-evaluate cadence against the recovery conditions in
+[Chat-run watch runtime](../../axstack-watch/references/watch-runtime.md#chat-run-watch).
+Keep native PR watches for forge-resolved waits.
 For chat-run cadence changes, follow [Chat-run watch runtime](../../axstack-watch/references/watch-runtime.md#chat-run-watch)
-for the normal 30-minute cadence, 5-minute recovery, and schedule update read-back.
+for the 60-minute backstop, 5-minute recovery, and schedule update read-back.
+An open PR left unwatched by a user Stop never triggers the 5-minute recovery cadence.
+After T3 auto-settles a multi-PR driver on one PR merge, it re-arms remaining
+open members through the recovery steps before ending the turn.
+If rate-limited, use the 5-minute schedule and next-wake recovery above.
 The schedule still reconciles author and review tasks, readiness, and release.
 When a PR merges or closes, or its watch is torn down, call `unwatch_pull_request`
 and keep its link.
@@ -358,13 +372,18 @@ The driver must retain a user-taken-over T3 thread; never send cleanup commands
 to it, including `t3_thread_organize` settle or archive.
 Require T3 terminal run evidence before `t3_thread_organize` settle or archive;
 these metadata actions are not worktree removal.
+Self-settle is the one exception to terminal-before-settle: T3 returns
+`settlesWhenTurnEnds:true` and the next pass verifies `settled: true`.
+Apply the guarded unbound pass-end action in
+[Finite-session teardown](automations.md#finite-session-teardown).
 
 ## Project preflight and run record
 
-`worktreeCleanup` must be `off` for every Axstack project. Preflight reads it
-with `t3_project_read` where exposed; otherwise record a limitation pointing
-to the documented installation setup step. Automatic worktree deletion cannot
-replace evidence readback and salvage.
+Hosts can delete author worktrees at merge through `storageCleanup.worktreeOnMerge`.
+`t3_project_read` cannot read `storageCleanup.worktreeOnMerge`.
+Evidence never lives in a worktree and belongs in private `<run>/evidence/<key>/`.
+A missing merged or closed author worktree is expected, not a hold.
+Automatic worktree deletion cannot replace evidence readback and salvage.
 
 The run record must contain driver threadId, projectId, host, T3 version,
 installed Axstack SHA, capabilities JSON path and scheduledTaskIds for every

package/skills/axstack/references/test-audit-weekly.md

@@ -1,6 +1,6 @@
 # Weekly test-audit prompt
 
-At pass start, follow [Provider bindings](t3-runtime.md#preflight-and-binding) for account selection and schedule recreation.
+At pass start, follow [Provider bindings](t3-runtime.md#preflight-and-binding) for provider binding.
 
 You are a fresh finite weekly test-audit session in this repository's dedicated
 T3 project worktree. Before admission, read the activation record: repository,
@@ -65,5 +65,17 @@ The recorded owning watch thread merges under the same watch predicate.
 Workers never merge.
 
 Raise decision and serious-risk holds in the T3 driver thread; end the turn
-parked on the decision. Keep routine reports there, including skipped or empty passes.
+waiting on the decision. Keep routine reports there, including skipped or empty passes.
 Settle owned workers and preserve evidence under the shared lifecycle.
+
+At pass start, read the recorded prior pass thread with `t3_thread_read` and
+apply [Finite-session teardown](automations.md#finite-session-teardown)'s guarded
+verification or hold/report before replacing its identity.
+Record own pass threadId in the existing activation record and read back the save.
+
+At pass end, an unbound pass calls `t3_thread_organize` with `action: settle` on its
+own thread only, only when it owns no PR watch, has zero unsettled descendants,
+has no pending receipt and is not held, wedged or a stalled owner.
+Follow [Finite-session teardown](automations.md#finite-session-teardown) for
+deferred self-settle and next-pass verification; this applies to quiet, skipped
+and empty passes too.

package/skills/axstack/references/workspace-hygiene.md

@@ -24,8 +24,10 @@ still appears is a hold; agents do not answer it.
 
 ## Project preflight
 
-`worktreeCleanup` must be `off` for every Axstack project.
-Preflight reads back `worktreeCleanup` via `t3_project_read` where exposed; otherwise record a limitation pointing to the documented installation setup step.
+Hosts can delete author worktrees at merge through `storageCleanup.worktreeOnMerge`.
+`t3_project_read` cannot read `storageCleanup.worktreeOnMerge`.
+Evidence never lives in a worktree and belongs in private `<run>/evidence/<key>/`.
+A missing merged or closed author worktree is expected, not a hold.
 Automatic deletion cannot replace evidence readback or salvage. Do not change
 project settings without recorded host-mutation authority.
 
@@ -33,10 +35,20 @@ project settings without recorded host-mutation authority.
 
 Cleanup order is: settled descendants -> evidence readback -> salvage dirty or ignored non-cache content -> t3_thread_organize archive -> exact git worktree remove without force -> git branch -d for local-only branches.
 Require terminal run evidence before `t3_thread_organize` settle or archive.
+Self-settle is the one exception to terminal-before-settle: T3 returns
+`settlesWhenTurnEnds:true` and the next pass verifies `settled: true`.
+Apply the guarded unbound pass-end action in
+[Finite-session teardown](automations.md#finite-session-teardown).
+Record `settle: native` only when no driver settle was issued for that thread;
+otherwise retain `settle: manual` even when a later read already shows settled.
 These metadata actions do not remove worktrees. Accept matching delegated task
 or launched run completion under the runtime contract before settlement.
 After the driver accepts a launched writer's (author or repair) or delegated task's completion from terminal run evidence plus a verified receipt or candidate check, in the same driver turn it settles the matching thread with `t3_thread_organize` using `action: settle` as metadata only.
 The driver reads back `settled: true` with `t3_thread_read` on the writer thread for launched writers and on the `childThreadId` for delegated tasks.
+For delegated authors after accepted completion, in the same driver turn settle with `t3_thread_organize` using `action: settle`, read back `settled: true` with `t3_thread_read` and record `settle: manual`.
+For delegated authors, archive and guarded manual worktree removal wait for PR merge or close.
+Never rely on automatic child cleanup.
+Delegated author threads stay hidden in the sidebar regardless of settlement; visibility statements below apply to launched writers.
 This extends the existing same-turn settle rule: a pinned run-owned child is still settled.
 T3's settle clears the pin, including one inherited from the parent at creation. There is no separate unpin step.
 Native T3 tools do not show pins, so the read-back stays `settled: true`.

package/skills/axstack/scripts/dispatch-plan.js

@@ -1,17 +1,16 @@
 import { readFileSync, writeFileSync } from 'node:fs';
 
-const flags = ['--role', '--roles', '--capabilities', '--picker', '--kind', '--verify', '--out'];
+const flags = ['--role', '--roles', '--capabilities', '--kind', '--verify', '--out'];
 const nonempty = (value) => typeof value === 'string' && value.trim().length > 0;
 const help = `Usage: bun dispatch-plan.js --role <id> --roles <roles.json>
-  --capabilities <saved.json> --picker <picker.json> --kind task|launch
+  --capabilities <saved.json> --kind task|launch
   [--verify <configuration.json>] [--out <report.json>]
-Example: bun dispatch-plan.js --role axstack-author --roles roles.json --capabilities capabilities.json --picker picker.json --kind launch
+Example: bun dispatch-plan.js --role axstack-author --roles roles.json --capabilities capabilities.json --kind task
 
 --role          Role ID from the supplied snapshot
 --roles         Installed-style roles.json (version 1, roles array)
 --capabilities  Saved orchestrator_capabilities JSON; reuse the run's saved snapshot
---picker        Saved picker JSON; uses chosenInstanceId
---kind          task emits target; launch emits modelSelection
+--kind          task emits target and, for axstack-author, isolation:"worktree"; launch emits modelSelection
 --verify        Compare t3_thread_configuration JSON; print evidence then MATCH or each mismatch
 --out           Save the payload as full JSON here; stdout is an input/path/omitted-count summary
 --help          Show all flags and exit codes
@@ -61,7 +60,7 @@ function normalizedOptions(options) {
   return JSON.stringify(entries.sort(([left], [right]) => left.localeCompare(right)));
 }
 
-function verify(configuration, instanceId, provider, model, options) {
+function verify(configuration, provider, model, options) {
   const mismatches = [];
   const selection = configuration?.modelSelection;
   const compare = (field, expected, observed, equal = expected === observed) => {
@@ -73,7 +72,7 @@ function verify(configuration, instanceId, provider, model, options) {
     compare('provider', provider, selection.provider,
       (selection.provider === 'claude' ? 'claudeAgent' : selection.provider) === provider);
   }
-  compare('instanceId', instanceId, selection?.instanceId);
+  compare('instanceId', provider, selection?.instanceId);
   compare('model', model, selection?.model);
   compare('options', options, selection?.options,
     normalizedOptions(options) === normalizedOptions(selection?.options));
@@ -130,8 +129,6 @@ function plan(argv, io) {
   if (!nonempty(role.model) && !nonempty(role.modelClass) && role.model !== null) {
     hold(`model unavailable for role ${role.id}`);
   }
-  const picker = readJSON(args['--picker']);
-  if (!nonempty(picker?.chosenInstanceId)) hold('picker chosen instance unavailable');
   const modelArgs = typeof role.model === 'string' ? ['--model', role.model]
     : role.modelClass ? ['--class', role.modelClass] : ['--model', String(role.model)];
   const resolved = Bun.spawnSync([process.execPath, `${import.meta.dir}/resolve-models.js`,
@@ -140,30 +137,16 @@ function plan(argv, io) {
   if (resolved.stderr.length) io.stderr(resolved.stderr.toString());
   if (resolved.exitCode !== 0) return resolved.exitCode === 1 ? 2 : 1;
   const { model, effortOption, providerInstanceId } = JSON.parse(resolved.stdout.toString());
-  const chosen = readJSON(args['--capabilities']).providers
-    .filter((provider) => provider.providerInstanceId === picker.chosenInstanceId);
-  if (chosen.length !== 1 || chosen[0].driverKind !== providerInstanceId
-    || (['grok', 'antigravity'].includes(role.provider) && picker.chosenInstanceId !== providerInstanceId)) {
-    hold(`picker instance ${picker.chosenInstanceId} does not bind provider ${role.provider}`);
-  }
-  if (!Array.isArray(chosen[0].models)) {
-    hold(`malformed models on instance ${picker.chosenInstanceId}; expected an array; observed ${JSON.stringify(chosen[0].models) ?? 'missing'}`);
-  }
-  const selectedModel = chosen[0].models.find((entry) => entry.id === model);
-  if (!selectedModel) hold(`model ${model} unavailable on instance ${picker.chosenInstanceId}`);
-  if (effortOption && !selectedModel.options?.some((option) => option.id === effortOption.id
-    && option.options?.some((value) => value.id === effortOption.value))) {
-    hold(`effort ${effortOption.value} unavailable on instance ${picker.chosenInstanceId}`);
-  }
   const options = effortOption ? [effortOption] : [];
   if (args['--verify']) {
-    const verification = verify(readJSON(args['--verify']), picker.chosenInstanceId, providerInstanceId, model, options);
+    const verification = verify(readJSON(args['--verify']), providerInstanceId, model, options);
     emit(verification);
     return verification.mismatches.length ? 2 : 0;
   }
-  const selection = { [args['--kind'] === 'launch' ? 'instanceId' : 'providerInstanceId']: picker.chosenInstanceId,
+  const selection = { [args['--kind'] === 'launch' ? 'instanceId' : 'providerInstanceId']: providerInstanceId,
     model, options };
-  emit({ [args['--kind'] === 'launch' ? 'modelSelection' : 'target']: selection, runtimeMode: 'full-access' });
+  emit({ [args['--kind'] === 'launch' ? 'modelSelection' : 'target']: selection, runtimeMode: 'full-access',
+    ...(args['--kind'] === 'task' && role.id === 'axstack-author' ? { isolation: 'worktree' } : {}) });
   return 0;
 }
 

package/skills/axstack/scripts/resolve-models.js

@@ -1,6 +1,6 @@
 import { readFileSync } from 'node:fs';
 
-const bindings = { codex: 'codex', claude: 'claudeAgent', grok: 'grok', antigravity: 'antigravity' };
+const bindings = { codex: 'codex', claude: 'claudeAgent', grok: 'grok' };
 const effortIds = { codex: 'reasoningEffort', claude: 'effort', grok: 'reasoningEffort' };
 const nonempty = (value) => typeof value === 'string' && value.trim().length > 0;
 
@@ -21,7 +21,7 @@ function argumentsFrom(args) {
     }
   }
   if (!options.provider || !options.capabilities || !options.effort) {
-    throw new Error('expected --provider codex|claude|grok|antigravity --capabilities path --effort level');
+    throw new Error('expected --provider codex|claude|grok --capabilities path --effort level');
   }
   return options;
 }
@@ -45,7 +45,7 @@ function providerFrom(catalog, provider) {
   return instance;
 }
 
-function modelFrom(models, { provider, model: pin, class: modelClass, excluded, effort }) {
+function modelFrom(models, { provider, model: pin, class: modelClass, excluded }) {
   if (pin && pin !== 'null') {
     const model = models.find((model) => model.id === pin && !excluded.includes(model.id));
     if (!model) throw new Error(`missing requested model ${pin}`);
@@ -56,9 +56,7 @@ function modelFrom(models, { provider, model: pin, class: modelClass, excluded,
     if (['codex', 'claude'].includes(provider)) {
       throw new Error(`intentional absence for ${provider}: missing model and class`);
     }
-    // Antigravity encodes effort in its ID; exclusions never select a substitute.
-    const model = provider === 'antigravity'
-      ? models.find((model) => model.id.endsWith(`-${effort}`)) : models[0];
+    const model = models[0];
     if (!model || excluded.includes(model.id)) throw new Error('missing first listed model');
     return model;
   }
@@ -89,19 +87,12 @@ try {
   const catalog = JSON.parse(readFileSync(path, 'utf8'));
   const instance = providerFrom(catalog, provider);
   const model = modelFrom(instance.models, options);
-  let effortOption = null;
-  if (provider === 'antigravity') {
-    if (!model.id.endsWith(`-${effort}`)) {
-      throw new Error(`unsupported effort ${effort} for ${provider}/${model.id}`);
-    }
-  } else {
-    const effortOptions = model.options.filter((option) => option.id === effortIds[provider]);
-    if (effortOptions.length !== 1 || !effortOptions[0].options?.some((value) => value.id === effort)
-      || (provider === 'grok' && effort === 'max')) {
-      throw new Error(`unsupported effort ${effort} for ${provider}/${model.id}`);
-    }
-    effortOption = { id: effortOptions[0].id, value: effort };
+  const effortOptions = model.options.filter((option) => option.id === effortIds[provider]);
+  if (effortOptions.length !== 1 || !effortOptions[0].options?.some((value) => value.id === effort)
+    || (provider === 'grok' && effort === 'max')) {
+    throw new Error(`unsupported effort ${effort} for ${provider}/${model.id}`);
   }
+  const effortOption = { id: effortOptions[0].id, value: effort };
   console.log(JSON.stringify({ provider, providerInstanceId: instance.providerInstanceId,
     model: model.id, effortOption, source: 'capabilities', path }));
 } catch (error) {

package/skills/axstack-brainstorm/references/arena.md

@@ -12,7 +12,7 @@ hard-to-reverse choices; they replace the critique round for that question.
    example, taking the shortest path that compiles. Treat them as prompts, not defects. Candidates receive only the brief; the rubric is for judging.
 2. **Fan out.** Produce one candidate per configured family independently from the same brief,
    without cross-reading: `axstack-advisor-astra`, `axstack-advisor-opus`,
-   `axstack-arena-candidate-grok`, and `axstack-arena-candidate-antigravity`.
+   and `axstack-arena-candidate-grok`.
    Each gives a design, rationale, and rejected alternatives. The driver authors no candidate.
    The driver drafts no recommendation until every candidate returns.
 3. **Cross-judge (Rung 2 only).** After every candidate completes, give round 1 judge
@@ -45,7 +45,7 @@ verdicts per round) as `Decisions` rows in the
 [caller's run record](../../axstack/references/run-record.md) when one exists,
 otherwise include it in the returned verdict. Load
 [T3 runtime](../../axstack/references/t3-runtime.md) immediately before the
-first candidate or judge dispatch. If an optional Grok or Antigravity candidate
+first candidate or judge dispatch. If an optional Grok candidate
 malfunctions (launch failure, trust/login prompt, or prompt block), fence it,
 record `absent (<reason>)`, name it once in the next
 read-back, and continue with available candidates without relay or substitution.

package/skills/axstack-cleanup/SKILL.md

@@ -20,9 +20,12 @@ Before any runtime action, load and follow:
   evidence is the last removable-worktree blocker
 
 Use project-scoped T3 thread inventory, `git worktree list --porcelain` and run
-records. Preflight requires `worktreeCleanup` off via `t3_project_read` where
-exposed, or a recorded setup limitation. Follow the runtime schema, never invent
-an alternate command protocol.
+records.
+Hosts can delete author worktrees at merge through `storageCleanup.worktreeOnMerge`.
+`t3_project_read` cannot read `storageCleanup.worktreeOnMerge`.
+Evidence never lives in a worktree and belongs in private `<run>/evidence/<key>/`.
+A missing merged or closed author worktree is expected, not a hold.
+Follow the runtime schema, never invent an alternate command protocol.
 
 ## Authority and scope