Wave 2: add durable DevSpace -> Codeg thin execution bridge

[James3014]

CURRENT STATUS — WAVE 2 SOURCE/ENGINEERING VERIFIED ON LATEST MAIN / LIVE 4-OF-5 PASS / ONLY W2.6 GROK WITNESS BLOCKED (2026-09-21)

Frozen implementation Candidate remains efc197bf3e7fdc49d357dab91eafc9eb152b9451 (tree f837ca7a0a7a8f2f5116e299c55ed982d89bdefd) from contract base b8f638f72c8dc4198b29e008f864026f55f2f4b6.

Current main advanced to 45ce06a51ab2af43f513ab49ad111be4cc8cc48c. The 8 intervening commits touch only carrier/cutover/CLI files and do not overlap the seven #224 paths. A disposable latest-main apply of the #224 diff completed without conflict and re-ran: bridge 10/10 PASS, Codeg MCP focused 2/2 PASS, config PASS, TypeScript PASS, git diff --check PASS, and npm run build PASS.

Live DevSpace -> Codeg bridge witnesses remain PASS for Codex, OpenCode, Agy/Antigravity and Cline; exact cancel and lost-ack/restart/no-duplicate reconciliation are also live-proven.

The only unmet Wave 2 engineering acceptance item is W2.6 Grok through the new DevSpace bridge. Fresh diagnosis proves the source/runtime path reaches Grok correctly but the current grok.com free rolling window rejects the Codeg-launched Grok turn before any model call: the exact failed session reports modelCalls=0, stop_reason=rate_limit, and subscription:free-usage-exhausted with 510976/500000 tokens. The same Grok 1.0.34 ACP protocol can complete successfully outside Codeg, and the successful/failed sessions use the same grok-build-plan / grok-4.6 / high configuration and essentially identical prompt/tool payload sizes. No alternate Grok model or XAI API credential is available on this host. Do not repair DevSpace/Codeg to work around this external quota and do not blind-retry.

Formal nexus.candidate_acceptance.v4 is a separate downstream independent-acceptance gate, not a Wave 2 engineering acceptance criterion. Its missing direct/Core evidence path must not be synthesized, but it no longer counts as a second Wave 2 implementation blocker.

Keep #224 open. Do not merge, cut over, retire adapters, release, or start Wave 3. The next engineering gate is one fresh Grok bridge nonce witness after legitimate Grok entitlement/headroom is available; then #224 becomes ready for independent acceptance.

Status

P0 — OWNER_AUTHORIZED / READY_FOR_BOUNDED_IMPLEMENTATION

Owner goal: complete Wave 2 by adding a thin DevSpace -> Codeg execution bridge on macOS, using the verified Codeg v0.31.1 five-route pilot from #217.

Source watermark at contract creation: main@b8f638f72c8dc4198b29e008f864026f55f2f4b6.

This is a bounded Candidate implementation. It does not authorize merge, production cutover, deletion of existing DevSpace provider adapters, Codeg auto-merge, release, or expansion of Nexus routing/acceptance authority.

Goal

Make DevSpace a thin, durable control gateway for Codeg execution so a host can start one already-selected worker task and later observe/reconcile/cancel it without keeping the MCP request open.

The intended seam is:

Nexus / host
  -> DevSpace thin Codeg bridge
       -> Codeg task/runtime
            -> Codex / OpenCode / Grok / Antigravity(Agy) / Cline

DevSpace owns gateway mechanics, durable operation identity, workspace containment, safe projection, timeout/reconciliation, and exact-effect fencing.

Codeg owns long-lived worker/task/worktree execution.

Nexus/Owner retains route selection, scope authority, verification, Candidate acceptance, merge, release, and production authority.

Required behavior

W2.1 Thin dispatch contract

Expose the smallest composable control surface needed for:

• dispatch/start;
• status/readback and terminal result collection;
• exact cancellation;
• reconciliation after timeout/restart/unknown acknowledgement.

Prefer reusing existing generic durable operation_status / operation_reconcile instead of adding duplicate status/collect authorities when they can carry the required Codeg receipt.

The dispatch request must carry an already-selected Codeg agent route; DevSpace must not choose/fallback/reroute providers.

Initial admitted routes for this Wave are exactly the five proven by #217:

• codex
• open_code
• grok
• antigravity
• cline

Cline must support the proven explicit config contract mode_id=plan and config_values.model=poolside/laguna-s-2.1:free; do not hard-code GLM quota as a prerequisite.

W2.2 Durable identity and no-blind-retry

Bind each logical dispatch to a caller-supplied stable attemptKey / operation identity before the first Codeg effect.

Persist enough request identity to reject conflicting reuse of the same key.

Codeg generic create does not provide a caller idempotency key. The bridge therefore must create a deterministic bridge marker for the Codeg task and persist the operation before create. If acknowledgement is lost:

• do not blindly create again;
• reconcile against Codeg physical state using the stored marker / task identity;
• bind exactly one matching Codeg task;
• fail closed on conflicting/multiple matches;
• only create again after reconciliation has authoritatively established that the prior create did not take effect.

Restart must not convert an unresolved create/start into a fresh dispatch.

W2.3 Workspace / folder boundary

The host addresses a DevSpace workspace, not an arbitrary Codeg filesystem path.

The bridge must resolve the Codeg execution folder from the already-open DevSpace workspace within approved-root rules. Do not expose arbitrary filesystem or credential-bearing Codeg configuration as a host-selected escape hatch.

If Codeg folder registration is needed, make it deterministic/reconcilable and keep it subordinate to the DevSpace workspace identity.

W2.4 Security projection

Do not proxy raw Codeg agent/config surfaces that can contain tokens, keys, auth state, or credential-bearing provider configuration.

Return only the bounded fields needed by the host, including stable DevSpace operation identity, Codeg task identity when known, agent route, task state, worktree/branch identity when safe, bounded result text, failure/cancel reason, and reconciliation status.

Apply existing DevSpace secret redaction to Codeg errors/results before exposing them.

Do not expose the Codeg bearer token.

W2.5 Authority containment

• Codeg delegation remains disabled for this bridge.
• no Codeg auto-merge;
• no provider fallback/routing;
• no automatic successor task;
• no merge/push/release/deploy;
• no direct replacement of existing DevSpace local-agent adapters in this Wave.

The bridge must not become another CapabilityPlanner, verifier, acceptance authority, or merge authority.

W2.6 Five-route live verification

Against an isolated disposable repository and local Codeg v0.31.1:

• dispatch all five routes through the new DevSpace bridge, not directly through Codeg;
• each route must produce a non-empty expected nonce result;
• each must have a stable DevSpace operation identity and bound Codeg task identity;
• disconnect/reconnect or equivalent restart reconciliation must preserve identity and not duplicate the task;
• exact cancel must affect only its target;
• baseline checkout must remain unchanged;
• no merge, push, release, or production effect.

A transient provider failure may be retried only as a new logical attempt after the previous effect is terminal and reconciled. Do not erase the failed receipt.

Expected implementation shape

Prefer a small Codeg client/bridge module plus the minimum durable-operation/server wiring and tests. Reuse the current durable operation store/manager introduced on main; do not create a second operation ledger.

Expected touched surface should remain close to:

• a new bounded Codeg bridge/client module and tests;
• src/durable-operations.ts / tests only as needed for durable Codeg operation lifecycle;
• src/server.ts / tests for the MCP surface;
• configuration types only if needed for Codeg endpoint/token.

Do not refactor src/local-agent-* merely to make this bridge fit.

Acceptance

A Candidate is ready for independent review only when all are true:

1. source tests for replay conflict, restart/outcome-unknown, reconcile-before-resend, exact cancel, secret-safe projection, and authority containment pass;
2. the real MCP tool schema rejects extra process-control/authority fields;
3. dispatch returns promptly with a durable operation rather than waiting for the worker turn;
4. exact replay of the same attemptKey and request returns the same operation; conflicting reuse fails closed;
5. unknown create/start acknowledgement is reconciled without duplicate Codeg tasks;
6. all five provider routes pass a new live bridge E2E on isolated worktrees;
7. DevSpace source checkout and disposable baseline are clean outside the Candidate worktree;
8. no existing provider adapter is removed or widened;
9. evidence is bound to exact Candidate SHA, Codeg v0.31.1, and the live package/runtime identity used for the E2E.

Workforce / execution boundary

Owner selected Codex CLI with Luna xhigh as the bounded implementer for this Wave. Fresh local availability/preflight is still required before mutation. This named worker does not receive acceptance, merge, release, or production authority.

Implementation realm: isolated local DevSpace worktree on the Owner's macOS host because final verification depends on the local Codeg runtime and installed provider CLIs.

Independent acceptance remains separate.

Non-goals

• no production cutover;
• no adapter deletion;
• no Chat On Steroids integration in this Issue;
• no generalized external-runtime plugin framework;
• no provider catalog redesign;
• no Codeg credential-management API exposure;
• no change to Nexus route/model selection authority;
• no auto-chain after Candidate completion.

[James3014]

Wave 2 Candidate evidence receipt

Frozen source subject

• repository: James3014/devspace
• exact base / current main at evidence cutoff: b8f638f72c8dc4198b29e008f864026f55f2f4b6
• local Candidate commit: efc197bf3e7fdc49d357dab91eafc9eb152b9451
• Candidate tree: f837ca7a0a7a8f2f5116e299c55ed982d89bdefd
• local Candidate worktree: clean
• changed paths only:
  • src/codeg-bridge.ts
  • src/codeg-bridge.test.ts
  • src/config.ts
  • src/config.test.ts
  • src/durable-operations.ts
  • src/server.ts
  • src/server.test.ts
• no src/local-agent-* mutation
• no push / PR / merge / cutover / release / production activation

Source verification

Independent controller execution on the frozen Candidate:

• node --import tsx src/codeg-bridge.test.ts -> 10/10 PASS
• node --import tsx src/config.test.ts -> PASS
• node --import tsx --test --test-name-pattern='Codeg bridge|Codeg operation_status' src/server.test.ts -> 2/2 PASS
• node_modules/.bin/tsc -p tsconfig.json --noEmit -> PASS
• git diff --check -> PASS
• npm run build -> PASS, build identity devspace-1.0.7-efc197bf

The Candidate reuses the existing durable-operation store, binds attemptKey before Codeg effects, reconciles marker/task identity before any safe resend, projects Codeg operations without prompt/config/token leakage, rejects half-configured URL/token, and fails closed before create/start unless Codeg effective settings prove auto_process=false, auto_merge=false, and delegation enabled=false.

A read-only independent Agy review was given the immutable base..Candidate diff directly and returned VERDICT: PASS / FINDINGS: none; it did not mutate the worktree. This supports source review only and is not a substitute for formal Candidate Acceptance.

Live Codeg v0.31.1 bridge evidence

Disposable baseline repo:

• HEAD 0644b2a06d60e951400dcc7bd63cc29f64862169
• final baseline status clean
• Codeg folder fix(mcp): bound MCP session lifecycle and make cutovers multi-session safe (#31) #35
• effective settings observed before dispatch: auto_process=false, auto_merge=false, max_concurrent=5
• delegation observed enabled=false

Successful routes through the new Candidate CodegTaskBridge:

• Codex: DevSpace operation op_0cd822a6b2cb520d -> Codeg task fix(mcp): bound MCP session lifecycle and make cutovers multi-session safe (#31) #35 -> review -> durable succeeded -> W2_BRIDGE_CODEX_OK; start returned in 19 ms.
• OpenCode: op_e788813e8ea939b6 -> task fix(#33): isolate conversational checkouts and surface cross-session capacity contention #36 -> review -> succeeded -> W2_BRIDGE_OPENCODE_OK; start returned in 1 ms.
• Agy/Antigravity: op_25b6722e377c09e0 -> task chore(issue-31): compose current main into cutover donor #39 -> review -> succeeded -> W2_BRIDGE_AGY_OK; start returned in 21 ms.
• Cline stable route: op_6827461fe740eba3 -> task fix(mcp): make cutovers crash-consistent across sessions #40 -> review -> succeeded -> W2_BRIDGE_CLINE_OK; exact config used mode_id=plan + config_values.model=poolside/laguna-s-2.1:free; start returned in 1 ms.

Exact cancel:

• OpenCode operation op_d948a6aec41ac423 was bound to task fix(agents): bind execution idle policy per turn #41.
• bridge cancel targeted that exact operation/task only.
• physical task settled canceled; durable operation mapped to failed/canceled as intended.

Lost acknowledgement / restart reconciliation:

• operation op_a70d7ee707bcfa1e executed a real Codeg start then the test transport intentionally lost the acknowledgement.
• first durable state became outcome_unknown, bound to task fix(workspaces): isolate shared conversation mutations #42, with exactly one initial create.
• after closing the first store and instantiating a fresh bridge/store, reconciliation preserved task fix(workspaces): isolate shared conversation mutations #42.
• reconcileCreates=0, deterministic marker physical matches = 1.
• final task state review, durable state succeeded, result W2_RECONCILE_OK.

Grok blocker — do not misclassify as bridge failure or PASS

Two new logical Wave 2 bridge attempts reached the real Grok path and then failed terminally:

• op_e38540eafec8bd58 -> task feat(codex): compose directory trust bootstrap after heartbeat integration #37 -> canceled
• op_5b3d47c005c1fe67 -> task fix(git): bind promotion to canonical runtime lineage #38 -> canceled

Physical Codeg evidence on the first attempt reached Initialize -> Connected -> Prompting -> Error -> Disconnected; task worktree and disposable baseline remained clean.

A native control probe outside Codeg then ran grok 1.0.34 and returned the provider message that the current free Grok Build usage limit has been reached. No XAI_API_KEY or GROK_CODE_XAI_API_KEY is present on this host, and the current grok.com session exposes only the default Grok model. Therefore no further blind Grok retry was attempted.

Classification: EXTERNAL_PROVIDER_ENTITLEMENT_BLOCKER. W2.6 remains physically unclosed because its contract requires a fresh live bridge nonce from all five routes.

Formal Candidate Acceptance boundary

The current acceptance skill requires new direct Candidates to bind physical devspace.direct_candidate_execution.v1 executor evidence and a matching nexus.core.generic-verification-response.v1-experimental verification response. Current DevSpace main/source inspection did not find a direct evidence producer for this Candidate. Those artifacts were not synthesized.

Formal v4 verdict ceiling: ACCEPTANCE_BLOCKED.
Engineering/source claim ceiling: SOURCE_CANDIDATE_IMPLEMENTED_AND_VERIFIED / LIVE_BRIDGE_4_OF_5_PASS / GROK_QUOTA_BLOCKED.

No Owner approval, merge, release, deployment, adapter retirement, production-readiness, or Wave 3 authority follows from this receipt.

[James3014]

W2.6 Grok root-cause reconciliation — no source repair authorized

CAUSAL_WATERMARK

• desired contract: Wave 2: add durable DevSpace -> Codeg thin execution bridge #224 W2.6 at current Issue watermark
• implementation Candidate: efc197bf3e7fdc49d357dab91eafc9eb152b9451
• original contract base: b8f638f72c8dc4198b29e008f864026f55f2f4b6
• observed current main: 45ce06a51ab2af43f513ab49ad111be4cc8cc48c
• latest-main overlap: none across the seven Wave 2: add durable DevSpace -> Codeg thin execution bridge #224 paths
• latest-main disposable apply: conflict-free; focused source verification + production build PASS

Grok causal evidence

The newest DevSpace-bridge Grok attempt:

• DevSpace operation op_6817c6ad3b5aeeca
• Codeg task test(agents): make capacity continuation rejection deterministic #44
• start returned in 31 ms
• terminal physical state: canceled
• durable state: failed
• disposable worktree/baseline remained clean

The exact Grok session behind task #44 reports:

• modelCalls=0
• assistantMessageCount=0
• errorCount=1
• retry state: HTTP 429 subscription:free-usage-exhausted
• rolling usage: 510976 / 500000
• terminal stop_reason=rate_limit

Control probes narrowed the boundary further:

1. Codeg raw ACP (bypassing work_task and DevSpace bridge) reaches Grok Initialize/Connected/Prompting and then the same rate-limit failure.
2. Direct xAI ACP grok --no-auto-update agent stdio can complete a real session/prompt with modelCalls=1, proving Grok 1.0.34 ACP itself is functional.
3. Successful direct ACP and failed Codeg ACP both use grok-build-plan, grok-4.6, reasoning_effort=high, sandbox=off.
4. Their system prompt/tool-definition payload sizes are materially the same (~8.7 KB system prompt, ~60.3 KB tool definitions). The extra Codeg companion MCP surface is not supported as the causal explanation.
5. Local Grok catalog exposes no alternate entitled Grok model; no XAI_API_KEY / GROK_CODE_XAI_API_KEY is present.

Classification: EXTERNAL_PROVIDER_ROLLING_QUOTA_BLOCKER.

This does not authorize:

• provider fallback;
• a direct-Grok bypass of Codeg;
• weakening W2.6;
• another blind logical attempt without new provider-availability evidence;
• source mutation in DevSpace or Codeg to work around account entitlement.

Wave 2 implementation is otherwise engineering-green. One fresh Grok nonce through the new DevSpace bridge remains the exact engineering completion gate. Formal v4 Candidate Acceptance remains a separate downstream gate.

[James3014]

W2.6 fresh Grok nonce — reconciled external rolling-quota block, no bridge defect proven

Fresh evidence after #64 / PR #225 cutover recovery completed:

• DevSpace current main/runtime: 45ce06a51ab2af43f513ab49ad111be4cc8cc48c
• fix: ChatGPT self-cutover can deadlock at prepared/reconcile-only #64 cutover 90f4590a-601b-4d6c-9a3b-d661ce9881f8 = closed
• cutover mode = normal
• reconciliationRequired=false
• Wave 2: add durable DevSpace -> Codeg thin execution bridge #224 seven-path Candidate still applies cleanly over current main; prior 4-of-5 bridge evidence remains intact.

Fresh provider-availability control — correction

A non-work-task Codeg ACP Grok control was used only to check provider availability before spending another W2.6 logical bridge nonce.

The controller initially misclassified the control as AVAILABLE because the live session snapshot still contained the user nonce while status remained prompting.

Exact Grok session readback proves that was a false green:

• control session: 01a0c13c-2469-71a0-a589-e4fab238aaf8
• usage.json was never created;
• no turn_completed success exists;
• Grok update instead records HTTP 429:
  subscription:free-usage-exhausted
• provider rolling usage in that control:
  510976 / 500000

Therefore that control is reclassified:

PROVIDER_AVAILABILITY_CONTROL=QUOTA_BLOCKED
MODEL_RESPONSE_PROVEN=FALSE
FALSE_GREEN_CORRECTED=TRUE

One fresh W2.6 bridge attempt

One fresh logical bridge witness was then attempted before the false-green was discovered:

• attempt key: wave2-live-grok-fresh-20260921-a1
• DevSpace durable operation: op_0127f9208a05e862
• Codeg task: #45
• route: grok
• marker/title binding matches the exact operation
• task reached: queued -> preparing -> running -> canceled
• no result summary
• no changed-file evidence
• exactly one create/start; no retry was issued.

Exact Grok execution session:

• session: 01a0c13c-b7ba-7ac3-8371-3fa228593d5d
• model: grok-4.6
• reasoning effort: high
• modelCalls=0
• input/output tokens = 0
• retry state: HTTP 429 subscription:free-usage-exhausted
• rolling usage: 501968 / 500000
• terminal stop_reason=rate_limit
• Codeg log physically shows:
  Connected -> Prompting -> Error -> Disconnected
  in about 5.6 seconds.

This is still consistent with the prior root-cause classification:

EXTERNAL_PROVIDER_ROLLING_QUOTA_BLOCKER

No DevSpace / Codeg bridge source defect is established by this attempt.

Earliest evidence-backed retry window

At controller readback time (2026-09-21 ~07:57 Asia/Taipei), local Grok usage records show the earliest positive model-call usage still inside the rolling 24-hour window at approximately:

2026-09-20 17:24 Asia/Taipei

No positive local model-call record was found between the rolling-window boundary and that time.

Therefore there is no local evidence supporting another Grok retry before approximately:

2026-09-21 17:25 Asia/Taipei

This is not a guarantee of entitlement recovery; it is only the earliest evidence-backed point at which a material local usage block should begin aging out. A fresh non-work-task provider control must still pass with an actual completed model turn before another W2.6 logical bridge nonce is permitted.

Current disposition

W2_SOURCE_ENGINEERING=GREEN
LIVE_BRIDGE_CODEX=PASS
LIVE_BRIDGE_OPENCODE=PASS
LIVE_BRIDGE_ANTIGRAVITY=PASS
LIVE_BRIDGE_CLINE=PASS
LIVE_BRIDGE_GROK=BLOCKED_EXTERNAL_QUOTA

FRESH_W2_6_ATTEMPT=FAILED_RATE_LIMIT
MODEL_CALLS=0
BRIDGE_DEFECT_PROVEN=FALSE
BLIND_RETRY=FORBIDDEN
SOURCE_REPAIR_AUTHORIZED=FALSE
ISSUE_224=KEEP_OPEN

Exact next gate:

FRESH_CODEG_ACP_GROK_CONTROL_COMPLETES_A_REAL_MODEL_TURN_AFTER_PROVIDER_HEADROOM_RETURNS

Only after that gate may one new bounded W2.6 bridge nonce be attempted. No provider fallback, direct-Grok substitution, alternate model substitution, or source workaround is authorized.

[James3014]

Wave 2 engineering verification complete — 5/5 live routes PASS

Fresh current-state binding:

• DevSpace canonical main: 45ce06a51ab2af43f513ab49ad111be4cc8cc48c
• frozen Wave 2: add durable DevSpace -> Codeg thin execution bridge #224 implementation Candidate: efc197bf3e7fdc49d357dab91eafc9eb152b9451
• Candidate tree: f837ca7a0a7a8f2f5116e299c55ed982d89bdefd
• Codeg runtime: v0.31.1
• disposable baseline: 0644b2a06d60e951400dcc7bd63cc29f64862169
• Codeg folder: #35

Fresh Grok account control

After the Owner switched Grok to another account, a non-work-task Codeg ACP control was executed first.

Exact control:

• connection: 8bb22eef-1dac-47f5-937d-1cd9dbe95571
• Grok session: 01a0c1ba-6fd9-7423-a20f-d7e71603d8a8
• model: grok-4.6
• modelCalls=1
• total tokens: 33509
• turn_completed
• stop_reason=end_turn
• rate_limited=false
• assistant nonce physically observed: W2_GROK_ACCOUNT2_CONTROL_OK_20260921

This closes the previous rolling-quota availability gate.

W2.6 fresh bridge witness

One new logical W2.6 attempt was then executed:

• attempt key: wave2-live-grok-account2-20260921-a1
• DevSpace durable operation: op_d037086f7f2c7ad6
• Codeg task: #46
• route: grok
• start returned in 22 ms
• terminal task state: review
• durable operation state: succeeded
• result: W2_BRIDGE_GROK_ACCOUNT2_OK_20260921
• expected nonce matched: true

Physical Grok execution:

• session: 01a0c1ba-eb81-7d93-9dcf-906af4db78a4
• model: grok-4.6
• modelCalls=1
• total tokens: 33970
• stop_reason=end_turn
• rate_limited=false
• assistant nonce physically observed: true

Physical side-effect readback:

• files_changed=0
• additions=0
• deletions=0
• Codeg task worktree dirty: false
• baseline SHA remained 0644b2a06d60e951400dcc7bd63cc29f64862169

Codeg safety settings immediately before dispatch:

• auto_process=false
• auto_merge=false
• max_concurrent=5
• delegation.enabled=false

Wave 2 engineering matrix

Codex        PASS
OpenCode     PASS
Antigravity  PASS
Cline        PASS
Grok         PASS

exact cancel sibling isolation            PASS
lost-ack/restart same-task reconciliation PASS
no blind duplicate create                 PASS
baseline checkout unchanged               PASS
auto-merge/delegation disabled            PASS

Therefore:

W2_SOURCE_ENGINEERING=GREEN
W2_LIVE_FIVE_ROUTE=PASS
W2_6_GROK=PASS
EXTERNAL_GROK_QUOTA_BLOCKER=CLOSED
ENGINEERING_ACCEPTANCE_CRITERIA=SATISFIED
ISSUE_224=READY_FOR_INDEPENDENT_ACCEPTANCE

Formal v4 acceptance evidence gate

Fresh physical search for this exact Candidate found no Candidate-bound:

• devspace.direct_candidate_execution.v1
• matching nexus.core.generic-verification-response.v1-experimental

Generic schema/source implementations exist elsewhere in Nexus/skill worktrees, but no physical executor/verification artifact is bound to Candidate efc197bf....

Under current nexus.candidate_acceptance.v4, those artifacts cannot be synthesized from tests, Agy review, chat context, Codeg receipts, or Git history.

Therefore the formal downstream gate is:

V4_EXECUTOR_EVIDENCE=ABSENT
V4_CORE_VERIFICATION_RESPONSE=ABSENT
FORMAL_CANDIDATE_ACCEPTANCE=BLOCKED_ON_EVIDENCE_PRODUCER_PATH
CANDIDATE_DEFECT_PROVEN=FALSE
MERGE_AUTHORITY=FALSE
PRODUCTION_CUTOVER_AUTHORITY=FALSE

Exact next gate:

PHYSICAL_DEVSPACE_DIRECT_CANDIDATE_EVIDENCE_PLUS_MATCHING_CORE_GENERIC_VERIFICATION_FOR_EFC197BF

Do not merge, cut over, retire adapters, release, or start Wave 3 from this engineering receipt alone.

[James3014]

Wave 2 formal-acceptance replay — direct-evidence lineage recovered, worker gate remains

CAUSAL_WATERMARK

• DevSpace main: 45ce06a51ab2af43f513ab49ad111be4cc8cc48c
• Wave 2: add durable DevSpace -> Codeg thin execution bridge #224 current durable watermark before this comment: comment 5754521888
• Nexus-new discovery main: 5cff3aeb85bd01574124234f09981253a1efab98
• capability index Git blob: d21f108ba4a65bc73230e22cf8b3129e39848758
• capability index SHA-256: c714e58f2615e5d5540606dc7ffb983322a9991e61a1ed4bdb4287bcaeeb0355
• matched existing capability: local_agent_execution_and_chat_swarm

Direct-evidence producer lineage

The immutable TG-A producer source referenced by current nexus.candidate_acceptance.v4 was physically recovered from the Owner host bootstrap object/worktree store:

• exact TG-A worktree HEAD: add3e0b73e1da02d08f09ca4c12108408492da4d
• exact committed source blobs are physically present:
  • src/execution-protocol.ts blob 0ae465535c5d8b3ce64c3f44215b76c2d36693dd
  • src/core-mutation-session.ts blob 566b01f4b1d1118c8ae64a512f369e7d211158da

A search of that exact TG-A worktree found no standalone devspace.direct_candidate_execution.v1 emitter or literal dce_ artifact producer. This matches the v4 contract design: TG-A supplies committed producer semantics (DispatchIntent normalization/hash, execution-generation binding, Core mutation/Candidate provenance); the acceptance validator independently reconstructs/cross-checks the physical artifact.

Current DevSpace main already contains those producer primitives. No new DevSpace evidence schema or second evidence authority is required.

Fresh replay workspace

A new managed isolated worktree was opened for a genuine evidence-tracked replay:

• workspace: ws_5b608fcd8f
• physical root: /Users/jameschen/Workspace/.devspace-chatgpt/worktrees/devspace-8db5f27c
• exact base/HEAD: 45ce06a51ab2af43f513ab49ad111be4cc8cc48c
• source tree: c3e5391d31b3be0b55513e06dcf6b668c1d9f2d2
• isolated managed worktree: true
• source dirty: false
• competing conversations: 0
• mutation allowed by workspace boundary: true

No repository mutation and no Core mutation session was started yet.

Worker preflight — current hard gate

The existing #224 Owner contract fixed the implementer to Codex CLI / Luna xhigh, with fresh preflight required before mutation.

Fresh direct preflight:

Codex gpt-5.6-luna / xhigh
profileResolved=true
providerConfigured=true
capacityAvailable=true
runtimeReady=false
dispatchState=BLOCKED
blocker=RUNTIME_STARTUP_NOT_READY
detail=Codex SDK package manifest could not be resolved

The currently advertised Codex GPT-5.6 Sol implement profile fails on the same runtime prerequisite.

Therefore:

• no core_mutation_session_open was created;
• no agent_start was attempted;
• no Agy/Gemini, Grok, OpenCode, Cline, or other worker was silently substituted;
• no repository files changed.

Current classification:

W2_ENGINEERING_5_OF_5=PASS
DIRECT_EVIDENCE_REPLAY_WORKSPACE=READY
DIRECT_EVIDENCE_PRODUCER_SEMANTICS=RECOVERED
ORIGINAL_FIXED_WORKER_PREFLIGHT=BLOCKED
REPOSITORY_MUTATION_STARTED=FALSE
FORMAL_V4_ACCEPTANCE=NOT_STARTED_FOR_NEW_REPLAY

The exact next gate is one of:

RESTORE_FIXED_CODEX_LUNA_RUNTIME

or an explicit Owner worker rebind for this bounded 7-file mechanical replay.

No model fallback is implied by this comment. Independent acceptance, integration, merge, cutover, release, production, and #982 B3 remain separate downstream gates.

[James3014]

Owner-bounded direct-evidence replay authority — current-main rebind

This durable record preserves the current Owner instruction to continue Issue #224 through the formal direct-evidence replay without changing the settled product semantics.

Exact execution subject

• repository: James3014/devspace
• current canonical base: f9305e926c0b5f64d84516b8038eacef329e15c5
• managed workspace: ws_713741306e
• execution lane: DIRECT_DELEGATED
• fixed worker: Codex CLI gpt-5.6-luna / xhigh
• worker preflight: runtimeReady=true, local capacity available
• task role: mechanical current-main replay of the already-verified Wave 2: add durable DevSpace -> Codeg thin execution bridge #224 Codeg thin bridge
• claim ceiling: CANDIDATE_READY

Allowed write scope

Only these seven repository-relative paths may change:

• src/codeg-bridge.ts
• src/codeg-bridge.test.ts
• src/config.ts
• src/config.test.ts
• src/durable-operations.ts
• src/server.ts
• src/server.test.ts

Deletion is forbidden. The replay must preserve all later current-main changes, including #228/#229 cutover lifecycle and recovery behavior.

Required outcome

• preserve the previously verified Codeg bridge semantics, durable attempt identity, lost-ack reconciliation, exact cancel, settings fail-closed behavior, and 5-provider route contract;
• integrate those semantics over current main rather than reverting later cutover work;
• run focused Wave 2: add durable DevSpace -> Codeg thin execution bridge #224 tests, TypeScript verification, build, and diff checks;
• leave a clean committed Candidate for independent verification.

Authority boundary

This record authorizes only the bounded delegated implementation/replay above. It does not grant independent acceptance, merge, deployment, release, production, adapter retirement, Issue closure, or #982 B3 execution authority.

Capability discovery remains REUSE_EXISTING: local_agent_execution_and_chat_swarm against Nexus-new 5cff3aeb85bd01574124234f09981253a1efab98.

[James3014]

Direct-evidence replay recovery attempt a2 — new isolated subject

Attempt a1 is retained as historical failure evidence and must not be retried:

• workspace: ws_713741306e
• Core session: cms_3512d76889df4c2190185a9cdc915529
• failure: dispatchIntent.attemptId did not match durable attemptKey
• current source proves this validation runs inside startAgent() before durable agent creation/provider launch
• DevSpace regression for that exact error requires zero durable agents; observed agent_list=[]
• workspace remained unmodified
• Core nevertheless retained AGENT / OUTCOME_UNKNOWN, so a1 is not reused.

This comment authorizes one new bounded recovery attempt with a new physical subject:

• repository: James3014/devspace
• base: f9305e926c0b5f64d84516b8038eacef329e15c5
• workspace: ws_87ecb47f5f
• execution lane: DIRECT_DELEGATED
• fixed worker: Codex CLI gpt-5.6-luna / xhigh
• durable attempt identity: issue224-f930-direct-evidence-replay-20260921-a2
• claim ceiling: CANDIDATE_READY

Writable paths remain exactly:

• src/codeg-bridge.ts
• src/codeg-bridge.test.ts
• src/config.ts
• src/config.test.ts
• src/durable-operations.ts
• src/server.ts
• src/server.test.ts

Deletion is forbidden. The worker must replay the already-verified Issue #224 Codeg thin bridge from donor commits efc197bf... / 5d8dc161... while preserving all current-main #228/#229 cutover lifecycle behavior.

Required verification remains focused #224 tests, TypeScript noEmit, build, and diff check. Worker must not commit, push, merge, deploy, release, or claim independent acceptance.

This recovery authority does not widen product semantics or downstream authority. Formal acceptance, integration, merge, deployment, Issue closure, and #982 B3 remain separate gates.

[James3014]

Direct-evidence replay attempt a3 — completed-agent recovery

Attempt a2 produced a valid bounded Candidate but cannot be used as v4 direct executor evidence because its durable Codex agent terminated with idle_timeout. Immutable TG-A producer source requires a successful terminal agent: status=idle, terminalReason=completed, scopeState=WITHIN_SCOPE, and provider continuity not UNKNOWN/LOST. a2 remains engineering/Candidate evidence only and is not laundered into direct evidence.

This record authorizes one new bounded direct delegated execution with a clean physical subject:

• repository: James3014/devspace
• exact source/base: f9305e926c0b5f64d84516b8038eacef329e15c5
• workspace: ws_98faf1fc06
• execution lane: DIRECT_DELEGATED
• fixed worker: Codex CLI gpt-5.6-luna / xhigh
• task id: devspace-issue224-f930-direct-evidence-replay-a3
• attempt id: issue224-f930-direct-evidence-replay-20260921-a3
• claim ceiling: CANDIDATE_READY

The settled donor is the already controller-verified current-main Candidate:

• commit: 71bdd67ebf10052d885873e21cd18feb52027d85
• tree: 8221baa72dbec6fff7abf79981ce71de9e4ef156

Worker responsibility is intentionally minimal:

1. reproduce exactly the donor bytes for the seven authorized paths;
2. verify only that no path outside those seven is changed;
3. stop immediately and return, without running the full verifier suite.

Writable paths are exactly:

• src/codeg-bridge.ts
• src/codeg-bridge.test.ts
• src/config.ts
• src/config.test.ts
• src/durable-operations.ts
• src/server.ts
• src/server.test.ts

Deletion/rename is forbidden. No other source, state, config, package, Git ref, runtime, cutover, or production mutation is authorized.

Controller-side required verification after worker completion remains:

• focused Codeg bridge tests;
• config tests;
• focused server Codeg tests;
• TypeScript --noEmit;
• git diff --check;
• production build in an isolated verification worktree.

The worker must not stage, commit, push, merge, deploy, release, close the Issue, or claim independent acceptance. Formal Core verification, independent Candidate Acceptance, integration, merge, deployment, release, production, and #982 B3 remain separate gates.

This a3 recovery also corrects the direct-evidence cross-binding contract:

• Core operation_id must equal the DispatchIntent taskId;
• Core integration authority_hash must equal sha256:<dispatchIntentHash>;
• binding/dispatch/durable attempt identities must be identical.

[James3014]

Current formal-acceptance frontier — fixed Luna executes; replay is blocked by an existing Core-session owner

Fresh downstream #227 evidence supersedes the earlier "Codex workspace out of credits" blocker as the immediate gate.

Current verified state:

• DevSpace main/runtime: f9305e926c0b5f64d84516b8038eacef329e15c5
• Wave 2: add durable DevSpace -> Codeg thin execution bridge #224 engineering witness: 5/5 live routes PASS (unchanged)
• fixed formal-replay worker: codex / gpt-5.6-luna / xhigh
• runtime preflight: runtimeReady=true
• a fresh read-only Luna control physically entered a real model session and produced repeated token/tool activity
• the previous terminal Your workspace is out of credits did not recur
• that control itself ended at its 120s wall bound with provider outcome UNKNOWN
• workspace remained clean, changedPaths=[], Candidate absent

Before a new a4 mutating replay could begin, DevSpace fail-closed ownership enforcement returned:

workspace=ws_713741306e
CORE_MUTATION_ACTOR_MISMATCH
Active Core mutation session belongs to a different caller identity.

No parallel a4 was started and no state DB / caller fence was bypassed.

Current serialized formal-acceptance path:

existing #227 Core-session owner reconciles/terminalizes its exact session
        ↓
fresh a4 DIRECT_DELEGATED replay on current main
        ↓
physical devspace.direct_candidate_execution.v1 evidence
        ↓
matching nexus.core.generic-verification-response.v1-experimental
        ↓
independent nexus.candidate_acceptance.v4
        ↓
#224 integration decision

Current disposition:

W2_ENGINEERING_5_OF_5=PASS
FORMAL_V4_ACCEPTANCE=BLOCKED_ON_EXISTING_CORE_SESSION_OWNERSHIP
MERGE_AUTHORITY=FALSE
PRODUCTION_CUTOVER_AUTHORITY=FALSE
WAVE3_AUTHORITY=FALSE
AUTO_CHAIN=false

[James3014]

#224 direct-evidence replay a3 — worker completed successfully; controller verification/Core closure belongs to the original Core-session owner

Fresh physical evidence for the already-authorized a3 subject:

• workspace: ws_98faf1fc06
• root: /Users/jameschen/Workspace/.devspace-chatgpt/worktrees/devspace-785374e5
• base/head: f9305e926c0b5f64d84516b8038eacef329e15c5
• worker: codex / gpt-5.6-luna / xhigh
• agent: agt_4122a4c7
• provider session: 01a0c31e-368d-7ee2-a6f7-afec39522d03
• task: devspace-issue224-f930-direct-evidence-replay-a3
• attempt: issue224-f930-direct-evidence-replay-20260921-a3
• DispatchIntent hash: 3d9c48a9941852cf7f095ca8a92ee2bbe9cc682e5963a263ab25344ecc9a725e

Terminal worker state:

agentState=idle
terminalReason=completed
scopeState=WITHIN_SCOPE
providerState=KNOWN_UNVERIFIED
Candidate present=true
unexpectedPaths=[]
diffHash=4e52f693e193cdf21f6571d02ec5bbbe558267104b8d82c8a5f920978f3bd0b7

Exactly seven authorized paths changed:

• src/codeg-bridge.ts
• src/codeg-bridge.test.ts
• src/config.ts
• src/config.test.ts
• src/durable-operations.ts
• src/server.ts
• src/server.test.ts

The worker's final bounded readback proved every one of those seven worktree blobs exactly matches donor Candidate 71bdd67ebf10052d885873e21cd18feb52027d85.

No deletion, rename, staging, commit, ref mutation, merge, deployment, or release was performed by the worker.

Controller read-only git diff --check returned exit code 0.

Current ownership gate

The current observing controller is not the Core-session owner for this a3 workspace.

• core_mutation_session_status(ws_98faf1fc06) cannot resolve a matching session for this caller;
• controller attempts to launch the required focused tests/typecheck through DevSpace are fail-closed with CORE_MUTATION_ACTOR_MISMATCH;
• no Remote Desktop / shell bypass was used.

Therefore the next step must remain with the original a3 Core-session caller identity:

run controller-side focused verifier set
→ verify seven-path donor parity remains exact
→ create exact scoped Candidate commit via the owning Core session
→ record physical Core Candidate provenance
→ produce devspace.direct_candidate_execution.v1 if the current committed producer path can truthfully do so
→ canonical Core generic verification
→ independent candidate_acceptance.v4

If the seven-path a3 Candidate cannot produce the required physical direct-evidence surface because current main lacks that producer, STOP and fall through to #227's already-recorded 12-path producer-restoration a4 contract (comment 5757664772). Do not fabricate historical producer evidence.

Current claim ceiling:

A3_WORKER_EXECUTION=COMPLETED
A3_SCOPE=WITHIN_SCOPE
A3_SEVEN_PATH_DONOR_PARITY=PASS
A3_CONTROLLER_DIFF_CHECK=PASS
A3_CONTROLLER_VERIFIER_SET=NOT_RUN_BY_THIS_CALLER
A3_CANDIDATE_COMMIT=NOT_PROVEN
FORMAL_V4_ACCEPTANCE=NOT_PROVEN
MERGE_AUTHORITY=FALSE
PRODUCTION_CUTOVER_AUTHORITY=FALSE
AUTO_CHAIN=false

[James3014]

OWNER HOLD — preserve Wave 2 Candidate evidence; stop spending acceptance effort pending HerdR #235

Fresh DevSpace main: 3f8d6c12c4986c0af806944d9aaa7c3427fb0380.

The five-route #224 engineering witness and the exact Candidate lineage remain valid historical evidence. They are not being rewritten as HerdR evidence.

Owner architecture direction has changed: HerdR #235 is now the sole active CLI runtime candidate.

Therefore:

• preserve the existing Wave 2: add durable DevSpace -> Codeg thin execution bridge #224 Candidate, tests, physical evidence and comments;
• do not start another Codeg replay/integration/cutover attempt solely to advance production adoption;
• no Codeg adapter deletion or production cutover is authorized;
• P0 prerequisite: restore current-main direct Candidate evidence producer for #227 #231 generic physical-evidence producer work remains independently useful and should continue under its own exact contract;
• formal Codeg acceptance may be resumed only by a new explicit Owner decision or if P0: qualify HerdR as the durable external coding-agent runtime substrate #235 fails structurally and Codeg is reselected.

Maximum current Codeg claim remains historical engineering/Candidate evidence only, not selected production execution plane.