P0: pilot Codeg as external coding-agent execution plane

[James3014]

CURRENT STATUS — FIVE-ROUTE DIRECT CODEG DISPATCH VERIFIED / THIN_GATEWAY_PILOT_SUPPORTED / INDEPENDENT ADJUDICATION STILL REQUIRED (2026-09-21)
The Owner-requested five-provider dispatch gate is now closed at the bounded Codeg execution-plane layer on this macOS host. Codeg v0.31.1 has direct work_task success evidence for all five required routes using isolated task worktrees:

• Codex: task feat(codex): bootstrap directory trust before codex_goal_start launch (Nexus #732) #29 -> review, result FINAL_CODEX_OK
• OpenCode: task P0: Prevent live Dev MCP runtime lineage drift and capability regression #30 -> review, result FINAL_OPENCODE_OK
• Grok: task fix: reconcile Goal and agent worker lifecycles #17 -> review, result GROK_CODEG_0311_OK
• Agy / Google Antigravity: task P1: Align idleTimeoutMs tool contract with enforced runtime semantics #32 -> review, result FINAL_AGY_OK
• Cline stable 3.0.62: task P1: Isolate mutating ChatGPT conversations and expose cross-session capacity contention #33 -> review, result FINAL_CLINE_OK; task fix(agents): provider output heartbeat + accurate idleTimeoutMs contract (Nexus #731) #28 independently requalified stable Cline with Laguna S 2.1 (free) and returned CLINE_STABLE_LAGUNA_OK

Cline's working Codeg task contract is explicit: mode_id=plan plus config_values.model=poolside/laguna-s-2.1:free. Earlier mode/model top-level fields were not the WorkTaskConfig schema and were silently ignored; the previously tried GLM route is not part of the final gate because its quota is unavailable. Raw ACP and Codeg work-task execution both verified the Laguna route.

Agy's former host-control gap is closed: task #32 was created/started through the Codeg work-task API from this ChatGPT-controlled host and returned a non-empty result. No permission bypass or YOLO mode was required for the text-only dispatch witness.

Residual observation, not a route blocker: in the later five-task mixed run, Grok task #31 reached Prompting then Error -> Disconnected and the engine recorded canceled; no assistant message or repository effect occurred. Grok's same Codeg v0.31.1 route already has an independent direct PASS (#17), so this is retained as concurrency/resilience evidence rather than evidence that Grok is undispatchable.

Disposable baseline repo remained at ee3a6da590a989695514502f582832e51814e96c and clean. No DevSpace provider adapter, production repository, merge route, or deployment was mutated.

Do not auto-chain into Wave 2, merge, cutover, or adapter retirement. The pilot supports the bounded adoption verdict THIN_GATEWAY_PILOT_SUPPORTED; #217 remains open for independent adjudication / downstream contract reconciliation rather than self-acceptance.

Maximum current claim: FIVE_ROUTE_DIRECT_DISPATCH_VERIFIED / THIN_GATEWAY_PILOT_SUPPORTED / INDEPENDENT_ADJUDICATION_REQUIRED.

Status

P0 — READY_FOR_BOUNDED_STANDALONE_PILOT / NO_DEVSPACE_SOURCE_MUTATION

Owner decision: evaluate Codeg as the candidate external heterogeneous coding-agent execution plane before any further expansion of DevSpace's own Grok/Cline/OpenCode/Codex/Agy runtime/adapters.

AUTO_CHAIN=false.

Evidence fence

• DevSpace decision watermark: James3014/devspace main@e03fa9ea19ec2f76f38008d7b4ac286005c26692
• Codeg pilot version: v0.31.0 (latest observed release on 2026-09-20; released 2026-09-19)
• This Issue authorizes only a bounded standalone pilot and evidence collection. It does not authorize DevSpace source integration, provider-adapter deletion, production cutover, merge, deployment, acceptance, or release.

Decision question

Can Codeg own the long-lived heterogeneous coding-agent execution responsibilities that DevSpace currently implements itself, while DevSpace is reduced to a thin ChatGPT MCP/control gateway and Nexus/Owner retains route, scope, verification, acceptance, merge, and release authority?

Target responsibility transfer under evaluation:

Nexus / Main ChatGPT
  -> thin DevSpace MCP gateway
       -> Codeg execution plane
            -> Codex / OpenCode / Grok / Cline / other admitted coding agents
            -> isolated task worktrees

Codeg must remain an executor/runtime. It must not become Nexus Planner, Verifier, Candidate acceptance authority, merge authority, or release authority.

Non-goals

• no DevSpace provider-adapter rewrite in this pilot;
• no Codeg auto-merge;
• no Codeg autonomous provider/worker routing on behalf of Nexus;
• no broad migration;
• no deletion of existing DevSpace adapters;
• no production cutover;
• no claim that Codeg is accepted merely because one task succeeds.

Pilot configuration

Use an isolated local pilot environment on macOS.

For the pilot:

• pin Codeg v0.31.0;
• disable/avoid auto-merge and authority-expanding automation;
• keep Codeg multi-agent delegation disabled unless a specific acceptance step explicitly requires observing it, and never use delegation as Nexus routing authority;
• use disposable/isolated worktrees and non-production test tasks;
• preserve exact task/runtime/provider identities in evidence;
• never blind-retry an ambiguous create/start/send after transport loss.

Representative routes should cover at least three materially distinct agent paths, preferably Codex + OpenCode + Grok/Cline, subject to fresh auth/runtime availability. A provider login/quota block is evidence, not authority to bypass account/security controls.

Gate sequence

C1 — Runtime/source bind

Prove exact Codeg version, server identity, storage/state location, task API surface, and configured agent runtime identities. Record any external credentials/config dependency without exposing secrets.

C2 — Route readiness

For at least three representative agent routes, distinguish:

• runtime/binary present;
• configured;
• authenticated/entitled where observable;
• actually runnable;
• provider quota/capacity unknown versus proven.

Do not infer readiness from catalog membership alone.

C3 — Isolated task/worktree identity

Create three independent bounded tasks and prove:

• distinct task IDs;
• distinct isolated worktrees/branches;
• no unintended baseline checkout mutation;
• task -> worktree -> provider identity remains attributable.

C4 — Real concurrency

Run the three tasks so their execution intervals materially overlap. PASS requires real concurrent execution, not sequential controller calls with queued backend work.

C5 — Controller disconnect continuity

While at least one task is nonterminal:

1. disconnect/stop the controller observation path;
2. leave Codeg runtime alive;
3. reconnect;
4. prove the same task continues or has a truthful terminal state.

Controller disconnect must not itself cancel the worker.

C6 — Durable recollection/reconciliation

After reconnect, retrieve status/events/result/diff for the original task IDs. Required states must distinguish at least running, review/completed, failed, canceled, and unresolved/unknown when applicable.

C7 — Exact cancellation

Cancel one exact task and prove:

• only that task is affected;
• sibling tasks continue;
• local cancellation is not misreported as remote/provider cancellation unless proven.

C8 — Duplicate-dispatch / create ambiguity

Codeg's observed work-task create contract does not currently expose a caller-supplied DevSpace/Nexus attemptKey/operation key. Test the unsafe boundary explicitly:

• simulate or observe ambiguous create/start acknowledgement;
• never blindly create a replacement;
• determine the minimum external idempotency/reconciliation seam required for a future thin bridge.

PASS does not require changing Codeg in this Issue. The output is a precise bridge requirement.

C9 — Authority containment

Prove the pilot does not grant Codeg:

• Nexus route authority;
• Candidate acceptance;
• merge/release authority;
• permission to silently widen task scope;
• permission to auto-chain successor work.

Acceptance

PASS requires all of:

• three attributable isolated tasks;
• 0 wrong-worktree mutations;
• 0 unintended baseline checkout mutations;
• materially overlapping execution for the concurrency trial;
• controller disconnect does not erase task truth;
• reconnect can retrieve/reconcile original task IDs;
• exact cancel does not affect siblings;
• 0 blind duplicate dispatch after ambiguous transport outcome;
• provider/runtime failures classified truthfully;
• authority boundaries above remain intact.

If a mandatory gate cannot be tested because of provider auth, installation, entitlement, or host policy, report the exact blocker and stop. Do not weaken the gate.

Deliverable

Produce one evidence-bound pilot report containing:

• Codeg version/runtime identity;
• task IDs and time intervals;
• worktree/branch identities;
• provider/model identities;
• disconnect/reconnect witness;
• cancellation witness;
• duplicate-risk/idempotency finding;
• observed failure classes;
• exact recommendation: KEEP_DEVSPACE_RUNTIME | THIN_GATEWAY_PILOT_SUPPORTED | INSUFFICIENT_EVIDENCE.

Even THIN_GATEWAY_PILOT_SUPPORTED does not authorize implementation; a separate Issue must own the DevSpace -> Codeg bridge.

Workforce guidance

• role: bounded_implementer
• Owner-requested worker candidate: Codex CLI / gpt-5.6-luna / xhigh
• guidance_class: CONDITIONAL_CANDIDATE until fresh dispatch-time admission/provider reachability is proven
• provider_preflight: UNPROVEN beyond local runtime/config parsing
• claim_intent: MANUAL_DISPATCH
• claim_mode: MANUAL_DISPATCH
• claim_ceiling: RESULT_RETURNED
• independent_verifier: required for any adoption conclusion
• fresh_admission_required: true
• no self-approval, merge, cutover, or successor implementation

Execution realm guidance

• preferred_implementation_realm: NEXUS_CANONICAL_LOCAL
• codex_cloud_eligibility: INELIGIBLE for the physical pilot
• evidence_locus: HOST_BOUND
• required_verification_realm: NEXUS_CANONICAL_LOCAL
• basis: the decision depends on the Owner Mac's Codeg server, installed coding-agent CLIs, worktree/process concurrency, disconnect/reconnect behavior, and provider authentication/runtime state.

Downstream

A PASS may unlock creation/activation of a separate bounded DevSpace -> Codeg thin bridge implementation contract. It does not itself authorize that mutation.

Blocked/superseded-by-decision work remains tracked under #15 and its provider-specific children until this pilot is adjudicated.

[James3014]

Wave 1 worker/realm preflight watermark

Observed through the currently loaded Dev MCP before any Wave 1 mutation:

• DevSpace loaded build/source: devspace-1.0.7-e03fa9ea / e03fa9ea19ec2f76f38008d7b4ac286005c26692
• Codex CLI execution identity resolves to @openai/codex runtime 0.154.0
• direct route parses as provider=codex / model=gpt-5.6-luna / effort=xhigh
• local execution capacity observed: 1/4 used, local slot available
• auth readiness: UNKNOWN without provider invocation
• provider reachability/quota: UNKNOWN without provider invocation
• current canonical /Users/jameschen/Workspace/devspace checkout is shared + dirty and mutation is blocked by conversation-safety fencing.

Wave 1 therefore must:

1. rebind fresh James3014/devspace/main;
2. create/use a DevSpace-managed isolated worktree (never mutate the shared checkout);
3. run fresh Codex provider preflight;
4. stop truthfully if auth/provider/runtime is blocked;
5. keep claim ceiling at pilot evidence only — no bridge implementation, merge, cutover, or auto-chain.

This is readiness evidence, not worker admission or execution authority.

[James3014]

OWNER CONTRACT DELTA — INSTALL AUTHORIZED

Owner reauthorized Wave 1 after the initial C1 blocker was observed.

Previous rule in this Issue said: if Codeg is absent, do not install and stop at INSUFFICIENT_EVIDENCE.

Superseding Owner decision (2026-09-20): installation of the pinned Codeg v0.31.0 runtime is explicitly authorized for this bounded pilot so that C1-C9 can continue.

Boundaries remain:

• install only the pinned Codeg v0.31.0 runtime needed for P0: pilot Codeg as external coding-agent execution plane #217;
• no DevSpace source mutation;
• no provider credential/security bypass;
• no production repo mutation;
• no bridge implementation, merge, cutover, deployment, or cleanup of existing DevSpace adapters;
• Codeg remains executor-only and may not gain Nexus routing/acceptance/merge/release authority;
• after installation, re-run C1 from the actual installed runtime before proceeding.

The earlier absence observation remains valid historical evidence; it is no longer a stop condition after this Owner authorization.

[James3014]

Wave 1 Codeg standalone pilot — evidence receipt

Bound identities

• DevSpace decision/source watermark: main@e03fa9ea19ec2f76f38008d7b4ac286005c26692
• Codeg: v0.31.0, tag commit aace536fe9e38575a8973ed83435199ecc2700c6
• macOS arm64 release artifact SHA-256 verified before install: c1dae878e6336198d70e7422abf1d20e84350efd06f4180e28b2027a383b5c80
• Runtime: headless codeg-server 0.31.0, localhost-only pilot server, isolated pilot data directory
• Production/DevSpace repositories were not used as Codeg mutation targets.
• Disposable baseline repo HEAD: ee3a6da590a989695514502f582832e51814e96c

The initial DevSpace -> Codex dispatch attempt (agt_ea815a8c) terminated by the existing 300 s idle fence with no provider activity. Reconciliation showed DevSpace workspace HEAD unchanged, dirty=false, no Candidate and no changed paths. The Codeg pilot was therefore executed directly on the host instead of weakening the Core-bound DevSpace fence.

C1-C9

Gate	Result	Evidence
C1 runtime/source bind	PASS	Pinned/verified Codeg v0.31.0; health endpoint returned version 0.31.0; isolated data dir; task HTTP surface live.
C2 >=3 representative routes actually runnable	FAIL	Codeg preflight passed for Codex, OpenCode, Grok and Cline, but live results diverged: OpenCode completed; Grok reached live agent progress; Codex ACP Initialize entered Error -> Disconnected; Cline live task failed agent stopped: empty. Only two routes were proven live enough for this gate.
C3 isolated task/worktree identity	PASS	Tasks 1-4 received distinct task IDs, branches task/1..4, and distinct worktrees; all were bound to the same exact disposable base SHA. Baseline checkout remained unchanged/clean.
C4 real concurrency	FAIL (partial mechanism proven)	A single work_task_start_all accepted 3 tasks; their engine start timestamps were within ~12 ms and OpenCode/Grok overlapped materially. Codex then failed during ACP initialization, so three materially live provider executions were not sustained.
C5 controller disconnect continuity	PASS	Controller polling was absent for ~15 s; after reconnect the same OpenCode/Grok task IDs remained live with unchanged worktree/base identities.
C6 durable recollection/reconciliation	PASS	Same task IDs were recollected with status/events/diffs: Codex=canceled/no diff, OpenCode=review/one-file diff, Grok=user-canceled/no diff, Cline=failed/no diff.
C7 exact cancellation	PASS	Exact cancel of Grok task #3 at 07:36:16Z produced a user cancellation event while sibling OpenCode task #2 independently settled to review.
C8 create ambiguity/idempotency seam	PASS as finding; no duplicate side effect performed	Exact v0.31.0 generic WorkTaskDraft contains only folder_id/title/config; generic create exposes no caller-supplied attemptKey/operationKey. Forge-trigger dedup is a separate source-key path and does not make generic create replay-safe. Future thin bridge therefore needs a durable pre-effect operationKey -> Codeg taskId mapping plus reconcile-before-resend; ideally Codeg gains caller-supplied idempotency support. Never blind-create after unknown acknowledgement.
C9 authority containment	PASS	Delegation remained disabled; auto_process=false; auto_merge=false; no merge/push/release/cutover endpoint was invoked; no successor work auto-started.

Task/runtime observations

• OpenCode task feat: reconcile DevSpace reliability extensions with current main #2 — system-installed OpenCode 1.18.31 was used; task reached review; Codeg engine recorded one changed file. The file content matched the requested nonce, but the Git diff showed no trailing newline despite the prompt requesting one. This is worker-output fidelity evidence, not a Codeg execution-state failure.
• Grok task agy dispatch escapes a linked-worktree workspace to the repo's main worktree via shared .git --add-dir #3 — Grok 1.0.34 initialized, reached Prompting/agent progress, then was intentionally canceled for C7. No baseline mutation.
• Codex task feat: integrate durable dispatch with bounded Codex Goal mode #1 — Codeg preflight found native Codex CLI 0.154.0 and installed codex-acp 1.12.0, but the live ACP connection transitioned Connecting -> Error -> Disconnected immediately after Initialize. This proves preflight PASS != runnable.
• Cline task fix: keep agy worker bound to a linked worktree, not the repo main worktree #4 — Cline 3.0.62 preflight passed; live task created its own worktree, entered running, then failed with agent stopped: empty.

Security observation

The authenticated acp_list_agents surface can return provider configuration containing credential-bearing material. No credential values are recorded here. The pilot server was bound to localhost with token authentication, so this did not create an external exposure during the pilot. Any future remote Codeg exposure needs an explicit data-minimization/security gate; do not expose this surface directly as a public Nexus/DevSpace API.

Baseline / scope

• disposable baseline repo remained at ee3a6da590a989695514502f582832e51814e96c and clean;
• DevSpace managed worktree remained at e03fa9ea19ec2f76f38008d7b4ac286005c26692, clean, with no Candidate/changed paths;
• no DevSpace source, provider adapter, production repository, merge route or deployment was modified.

Verdict

INSUFFICIENT_EVIDENCE

The pilot does support the narrower statement that Codeg's task/worktree/concurrency/reconnect/cancel mechanics are promising for a thin execution plane. It does not yet support Wave 2 or replacement of DevSpace's heterogeneous provider runtime because the mandatory three-runnable-route gate is unmet.

Next gate

Keep #217 open. Run one bounded provider-compatibility/requalification pass focused on the existing Codeg v0.31.0 Codex/Cline failures (or another Owner-approved representative provider already present), without modifying DevSpace source and without widening Codeg authority. Wave 2 remains blocked until at least three representative routes are actually runnable and C4 is rerun with three materially overlapping live workers.

No bridge implementation, merge, cutover, adapter retirement, release, or auto-chain is authorized by this receipt.

[James3014]

Pilot cleanup / residual host state

After evidence capture:

• the temporary Codeg pilot server was stopped;
• localhost port 31817 was verified closed;
• the one-run pilot token file was removed;
• the verified Codeg v0.31.0 binaries remain installed under the user's local prefix for a future explicitly authorized requalification;
• isolated pilot data/worktrees/evidence were retained for reconciliation.

No persistent Codeg service, production cutover, or DevSpace bridge is active.

[James3014]

Agy / Antigravity requalification and provider-boundary refinement

This comment corrects the original Wave 1 coverage gap: Agy had not been exercised in the first provider matrix.

Bound evidence

• DevSpace source watermark remains main@e03fa9ea19ec2f76f38008d7b4ac286005c26692.
• Codeg remains pinned to v0.31.0.
• Disposable repository remains ee3a6da590a989695514502f582832e51814e96c, clean after all probes.
• Native Agy CLI: agy 1.2.7.
• Codeg Agy route: built-in agent type antigravity, registry id antigravity-acp, Google's first-party agy_acp_server 1.1.1.
• The Antigravity binary was installed only into the isolated Codeg pilot cache; the native agy CLI was not replaced.

Agy observations

1. Native Agy 1.2.7 completed a zero-tool probe and returned the expected AGY_NATIVE_OK; disposable repo stayed clean.
2. Codeg Antigravity preflight moved from “binary not installed” to cached/launchable after the pinned 1.1.1 first-party ACP server was installed.
3. Codeg task Fix terminal agent wall/idle telemetry continuing after completion #5 received its own task/5 branch/worktree on the exact disposable base.
4. Runtime evidence reached:
   • cached agy_acp_server 1.1.1 launch;
   • auth.type=oauth-personal synchronized into the Antigravity ACP settings;
   • Initialize completed in ~16.4s;
   • Connecting -> Connected -> Prompting;
   • live session id/external id established;
   • model selector populated (including Gemini 3.8 Flash variants; session current value observed as gemini-3.7-flash-high);
   • real tool/permission requests surfaced.
5. The next exact tool permission could not be completed from this ChatGPT control surface because the host safety layer blocked automated permission-response/direct-prompt attempts. That restriction was not bypassed. Task Fix terminal agent wall/idle telemetry continuing after completion #5 was then exactly canceled and no baseline mutation occurred.

Agy classification: RUNTIME_LIVE / TOOL_PERMISSION_COMPLETION_UNVERIFIED.

This is materially stronger than preflight-only evidence, but it is not a completed tool-action task and therefore does not, by itself, close C2.

Codex refinement

• Codeg diagnostics report the environment healthy and resolve codex-acp 1.12.0.
• Upstream codex-acp v1.12.0 explicitly bundles/updates to Codex 0.154.0, matching the installed native Codex CLI.
• Native Codex 0.154.0 completed a read-only ephemeral zero-tool probe and returned CODEX_NATIVE_OK; repo stayed clean.
• The native run emitted pre-existing skill-frontmatter/OAuth-refresh warnings but still completed the turn.
• The Codeg path remains different: its Codex task failed during ACP Initialize with Connecting -> Error -> Disconnected.

Codex classification: native provider path runnable; Codeg <-> codex-acp initialization compatibility remains unresolved.

Cline refinement

• Codeg diagnostics report Node/PATH/Cline 3.0.62 healthy and resolve the official cline --acp command.
• Native Cline completed a no-tool probe and returned CLINE_NATIVE_OK with model z-ai/glm-5.3-flash; repo stayed clean.
• Codeg's Cline path did not fail Initialize/auth: logs show Initialize response (~0.5s), Connected -> Prompting, then turn_complete ... stop_reason=empty.
• Codeg upstream #773 is an open Cline authentication report, but this machine's evidence is different because native authentication works and the Codeg session reaches Prompting.

Cline classification: native provider path runnable; ACP turn/output compatibility remains unresolved.

Updated provider matrix

Route	Current live evidence
OpenCode	COMPLETED bounded task
Grok	RUNTIME_LIVE until intentional exact cancellation
Agy / Antigravity	RUNTIME_LIVE THROUGH PERMISSION BOUNDARY, final tool action unverified
Codex	native works; Codeg ACP Initialize failure
Cline	native works; Codeg ACP prompt returns empty

Adoption consequence

C2 remains NOT CLOSED and Wave 2 remains blocked. The evidence is now strong enough to distinguish “Codeg execution/session machinery works for multiple providers” from “Codeg can already replace DevSpace's heterogeneous provider runtime.” The latter is not yet proven.

The next smallest gate is not another DevSpace adapter repair. It is:

1. complete one bounded Agy/Antigravity tool action through an authorized interactive permission path; and
2. separately reproduce/report the Codeg-specific Codex Initialize and Cline empty-turn failures against their exact upstream runtimes.

No DevSpace source integration, adapter retirement, merge, cutover, release, or auto-chain is authorized by this requalification.

Residual host footprint

The retained pilot footprint is now material because the Google ACP server is large:

• pilot Codeg data: ~877 MB;
• Antigravity ACP cache within that data: ~876 MB;
• retained Codeg release/download material: ~233 MB;
• worktrees themselves: ~44 KB at observation time.

Treat these as explicit retained pilot assets, not unexplained DevSpace growth.

[James3014]

Agy requalification cleanup

After the Agy/Codex/Cline refinement:

• temporary Codeg localhost server was stopped;
• port 31817 was verified closed;
• the second one-run pilot token was removed;
• ~/.gemini/antigravity-acp/settings.json remains present with the Antigravity ACP auth-method configuration created/synchronized by Codeg; no credential value is recorded in this Issue;
• retained Antigravity pilot binary cache: ~876 MB;
• total retained pilot Codeg data: ~877 MB;
• retained original Codeg release/download material: ~233 MB.

The retained footprint is deliberate evidence/requalification state, not an active service. No DevSpace bridge or production Codeg runtime is active.

[James3014]

Five-route dispatch requalification — execution-runtime gate closed

Owner requested that the pilot not report success until OpenCode, Grok, Agy/Antigravity, Codex, and Cline were each proven runnable, with repair rather than hand-waving where a route failed.

Evidence watermark

• DevSpace main: e03fa9ea19ec2f76f38008d7b4ac286005c26692
• Codeg: v0.31.0 / aace536fe9e38575a8973ed83435199ecc2700c6
• disposable baseline: ee3a6da590a989695514502f582832e51814e96c
• production/DevSpace source mutation: none
• auto-merge / push / merge / release: none

Final route matrix

Route	Final witness	Result
Cline built-in	Codeg task #8, branch task/8, exact model zai/glm-5.3-flash	PASS — review, 1 file / 1 addition / 0 deletions
Codex built-in	Codeg task #9, branch task/9, gpt-5.6-luna	PASS — review, 1 file / 1 addition / 0 deletions
Grok built-in	Codeg task #10, branch task/10	PASS — review, 1 file / 1 addition / 0 deletions
OpenCode built-in	Codeg task #11, branch task/11, run_seq=2 after host verifier rejected first result	PASS — review, 1 file / 1 addition / 0 deletions
Google Antigravity / Agy	exact Codeg runtime agy_acp_server 1.1.1, isolated pilot/agy-autoedit worktree, ACP auto_edit, model gemini-3.8-flash-high	PASS at execution-runtime layer — initialize -> session/new -> set_mode(auto_edit) -> edit_file -> end_turn, exact file bytes verified

Host-side exact-byte witnesses:

• Cline: GATE_CLINE_BUILTIN_PASS\n
• Codex: GATE_CODEX_PASS_20260920\n
• Grok: GATE_GROK_PASS_20260920\n
• OpenCode: GATE_OPENCODE_PASS_20260920\n
• Agy: GATE_AGY_RAW_PASS_20260920\n

Every witness started from the same disposable base SHA. The baseline checkout remained clean.

Repairs / root causes

Codex — command collision, repaired

The command Codeg resolved as codex-acp was actually the global symlink for @zed-industries/codex-acp 0.11.1, not Codeg's pinned @agentclientprotocol/codex-acp 1.12.0. The wrong adapter failed raw ACP initialize while parsing the current Codex config. Codeg's own NPM-agent installer was then used to install/activate @agentclientprotocol/codex-acp 1.12.0 in the current npm global prefix. The Zed package directory was not deleted. After the command identity was corrected:

• raw ACP returned CODEX_RAW_FIXED_OK;
• Codeg built-in task Add durable local Candidate branch promotion primitive #9 completed successfully.

Cline — wrong ACP model id, repaired

Native and raw ACP Cline were already healthy. The failing Codeg task requested z-ai/glm-5.3-flash, but Cline 3.0.62's ACP catalog advertises zai/glm-5.3-flash. Re-running with the exact advertised id plus auto_approve=true made both the diagnostic custom route and built-in task #8 complete.

A separate Codeg compatibility defect remains observable: Cline exposes both provider and model with category:"model", while Codeg's current current_model_id_from_opts() selects the first category match and can therefore report provider value cline as if it were a model. This did not block execution once the exact model config id/value was used.

OpenCode — worker summary false green caught by independent host readback

Task #11 initially claimed the trailing newline existed, but host-side bytes proved it did not. The task was returned to the same worker/worktree with a bounded correction. run_seq=2 produced the required trailing 0x0a; host readback then passed. This is a concrete example of why worker prose is not verification.

Agy / Antigravity — runtime proven, direct ChatGPT work-task effect remains host-blocked

The exact Google first-party runtime that Codeg launches was exercised directly over ACP:

• initialize PASS;
• authenticated session/new PASS;
• advertised modes default / auto_edit / yolo;
• session/set_mode(auto_edit) PASS;
• exact model switch to gemini-3.8-flash-high PASS;
• bounded edit_file completed;
• end_turn PASS;
• host readback confirmed exact bytes.

No yolo/permission bypass was used.

However, this ChatGPT host rejects direct effect calls targeting the Codeg Antigravity work-task lifecycle (create/requeue/start) even when the payload contains no permission expansion. Parent->Antigravity delegation attempts are blocked at the same host layer. That host boundary was not bypassed.

Therefore:

• provider/runtime readiness: 5/5 proven;
• direct Codeg work_task witness from this ChatGPT host: 4/5 proven;
• remaining Agy gap: host-control integration, not provider/auth/runtime capability.

Gate disposition

C2_FIVE_ROUTE_RUNTIME_READY is supported.

This does not by itself issue the overall adoption verdict, authorize Wave 2 implementation, delete DevSpace adapters, or change Nexus route/acceptance/merge/release authority. #217 remains open pending independent adjudication of the full pilot evidence and the direct ChatGPT->Codeg Agy work-task control seam.

[James3014]

Five-route gate cleanup / retained evidence

Final host cleanup after the five-route readiness run:

• temporary Codeg server stopped;
• localhost port 31817 verified closed;
• one-run token3 removed;
• disposable baseline still exactly ee3a6da590a989695514502f582832e51814e96c and clean;
• active Codex ACP command now resolves to @agentclientprotocol/codex-acp 1.12.0;
• the older @zed-industries/codex-acp 0.11.1 package directory remains installed, but no longer owns the codex-acp command symlink.

Retained evidence footprint:

• Codeg pilot data: ~879 MB (dominated by the Google Antigravity ACP binary/cache);
• Codeg task worktrees: ~112 KB;
• raw Agy isolated worktree: ~12 KB;
• retained Codeg release/download material: ~233 MB.

A diagnostic custom route cline-no-mcp-pilot remains only inside the isolated pilot DB because the current ChatGPT host blocked the Codeg custom-agent delete operation. It is not part of the accepted route evidence; built-in Cline task #8 is the final Cline witness. The DB was not edited directly to bypass that protection.

No Codeg service is active, and no DevSpace bridge/cutover is active.

[James3014]

OWNER RECONCILIATION — Codeg pilot becomes historical execution-plane baseline

Fresh DevSpace main: 3f8d6c12c4986c0af806944d9aaa7c3427fb0380.

#217 remains valuable evidence: it established bounded live behavior across the five Codeg routes and exposed useful gateway/recovery requirements.

However, Owner architecture selection has moved the active CLI runtime candidate to HerdR qualification #235.

Current disposition:

• preserve all P0: pilot Codeg as external coding-agent execution plane #217 evidence and route witnesses;
• use P0: pilot Codeg as external coding-agent execution plane #217 as an A/B historical baseline for P0: qualify HerdR as the durable external coding-agent runtime substrate #235;
• do not extend this Issue into new Codeg integration work;
• do not treat historical Codeg pilot success as authority to continue P0: implement bounded DevSpace -> Codeg thin execution gateway #220/Wave 2: add durable DevSpace -> Codeg thin execution bridge #224;
• Codeg remains rollback/reference evidence until a later explicit Owner decision.

No historical evidence is rewritten or invalidated.

[James3014]

Independent adjudication closeout — Codeg retained as historical baseline; HerdR is the selected execution plane

Fresh causal watermark:

• DevSpace main: 7feaeb786ef5c82d2ccdfa6a47f0928ba5b49229
• P0: pilot Codeg as external coding-agent execution plane #217 historical Codeg pilot: five-route runtime evidence retained; bounded verdict THIN_GATEWAY_PILOT_SUPPORTED remains historical pilot evidence only
• Owner reconciliation issue217-codeg-historical-baseline-20260922-v1: active runtime candidate moved from Codeg to HerdR
• P0: qualify HerdR as the durable external coding-agent runtime substrate #235: closed with HERDR_RUNTIME_PILOT_SUPPORTED
• P0: implement thin DevSpace -> HerdR external-agent runtime gateway #236: closed thin DevSpace -> HerdR gateway implementation Issue
• PR P0: cut over DevSpace local-agent lifecycle to HerdR backend (#242) #243: merged HerdR public local-agent lifecycle cutover
• P0: cut over DevSpace local-agent lifecycle to HerdR production backend #242: closed after current-runtime W2/W3/W4 reconciliation with HERDR_DEFAULT_ACTIVE_OPENCODE_AGY and bounded HERDR_CUTOVER_STABLE

Adjudication

The remaining question in #217 was whether Codeg should become the retained heterogeneous execution plane. That question is now resolved by a newer explicit Owner architecture decision plus stronger current physical evidence from the HerdR production cutover.

Disposition:

• preserve all Codeg C1-C9 / provider-route evidence as historical A/B baseline;
• do not reinterpret Codeg pilot evidence as current production selection;
• do not resume Codeg bridge / adapter-retirement work from P0: pilot Codeg as external coding-agent execution plane #217, P0: implement bounded DevSpace -> Codeg thin execution gateway #220 or Wave 2: add durable DevSpace -> Codeg thin execution bridge #224 without a new explicit Owner decision;
• retained execution path is now Host/Nexus -> DevSpace thin gateway -> HerdR -> admitted provider runtime.

Closure classification: DONE_NO_FOLLOW_UP for #217's evaluation decision under the superseding Owner architecture selection.

This closeout does not claim Codeg production acceptance. It records that the evaluation is complete and Codeg has been superseded as the active candidate. The surviving tool/exposure authority work already has durable homes in DevSpace #190 and Nexus-new #982/#1144.