# Proof audit, pass 1 — held-queue provider wakes

## Findings

1. **Current-head proof is missing.** This is a fixture derivation, not a test or runtime capture. All rows below need capture. The earlier [evidence index](https://gh-file-drop-api-prod-mi5fy3sowv63ufte.pinglabs.workers.dev/f/855fb0736961017d/evidence-index.md) and [matrix](https://gh-file-drop-api-prod-mi5fy3sowv63ufte.pinglabs.workers.dev/f/8e72424050fa5515/proof-matrix.md) describe [ea3642a487](https://github.com/pingdotgg/t3code/commit/ea3642a4872efa089663fff337bd6283c52e17be) and an older base. Their recipes are useful; their results do not prove this head.
2. **The newest commit adds two distinct proof obligations.** Historical failed/interrupted worktree setup must still prevent a provider wake bypass when a later active run exists. Explicit queue resume must check the first run being released, even when it is held and uses a different provider from the thread's current selection. These controls should pass on the requested merge-base and fail on the immediate pre-fix parent, not be misrepresented as red-on-base regressions.
3. **Codex command completion lacks a direct delivery assertion.** The existing Codex test asserting `message_text` is for native-child completion, a different offer site. The continuation-service test proves the mapping from an already supplied delivery value, and the scheduler test proves server-text inheritance; neither proves that the changed commandExecution offer supplies that value. Close this with an actual Codex background-command runtime transcript or an authorized direct adapter replay test. No new test is written in this read-only audit.
4. **Preserving the held queue is essential to the native fixture.** A normal web/mobile user send releases holds. The prior native reproduction used CLI/MCP sends, which are agent/mcp and do not release them. Public WebSocket dispatch rewrites `createdBy` to user, so a driver must not claim it created a provider wake merely by putting agent/provider into a client command. Real adapter output must create the native wake.
5. **Scope is the held-wake scheduler route.** The linked [#22033](https://git.cafe/pingdotgg/t3code/issues/22033) also describes an idle-launch adapter replay without a held queued run. This diff does not change the Claude adapter's idle outcome guard. A successful held-queue reproduction does not by itself prove every issue variant fixed. No independent code defect is asserted by this pass.

## Revision and coverage

Read-only audit for [#17885](https://git.cafe/pingdotgg/t3code/pull/17885), mirrored as [#17885](https://github.com/pingdotgg/t3code/pull/17885), targeting main; fork branch `fireboltdude1357:fix/wake-continuation-held-queue`. Local HEAD and refreshed GitCafe metadata both identify [c740ee52fa](https://github.com/pingdotgg/t3code/commit/c740ee52fabfabea61f16a43a1591c5777d54eca). Requested base [e5ea25d129](https://github.com/pingdotgg/t3code/commit/e5ea25d1292e5342db8508bf48ded67b88b82b82) is an ancestor and is the comparison used here. The local `main` ref has a different merge-base; it was not silently substituted. New guard comparison parent: [39c49baf05](https://github.com/pingdotgg/t3code/commit/39c49baf05620e1c1c0e1a4af251f301a51944c3).

Inspected all seven changed files, direct scheduler callers, queue ordering, continuation classification, relevant test bodies, notification conversion, client/MCP provenance, issue description, PR description and existing reviews. No tests, server, browser, emulator or lease started; no source edits, pushes, comments, checkouts or forge mutations. Worktree was clean. Disk had 19 GB available. Execution host: fs-33, Linux; this is not the old fs-27 runtime environment. Forge's green status contexts are not a substitute for the requested proof artifacts.

**Changed visual matrix: empty.** There is no changed render component, CSS, contract or client code. Theme, viewport width and web/desktop/mobile platform do not create distinct scheduler branches. The server state is visible in client activity, queues and native-subagent status, but this calls for runtime transcripts, not screenshots or recordings. Codex always supplies notification metadata on this path; `notificationTurnItem` converts it to a notification and strips message attribution fields. Its source change is not evidence of a new ordinary message-bubble layout.

## Complete branch inventory for the changed decisions

- [nextQueuedRun and blocking statuses](https://github.com/pingdotgg/t3code/blob/c740ee52fabfabea61f16a43a1591c5777d54eca/apps/server/src/orchestration-v2/Orchestrator.ts#L610): only queued runs enter delivery ordering; select the first whose `queueHeld !== true`. Missing/false holds are eligible; true holds are skipped regardless of their priority. Zero eligible returns undefined. Delivery order is automatic delegated completion first, then `queuePosition ?? ordinal`, then ordinal. One or many held/unheld entries are equivalent except for which eligible item wins.
- Its **two remaining direct callers** are [failQueuedRunStart](https://github.com/pingdotgg/t3code/blob/c740ee52fabfabea61f16a43a1591c5777d54eca/apps/server/src/orchestration-v2/Orchestrator.ts#L1356) and [startNextQueuedRun](https://github.com/pingdotgg/t3code/blob/c740ee52fabfabea61f16a43a1591c5777d54eca/apps/server/src/orchestration-v2/Orchestrator.ts#L1466). Both use an explicitly selected queued ID instead when supplied. Start first checks store readiness, then rechecks archive/deletion/blocking under the thread lock. It no longer vetoes a thread merely because another queued run is held. Undefined selection is a no-op. A selected eligible run still faces usage limits, failed workspace preparation, disabled instance and provider-failure holds, execution/projection identity validation, and adapter/handoff errors. Error fallback must fail the eligible run, not an earlier held run.
- **All start entry points:** recovery sweep `resumeQueuedRuns`; terminal `run.updated` handler with `endedRunId` and optional `failedRunId`; fresh committed `queue.resume`/`queued-run.start`; replayed receipt for those commands. Terminal reactions cover completed/failed/cancelled/interrupted/rolled_back; preparing/starting/running/waiting block. Locking and checkpoint/outbox processing must still serialize provider starts.
- [wakeSkipsHold and inheritance](https://github.com/pingdotgg/t3code/blob/c740ee52fabfabea61f16a43a1591c5777d54eca/apps/server/src/orchestration-v2/Orchestrator.ts#L5429): queued construction is reached only when `shouldQueue` (blocking active run or failed/interrupted missing-worktree predecessor, and defer/start/queue dispatch). Steer/restart are handled before this branch; normal idle dispatch follows fresh-run creation instead. `wakeSkipsHold` is exactly: `!worktreeSetupUnresolved && activeRun !== undefined && queueIsHeld && createdBy === agent && creationSource === provider && !stopReachedRun(activeRun.id)`. `queueIsHeld` counts only queued true holds. Stop is a persisted `run_interrupt_request` for this active run, not any historical stop. `worktreeSetupUnresolved` means null worktree path plus ANY historical failed/interrupted worktree preparation, even if a newer active run has no preparation field. The new run is held if `worktreeMissingRun` exists OR no held runs are being released and the queue is held and the exemption does not apply. Client user web/mobile sends without `scheduledTaskId` release existing holds when worktree setup is resolved. Agent/server, agent/mcp, scheduled sends and non-agent provider-source messages do not get the exemption. A provider-source message does not need `notification` for the predicate; genuine runtime continuation messages do include it.
- [SQL readiness](https://github.com/pingdotgg/t3code/blob/c740ee52fabfabea61f16a43a1591c5777d54eca/apps/server/src/orchestration-v2/ProjectionStore.ts#L5268) and [memory readiness](https://github.com/pingdotgg/t3code/blob/c740ee52fabfabea61f16a43a1591c5777d54eca/apps/server/src/orchestration-v2/ProjectionStore.ts#L7503): existing live thread, at least one queued unheld run, and no preparing/starting/running/waiting run. SQL uses `json_extract(...queueHeld) IS NOT 1`, admitting an absent field and false just like memory `!== true`. Held-only/empty/terminal-only are false. Archived/deleted are false; missing thread is a typed error. Both scheduler start and recovery sweep call readiness, including its fast precheck.
- [Explicit resume](https://github.com/pingdotgg/t3code/blob/c740ee52fabfabea61f16a43a1591c5777d54eca/apps/server/src/orchestration-v2/Orchestrator.ts#L11976): the new head intentionally uses the first delivery-ordered run INCLUDING held rows, or explicit selected run, to choose whose usage limit is checked before all queued holds are cleared. Empty queue uses thread provider and writes metadata if accepted. Selection follows the queued run except app-owned monitor notifications follow the current thread selection; buffered notifications keep their stored selection. Archived/deleted and invalid selected run reject. A selected run must be a queued ordinary user message, not notification/delegated completion, and no blocking run may exist. Same receipt replay must not duplicate a start.
- [Codex changed offer](https://github.com/pingdotgg/t3code/blob/c740ee52fabfabea61f16a43a1591c5777d54eca/apps/server/src/orchestration-v2/Adapters/CodexAdapterV2.ts#L4788): only commandExecution item completion after context resolution, not a closed command, in a settled root context, with continuation service, outside interrupting native turns, and not already offered for this turn/item produces the changed request. It always sets `delivery: message_text`; exit 0/nonzero/null affect completed/failed/unknown notification outcome, not delivery. A drained settled turn releases its retained context. Nonsettled, child, unavailable service, interrupting and duplicate paths do not newly offer. The unrelated child-completion offer already supplies message_text. [ProviderContinuationService](https://github.com/pingdotgg/t3code/blob/c740ee52fabfabea61f16a43a1591c5777d54eca/apps/server/src/orchestration-v2/ProviderContinuationService.ts#L189) maps message_text to agent/server and buffered/default to agent/provider.

## Fixture matrix

All statuses are **NEEDS CAPTURE**. `D` is a changed outcome versus merge-base; `C` is a control whose preserved behavior must be demonstrated; `H` specifically guards the new head commit. Test references resolve to exact files and names in the catalog below. A test existing in source is not a captured pass. Rows can share evidence bundles; this is not a demand for one independent runtime per row.

| ID / named fixture | Affected / required data and result | How to seed the real application, or automated-only boundary | Minimum proving evidence | Status |
| --- | --- | --- | --- | --- |
| F01 — held user Q, buffered wake W during settlement of A | D. Worktree resolved, old Q queued/held, A still blocking with no Stop marker for A; agent/provider W queues unheld. After A settles, W starts once and completes; Q remains byte-for-byte held with null start/completion. | UI or RPC starts long turn, queues Q, stops it; after interruption use isolated-server CLI/MCP send to start A without releasing Q. Real Claude background completion must offer W while A is still blocking. Reject attempts where W arrives after A is terminal or Q was released. | T1 red on base / green on head AND paired **runtime transcript** N1. Record A/Q/W run, attempt, message and provider-turn IDs, ordered queue-held/status events and native start/result frames. | NEEDS CAPTURE |
| F02 — subsequent native local_agent and another wake | D, downstream incident outcome. After F01, actual native task is discovered, progresses and finalizes; same native ID must become completed with result marker and completedAt; a later continuation is consumed. | In A's prompt arrange native Agent work on the background completion, ending parent without waiting. MCP ping during child work can exercise later progress discovery without releasing Q. | **Runtime transcript** N1 on both revisions, native task_started/progress/task_notification plus persisted same-ID subagent row and subsequent completed wake. T1 alone never proves native latch recovery. | NEEDS CAPTURE |
| F03 — buffered wake while idle beside an older hold | C. No active run, no missing-worktree predecessor; queue hold alone must not prevent a new provider continuation from starting. `activeRun` term is false; this does not use queued exemption. | After holding Q and settling old active run, genuine idle continuation or MCP send starts first new work; preserve Q. T1's first provider send exercises the service equivalent. | T1 head-green first wake/active assertions; N1 should log idle-to-new-run boundary. Base-green control, not red-on-base. | NEEDS CAPTURE |
| F04 — no held queue / normal serial work | C. `queueIsHeld=false`, including false/absent holds and holds on nonqueued records; normal user/provider runs still serialize. Empty eligible selection is no-op. | Fresh thread: active A, queue two follow-ups, allow A then first follow-up to finish. UI or client RPC is sufficient. | T8 both notification parameters plus T10. T10 supplies absent/true queueHeld cases; explicit false is observed after T7 resume. Nonqueued held-field variation is code-equivalent, not separately asserted by these tests. | NEEDS CAPTURE |
| F05 — Stop commits before wake while active still blocks | C. `stopReachedRun=true`; W and Q held, active later interrupted, no extra native start after worker drain/recovery resume. Historical Stop of another run must not block F01. | Exact pre-interrupt completion window is not deterministically controllable through public UI/RPC. Native timing attempts count only if ordered events prove this window; otherwise automated-only. | T2 exact named integration test head-green (base also expected green). It deliberately commits Stop before running interrupt effects. N1/F01 supplies unrelated historical Stop contrast. | NEEDS CAPTURE |
| F06 — fresh text / non-provider provenance inherits hold | C/D boundary. With held Q plus active A, agent/server and agent/mcp text stay held; scheduled user sends do not release Q; user/provider is not agent/provider. Ordinary unscheduled client send belongs to F07. | Real Codex gives agent/server in F20; MCP queue while A busy gives agent/mcp. Scheduled work via actual scheduled-task service. Public WS cannot forge agent/provider because provenance is rewritten. Arbitrary user/provider combinations are automated-only. | T1's server-text assertion + T5 mapping + F20 native transcript cover essential production contrast. Existing T1 does not directly assert mcp/scheduled/user-provider subcases; catalog those as uncovered predicate variants, not new passing tests. | NEEDS CAPTURE |
| F07 — explicit user send releases holds | C, reverse state. `heldRunsToRelease` nonempty suppresses inherited hold when client is user web/mobile, no scheduledTaskId, workspace resolved. Holds clear, order survives, no lost prompt. | After Stop/recovery, ordinary web/mobile send or client RPC with web/mobile provenance. Unlike MCP, this deliberately resumes queue. | T9 head-green and T7 resume/replay controls. T9 directly uses web; mobile shares server predicate but has no separate native-client capture. | NEEDS CAPTURE |
| F08 — late wake after failed/interrupted worktree setup, no active run | C. `worktreeMissingRun` forces hold even without exemption prerequisites; worktreePath null. No execution in project root. | Launch worktree against deliberately inaccessible isolated remote; queue after failure, or interrupt in-flight preparation. A genuine provider cannot emit a wake before any session exists; direct provider command in this state is automated-only. | T3 failed/interrupted head-green, plus T4 during-setup cases. No native Claude worktree-wake claim. | NEEDS CAPTURE |
| F09 — historical unresolved worktree + newer active run | H. Historical failed/interrupted worktree preparation, null path, later user-started A without workspacePreparation, held Q, provider wake W while A blocks. W remains held and Q never released. With resolved nonnull path use F01 instead. | User auto-start after failed setup creates newer active root; a real background wake is timing-dependent. Exact controlled history is **automated-only minimum**. | T3 failed/interrupted: run current test sequence (user start BEFORE provider wake). Head-green, base-green; expected red on immediate parent lacking guard. Older sequence with wake before user start does not distinguish this fix. | NEEDS CAPTURE |
| F10 — mixed held+eligible queue readiness | D. Old held Q plus unheld W, live thread and no blocking run: ready true in both stores; Q unchanged. | Real F01 after A settles exercises SQL. Memory store is an in-process test service, not an app connection mode. | T6 memory and SQL red-on-base / green-on-head; F01 for SQL-to-native integration. | NEEDS CAPTURE |
| F11 — held-only / empty / no eligible wake | C. Held-only, empty, terminal-only, or held Q plus completed wake must be not-ready. Pre-existing held wakes are not auto-migrated or released. | Hold Q via Stop/restart. Empty/terminal-only normal threads. Exact store combinations and absent thread use tests. | T6 plus T10 both storage parameters and T7. These are preserved controls; base also green on the negative subassertions. | NEEDS CAPTURE |
| F12 — active work vetoes queue readiness | C. Unheld W beside each preparing/starting/running/waiting status never starts. Completion clears barrier; still starts only one. | Slow setup/provider, active question or settlement can expose states, but exact four-state comparison is automated-only minimum. | T10 sqlite/memory explicitly enumerates all four blockers, T6 enumerates running beside held Q, T8 enforces one promotion. Do not describe T6 alone as four-state coverage. | NEEDS CAPTURE |
| F13 — archived/deleted/missing thread | C. Live-thread predicate false for archive/delete despite unheld queue; missing thread returns typed not-found. Scheduler recheck must not start it. | Archive thread through client or RPC. Missing/deleted projection edge cases use stores, not a real CLI. | T10 sqlite/memory covers both inactive flags and typed missing error. Store-only control; no native runtime needed. | NEEDS CAPTURE |
| F14 — ordering, multiple eligible runs and ordinals | D/C. Skip earlier held row, retain automatic-completion priority and queuePosition/ordinal order among remaining eligible rows; one start per terminal; delayed user rows move behind already-started continuation where needed. | Use queue, reorder, hold, resume through UI/RPC; F01 supplies held skip. Full tie/automatic priority combinations are store/service fixtures. | T1 + T8 + T11 + T12. T12 tests order only, not hold filtering; combined coverage must be described honestly. No separate test directly combines held automatic completion with multiple unheld rows. | NEEDS CAPTURE |
| F15 — startup/shutdown recovery and receipt replay | C. All held runs remain held through recovery/rebuild, edit/reorder still works, explicit resume and same-command replay create no duplicate run/start. Persisted already-held provider wakes remain held as well; no repair migration added. | Restart only the isolated dev server with queued work; then Resume. Memory reconciliation/rebuild exactness is automated-only. Never use the live install. | T7 startup/shutdown head-green plus T17 selected command replay; F01/10 prove recovery can start an eligible wake beside held work. T7 uses held user messages, not a pre-upgrade native wake row. | NEEDS CAPTURE |
| F16 — Resume uses held queued run's provider, not thread fallback | H. Current thread provider P limited; oldest queued run Q uses available provider R and is held. After canceling earlier limited queued work, Resume must release and start Q using its saved model selection. Conversely, first queued provider limited must reject without clearing holds; empty queue falls back to current provider. | Queue per-message model/provider selections, induce P limit in isolated state, retain Q held, then Resume. Exact provider error/history arrangement is automated-only minimum; public UI cannot reliably manufacture a usage-limit session. | T13 current head sequence with `hold-available` + explicit `resume-available`: head-green, base-green, expected parent-red. Same test covers limited refusal; T18 covers empty queue. T14 covers app-owned vs buffered monitor selection. | NEEDS CAPTURE |
| F17 — selected held user message / invalid selection | C. `queued-run.start` selects given user row rather than helper, releases holds and starts exactly once on receipt replay. Running-thread race rejects; notification/delegated rows are not send-now candidates. | Stop with several queued user messages, Send now on a chosen item; driver repeats same commandId. Notification-selection negative is automated-only. | T17 and T19 head-green. Existing tests cover ordinary selection and running race, not every notification/delegated rejection arm. | NEEDS CAPTURE |
| F18 — queued-start error chooses eligible row | D caller consequence. Held Q sorts before unheld W; W encounters capability/handoff/start validation failure. Error fallback must fail W, leave Q queued/held, and allow next eligible run as policy permits. Explicit selection failure targets its supplied ID. | Supported-path handoff rejection can be arranged via provider switch, but deterministic held+failing wake and malformed projection identities are **automated-only**. | T20 is existing failure control WITHOUT held Q, combined with T1 selection proof. No existing exact held-Q/error-fallback test was found. Capture this limitation explicitly; do not claim T20 alone proves held-run targeting. An authorized focused test is needed for direct proof if this edge is required beyond compositional coverage. | NEEDS CAPTURE |
| F19 — existing post-selection vetoes remain effective | C, new eligible path reaches existing usage-limit / provider-error / disabled-instance / missing-worktree protections. Usage limit leaves queue; provider error or disabled instance re-holds it; failed setup never runs follow-up in project root. | Actual provider limit/error and per-project disable via settings/RPC; worktree failure via isolated remote. Controlled service tests are minimum, native induced failures not required. | T15 both failure classes, T16 disabled instance, T4 worktree failure/interruption; T13 queued-provider contrast. These are controls, not necessarily red on base. | NEEDS CAPTURE |
| F20 — Codex settled root background command needs a fresh prompt | D. Real commandExecution completes after root settles; actual offer is message_text, dispatched agent/server notification remains held beside Q and active A. No native turn/start until explicit release; after Resume/client release exactly one fresh prompt receives command detail. | Real Codex CLI background command outlives root; while another MCP-started run is settling beside held Q, command completes. Capture Stop case if completion races committed Stop. Then explicitly release. A synthetic continuation-service offer is not this fixture. | **Runtime transcript** N2 before/after actual command path; T5 + T1 are supporting mapping/hold controls only. No direct changed-offer automated assertion exists. If native Codex capture unavailable in this round, mark row unproven, not automatically covered by Claude. | NEEDS CAPTURE |
| F21 — Codex offer guards and completion outcomes | C around F20. Nonsettled/child/no-service/interrupting/closed/duplicate completion must not make extra root offers. Successful exit 0, failure nonzero and unknown null all retain message_text; retained context release depends on remaining work. | Native duplicate frames/service-absent/closed-context conditions cannot be deterministically seeded by public UI/RPC; these are adapter replay fixtures only. Native success can share N2; failure/unknown are protocol variants. | No exact existing command-completion delivery/guard matrix test found. T21 covers background Stop only; T22 is the DIFFERENT native-child path. Keep excluded-guard/outcome coverage labelled partial unless direct replay evidence is supplied. Do not enlarge native capture into every unchanged protocol branch. | NEEDS CAPTURE |

## Exact test catalog

All paths below are relative to the worktree; links pin the reviewed head. Parameter placeholders are the source's exact test title and the required values are stated. None was executed in pass 1.

| Ref | Exact file | Exact test name / parameter |
| --- | --- | --- |
| T1 | [runtimeLayer.test.ts](https://github.com/pingdotgg/t3code/blob/c740ee52fabfabea61f16a43a1591c5777d54eca/apps/server/src/orchestration-v2/runtimeLayer.test.ts#L5083) | `starts a provider wake queued beside a held queue` |
| T2 | [BackgroundWorkStop.integration.test.ts](https://github.com/pingdotgg/t3code/blob/c740ee52fabfabea61f16a43a1591c5777d54eca/apps/server/src/orchestration-v2/BackgroundWorkStop.integration.test.ts#L1062) | `Stop holds a provider wake that queues before the stopped turn ends` |
| T3 | [ThreadLaunchService.test.ts](https://github.com/pingdotgg/t3code/blob/c740ee52fabfabea61f16a43a1591c5777d54eca/apps/server/src/orchestration-v2/ThreadLaunchService.test.ts#L1244) | `holds a message queued during setup that arrives after the setup %s` — failed, interrupted |
| T4 | [ThreadLaunchService.test.ts](https://github.com/pingdotgg/t3code/blob/c740ee52fabfabea61f16a43a1591c5777d54eca/apps/server/src/orchestration-v2/ThreadLaunchService.test.ts#L1159) | `holds a message queued during setup when the workspace preparation %s` — fails, is interrupted |
| T5 | [ProviderContinuationService.test.ts](https://github.com/pingdotgg/t3code/blob/c740ee52fabfabea61f16a43a1591c5777d54eca/apps/server/src/orchestration-v2/ProviderContinuationService.test.ts#L159) | `delivers a message_text wake as a real prompt, not a buffered wake` |
| T6 | [ProjectionStore.test.ts](https://github.com/pingdotgg/t3code/blob/c740ee52fabfabea61f16a43a1591c5777d54eca/apps/server/src/orchestration-v2/ProjectionStore.test.ts#L189) | `%s queue readiness skips held runs without bypassing active work` — memory, SQL |
| T7 | [runtimeLayer.test.ts](https://github.com/pingdotgg/t3code/blob/c740ee52fabfabea61f16a43a1591c5777d54eca/apps/server/src/orchestration-v2/runtimeLayer.test.ts#L4984) | `preserves and holds queued messages across %s until explicitly resumed` — startup, shutdown |
| T8 | [runtimeLayer.test.ts](https://github.com/pingdotgg/t3code/blob/c740ee52fabfabea61f16a43a1591c5777d54eca/apps/server/src/orchestration-v2/runtimeLayer.test.ts#L4087) | `promotes only one queued run after each terminal run (notification: %s)` — false, true |
| T9 | [SteeringCompletion.integration.test.ts](https://github.com/pingdotgg/t3code/blob/c740ee52fabfabea61f16a43a1591c5777d54eca/apps/server/src/orchestration-v2/SteeringCompletion.integration.test.ts#L997) | `queues a plain send behind the stopped queue and releases its hold` |
| T10 | [RunCompletionReads.test.ts](https://github.com/pingdotgg/t3code/blob/c740ee52fabfabea61f16a43a1591c5777d54eca/apps/server/src/orchestration-v2/RunCompletionReads.test.ts#L27) | `checks queue eligibility and delivery ownership without unrelated history in %s` — sqlite, memory |
| T11 | [runtimeLayer.test.ts](https://github.com/pingdotgg/t3code/blob/c740ee52fabfabea61f16a43a1591c5777d54eca/apps/server/src/orchestration-v2/runtimeLayer.test.ts#L4876) | `places held queued messages after a continuation that started first` |
| T12 | [QueuedRunOrder.test.ts](https://github.com/pingdotgg/t3code/blob/c740ee52fabfabea61f16a43a1591c5777d54eca/apps/server/src/orchestration-v2/QueuedRunOrder.test.ts#L6) | `keeps automatic completion delivery ahead of visible queued messages` |
| T13 | [runtimeLayer.test.ts](https://github.com/pingdotgg/t3code/blob/c740ee52fabfabea61f16a43a1591c5777d54eca/apps/server/src/orchestration-v2/runtimeLayer.test.ts#L4546) | `keeps queued user selections and pauses only the limited provider` |
| T14 | [runtimeLayer.test.ts](https://github.com/pingdotgg/t3code/blob/c740ee52fabfabea61f16a43a1591c5777d54eca/apps/server/src/orchestration-v2/runtimeLayer.test.ts#L4710) | `delivers a queued monitor update from %s after conversation selection %j` — all three source/selection rows |
| T15 | [runtimeLayer.test.ts](https://github.com/pingdotgg/t3code/blob/c740ee52fabfabea61f16a43a1591c5777d54eca/apps/server/src/orchestration-v2/runtimeLayer.test.ts#L4409) | `handles a queued message after a %s failure` — usage_limit, provider_error |
| T16 | [runtimeLayer.test.ts](https://github.com/pingdotgg/t3code/blob/c740ee52fabfabea61f16a43a1591c5777d54eca/apps/server/src/orchestration-v2/runtimeLayer.test.ts#L6871) | `holds a queued run instead of starting it on an instance the project turned off` |
| T17 | [SteeringCompletion.integration.test.ts](https://github.com/pingdotgg/t3code/blob/c740ee52fabfabea61f16a43a1591c5777d54eca/apps/server/src/orchestration-v2/SteeringCompletion.integration.test.ts#L553) | `sends a selected held message once and preserves the remaining queue order` |
| T18 | [Orchestrator.control-reads.test.ts](https://github.com/pingdotgg/t3code/blob/c740ee52fabfabea61f16a43a1591c5777d54eca/apps/server/src/orchestration-v2/Orchestrator.control-reads.test.ts#L263) | `dispatches metadata, queue resume and request controls without hydrating unrelated history` |
| T19 | [SteeringCompletion.integration.test.ts](https://github.com/pingdotgg/t3code/blob/c740ee52fabfabea61f16a43a1591c5777d54eca/apps/server/src/orchestration-v2/SteeringCompletion.integration.test.ts#L648) | `keeps a message queued when send now races with a running turn` |
| T20 | [testkit/ProviderSwitch.integration.test.ts](https://github.com/pingdotgg/t3code/blob/c740ee52fabfabea61f16a43a1591c5777d54eca/apps/server/src/orchestration-v2/testkit/ProviderSwitch.integration.test.ts#L2583) | `fails an unsupported queued handoff and advances to the next queued provider` |
| T21 | [Adapters/CodexAdapterV2.test.ts](https://github.com/pingdotgg/t3code/blob/c740ee52fabfabea61f16a43a1591c5777d54eca/apps/server/src/orchestration-v2/Adapters/CodexAdapterV2.test.ts#L3044) | `stops a completed run's background command without a client-supplied run` (support only, not delivery proof) |
| T22 | [Adapters/CodexAdapterV2.test.ts](https://github.com/pingdotgg/t3code/blob/c740ee52fabfabea61f16a43a1591c5777d54eca/apps/server/src/orchestration-v2/Adapters/CodexAdapterV2.test.ts#L4948) | `wakes the parent when a native child finishes after the parent's turn` (different offer site; do not substitute for F20) |

## Minimum capture bundles and provenance

1. **Automated regression bundle:** identical T1 and T6 test definitions against production code at base and head. Base must fail on wake hold/readiness, not on missing test, compile error or fixture setup; head must pass. Preserve full command, exact production SHA, test-only overlay identification if needed, exit code and start/end HEAD. There is no demand that negative controls fail on base.
2. **New-head guard bundle:** T3 failed/interrupted and T13 with current test bodies, head-green. For direct evidence of the latest fixes run the same definitions against immediate parent production: T3 must reach active-run provider wake and fail its hold assertion; T13 must fail Resume's incorrect provider usage-limit selection. These rows are expected base-green. Do not label parent-red as merge-base-red.
3. **Focused control bundle:** T2, T4, T5, T7–T12 and T14–T20 at head, with exact filters and executed case counts. Reuse T1/T6/T13 from the first two bundles. Aggregate logs can cover many rows but should map assertions and skipped cases; do not add overlapping totals. T21/T22 are optional supporting adapter controls and never replace direct F20 delivery proof.
4. **N1 real Claude before/after runtime transcript:** base and current head, isolated dev server plus actual Claude Code CLI through the existing CLIProxyAPI hub. Record CLI/model versions, OS, isolated home, production SHA, tested commands/prompts and whether a client was used. First-party Claude OAuth is not this VM's working route. Never copy credentials or pairing links into evidence. A current-head server whose production code was subsequently changed is invalid evidence.
5. **N2 Codex command-completion before/after runtime transcript:** close F20's changed-offer gap with actual native commandExecution completion and no fresh prompt before release on head, then one prompt after release. Need observable offer delivery or an equivalent event/log chain proving actual command item -> server-owned notification -> held run -> native input after release. A provider's narrative claim is not a wire/projection observation. If the actual offer is not logged, don't claim its delivery value was directly observed; identify inferred classification separately.

These bundles are the minimum for the direct changed behavior. Matrix rows F06/F14/F17/F18/F21 explicitly identify extra predicate/guard combinations without a direct existing assertion. They remain limitations unless authorized automated evidence is supplied; no instruction here permits editing source during this read-only pass. An unchanged guard does not require a new native capture for every combinatorial input, and a broad suite's pass count is not direct proof of an uncovered branch.

### N1 practical recipe and acceptance boundaries

Use the actual app/server entry points; CLI commands must target the new isolated environment, never the user's live T3 instance. A driver can use `orchestration.launchThread`, `orchestration.dispatchCommand` for user send/queue/Stop/resume, `orchestration.getThreadProjection` plus subscriptions for observations, and the isolated server's MCP `t3_thread_send`/CLI `thread send` to send agent/mcp text without releasing holds. The [WebSocket handler](https://github.com/pingdotgg/t3code/blob/c740ee52fabfabea61f16a43a1591c5777d54eca/apps/server/src/ws.ts#L1905) rewrites createdBy; the [MCP send service](https://github.com/pingdotgg/t3code/blob/c740ee52fabfabea61f16a43a1591c5777d54eca/apps/server/src/mcp/OrchestratorMcpService.ts#L2816) sets agent/mcp. Do not fabricate a provider command through WS and label it native.

The previous successful recipe was: long 60-sequential-echo user turn, queue follow-up Q, Stop, wait for interruption; then CLI/MCP send a prompt requesting a 30-second background Node timer and a 26-second foreground timer followed by roughly 300 words; on the background completion launch a native Agent doing 60 sequential foreground echo calls, and end the wake turn without awaiting it; later CLI/MCP ping while child works. The durations are a timing recipe, not proof of interleaving. Native/model variance may require more attempts. Each attempt gets a new timestamped directory and its own IDs. Do not recycle the old artifact's identifiers or assume a successful prompt means the race occurred.

Acceptance requires a captured intermediate projection/event showing W requested/queued while A is still preparing/starting/running/waiting, with Q held and no Stop marker for A. Then show A terminal, W started once, W terminal, and Q unchanged. Include native session/task/turn IDs and map them to projection IDs. Continue until same native child gets final notification and a persisted completed row/result, then another wake completes. Base transcript should demonstrate the held-wake/later-running defect under the same verified ordering. A final snapshot alone cannot prove initial W hold state, ordering, or exactly-once starts. MCP sends after Stop are intended; browser/web/mobile sends would release Q and make the fixture invalid.

For F05's exact Stop race and F08/F09's provider command before a usable native worktree exists, use the identified deterministic automated fixture rather than claiming an unreliable native reproduction. Failed/interrupted worktree setup can be seeded through launch/retry/interrupt APIs, but emitting provider output without a session would be synthetic.

### Surface and provider decisions

All clients and connection modes consume the same server policy: local and hosted web, desktop web shell, and mobile; local/remote/relay/tunnel carry no changed contract. No separate visual or Electron/native-client evidence is needed for this server-only change. Runtime transcripts should name the client actually used and not imply all clients were exercised.

Claude is the mandatory real buffered-wake runtime. Codex command text is the distinct mandatory changed adapter path. Other providers' buffered continuations share the agent/provider predicate (including OpenCode, Pi, and enabled ACP/Grok post-settle paths); the generic scheduler test covers that classification, without claiming live provider-specific verification. Cursor and Antigravity have no changed adapter code or newly enabled capability in this diff; any message reaching the same scheduler predicate obeys it. No unsupported provider is to be silently swapped into the Claude/Codex evidence slots.

## Pass 1 disposition

All 21 rows await current-head capture. Direct regression proof, latest-commit guard proof and native transcripts are outstanding; the explicitly listed partial branch coverage remains a limitation to track. No merge recommendation or code change is made.

FRICTION:
tool | Initial ghdrop upload returned a POST Transport error; curl reached the service | Ensure the uploader runtime can reach the configured HTTPS service.
tool | Web fetch could not open the two supplied evidence Markdown URLs; curl retrieved them successfully | Use direct download for ghdrop text artifacts when web fetch reports inaccessible.

VERDICT: INSUFFICIENT F01-F21 need capture; F06/F14/F17/F18/F21 also have explicitly identified partial direct-test coverage