A-gate: produce current-main v4 evidence and independently accept the Codeg Wave 2 Candidate

[James3014]

Status

P0 / OWNER_AUTHORIZED FOLLOW-UP FROM #224 / DIRECT_DELEGATED / AUTO_CHAIN=false

Owner direction: complete #224 formal Candidate acceptance before continuing #226 Grok multi-account live closure.

Fresh source fence:

• DevSpace main@45ce06a51ab2af43f513ab49ad111be4cc8cc48c
• historical Wave 2: add durable DevSpace -> Codeg thin execution bridge #224 engineering Candidate efc197bf3e7fdc49d357dab91eafc9eb152b9451, tree f837ca7a0a7a8f2f5116e299c55ed982d89bdefd
• Wave 2: add durable DevSpace -> Codeg thin execution bridge #224 engineering gate: 5/5 live Codeg routes PASS
• formal v4 gate: blocked because the exact historical Candidate has no physical Candidate-bound devspace.direct_candidate_execution.v1 executor artifact and no matching Core generic-verification response.

Evidence-integrity decision

The historical efc197bf... Candidate MUST NOT receive retroactively synthesized executor lineage.

Current durable DevSpace stores were searched for that exact Candidate and no Core mutation Candidate row / direct executor artifact was found. The historical TG-A direct-evidence producer contract survives only as source-binding/spec history; its producer commit/worktree is not a current physical executor artifact for #224.

Therefore this follow-up creates a new current-main acceptance Candidate that preserves the #224 semantic delta while executing through current Core-bound DIRECT_DELEGATED machinery. Old efc197bf... remains historical engineering evidence only.

Goal

Produce one new immutable #224-equivalent Candidate on current DevSpace main with truthful physical v4 evidence:

1. real current DevSpace DIRECT_DELEGATED execution;
2. pre-effect nexus.repository_mutation_binding.v1 Core session;
3. exact bounded DispatchIntent with claimCeiling=CANDIDATE_READY;
4. durable completed worker identity / execution generation;
5. exact Candidate commit/tree/change manifest;
6. physical devspace.direct_candidate_execution.v1 emitted from durable state;
7. matching canonical nexus.core.generic-verification-response.v1-experimental;
8. independent nexus.candidate_acceptance.v4 audit against that exact Candidate.

Source scope

The implementation Candidate must reproduce the already-verified #224 thin Codeg bridge semantics on current main, with no new provider behavior or architecture expansion.

Historical #224 changed paths form the maximum semantic scope:

• 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

Evidence-producer source changes, if current DevSpace lacks a canonical producer, must be the minimum typed producer needed to serialize already-durable execution/Core/Candidate state into devspace.direct_candidate_execution.v1. It must not become a second execution lifecycle, verifier, acceptance authority, or Core implementation.

Required evidence-producer semantics

The emitted direct evidence must match the frozen v4 producer contract:

• contract_kind=OWNER_INLINE;
• authority task/attempt + normalized DispatchIntent;
• OWNER_DIRECT / DIRECT_DELEGATED;
• completed durable execution with exact agent/profile/provider/model/session/workspace/generation identity;
• scope_state=WITHIN_SCOPE, retry_safe=false, reconciliation_required=false;
• exact embedded Core mutation binding and AcceptanceContract hash;
• physical Candidate source/commit/tree, Core-compatible change manifest and canonical diff hash;
• deterministic evidence id/integrity;
• claim ceiling exactly CANDIDATE_READY;
• all Core verification/certification/acceptance/approval/merge/release/deploy/public-claim flags false.

Do not hand-author a passing artifact from chat prose. The producer must derive fields from the physical durable records / Git objects and fail closed on missing or inconsistent lineage.

Verification

Before acceptance:

• exact scoped source tests for producer + bridge semantics;
• typecheck/build/diff checks;
• one real delegated Codex execution on an isolated managed worktree;
• physical Core session close with writer reconciliation CLEAR;
• Candidate source/tree/manifest reconstruction;
• canonical Core generic verification = VERIFIED / VALID;
• independent v4 validator/audit with a reviewer distinct from the implementer and materially independent oracle.

Worker

Implementation worker: Codex CLI / Luna / xhigh after fresh preflight.

The implementer cannot self-accept. Coordinator independently verifies source/diff/evidence. Candidate Acceptance is a separate read-only audit.

Non-goals

• no merge/cutover/adapter retirement/release/production;
• no change to provider/model routing;
• no rewrite of historical Wave 2: add durable DevSpace -> Codeg thin execution bridge #224 evidence;
• no synthetic Task Card/MCP lineage;
• no B/Wave 1: bind Grok account leases to immutable Codeg profiles #226 work until A reaches a valid independent acceptance result;
• no AUTO_CHAIN beyond this exact A sequence.

Completion ceiling

#224_NEW_CURRENT_MAIN_CANDIDATE_ACCEPTED_PENDING_OWNER_APPROVAL

This is Candidate acceptance only. It grants no merge, cutover, release or production authority.

[James3014]

A is still the only active workstream; B/#226 remains blocked.

Current #227 implementation attempts are blocked by a production DevSpace cutover in the exact #64/#199 expired PREPARED + zero drain/restart effect family.

Bound cutover:

• 6f353f98-5be1-400e-a8df-4e5d91fdd9d4
• operation op_a8e47350e96461a9
• lease lease_d93e6fbe-28e0-47af-b43d-988149221cf0
• carrier carrier_18a9d6b9-1460-47e5-9454-9a93b163303d v1/validity-v1
• phase prepared, expired
• no drain/restart marker/effect
• original server still running

Current main 45ce06a51ab2af43f513ab49ad111be4cc8cc48c already includes PR #199's host-local abort-expired-prepared recovery. That exact existing path is the next gate. No restart or stale finish witness will be used.

After terminal readback returns cutover normal/unfenced, #227 resumes from a fresh Core/worker attempt. Historical a1/a2 failures remain preserved and will not be relabeled as evidence.

[James3014]

A/#227 frontier — PR #229 verified, integration authority is the only current blocker

Fresh DevSpace watermark:

• main: cf345b4feee1ac447abdffc66cdf7f2079ad3f8f
• blocking recovery PR: fix: terminalize drained cutover after unexpected replacement #229
• exact PR head: 5d379651733eeaa50e0998983024de62aa7b10bd
• PR base: exact current main
• mergeable: true / clean

Exact-head verification:

• CI 35562339011: SUCCESS
• Ubuntu/macOS Smoke Test + Build + Doctor: SUCCESS
• Repository Intelligence 35562339006: SUCCESS
• bounded Luna xhigh ordering repair changes only src/cli.ts beyond the prior fix: terminalize drained cutover after unexpected replacement #229 Candidate.

Current A state:

#229 source repair          VERIFIED / READY_FOR_INTEGRATION
#229 merge                  NOT AUTHORIZED / NOT DONE
live cutover recovery       BLOCKED ON #229 INTEGRATION
#227 v4 Candidate replay    BLOCKED ON LIVE CUTOVER NORMALIZATION
#227 independent acceptance NOT STARTED ON NEW CANDIDATE
#226 / B                    MUST NOT START

No exact-head Owner merge authorization for #229 is durable in #64/#229. PR #225's prior exact-head authorization does not transfer.

Do not bypass by rewriting cutover state, replaying the old restart, using stale carrier authority, or starting B. Next gate is explicit integration authority for PR #229 head 5d379651733eeaa50e0998983024de62aa7b10bd.

[James3014]

A/#227 fresh a3 — runtime repaired; fixed Luna worker now blocked only by provider credits

Fresh canonical state:

• DevSpace main/runtime: f9305e926c0b5f64d84516b8038eacef329e15c5
• runtime build: devspace-1.0.7-f9305e92
• health: full capability manifest, cutover mode normal, reconciliationRequired=false
• Nexus capability index: James3014/Nexus-new@5cff3aeb85bd01574124234f09981253a1efab98
• discovery index blob: d21f108ba4a65bc73230e22cf8b3129e39848758
• discovery SHA-256: c714e58f2615e5d5540606dc7ffb983322a9991e61a1ed4bdb4287bcaeeb0355
• matched capability: local_agent_execution_and_chat_swarm

A fresh isolated current-main worktree was opened and Luna xhigh preflight is now runtime-ready:

• workspace ws_1f77651443
• base/head f9305e926c0b5f64d84516b8038eacef329e15c5
• source tree 8ee0cf89a9ed235146fb9432e30d49611740433b
• isolated/clean/mutationAllowed=true
• Codex CLI runtime 0.154.0
• runtimeReady=true
• no preflight blocker

A pre-effect Core session was then physically opened before provider launch:

• Core session cms_738ce33ab4294c82a1f79d2c20e91489
• binding sha256:675b993050d0ee098e9548a43619b64638d9aacee17afd422981fd17b7c4cd69
• ACTIVE / FRESH / BOUND_CURRENT at launch
• deletion policy FORBID
• bounded Wave 2: add durable DevSpace -> Codeg thin execution bridge #224 + permitted producer-path scope

Fresh Luna attempt:

• agent agt_90a84679
• provider/model codex / gpt-5.6-luna / xhigh
• dispatch task devspace-227-a-gate
• attempt issue227-codex-luna-xhigh-a3
• DispatchIntent hash 2407a7426f1f172f81f3e71c9977e4cc3331b6a1cf6c1af571771d662e46d552
• provider session 01a0c270-6a8f-7d23-b28b-71d1cf9a95a1

Provider terminal:

Your workspace is out of credits.
Ask your workspace owner to refill in order to continue.

Physical reconciliation:

• agent terminal = provider_error
• workspace HEAD unchanged at f9305e92...
• workspace dirty=false
• Candidate present=false
• changedPaths=[]
• unexpectedPaths=[]
• scopeState=WITHIN_SCOPE
• no repository mutation occurred

Therefore this is an external Codex account/workspace entitlement blocker, not a DevSpace runtime/startup blocker and not an implementation defect.

Evidence-lineage correction for next attempt

While checking the v4 validator before any Candidate existed, the controller found that the a3 Core binding is not suitable for a future passing direct-evidence artifact:

• embedded Core operation_id must equal direct-evidence/DispatchIntent task_id;
• embedded Core attempt_id must equal DispatchIntent attempt_id;
• embedded Core integration_authority.authority_hash must equal the direct evidence core_authority_hash, which is the committed DispatchIntent hash projection.

Because a3 produced no Candidate, no invalid direct evidence was emitted. Do not retrofit a3.

The a3 Core session is retained as failed-attempt history. It currently records AGENT outcome unknown after admitted writer start, but the exact physical agent is terminal and the workspace is clean. No blind retry and no attempt-id reuse is authorized.

Exact next gate

After the Codex account/workspace has usable credits again:

1. open a new current-main managed worktree;
2. create a new a4 Core binding before mutation with:
   • operation_id = devspace-227-a-gate;
   • attempt_id = issue227-codex-luna-xhigh-a4;
   • integration authority hash cross-bound to the exact a4 normalized DispatchIntent hash;
3. fresh Luna/xhigh preflight;
4. one new DIRECT_DELEGATED Luna attempt;
5. only then continue Candidate/ChangeSet/direct-evidence/Core-verification/v4 acceptance.

A3_REPOSITORY_EFFECT=CONFIRMED_NO_EFFECT
A3_CANDIDATE=NONE
A3_RETRY=FORBIDDEN
FIXED_WORKER_RUNTIME=READY
CURRENT_BLOCKER=CODEX_WORKSPACE_OUT_OF_CREDITS
B/#226=DO_NOT_START
AUTO_CHAIN=false

No model substitution, merge, release, cutover, production, or acceptance authority follows from this receipt.

[James3014]

Fresh fixed-worker credit control — blocker persists, no repository effect

Fresh control at the current DevSpace runtime confirms the existing #227 blocker is still external provider entitlement, not DevSpace runtime readiness.

Bound state:

• DevSpace main/workspace HEAD: f9305e926c0b5f64d84516b8038eacef329e15c5
• isolated workspace: ws_1f77651443
• Codex CLI runtime: 0.154.0
• provider/model/effort: codex / gpt-5.6-luna / xhigh
• preflight: profile resolved, runtimeReady=true, local capacity available, no local blocker
• provider auth/reachability remained correctly UNKNOWN before spawn

Read-only availability control:

• agent: agt_6f3f6003
• provider session: 01a0c276-127e-7c40-bd09-081833d15858
• task: issue227-codex-credit-control
• attempt: issue227-codex-luna-credit-control-20260921-a1
• claim ceiling: RESULT_RETURNED
• write scope: empty
• terminal: provider_error

Provider result:

Your workspace is out of credits.
Ask your workspace owner to refill in order to continue.

Physical reconciliation:

• changedPaths=[]
• no Candidate
• no Core mutation session opened for this control
• no repository/GitHub mutation from the worker
• no a4 attempt started
• no worker substitution attempted

Current disposition remains:

FIXED_CODEX_LUNA_RUNTIME=READY
FIXED_CODEX_LUNA_PROVIDER_CREDITS=BLOCKED
A4_NOT_STARTED
CANDIDATE=NONE
REPOSITORY_EFFECT=NONE
WORKER_SUBSTITUTION=NOT_AUTHORIZED
AUTO_CHAIN=false

Exact next gate remains one of:

1. restore usable credits for the fixed Codex Luna/xhigh account/workspace, then start a fresh current-main a4 attempt under the existing A-gate: produce current-main v4 evidence and independently accept the Codeg Wave 2 Candidate #227 contract; or
2. obtain an explicit Owner worker-rebind decision and recompile/reverify the affected execution identity before dispatch.

This control does not authorize #226, #982 B3, merge, release, cutover or production.

[James3014]

CONTRACT_DELTA — a4 must restore the real direct-evidence projection surface; a3 remains historical/no-effect

Fresh watermark:

• DevSpace main: f9305e926c0b5f64d84516b8038eacef329e15c5
• A-gate: produce current-main v4 evidence and independently accept the Codeg Wave 2 Candidate #227 current Issue watermark: 2026-09-21T05:37:58Z
• historical Wave 2: add durable DevSpace -> Codeg thin execution bridge #224 semantic Candidate: efc197bf3e7fdc49d357dab91eafc9eb152b9451
• a3 repository effect: confirmed none; Candidate absent; do not retrofit a3
• fixed worker remains codex / gpt-5.6-luna / xhigh; current provider blocker is workspace credits only
• B/Wave 1: bind Grok account leases to immutable Codeg profiles #226 remains forbidden until A independent acceptance completes

Why the a3 path set is not reusable

Fresh readback of cms_738ce33ab4294c82a1f79d2c20e91489 shows the a3 AcceptanceContract allowed:

• the seven Wave 2: add durable DevSpace -> Codeg thin execution bridge #224 bridge paths;
• src/execution-protocol.ts
• src/execution-protocol.test.ts
• src/core-mutation-session.ts
• src/core-mutation-session.test.ts
• non-existent src/direct-candidate-evidence.ts
• non-existent src/direct-candidate-evidence.test.ts

It omitted the actual host-tool owner src/core-mutation-tools.ts.

Because a3 made no repository mutation and no Candidate, this is a contract defect in a failed attempt, not source debt to preserve.

Frozen donor evidence

The v4 source binding names the immutable TG-A producer Candidate add3e0b73e1da02d08f09ca4c12108408492da4d and exact historical blobs for src/execution-protocol.ts and src/core-mutation-session.ts. Those Git objects are no longer fetchable from the current remote, so they are not current repository authority.

However, historical Codex execution logs retain the original git show stdout from that bound Candidate. Combined with the frozen v4 validator/source-binding, they establish the producer mechanism:

• src/execution-protocol.ts: schema/types, integrity signing, strict validateDirectCandidateExecutionEvidence;
• src/core-mutation-session.ts: produceDirectCandidateEvidence(...), which reads exact durable agent + Core session + original Candidate provenance and fails closed on reconstruction/mismatch;
• src/core-mutation-tools.ts: host tool direct_candidate_execution_evidence and its output schema/wiring;
• src/execution-protocol.test.ts and src/core-mutation-session.test.ts: protocol/producer positive + negative controls;
• src/server.test.ts: existing host-tool registration/real MCP test surface for Core tools.

Current-main ownership that MUST remain unchanged

Current f9305e9... already owns Candidate lifecycle correctly:

git_commit -> Core admission -> physical commit -> synchronous reconciliation -> coreMutationGuard.recordCandidate(...)

Therefore the restored direct-evidence surface is projection/readback only. It must not create:

• a second Candidate ledger;
• a second mutation lifecycle;
• a second verifier;
• acceptance/approval/merge authority;
• reconstructed historical provenance.

a4 maximum allowed source paths

The next passing attempt must use a fresh worktree + fresh Core binding. Maximum mutation scope is exactly:

1. src/codeg-bridge.ts
2. src/codeg-bridge.test.ts
3. src/config.ts
4. src/config.test.ts
5. src/durable-operations.ts
6. src/server.ts
7. src/server.test.ts
8. src/execution-protocol.ts
9. src/execution-protocol.test.ts
10. src/core-mutation-session.ts
11. src/core-mutation-session.test.ts
12. src/core-mutation-tools.ts

Do not create src/direct-candidate-evidence.ts or src/direct-candidate-evidence.test.ts unless a later explicit contract delta proves a new owning boundary is necessary.

a4 authority/binding requirements

Before first repository effect:

• task/operation id = devspace-227-a-gate;
• attempt id = one new exact a4 attempt identity;
• Core operation_id == DispatchIntent.taskId;
• Core attempt_id == DispatchIntent.attemptId;
• Core integration authority hash == exact normalized a4 DispatchIntent hash projection;
• lane = DIRECT_DELEGATED;
• claim ceiling = CANDIDATE_READY;
• deletion policy = FORBID;
• source commit/tree and workspace identity bound to fresh current main/worktree;
• capability-discovery receipt rebound fresh before effect.

Required implementation properties

Bridge:

• mechanically reproduce the already-verified Wave 2: add durable DevSpace -> Codeg thin execution bridge #224 thin Codeg bridge semantics only;
• no provider/model routing expansion, fallback, delegation, auto-merge or successor authority.

Direct evidence:

• exact schema devspace.direct_candidate_execution.v1;
• require original durable Core Candidate provenance;
• require exact successful terminal durable agent record and execution generation;
• exact DispatchIntent/Core binding cross-binding;
• physical clean Candidate commit/tree/manifest/diff readback;
• deterministic dce_<32hex> identity and integrity;
• OWNER_DIRECT / DIRECT_DELEGATED;
• state=completed, terminal_reason=completed, WITHIN_SCOPE, retry_safe=false, reconciliation_required=false;
• all verification/certification/acceptance/approval/merge/release/deploy/public-claim flags remain false.

Required verifier set before independent acceptance

• focused Wave 2: add durable DevSpace -> Codeg thin execution bridge #224 Codeg bridge tests;
• config focused tests;
• server Codeg/operation-status tests;
• execution-protocol direct-evidence protocol/forgery negatives;
• core-mutation-session direct-evidence producer positives + reconstruction/cross-binding/scope negatives;
• server host-tool registration/call-path witness for direct_candidate_execution_evidence;
• TypeScript typecheck;
• production build;
• git diff --check;
• exact Candidate provenance from current git_commit;
• physical devspace.direct_candidate_execution.v1;
• canonical nexus.core.generic-verification-response.v1-experimental = VERIFIED / VALID;
• independent nexus.candidate_acceptance.v4 reviewer/validator.

Self-hosting stop condition

The producer may be implemented in the same new Candidate only if, after that Candidate commit is formed, the controller can invoke the committed producer against the exact real durable agent/Core/Candidate records without replacing production DevSpace or fabricating/copying lineage.

If that cannot be proven safely, STOP and split a producer-restoration prerequisite. Do not cut over production merely so an unaccepted Candidate can manufacture its own evidence.

Current frontier

A3                       TERMINAL / NO REPOSITORY EFFECT
A4 CONTRACT              CORRECTED_PENDING_FRESH_BIND
LUNA CREDITS              EXTERNAL_BLOCKER
#224 PATCH ON CURRENT MAIN git apply --check = PASS
DIRECT EVIDENCE DONOR      MECHANISM RECOVERED / CURRENT MAIN SURFACE ABSENT
CORE GENERIC VERIFIER      AVAILABLE IN nexus-core
A CANDIDATE                NONE
A INDEPENDENT ACCEPTANCE   NOT STARTED
B / #226                   DO NOT START
AUTO_CHAIN                 false

This delta supersedes only the failed a3 path/binding assumptions. It does not rewrite historical #224 evidence or authorize worker substitution, merge, cutover, release or production.

[James3014]

A/#227 current frontier — Luna provider executes again; a4 is blocked by existing Core-session ownership, not credits

Fresh current-state fence:

• DevSpace canonical main/runtime: f9305e926c0b5f64d84516b8038eacef329e15c5
• fixed replay workspace: ws_713741306e
• workspace root: /Users/jameschen/Workspace/.devspace-chatgpt/worktrees/devspace-ec65075b
• workspace HEAD: f9305e926c0b5f64d84516b8038eacef329e15c5
• workspace: isolated / clean
• fixed worker preflight: codex / gpt-5.6-luna / xhigh
• Codex CLI: 0.154.0
• runtimeReady=true, local capacity available

Contract-scope correction

The immediately preceding durable contract delta, comment 5757664772, supersedes the failed a3 seven-path assumption.

The next passing a4 maximum mutation scope is exactly 12 paths:

1. src/codeg-bridge.ts
2. src/codeg-bridge.test.ts
3. src/config.ts
4. src/config.test.ts
5. src/durable-operations.ts
6. src/server.ts
7. src/server.test.ts
8. src/execution-protocol.ts
9. src/execution-protocol.test.ts
10. src/core-mutation-session.ts
11. src/core-mutation-session.test.ts
12. src/core-mutation-tools.ts

src/direct-candidate-evidence.ts and its test are not authorized absent a later explicit boundary decision.

Fresh read-only availability control

One new non-mutating control was started only to determine whether the previous terminal
Your workspace is out of credits
still described the live provider boundary.

Exact control:

• agent: agt_0b050c94
• task: issue227-codex-credit-control
• attempt: issue227-codex-luna-credit-control-20260921-a2
• intent hash: ccbd649abe0965afb0124d9f183f4889e4012a24effe2aadf95dac9fa8b6252d
• writeScope=[]
• claim ceiling: RESULT_RETURNED
• max wall: 120s

The exact local Codex session is physically correlated by the full DispatchIntent and control prompt:

• session: 01a0c305-e104-7173-931b-336c871091f2
• session file: .codex/sessions/2026/09/21/rollout-2026-09-21T16-12-17-01a0c305-e104-7173-931b-336c871091f2.jsonl

This session shows repeated real model token activity and tool-call turns. The old terminal entitlement string did not recur.

The session's rate-limit metadata still reported credits.has_credits=false, but that metadata did not prevent this Luna turn from executing and producing model output/activity, so it must not be treated as equivalent to the prior terminal provider entitlement error.

The control itself did not satisfy its desired exact-output terminal because the model over-explored the controller environment and the outer DevSpace execution contract reached its 120s wall bound:

agent status=error
terminalReason=timeout
providerState=UNKNOWN
changedPaths=[]
workspace dirty=false
Candidate present=false

A nested ad-hoc codex exec attempted by that model failed locally with:
failed to initialize in-process app-server client: Operation not permitted.
That nested probe is not the DevSpace fixed-worker transport and is not used as provider-admission evidence.

No retry of this exact control was issued.

Current hard gate — existing Core mutation ownership

Before opening the a4 pre-effect binding, the current controller attempted read-only workspace/Core inspection.

DevSpace failed closed with:

[CORE_MUTATION_ACTOR_MISMATCH]
Active Core mutation session belongs to a different caller identity.

and direct Core-session status returns the same ownership fence.

The visible agent list for this caller contains only the completed read-only control above. No new a4 implementation agent was started by this controller.

Therefore:

FIXED_LUNA_RUNTIME=READY
PREVIOUS_OUT_OF_CREDITS_TERMINAL=NOT_REPRODUCED
LUNA_MODEL_EXECUTION_OBSERVED=TRUE
READ_ONLY_CONTROL_TERMINAL=TIMEOUT_UNKNOWN
READ_ONLY_CONTROL_REPOSITORY_EFFECT=NONE

A4_STARTED=FALSE
A4_REPOSITORY_EFFECT=NONE
A4_MAX_SCOPE=12_PATHS_PER_COMMENT_5757664772
CURRENT_HARD_BLOCKER=CORE_MUTATION_ACTOR_MISMATCH_ON_WS_713741306e
PARALLEL_A4_DISPATCH=FORBIDDEN

The existing Core session must be continued/closed/abandoned/reconciled by its owning caller identity before another controller can safely start a new #227 mutating attempt. Do not bypass the caller fence by reading/editing the underlying state DB or by opening a parallel replay of the same 12-path logical Candidate.

After that ownership gate is cleared, the corrected a4 contract remains:

• operation_id=devspace-227-a-gate
• one new exact a4 attempt identity
• DIRECT_DELEGATED
• exact 12-path maximum write ceiling from comment 5757664772
• DispatchIntent/Core authority hash cross-binding before first mutation
• physical Candidate + devspace.direct_candidate_execution.v1 + Core generic verification
• independent v4 acceptance
• no self-acceptance / merge / cutover / #982 B3 auto-chain.

AUTO_CHAIN=false.

[James3014]

CONTRACT_DELTA — a4 Core verifier set must not depend on downstream Core verification or Candidate Acceptance

Fresh watermark:

• DevSpace main: f9305e926c0b5f64d84516b8038eacef329e15c5
• A-gate: produce current-main v4 evidence and independently accept the Codeg Wave 2 Candidate #227 updated_at before this delta: 2026-09-21T08:38:42Z
• nexus-core canonical main: ee64716f2da3db9e6fddb3f3271e655bcbb8dd11

Fresh readback of the failed/no-effect a3 Core binding shows required_verifier_ids included candidate-acceptance-v4-validator. That creates a circular dependency: Core verification is an input to Candidate Acceptance, so Candidate Acceptance cannot also be a prerequisite observation for Core verification.

Likewise, nexus.core.generic-verification-response.v1-experimental is the output of the Core verification stage and must not be listed as a required pre-verification observation.

Because a3 produced no repository effect or Candidate, do not preserve this circular verifier list.

a4 Core AcceptanceContract required_verifier_ids

Use only verifier observations that can terminally run before Core generic verification:

1. codeg-bridge-focused-tests
2. config-focused-tests
3. server-codeg-focused-tests
4. execution-protocol-direct-evidence-tests
5. core-mutation-direct-evidence-tests
6. server-direct-evidence-tool-tests
7. typescript-typecheck
8. production-build
9. git-diff-check

Every verifier id must have exactly one physical observation in the Core evidence bundle. All nine must be PASS for a positive Core result.

The direct-evidence artifact itself remains executor lineage, not a verifier observation. It is separately hash-bound into nexus.candidate_acceptance.v4.

Downstream sequence — not part of required_verifier_ids

After the Candidate commit and the nine physical observations exist:

Core-bound git_commit
  -> durable Candidate provenance / change manifest
  -> devspace.direct_candidate_execution.v1
  -> build nexus.core.generic-verification-request.v1-experimental
  -> Core factual verification
  -> nexus.core.generic-verification-response.v1-experimental
       status=VERIFIED
       reason_codes=[]
       integrity=VALID
       certification=null
  -> distinct independent reviewer
  -> nexus.candidate_acceptance.v4 validator/audit

certification_policy for the #227 factual Core request must be null; #227 does not ask Core to certify, approve, accept, merge, release or deploy the Candidate.

Canonical Core request contract

The request to verify_generic_changeset / POST /v1/changesets/verify has exactly:

• protocol_version
• schema
• acceptance_contract
• change_set
• change_manifest
• verification_plan
• evidence_bundle
• certification_policy

Required cross-bindings:

• ChangeSet paths == manifest paths;
• deleted paths == manifest DELETE entries;
• ChangeSet diff hash == canonical Core change-manifest hash;
• plan acceptance-contract hash == canonical AcceptanceContract hash;
• plan ChangeSet hash == canonical ChangeSet hash;
• evidence bundle hashes == canonical contract/ChangeSet/plan hashes;
• observed verifier ids == the nine required ids exactly;
• every positive observation status == PASS.

All hashes must come from the canonical nexus-core implementation at the bound Core revision; do not hand-roll equivalent JSON hashing.

Transport note

At this reconciliation point no process is listening on local port 8767. This is not a product failure and does not block implementation. After a4 Candidate exists, verification must bind to canonical nexus-core source ee64716f... and either:

1. use its authenticated loopback POST /v1/changesets/verify surface if the canonical service is live; or
2. run the same canonical verify_generic_changeset adapter source-bounded against the exact request and retain the exact response bytes/digest.

No alternate verifier implementation is authorized.

Current consequence

A4 SOURCE SCOPE           CORRECTED
A4 CORE VERIFIER SET      CORRECTED / NON-CIRCULAR
A4 CORE RESPONSE          DOWNSTREAM, NOT SELF-REQUIRED
A4 CANDIDATE ACCEPTANCE   DOWNSTREAM, DISTINCT REVIEWER
LUNA CREDITS              STILL EXTERNAL BLOCKER
B/#226                    DO NOT START

This delta supersedes only the failed a3 verifier-list assumption.

[James3014]

#227 serialization update — do not start 12-path a4 until the now-completed #224 a3 subject is dispositioned

Fresh upstream #224 a3 has progressed beyond the earlier credit/Core-workspace confusion:

workspace=ws_98faf1fc06
agent=agt_4122a4c7
provider session=01a0c31e-368d-7ee2-a6f7-afec39522d03
worker terminal=completed
scope=WITHIN_SCOPE
changed paths=exactly seven authorized #224 paths
unexpected paths=[]
seven worktree blobs=exact donor 71bdd67e... blobs
controller git diff --check=PASS

The observing controller is not the a3 Core-session owner and therefore did not run the remaining controller verifier set, commit the Candidate, or create direct evidence by bypassing DevSpace actor fencing.

This changes #227 sequencing:

FIRST:
original #224 a3 Core-session owner completes verifier/Core Candidate closure
        ↓
attempt truthful direct_candidate_execution.v1 + Core verification
        ↓
if sufficient → independent v4 acceptance / #224 integration

ONLY IF a3 cannot truthfully produce the required physical direct-evidence producer surface:
        ↓
use #227 comment 5757664772
fresh worktree + fresh Core binding
12-path DIRECT_DELEGATED a4 producer-restoration Candidate

Do not start a parallel 12-path a4 while the successful seven-path a3 subject is still awaiting owner-side disposition.

The earlier ws_713741306e actor mismatch is historical physical-workspace ownership and is not a global Core outage.

#227_A4_STARTED=FALSE
#227_A4_NEEDED=CONDITIONAL_ON_A3_DIRECT_EVIDENCE_DISPOSITION
PARALLEL_REPLAY=FORBIDDEN
B/#226=DO_NOT_START
AUTO_CHAIN=false

[James3014]

New hard prerequisite — #231 direct-evidence producer restoration

Fresh main: f9305e926c0b5f64d84516b8038eacef329e15c5.

Read-only current-state audit confirmed two independent facts:

1. the existing replay workspace ws_713741306e is still fenced by active Core session cms_3512d76889df4c2190185a9cdc915529 owned by another caller identity; current caller receives CORE_MUTATION_ACTOR_MISMATCH, so that replay must not be bypassed or impersonated;
2. current main has no safe readonly self-hosting path for an unintegrated direct-evidence producer: openDatabase(stateDir) configures writable SQLite/WAL and runs migrations, and no existing readonly DB helper was found.

Therefore #227 now has a semantic hard prerequisite:

#231 — restore current-main devspace.direct_candidate_execution.v1 producer surface.

#231 is intentionally non-overlapping with the historical seven Codeg bridge paths. Its exact mutation ceiling is only:

• src/execution-protocol.ts
• src/execution-protocol.test.ts
• src/core-mutation-session.ts
• src/core-mutation-session.test.ts
• src/core-mutation-tools.ts

#231 does not claim formal v4 acceptance for itself and does not cut over production to self-produce evidence. It must reach an independently reviewed/tested exact-head integration decision first.

After #231 is integrated and live-read back, #227 must still:

• clear/rebind the stale Core owner before any replay;
• open a fresh current-main Core-bound attempt;
• run the bounded Wave 2: add durable DevSpace -> Codeg thin execution bridge #224-equivalent Codeg replay;
• produce physical direct evidence from the integrated producer;
• obtain canonical Core generic verification;
• complete independent v4 Candidate Acceptance.

#231 producer restoration       HARD PREREQUISITE
ws_713 stale Core ownership     STILL BLOCKING THAT WORKSPACE
#227 fresh replay               NOT STARTED
#227 Candidate                  NONE
#226 / B                        DO NOT START
AUTO_CHAIN                      false

[James3014]

#231 dependency refinement — producer core can proceed; host activation serializes on existing Core owner

Fresh source inspection proved that current core-mutation-tools.ts does not own/read durable agent records; server.ts is the composition root that owns agentSessionManager.

Therefore #231 cannot truthfully complete the live direct_candidate_execution_evidence tool using only its original five files without duplicating agent authority. #231 is now split internally:

• P1 five-file producer core: non-overlap, may proceed now under a fresh Luna/Core attempt;
• P2 server.ts (+ real host witness) activation: must serialize until the existing ws_713741306e Core owner is reconciled, because those server paths overlap the historical A-gate: produce current-main v4 evidence and independently accept the Codeg Wave 2 Candidate #227 replay scope.

The first #231 Luna attempt agt_ca86c1c8 ended by idle timeout with confirmed zero repository effect and will not be retried/reused.

#227 remains blocked; #226/B remains forbidden. No Core-owner bypass or direct DB mutation is authorized.

[James3014]

OWNER DEFER — formal Codeg acceptance no longer on the active execution frontier

Fresh DevSpace main: 3f8d6c12c4986c0af806944d9aaa7c3427fb0380.

#227's acceptance contract and existing Core/Candidate evidence remain preserved. The Issue is deferred, not declared failed and not closed by this comment.

Reason: Owner selected HerdR #235 as the sole active CLI runtime candidate before spending further effort proving a production path through Codeg.

Consequences:

• do not start a fresh mutating Codeg replay for A-gate: produce current-main v4 evidence and independently accept the Codeg Wave 2 Candidate #227 while P0: qualify HerdR as the durable external coding-agent runtime substrate #235 is unresolved;
• do not bypass/reuse stale Core ownership to force completion;
• P0 prerequisite: restore current-main direct Candidate evidence producer for #227 #231 remains active because its direct-Candidate evidence producer is generic infrastructure;
• if P0: qualify HerdR as the durable external coding-agent runtime substrate #235 passes, any future production Candidate should be produced under a new HerdR gateway contract;
• if P0: qualify HerdR as the durable external coding-agent runtime substrate #235 fails structurally and Codeg is explicitly reselected, A-gate: produce current-main v4 evidence and independently accept the Codeg Wave 2 Candidate #227 can be rebound from fresh main/Core state.

No Candidate is accepted, rejected, merged, released or deployed by this decision.