P0: implement bounded DevSpace -> Codeg thin execution gateway

[James3014]

Status

P0 — OWNER_AUTHORIZED / READY_FOR_BOUNDED_IMPLEMENTATION

Owner authorization: continue through Wave 2 completion.

Independent evidence adjudication on 2026-09-20 returned ADVANCE_TO_WAVE2. This Issue is the bounded brownfield implementation contract that follows #217; it does not rewrite #217's pilot history.

Evidence fence

• DevSpace canonical main / loaded Dev MCP source: e03fa9ea19ec2f76f38008d7b4ac286005c26692
• Codeg pilot: v0.31.0 / aace536fe9e38575a8973ed83435199ecc2700c6
• Wave 1 provider/runtime evidence: P0: pilot Codeg as external coding-agent execution plane #217
• Existing provider-adapter hardening frontier: Harden Dev MCP reliability across host binding, worker startup, and timeout reconciliation #15 (remain frozen while this Wave 2 contract is active)
• Canonical capability discovery owner: DevSpace capability local_agent_execution_and_chat_swarm; extend/wrap existing durable agent primitives, do not create a second agent controller, provider-catalog truth source, or task/effect/session ledger.

Objective

Implement a thin DevSpace -> Codeg execution gateway beneath the existing DevSpace durable agent/control semantics so Codeg can own long-lived heterogeneous coding-agent execution while DevSpace remains the ChatGPT-facing workspace/control boundary.

The target shape is:

ChatGPT / Nexus controller
  -> existing DevSpace durable agent control surface
       identity / attemptKey / workspace authority / status / cancel / reconcile
       -> thin Codeg execution gateway
            -> Codeg work_task
                 -> Codex / OpenCode / Grok / Cline / Antigravity

Codeg is an executor/runtime only. Nexus/Owner retain route, scope, verification, acceptance, merge, release and production authority.

Brownfield requirement delta

The current DevSpace durable agent manager/store/control contract is retained. Wave 2 adds a replaceable Codeg execution backend and the minimum binding/reconciliation state needed to address Codeg work tasks.

Existing direct provider adapters are not deleted in Wave 2; they remain rollback/compatibility paths until a later separately-authorized retirement decision.

Binding requirements

REQ-001 — Preserve one durable DevSpace control authority

DevSpace SHALL preserve the existing public durable agent identity and workspace/attempt fencing semantics. The Codeg bridge SHALL NOT create a second DevSpace task/session/effect ledger, Planner, router, verifier or acceptance authority.

REQ-002 — Explicit backend selection

The Codeg execution backend SHALL be explicitly configured/admitted and SHALL be off-path when not configured. DevSpace SHALL NOT silently reroute a provider to Codeg based on model preference, failure, cost or hidden fallback.

REQ-003 — Exact workspace binding

For each Codeg-backed execution, DevSpace SHALL deterministically bind the exact DevSpace workspace root to the corresponding Codeg folder/workspace before task creation. A task SHALL NOT be created against a different folder because of stale history, basename collision or prior session state.

REQ-004 — Durable external handle before semantic completion

A Codeg-backed start SHALL persist the exact Codeg work_task identity as the external execution handle before the execution can be treated as durably started. Status, continuation, cancellation and reconciliation SHALL address that same handle.

REQ-005 — No blind duplicate create

The caller's existing DevSpace attemptKey / replay contract SHALL remain the idempotency authority. Because Codeg work-task create has no caller-supplied idempotency key, an ambiguous create/start outcome SHALL enter reconciliation; DevSpace SHALL NOT blindly create a replacement task.

REQ-006 — Provider/model projection only

Host-selected provider/model intent MAY be translated into the exact Codeg agent/config identifiers needed by Codeg. The gateway SHALL NOT choose a worker/model on behalf of Nexus/Owner, and SHALL NOT maintain a competing provider catalog truth source.

REQ-007 — Durable status and reconnect

After MCP/controller disconnect or DevSpace process restart, DevSpace SHALL be able to recover or reconcile the same Codeg task identity and return truthful running/review/completed/failed/canceled/unknown state. A DevSpace restart SHALL NOT convert a still-running Codeg task into a false terminal provider failure merely because the local wrapper process ended.

REQ-008 — Exact cancel

Cancellation SHALL target exactly one Codeg task handle. It SHALL NOT cancel sibling tasks or claim provider-side cancellation unless Codeg confirms it.

REQ-009 — Agy direct gateway path is mandatory

Wave 2 SHALL prove a direct ChatGPT -> DevSpace gateway -> Codeg built-in Antigravity work_task path. Raw ACP-only evidence and parent->Antigravity delegation are insufficient substitutes. The accepted live witness SHALL perform a bounded mutation in an isolated worktree and host-side readback SHALL verify the physical result. No yolo, permission bypass, DB mutation or safety-control bypass is allowed.

REQ-010 — Five-route live coverage

The integrated gateway SHALL complete bounded live work through Codeg for:

• OpenCode
• Grok
• Codex
• Cline
• Google Antigravity/Agy

Each route must remain attributable to exact DevSpace operation/agent identity, Codeg task identity and isolated worktree.

REQ-011 — Real concurrency

At least three gateway-backed tasks SHALL have materially overlapping execution intervals. Sequential controller calls that merely queue work do not satisfy this requirement.

REQ-012 — Disconnect/recollection

A nonterminal gateway-backed task SHALL survive controller observation disconnect. After reconnect, the same DevSpace handle SHALL recollect/reconcile the original Codeg task; no replacement dispatch is allowed.

REQ-013 — False-green defense

Worker/result prose SHALL NOT be sufficient verification. Acceptance SHALL inspect Codeg task state plus physical worktree/file/diff evidence. The OpenCode Wave 1 missing-newline case is the required false-green model.

REQ-014 — Authority containment

The gateway SHALL NOT grant Codeg route selection, Candidate acceptance, merge, push, release, deployment, production or successor auto-chain authority. Codeg auto-merge/auto-chain SHALL remain disabled/out of scope.

REQ-015 — Secret containment

Codeg URL/token/private runtime configuration SHALL remain private configuration. Secrets SHALL NOT appear in MCP results, logs committed to Git, GitHub Issue evidence, worker prompts or public schemas.

REQ-016 — Rollback path

Existing direct DevSpace provider adapters SHALL remain available during Wave 2. This Issue does not authorize adapter deletion or production cutover.

Acceptance criteria

AC-001 — Contract/API preservation

Linked: REQ-001, REQ-002, REQ-014, REQ-016
PASS when existing non-Codeg agent_start/status/cancel/reconcile tests remain green and the Codeg path is explicit rather than default/fallback.
Negative control: Codeg unavailable/disabled must not silently fall back or mutate route truth.

AC-002 — Folder/workspace identity

Linked: REQ-003
PASS when two same-basename repositories in different absolute roots cannot cross-bind, and an existing Codeg folder for the exact path is reused rather than duplicated.

AC-003 — Start/replay/idempotency

Linked: REQ-004, REQ-005
PASS when exact replay of one DevSpace attempt returns/reconciles one Codeg task; changed payload under the same attempt key fails closed.
Negative control: simulate ambiguous create/start acknowledgement and prove no second task is blindly created.

AC-004 — Restart/reconcile

Linked: REQ-007, REQ-012
PASS when a Codeg task continues independently of the controller and the same external handle is recovered after reconnect/restart.
Negative control: missing/unreachable Codeg state reports unresolved/unknown, never fabricated success or absence.

AC-005 — Exact cancellation

Linked: REQ-008
PASS when canceling task A changes only A and concurrently running sibling B remains live/settles normally.

AC-006 — Five-route direct gateway canary

Linked: REQ-009, REQ-010, REQ-013
PASS only when all five providers complete bounded work through the integrated DevSpace gateway, including Antigravity through Codeg work_task, with independent host-side physical readback.

AC-007 — Concurrent execution

Linked: REQ-011
PASS when at least three exact task intervals overlap materially.

AC-008 — Authority/security negative controls

Linked: REQ-014, REQ-015, REQ-016
PASS when no gateway action exposes Codeg credentials, no Codeg action can merge/push/release through this bridge, and legacy adapters remain physically present.

AC-009 — Source/build quality

PASS when focused tests, affected full test suite, typecheck/build and package/runtime checks succeed on the exact Candidate. Test PASS is Candidate evidence only; it does not replace AC-004 through AC-008 live evidence.

AC-010 — Integrated runtime witness

PASS when the accepted Candidate is integrated/reloaded into the actual Dev MCP runtime and the live MCP action surface plus AC-004–AC-008 canaries are re-run against the integrated source identity.

Expected implementation shape

Prefer the smallest extension of existing primitives:

• existing DevSpace durable agent manager/store remain the control-plane owner;
• one thin Codeg client/execution adapter owns HTTP request/response translation and Codeg task-handle reconciliation;
• provider-specific Codeg ids/config are edge translation only;
• no new planner/router;
• no duplicate task/session ledger.

The implementation may choose exact files after current-source inspection. Any material scope expansion requires a contract delta before mutation.

Verification / claim ceiling

Required evidence:

• focused deterministic tests including negative controls above;
• exact Candidate diff and source identity;
• independent Candidate acceptance;
• integrated/reloaded runtime identity;
• five-provider live gateway canary;
• concurrency, disconnect/reconcile, cancel and duplicate-ambiguity witnesses.

Maximum pre-integration claim: CANDIDATE_READY.

Maximum Wave 2 terminal claim: WAVE2_THIN_GATEWAY_COMPLETE only when AC-001..AC-010 are all satisfied on the integrated runtime.

This Issue does not authorize provider-adapter retirement, production cutover, release, or Wave 3.

Execution / authority

• execution lane: DIRECT_CANONICAL in an isolated DevSpace-managed worktree based on e03fa9e...
• deletion policy: FORBID
• Owner authorization: explicit in current conversation on 2026-09-20
• independent Candidate acceptance: required
• merge/integration: only after Candidate acceptance; reverify exact integrated revision
• AUTO_CHAIN outside this Wave 2 contract: false

Contract delta — durable recovery intent (2026-09-20)

Evidence requiring the delta

The first two Codex Luna xhigh implementation attempts exposed a bounded semantic gap in REQ-007 / REQ-012. A Codeg-backed DevSpace worker can terminate locally while the exact remote Codeg work_task continues. A later recovery cannot infer whether to recollect the unsettled prior turn or send a new continuation prompt from the remote task's current status alone: the task may legitimately advance from running to review after the local worker is gone. Using remote status as the discriminator can therefore convert an uncollected prior result into a new work_task_return side effect.

This is a DevSpace durable-state ownership problem, not a Codeg routing decision. The recovery semantic SHALL be persisted by the existing DevSpace lifecycle owner and SHALL survive local worker/process replacement.

REQ-017 — Durable recovery intent

DevSpace SHALL persist, within its existing local-agent lifecycle authority, whether a newly launched local worker turn is a normal continuation or a recollection of the previous unsettled Codeg turn. The marker SHALL be bound to the exact durable agent / lifecycle generation and exact Codeg task handle.

A recollection turn SHALL:

• address the same persisted Codeg work_task handle;
• perform read/poll/collect/materialize only;
• SHALL NOT call work_task_create, work_task_start, or work_task_return;
• remain recollection even if Codeg has already advanced the task from running to review before the recovery worker starts;
• clear/settle the recovery intent only through the existing lifecycle CAS that settles the recovered turn.

A normal continuation after a successfully settled prior turn MAY use work_task_return against the same Codeg task when the task is in the expected review state.

DevSpace SHALL NOT infer recollection-vs-continuation from Codeg task status, prompt wording, process PID, transport session, or in-memory-only state.

AC-011 — Recovery-intent crash/race witness

Linked: REQ-004, REQ-007, REQ-012, REQ-017.

PASS only when deterministic tests prove both schedules:

1. local worker is lost while Codeg remains running, then a recovery turn recollects the same task to terminal without create/start/return; and
2. local worker is lost, Codeg reaches review before the recovery worker starts, and the persisted recovery intent still causes collection/materialization of that prior result without work_task_return.

Negative control: a genuinely successful prior DevSpace turn followed by an explicit new continuation must still be able to call work_task_return; recovery state must not leak across settled turns.

Authorized implementation-scope delta

The previous four-file scope was insufficient because the recovery discriminator must be durable rather than inferred. The bounded allowed path set for the next Candidate is expanded to:

• src/local-agent-codeg.ts
• src/local-agent-codeg.test.ts
• src/local-agent-sessions.ts
• src/local-agent-sessions.test.ts
• src/local-agent-contract.ts
• src/local-agent-store.ts
• src/local-agent-store.test.ts

No server.ts / public MCP schema change is authorized by this delta. No new database table or second task ledger is authorized. Prefer a backwards-compatible optional field inside the existing persisted lifecycle JSON plus existing CAS transitions.

Deletion policy remains FORBID. Authority, merge/release limits, five-route integrated canary requirements, and all other #220 acceptance criteria remain unchanged.

[James3014]

Wave 2 implementation frontier — Candidate frozen, verification incomplete

Fresh source/Candidate watermark:

• DevSpace canonical main: e03fa9ea19ec2f76f38008d7b4ac286005c26692
• Wave 2 checkpoint: f3ae2dbb4328914a4267eecd95bccd2bb6c8edb8
• current Candidate: 6d6ce587a89ccc7387f99123bb763e9d6d34a6f0
• Candidate tree: 79b405d587c6f59ca45db5dff4d9d06704b68c2d
• changed paths: exactly the seven P0: implement bounded DevSpace -> Codeg thin execution gateway #220 authorized files; no deletions
• Core mutation closure: COMPLETED, writerReconciliationState=CLEAR
• Core trusted-engineering claim: false (Candidate provenance only, not acceptance)

What is now implemented in the Candidate

• explicit/off-path Codeg backend beneath existing DevSpace durable agent/session authority;
• exact Codeg work_task handle binding;
• create/start lost-ack reconciliation with no blind resend;
• exact cancel semantics with non-canceled terminal observations kept unconfirmed;
• direct Codeg built-in Antigravity configured as auto_edit, never yolo;
• scoped Codeg worktree materialization with whole-set preflight, same-repository/exact-base checks, symlink/special-file rejection, deletion proof, staging/backups and compensating rollback;
• durable DevSpace lifecycle recovery intent per REQ-017/AC-011;
• recovery vs normal continuation no longer inferred from Codeg remote status;
• recollection of the same exact task is read/poll/collect-only even when Codeg reaches review before the replacement local worker starts;
• normal continuation encountering a still-running task fails closed unless durable recollectOnly authority exists;
• native/direct provider adapters remain present as rollback paths.

Verification evidence

Controller-run focused command on the final dirty state before Candidate commit:

npx --offline tsx src/local-agent-codeg.test.ts

Result: 26/26 PASS, 0 fail.

The suite includes negative controls for create/start lost acknowledgements, duplicate ownership, running-handle continuation without recovery authority, review-before-recovery race, missing recovery handle, exact cancel/sibling isolation, ambiguous cancel, materialization scope/base/symlink/deletion handling, read-only/tool-projection fail-closed behavior, and Agy auto_edit.

Remaining mandatory gates — DO NOT auto-integrate

Store/session/typecheck/build are currently NOT_RUN, not PASS. The isolated worktree lacks project dependencies (e.g. better-sqlite3); the frozen dependency operation requires an Owner-approved DevSpace carrier and is not being bypassed with manual install/NODE_PATH/symlinks.

After dependency verification succeeds, #220 still requires:

1. independent Candidate acceptance on exact Candidate 6d6ce587...;
2. integration only after that acceptance;
3. reload/rebind to the integrated Dev MCP source identity;
4. integrated five-route live canary, including direct DevSpace -> Codeg built-in Antigravity work_task;
5. three materially overlapping gateway tasks;
6. disconnect/recollection of the same task handle;
7. exact cancel sibling isolation;
8. authority/security negative controls.

Current classification: KEEP_OPEN / CANDIDATE_EXISTS / VERIFICATION_BLOCKED_ON_OWNER_APPROVED_DEPENDENCY_SYNC.

No merge, push, release, adapter retirement, production cutover, or Wave 3 is authorized by this checkpoint.

[James3014]

Local-only Candidate object preservation receipt

The frozen Wave 2 Candidate previously existed only as a local Git object (no remote ref). Its object is now durable.

• preserved candidate: 6d6ce587a89ccc7387f99123bb763e9d6d34a6f0
• preservation ref: preserve/20260920/issue-220-codeg-candidate-6d6ce587
• remote readback: exact match — git ls-remote origin refs/heads/preserve/20260920/issue-220-codeg-candidate-6d6ce587 returns 6d6ce587a89ccc7387f99123bb763e9d6d34a6f0
• ancestry reached by this tip (both commits were local-only with no remote ref before this operation):
  • f3ae2dbb4328914a4267eecd95bccd2bb6c8edb8 — wip: checkpoint Codeg gateway before durable recovery state
  • 6d6ce587a89ccc7387f99123bb763e9d6d34a6f0 — feat: persist Codeg recovery intent
• additional local-only Codeg history preserved in the same bounded operation:
  • preserve/20260920/issue-220-codeg-chain-706ddf897 -> 706ddf8971ec1690400b8bbb8e18e72ff7c425c7 (reaches 74b94839c, fc4b0d111, 344dca092 on top of PR Wave 2: add bounded Codeg thin execution gateway #221 head 89ef7a8b33…)
  • preserve/20260920/codeg-detached-e186155 -> e18615504389afc24a16f167cd6ab1190e414f8b
• PR Wave 2: add bounded Codeg thin execution gateway #221 remains unchanged: 89ef7a8b333c8332eae9a11c4b0591e59d783977 on base e03fa9ea19ec2f76f38008d7b4ac286005c26692
• meaning: preservation only; not PR update; not Candidate acceptance; not merge authorization; not Wave 2 completion.
• verification state remains: Candidate frozen; broader verification incomplete (store/session/typecheck/build NOT_RUN; blocked on approved dependency sync).

No Issue contract text was modified by this operation.

[James3014]

Independent review gate — Candidate 5f15906c rejected pending two materialization fixes

Frozen Candidate under review:

• commit 5f15906c55523b1ddaed53e83f96992106e06513
• tree c6f6de5ef9774c808be5aa5b8e2bdf2afe69c5c9
• production diff packet SHA-256 28fe22bad520febaea99f447b6fbb25f2cb3658cc17e496e5cc1b15def9baace

Independent reviewer:

• native Agy CLI 1.2.7
• model gemini-3.8-flash-medium
• read-only text/diff review in /tmp; no repository mutation
• verdict: REJECT_CANDIDATE

Blocking findings:

1. materializeCodegTask enforces writePaths but the Codeg edge currently receives no maxFiles authority, so a large changed-file set can exceed the DevSpace execution-contract blast-radius cap while remaining path-valid.
2. Parent/symlink validation is only preflighted before apply. The reviewer identified a race/escape seam around missing parents and later recursive creation. The repair gate is bounded: revalidate the physical root/parents immediately before each apply and create missing parents one level at a time with post-create non-symlink/directory checks. This does not claim to defeat an equally privileged malicious local process indefinitely; it closes the current unguarded substitution seam.

Independent verification already completed on the same Candidate:

• Codeg focused tests: 26/26 PASS
• local-agent-sessions: 23/23 PASS
• local-agent-store test command: exit 0
• tsc -p tsconfig.json --noEmit: PASS
• npm run build: PASS, build identity devspace-1.0.7-5f15906c
• full npm test: exit 0; no TAP failures observed
• verifier worktrees used an already-installed dependency tree whose package.json and package-lock.json hashes exactly match the Candidate; no package installation was performed.

Disposition:

• Candidate 5f15906c... is not accepted.
• Do not integrate/reload/canary this Candidate.
• Repair only the two bounded materialization findings, rerun the same source/build/full-test gates, then obtain a new independent review.
• All other P0: implement bounded DevSpace -> Codeg thin execution gateway #220 authority and stop boundaries remain unchanged.

[James3014]

Wave 2 exact Candidate — independently accepted and physically verified

Exact subject

• base: e03fa9ea19ec2f76f38008d7b4ac286005c26692
• Candidate: 37a907b5dcbeaf8b372ae1ed6029e6b855364c6c
• tree: 84ed57c7c06a3290c529ae4aa246f94bcbf1ac65
• production diff packet SHA-256: d375c966b789e9eb033d48ce8b3e7e044ce184041e33dc401e7b4bb2018faf6e
• changed paths: exactly the seven P0: implement bounded DevSpace -> Codeg thin execution gateway #220-authorized local-agent/Codeg files
• deleted paths: none

Independent review

Independent reviewer:

• Agy CLI 1.2.7
• model: gemini-3.8-flash-medium
• source: exact immutable production diff text; no repository mutation/tools
• verdict on exact Candidate: BLOCKERS: NONE / ACCEPT_CANDIDATE

The reviewer explicitly rechecked the two blockers that rejected Candidate 5f15906c...:

1. maxFiles materialization authority — CLOSED
   executionContract.maxFiles is projected through the DevSpace session edge into CodegRunInput, and the complete changed-file manifest is rejected before materialization when it exceeds the cap.
2. apply-time parent/symlink substitution — CLOSED
   materialization revalidates source/root/parent paths at apply time, creates missing parent segments one-by-one with non-symlink directory checks, and has a deterministic regression witness proving a parent substituted with a symlink is rejected before outside mutation.

The final 37a907b... delta over the independently accepted 9a1bfad... is compile-only:

• materializeCodegTask(... input: CodegRunInput ...);
• lstatIfPresent(...): fs.Stats | undefined.
  Independent review found no runtime/authority change from this delta.

Physical verifier — exact Candidate 37a907b

Verifier worktree: isolated exact Candidate checkout.
Dependency method: pre-existing node_modules tree whose package.json and package-lock.json hashes match the Candidate; no package installation. Temporary link/build outputs were removed after verification.

Results:

• Codeg gateway focused suite: 28/28 PASS
  • create/start lost-ack reconciliation and no blind retry;
  • same-task recollection from remote running and review;
  • normal continuation discrimination;
  • exact cancel confirmation;
  • exact folder/task handle recovery;
  • materialization scope/base/deletion/symlink protection;
  • maxFiles pre-mutation negative;
  • apply-time substituted-parent symlink negative;
  • Agy built-in antigravity + auto_edit, never yolo.
• local-agent session suite: 24/24 PASS
  • durable recovery marker;
  • errored Codeg binding recovery;
  • Codeg cancel fail-closed when configuration disappears;
  • explicit Codeg Agy preflight;
  • durable executionContract.maxFiles projection.
• local-agent-store test command: PASS / exit 0.
• tsc -p tsconfig.json --noEmit: PASS.
• npm run build: PASS, build identity devspace-1.0.7-37a907b5.
• complete npm test: PASS / exit 0.
• verifier Git state before cleanup: clean.
• final Candidate contains no test/dependency/build-output residue.

Acceptance disposition

The exact Candidate is independently accepted for integration under #220.

This is not a production-release claim. The stricter packaged nexus.candidate_acceptance.v4 direct-evidence branch is not asserted because the current e03fa9e DevSpace build does not expose a physical devspace.direct_candidate_execution.v1 producer; no post-hoc artifact is fabricated.

Owner authorization to continue through Wave 2 is already explicit in the current conversation. The next gate is exact integration onto fresh canonical main, then build/reload and AC-004..AC-010 integrated runtime canaries. Adapter retirement, Wave 3 and production-default Codeg routing remain unauthorized.

[James3014]

Wave 2 runtime activation frontier — host Owner approval required

Fresh watermark:

• GitHub main: e03fa9ea19ec2f76f38008d7b4ac286005c26692
• accepted content tree: 84ed57c7c06a3290c529ae4aa246f94bcbf1ac65
• accepted implementation Candidate: 37a907b5dcbeaf8b372ae1ed6029e6b855364c6c
• single-Core-provenance promotion Candidate: 32cb2707c3a34ac2b1f6ef493c54099dc761dfca
• 32cb2707 tree is exactly the same accepted tree 84ed57c7...

Runtime staging is complete but no cutover/promotion has occurred yet:

• staged npm package built from clean 32cb2707;
• build identity: devspace-1.0.7-32cb2707, source_dirty=false;
• staged tgz SHA-256: 9379c03b21a18ee1d2ad49a43238c7536196c2cd732302fa4e9cbcd0804c0090;
• staged package byte-matches the tgz postimage excluding unchanged nested dependencies;
• localhost Codeg v0.31.0 canary server is healthy on 127.0.0.1 with a one-run private token; the token is not recorded here;
• a temporary DevSpace canary env block is staged so the replacement runtime can explicitly route only codex,opencode,grok,cline,agy through Codeg during AC-010 canaries.

Canonical promotion attempts were correctly fenced:

1. aggregate multi-session Candidate 37a907b was rejected by the single-provenance promotion invariant;
2. a tree-identical single-Core Candidate 32cb2707 was created;
3. a cross-clone promotion carrier was rejected by repository-identity fencing;
4. a same-common-dir promotion carrier is now prepared at exact origin/main@e03fa9e.

The current blocker is not code or Git. cutover_start requires the separately paired local host Owner carrier. Pending pairing:

• pair_77914d33-1a2f-400a-ae60-0a81eb748897
• approval contract: ~/.devspace-chatgpt/cutover-contract-wave2-codeg-32cb2707.json
• contract validation: PASS
• authority: controller, operations=[cutover_start] only
• expected replacement: 32cb2707 / devspace-1.0.7-32cb2707 / capability 6209829d...

Do not claim runtime activation, canonical promotion, integrated five-route canary, or Wave 2 completion until this local Owner approval is redeemed and the remaining gates run.

Next exact gate after Owner approval:
coordination_resume -> cutover_start -> drain -> atomic package swap -> restart -> replacement identity/witness -> integrated Codeg canaries -> canonical fast-forward promotion -> disable temporary Codeg default routing -> final reload/readback.

[James3014]

Pairing refresh

The previously recorded pending pairing pair_77914d33-1a2f-400a-ae60-0a81eb748897 is superseded by the fresh pending request:

pair_abc67e12-4302-4866-87fc-548989d7e0fe

The already validated cutover contract is unchanged:
~/.devspace-chatgpt/cutover-contract-wave2-codeg-32cb2707.json

No new authority or runtime effect was created by refreshing the pending pairing.

[James3014]

Wave 2 execution block — live DevSpace cutover recovery gap (#64)

Wave 2 Candidate work reached an exact source/build verification gate, but further DevSpace mutation is currently blocked by the canonical runtime's unresolved coordination-bound cutover 90f4590a-601b-4d6c-9a3b-d661ce9881f8.

Fresh evidence:

• current runtime/main = b8f638f72c8dc4198b29e008f864026f55f2f4b6;
• cutover is drained, replacement source/build match the bound target, but capability expectation 6931b6b5... does not match observed 6209829d...;
• normal finish cannot close;
• cross-domain binding repair is inapplicable because target build-manifest digest is 5e4e9ccd..., not 6931b6b5...;
• predecessor-digest mismatch recovery is inapplicable because expected 6931b6b5... != predecessor 6209829d...;
• legacy recovery is forbidden by coordinationBinding;
• mutation surfaces correctly return CUTOVER_RECONCILIATION_REQUIRED.

The exact missing recovery contract and crash-safe acceptance tests have been added to #64. Do not start another #220 implementation attempt or bypass the cutover state/lease. Resume #220 only after #64's exact coordination-bound terminal recovery closes this live generation and runtime mode reads normal.

Existing #220 Candidate lineage/evidence remains preserved; this block does not invalidate its already-run focused behavioral tests.

[James3014]

Current-main rebind required before Wave 2 runtime activation

Fresh DevSpace main:
b8f638f72c8dc4198b29e008f864026f55f2f4b6

This supersedes the earlier runtime-activation watermark that treated e03fa9ea19ec2f76f38008d7b4ac286005c26692 as canonical main.

Material current-state change:

• fix: make Gateway preflight durable across MCP timeouts #223 merged after the accepted P0: implement bounded DevSpace -> Codeg thin execution gateway #220 Candidate lineage was produced;
• live DevSpace source/build is now b8f638f7... / devspace-1.0.7-b8f638f7;
• the fix: make Gateway preflight durable across MCP timeouts #223 cutover is still reconcile-only / reconciliationRequired=true;
• expected/live capability manifest identities are not yet equal;
• therefore P0: implement bounded DevSpace -> Codeg thin execution gateway #220 MUST NOT continue using the previous e03fa9e... cutover plan as if main/runtime were unchanged.

The existing #220 accepted content remains Candidate evidence, but integration/runtime activation now requires a fresh brownfield rebind onto current main.

Required next sequence:

1. close/reconcile the already-started #223 DevSpace cutover
   -> normal
   -> reconciliationRequired=false
   -> converged live generation

2. rebase/reapply the already-accepted #220 semantic content onto fresh current main
   -> preserve #223 behavior
   -> no silent deletion of the durable Gateway-preflight repair
   -> resolve overlap only within #220's authorized contract

3. rerun verification on the new exact Candidate
   -> focused Codeg tests
   -> affected session/store tests
   -> typecheck/build/full test
   -> independent acceptance bound to the new exact head

4. only then perform #220 integrated runtime activation/canaries
   -> five-route live gateway
   -> concurrency
   -> disconnect/recollection
   -> exact cancel
   -> authority/security negatives

Do not treat the previously accepted 37a907b... / tree 84ed57c7... or the single-provenance promotion Candidate 32cb2707... as directly promotable onto current main without this rebind and fresh exact-head verification.

Cross-Issue effect:

• Nexus-new #982 B3 is now intentionally serialized behind completion of this current-main Wave 2 runtime path, after fix: make Gateway preflight durable across MCP timeouts #223 cutover closure.
• P0: pilot Codeg as external coding-agent execution plane #217 remains historical pilot evidence and is not rewritten.

Current disposition:

ISSUE_220=KEEP_OPEN
PREVIOUS_ACCEPTED_CONTENT=VALID_AS_DONOR_EVIDENCE
PREVIOUS_PROMOTION_PLAN=STALE_AFTER_MAIN_ADVANCE
CURRENT_MAIN_REBIND=REQUIRED
RUNTIME_ACTIVATION=BLOCKED_UNTIL_REBIND_AND_REVERIFICATION
ADAPTER_RETIREMENT=NOT_AUTHORIZED
AUTO_CHAIN=false

[James3014]

OWNER HOLD — freeze new Codeg gateway implementation while HerdR #235 is qualified

Fresh DevSpace main: 3f8d6c12c4986c0af806944d9aaa7c3427fb0380.

Owner decision: do not start another #220 Codeg implementation/replay attempt while the external runtime boundary is being qualified in #235.

Preserve #220's requirements as design evidence, especially:

• explicit backend selection;
• exact workspace binding;
• durable external identity;
• no blind duplicate create;
• provider/model projection only;
• reconnect/reconciliation;
• exact cancellation/settlement;
• real concurrency;
• authority/secret containment;
• rollback.

But do not assume Codeg's work_task lifecycle is the future execution authority.

Current state:

• existing Candidate/test/runtime evidence remains historical evidence;
• no new Codeg source mutation is authorized by this hold;
• no retirement/deletion of the Codeg path is authorized yet;
• P0: qualify HerdR as the durable external coding-agent runtime substrate #235 PASS is required before a separate HerdR thin-gateway Issue may be created.

If #235 FAILS for a structural reason, #220 may be reconsidered from its preserved evidence rather than restarted blindly.

AUTO_CHAIN=false.