@bridge_gpt/mcp-server 0.2.68 → 0.2.70

package/build/executor/required-work-ledger.js

@@ -15,19 +15,47 @@
  * the per-task lifecycle, keyed by the FULL `tool_use_id`, says whether the work
  * the worker started actually finished.
  *
+ * A task ID may identify sequential runs, each with its own tool_use_id.
+ * Lifecycle-terminal failure permits a new run but need not resolve execution.
+ *
  * Two places deliberately differ from the probe reducer (`reducer-v2.mjs`), on
  * the user-approved ticket's terms:
- *  - A REQUIRED task that ended `failed`, `stopped`, or `withdrawn` (the worker
- *    ran its own `TaskStop`) stays UNRESOLVED. The probe counted a worker
- *    withdrawal as complete; a worker giving up on required work is not success.
+ *  - A REQUIRED task that ended `failed` or `stopped` stays UNRESOLVED. A worker
+ *    withdrawal (the worker ran its own `TaskStop`) and a background command
+ *    that failed inside the startup window (`failed_to_start`) resolve
+ *    EXECUTION only: the work is no longer running, but nothing here says it
+ *    succeeded or that anything was verified. Declared verification still
+ *    depends only on verification facts.
+ *  - BAPI-1455: a required COMMAND (`bash_task`, `bash_bg`, `subagent_bash`)
+ *    that ended `failed` or `stopped` is resolved when the worker received
+ *    that command's OWN terminal result — today only its foreground
+ *    tool_result, bound by the exact tool_use_id. The recorded state stays the
+ *    real one and the envelope carries `result_delivered: true` beside it.
+ *    Delegates, monitors, denials, launch acknowledgements, and background
+ *    output reads never count: no background result shape has been measured
+ *    that binds to its task by structure rather than text, so background
+ *    commands stay unresolved exactly as before.
  *  - A denial links to an obligation only on the exact OPERATION and TARGET (for
  *    example the prepared branch on `origin`), never on the effect class alone.
  *
- * Purity: no I/O, no real timers (the supervisor takes injected timer deps), no
+ * Purity: no I/O, no real timers (the supervisor takes injected timer deps; the
+ * ledger itself only reads an injected clock and starts no timers), no
  * retained prompt, command, argument, URL, or path. Tool inputs and denial
  * targets are kept only as SHA-256 digests.
  */
-import { MAX_DENIALS, MAX_EVENT_BYTES, MAX_TASKS, TASK_RESOLVING_STATES, boundEnvelope, boundedIdentifier, deriveCompletionCause, digestStructured, runtimeMatchesSupported, successRefusalReason, COMPLETION_CONTRACT_VERSION, COMPLETION_CONTRACT_VERSION_V2, } from "./completion-contract.js";
+import { DELIVERY_RESOLVABLE_KINDS, DELIVERY_RESOLVABLE_STATES, MAX_DENIALS, MAX_EVENT_BYTES, MAX_TASKS, boundEnvelope, boundedIdentifier, deriveCompletionCause, digestStructured, isTaskResolved, runtimeMatchesSupported, successRefusalReason, COMPLETION_CONTRACT_VERSION, COMPLETION_CONTRACT_VERSION_V2, } from "./completion-contract.js";
+/**
+ * A background command that fails this soon after its launch acknowledgement is
+ * classified `failed_to_start` and resolves execution of a required task.
+ *
+ * Accepted risk: a background verification command that genuinely fails inside
+ * the window also resolves execution. The envelope keeps the visible
+ * `failed_to_start` state and does not establish verification. Required CI and
+ * merge admission stay fail-closed, and the existing CI-failure and
+ * observation-timeout notices remain the alert paths. A check outside required
+ * CI is an accepted gap whose exposure can last one CI cycle.
+ */
+export const FAILED_TO_START_WINDOW_MS = 30_000;
 // ---------------------------------------------------------------------------
 // Bounds and small pure helpers
 // ---------------------------------------------------------------------------
@@ -309,12 +337,15 @@ const TERMINAL_STATES = new Set([
     "failed",
     "stopped",
     "withdrawn",
+    "failed_to_start",
     "conflict",
 ]);
+const FAILED_TO_START_KINDS = new Set(["bash_bg", "bash_task", "subagent_bash"]);
 const KNOWN_TASK_STATUSES = new Set(["pending", "running", "completed", "failed", "stopped", "killed"]);
 export function createRequiredWorkLedger(init) {
     const binding = { ...init.binding };
     const lifecycleSupported = init.lifecycleSupported === true;
+    const clock = init.now ?? Date.now;
     const optionalWatchers = (init.optionalWatchers ?? []).slice(0, 16).map((w) => ({ ...w }));
     // An obligation whose target cannot be normalized links nothing: a denial of
     // it then reads `unlinked`/`ambiguous`, and unmet finalization still refuses
@@ -326,7 +357,8 @@ export function createRequiredWorkLedger(init) {
     const obligations = new Map();
     const evicted = new Map();
     const toolUses = new Map();
-    const workerStops = new Set();
+    const workerStops = new Set(); // bound obligation keys
+    const deferredWorkerStops = new Set(); // consumed at first association
     const denials = [];
     let latestSnapshot = null;
     let materialSeq = 0;
@@ -352,7 +384,7 @@ export function createRequiredWorkLedger(init) {
                 continue;
             if (latestSnapshot?.includes(o.taskId ?? "\u0000"))
                 continue;
-            evicted.set(o.key, { state: o.state, taskId: o.taskId, kind: o.kind, inputDigest: o.inputDigest, order: o.order });
+            evicted.set(o.key, { key: o.key, state: o.state, taskId: o.taskId, kind: o.kind, inputDigest: o.inputDigest, order: o.order });
             obligations.delete(o.key);
             return true;
         }
@@ -372,18 +404,48 @@ export function createRequiredWorkLedger(init) {
             key,
             state: "pending",
             order: ++orderSeq,
+            launchedAt: null,
+            resultDelivered: false,
+            failedByResult: false,
             ...spec,
             required: spec.required ?? !isOptional(spec.kind, spec.inputDigest),
         };
         obligations.set(key, o);
+        if (o.taskId !== null)
+            bindDeferredStop(o);
         return o;
     };
-    const findByTaskId = (taskId) => {
-        for (const o of obligations.values())
-            if (o.taskId === taskId && !o.placeholder)
-                return o;
-        return obligations.get(`t:${taskId}`);
+    const bindDeferredStop = (o) => {
+        if (o.taskId !== null && deferredWorkerStops.delete(o.taskId))
+            workerStops.add(o.key);
+    };
+    /** Record the clock at the FIRST launch event only; a later event never moves it. */
+    const recordLaunch = (o) => {
+        if (o.launchedAt !== null || o.state !== "pending")
+            return;
+        o.launchedAt = clock();
+    };
+    /** `failed_to_start` only for a first failure of background work inside the startup window. */
+    const classifyFailure = (o) => {
+        if (o.state !== "pending" || !o.background || !FAILED_TO_START_KINDS.has(o.kind) || o.launchedAt === null)
+            return "failed";
+        const elapsed = clock() - o.launchedAt;
+        return Number.isFinite(elapsed) && elapsed >= 0 && elapsed <= FAILED_TO_START_WINDOW_MS ? "failed_to_start" : "failed";
+    };
+    /** Prefer a live run, then the newest lifecycle-terminal run, including evictions. */
+    const findCurrentRunByTaskId = (taskId) => {
+        let current;
+        for (const o of [...obligations.values(), ...evicted.values()]) {
+            if (o.taskId !== taskId)
+                continue;
+            if (!current ||
+                (!TERMINAL_STATES.has(o.state) && TERMINAL_STATES.has(current.state)) ||
+                (TERMINAL_STATES.has(o.state) === TERMINAL_STATES.has(current.state) && o.order > current.order))
+                current = o;
+        }
+        return current;
     };
+    const hasOtherLiveClaim = (taskId, key) => [...obligations.values(), ...evicted.values()].some((o) => o.taskId === taskId && o.key !== key && !o.key.startsWith("t:") && !TERMINAL_STATES.has(o.state));
     /** Apply a terminal state. Identical duplicates are idempotent; a contradiction is `conflict`. */
     const applyTerminal = (o, next) => {
         if (!TERMINAL_STATES.has(o.state)) {
@@ -394,7 +456,11 @@ export function createRequiredWorkLedger(init) {
             return o.state === "conflict" ? "conflict" : "applied";
         // A stop (CLI teardown or worker TaskStop) after the task already ended is
         // measured noise (reducer-v2 R3), not a contradiction of the recorded end.
-        if ((next === "stopped" || next === "withdrawn") && (o.state === "succeeded" || o.state === "failed"))
+        if ((next === "stopped" || next === "withdrawn") && (o.state === "succeeded" || o.state === "failed" || o.state === "failed_to_start"))
+            return "applied";
+        // A repeated failure notice keeps the first classification: a duplicate
+        // after the window must not contradict `failed_to_start`.
+        if (next === "failed" && o.state === "failed_to_start")
             return "applied";
         // A killed foreground call reports `stopped` and then its own error
         // tool_result (measured C5k, "Exit code 137"): one ending, not two.
@@ -410,21 +476,40 @@ export function createRequiredWorkLedger(init) {
         insufficient.add("event_conflict");
         return "conflict";
     };
+    /**
+     * BAPI-1455 — apply a task's own foreground result and record that it was
+     * delivered. The recorded state stays the real outcome; a later lifecycle
+     * `stopped` may still refine a result-derived `failed` (a killed call).
+     */
+    const applyForegroundResult = (o, next) => {
+        const wasPending = !TERMINAL_STATES.has(o.state);
+        const r = applyTerminal(o, next);
+        o.resultDelivered = true;
+        if (wasPending && o.state === "failed")
+            o.failedByResult = true;
+        return r;
+    };
     /** Fold a placeholder (snapshot-only or orphan terminal keyed by task id) into the real obligation. */
     const mergePlaceholder = (real, taskId) => {
         const ph = obligations.get(`t:${taskId}`);
         if (!ph || ph === real)
             return "applied";
         obligations.delete(ph.key);
+        if (workerStops.delete(ph.key))
+            workerStops.add(real.key);
+        if (ph.resultDelivered)
+            real.resultDelivered = true;
+        if (real.launchedAt === null && ph.launchedAt !== null && real.state === "pending")
+            real.launchedAt = ph.launchedAt;
         if (TERMINAL_STATES.has(ph.state))
             return applyTerminal(real, ph.state);
         return "applied";
     };
-    const terminalOnEvicted = (key, next) => {
+    const terminalOnEvicted = (key, taskId, next) => {
         const ev = evicted.get(key);
         if (!ev)
             return "ignored";
-        if (ev.state === next || next === "stopped" || next === "withdrawn")
+        if (ev.taskId === taskId && (ev.state === next || next === "stopped" || next === "withdrawn"))
             return "applied";
         insufficient.add("event_conflict");
         return "conflict";
@@ -492,6 +577,7 @@ export function createRequiredWorkLedger(init) {
             }
             const input = b["input"];
             const inputDigest = obligationInputDigest(input);
+            const bg = isRecord(input) && input["run_in_background"] === true;
             // Bounded index; the input itself is dropped here, only digests remain.
             if (!toolUses.has(id)) {
                 if (toolUses.size >= MAX_TOOL_USE_INDEX) {
@@ -499,9 +585,14 @@ export function createRequiredWorkLedger(init) {
                     if (oldest !== undefined)
                         toolUses.delete(oldest);
                 }
-                toolUses.set(id, { name, inputDigest, denial: resolveDenialOperation(name, input) });
+                toolUses.set(id, {
+                    name,
+                    inputDigest,
+                    denial: resolveDenialOperation(name, input),
+                    background: bg,
+                    foregroundResult: null,
+                });
             }
-            const bg = isRecord(input) && input["run_in_background"] === true;
             if (name === "Agent" || name === "Task") {
                 track(id, { toolUseId: id, taskId: null, kind: bg ? "delegate_bg" : "delegate", inputDigest, background: bg, placeholder: false });
             }
@@ -513,10 +604,16 @@ export function createRequiredWorkLedger(init) {
             }
             else if (name === "TaskStop") {
                 // R13: the worker's OWN stop request. It turns a later stop into
-                // `withdrawn` for the record — still unresolved when the task was required.
+                // `withdrawn` for the record. A withdrawal resolves execution of a
+                // required task (the work is no longer running); it is not success.
                 const tid = isRecord(input) ? boundedIdentifier(input["task_id"]) : null;
-                if (tid && workerStops.size < MAX_WORKER_STOPS)
-                    workerStops.add(tid);
+                if (tid && workerStops.size + deferredWorkerStops.size < MAX_WORKER_STOPS) {
+                    const current = findCurrentRunByTaskId(tid);
+                    if (current)
+                        workerStops.add(current.key);
+                    else
+                        deferredWorkerStops.add(tid);
+                }
             }
             // Synchronous foreground Bash and every other tool are exploratory: not
             // obligations. Their denials are still recorded from the tool_result.
@@ -546,9 +643,25 @@ export function createRequiredWorkLedger(init) {
                 continue;
             }
             const o = obligations.get(id);
-            if (!o || o.background)
-                continue; // background: a launch acknowledgement, not a result.
-            const r = applyTerminal(o, isError ? "failed" : "succeeded"); // foreground delegate result.
+            if (!o) {
+                // BAPI-1455: a foreground Bash result can precede the lifecycle start
+                // that turns it into an obligation. Keep only the closed outcome.
+                const entry = toolUses.get(id);
+                if (entry && entry.name === "Bash" && !entry.background && entry.foregroundResult === null) {
+                    entry.foregroundResult = isError ? "failed" : "succeeded";
+                }
+                continue;
+            }
+            if (o.background) {
+                // A launch acknowledgement, not a result: non-terminal. It is the
+                // first named launch event for the startup window. No result text is read.
+                if (!isError)
+                    recordLaunch(o);
+                continue;
+            }
+            // A foreground result is the task's own terminal result, delivered to the
+            // worker under its exact tool_use_id (BAPI-1455): whatever its exit code.
+            const r = applyForegroundResult(o, isError ? "failed" : "succeeded");
             if (r === "conflict")
                 outcome = "conflict";
         }
@@ -572,6 +685,7 @@ export function createRequiredWorkLedger(init) {
             track(`t:${taskId}`, { toolUseId: taskId, taskId, kind, inputDigest: null, background: bg, placeholder: true, required: true });
             return "applied";
         }
+        const repeatedStart = obligations.get(toolUseId)?.taskId === taskId;
         const entry = toolUses.get(toolUseId);
         const o = track(toolUseId, {
             toolUseId,
@@ -587,8 +701,28 @@ export function createRequiredWorkLedger(init) {
             insufficient.add("event_conflict");
             return "conflict";
         }
+        if (!repeatedStart && hasOtherLiveClaim(taskId, o.key)) {
+            o.taskId = taskId;
+            o.state = "conflict";
+            insufficient.add("event_conflict");
+            return "conflict";
+        }
         o.taskId = taskId;
-        return mergePlaceholder(o, taskId);
+        bindDeferredStop(o);
+        // An orphan terminal recorded before this start had to guess a generic
+        // background `task`; the trusted start now names the real kind.
+        if (o.kind === "task") {
+            o.kind = kind;
+            o.background = bg;
+        }
+        recordLaunch(o);
+        const merged = mergePlaceholder(o, taskId);
+        if (merged === "conflict")
+            return merged;
+        // BAPI-1455: the command's own foreground result arrived before this start.
+        if (!bg && entry?.foregroundResult)
+            return applyForegroundResult(o, entry.foregroundResult);
+        return merged;
     };
     const handleTaskTerminal = (e, status) => {
         const taskId = boundedIdentifier(e["task_id"]);
@@ -603,8 +737,6 @@ export function createRequiredWorkLedger(init) {
         let next = status === "completed" ? "succeeded" : status === "failed" ? "failed" : status === "stopped" || status === "killed" ? "stopped" : null;
         if (next === null)
             return "applied"; // pending/running: non-terminal progress.
-        if (next === "stopped" && workerStops.has(taskId))
-            next = "withdrawn";
         const rawToolUse = e["tool_use_id"];
         const toolUseId = rawToolUse === undefined || rawToolUse === null ? null : boundedIdentifier(rawToolUse);
         if (rawToolUse !== undefined && rawToolUse !== null && !toolUseId) {
@@ -613,42 +745,66 @@ export function createRequiredWorkLedger(init) {
         }
         let o;
         if (toolUseId) {
-            const byTask = findByTaskId(taskId);
-            if (byTask && !byTask.placeholder && byTask.key !== toolUseId) {
+            // Exact keyed notices are authoritative for their own run, even after resume.
+            if (evicted.has(toolUseId))
+                return terminalOnEvicted(toolUseId, taskId, next);
+            o = obligations.get(toolUseId);
+            if (o?.taskId !== null && o?.taskId !== undefined && o.taskId !== taskId) {
                 insufficient.add("event_conflict");
                 return "conflict";
             }
-            if (evicted.has(toolUseId))
-                return terminalOnEvicted(toolUseId, next);
-            // R4: a terminal without a start is retained, not dropped.
-            o = track(toolUseId, {
-                toolUseId,
-                taskId,
-                kind: "task",
-                inputDigest: toolUses.get(toolUseId)?.inputDigest ?? null,
-                background: true,
-                placeholder: false,
-            });
-            if (!o)
-                return "applied";
-            if (o.taskId === null)
+            if (!o || o.taskId === null) {
+                const byTask = findCurrentRunByTaskId(taskId);
+                // An unexplained terminal cannot introduce a resumed start. Association
+                // of an existing anonymous tool use still requires no competing live claim.
+                if ((o && hasOtherLiveClaim(taskId, toolUseId)) ||
+                    (!o && byTask && !byTask.key.startsWith("t:") && byTask.key !== toolUseId)) {
+                    insufficient.add("event_conflict");
+                    return "conflict";
+                }
+                o = o ?? track(toolUseId, {
+                    toolUseId, taskId, kind: "task",
+                    inputDigest: toolUses.get(toolUseId)?.inputDigest ?? null,
+                    background: true, placeholder: false,
+                });
+                if (!o)
+                    return "applied";
                 o.taskId = taskId;
-            const merged = mergePlaceholder(o, taskId);
-            if (merged === "conflict")
-                return merged;
+                bindDeferredStop(o);
+                const merged = mergePlaceholder(o, taskId);
+                if (merged === "conflict")
+                    return merged;
+            }
         }
         else {
-            o = findByTaskId(taskId);
+            // A late unkeyed original terminal is inherently indistinguishable from
+            // a current-run update; no new correlation protocol is inferred here.
+            const current = findCurrentRunByTaskId(taskId);
+            if (current && evicted.has(current.key))
+                return terminalOnEvicted(current.key, taskId, next);
+            o = current ? obligations.get(current.key) : undefined;
             if (!o) {
-                for (const [k, ev] of evicted)
-                    if (ev.taskId === taskId)
-                        return terminalOnEvicted(k, next);
                 o = track(`t:${taskId}`, { toolUseId: taskId, taskId, kind: "task", inputDigest: null, background: true, placeholder: true, required: true });
                 if (!o)
                     return "applied";
             }
         }
-        return applyTerminal(o, next);
+        if (next === "stopped" && workerStops.has(o.key))
+            next = "withdrawn";
+        // BAPI-1455: a killed foreground call can deliver its error result before
+        // the lifecycle `stopped`. The lifecycle names the real end, so a
+        // result-derived `failed` is refined to `stopped` (one ending, not two).
+        if (next === "stopped" && o.state === "failed" && o.failedByResult) {
+            o.state = "stopped";
+            o.failedByResult = false;
+            return "applied";
+        }
+        const applied = applyTerminal(o, next === "failed" ? classifyFailure(o) : next);
+        // A lifecycle failure confirms a result-derived one: later teardown noise
+        // must not refine it.
+        if (o.state === "failed")
+            o.failedByResult = false;
+        return applied;
     };
     const handleSnapshot = (e) => {
         const tasks = e["tasks"];
@@ -673,13 +829,7 @@ export function createRequiredWorkLedger(init) {
         // A task the snapshot lists but no start/tool use explains yet is an
         // UNKNOWN obligation, required until a lifecycle event resolves it.
         for (const tid of ids) {
-            if (findByTaskId(tid))
-                continue;
-            let wasEvicted = false;
-            for (const ev of evicted.values())
-                if (ev.taskId === tid)
-                    wasEvicted = true;
-            if (wasEvicted)
+            if (findCurrentRunByTaskId(tid))
                 continue;
             track(`t:${tid}`, { toolUseId: tid, taskId: tid, kind: "task", inputDigest: null, background: true, placeholder: true, required: true });
         }
@@ -779,19 +929,14 @@ export function createRequiredWorkLedger(init) {
         const required = [];
         const optional = [];
         for (const tid of latestSnapshot ?? []) {
-            const o = findByTaskId(tid);
+            const o = findCurrentRunByTaskId(tid);
             if (!o) {
-                let evictedResolved = false;
-                for (const ev of evicted.values())
-                    if (ev.taskId === tid)
-                        evictedResolved = true;
-                if (!evictedResolved)
-                    required.push(tid);
+                required.push(tid);
                 continue;
             }
             if (!isLive(o))
                 continue;
-            (o.required ? required : optional).push(tid);
+            (obligations.get(o.key)?.required !== false ? required : optional).push(tid);
         }
         return { required, optional };
     };
@@ -814,7 +959,7 @@ export function createRequiredWorkLedger(init) {
         return all.map((o) => {
             // Only a terminal non-success is replaceable: live work is not superseded,
             // and a `conflict` is contradictory evidence, not a failure to retry.
-            const replaceable = o.state === "failed" || o.state === "stopped" || o.state === "withdrawn";
+            const replaceable = o.state === "failed" || o.state === "failed_to_start" || o.state === "stopped" || o.state === "withdrawn";
             return { o, state: replaceable && succeededLater(o) ? "replaced" : o.state };
         });
     };
@@ -869,7 +1014,7 @@ export function createRequiredWorkLedger(init) {
         // A snapshot id whose obligation is already listed (by its tool_use_id or as
         // a placeholder) is the same work: list it once, not under both handles.
         for (const tid of snap.required)
-            if (!liveRequired.includes(tid) && !findByTaskId(tid))
+            if (!liveRequired.includes(tid) && !findCurrentRunByTaskId(tid))
                 liveRequired.push(tid);
         for (const tid of snap.optional)
             if (!liveOptional.includes(tid))
@@ -886,11 +1031,11 @@ export function createRequiredWorkLedger(init) {
                 onlyBashBg = false;
         }
         for (const tid of snap.required) {
-            const o = findByTaskId(tid);
+            const o = findCurrentRunByTaskId(tid);
             if (!o || o.kind !== "bash_bg")
                 onlyBashBg = false;
-            else if (!bashBgIds.includes(o.taskId ?? o.toolUseId))
-                bashBgIds.push(o.taskId ?? o.toolUseId);
+            else if (!bashBgIds.includes(o.taskId ?? o.key))
+                bashBgIds.push(o.taskId ?? o.key);
         }
         return {
             readyToClose,
@@ -901,6 +1046,12 @@ export function createRequiredWorkLedger(init) {
             turnOpen,
             finalResultNoOpenTurn: resultsSeen > 0 && latestIsResult && !turnOpen,
             liveRequiredBashBg: onlyBashBg ? bashBgIds : [],
+            liveRequiredAfterFinal: resultsSeen > 0 && latestIsResult && !turnOpen
+                ? [...new Set([
+                        ...[...obligations.values()].filter((o) => isLive(o) && o.required).map((o) => o.taskId ?? o.toolUseId),
+                        ...snap.required,
+                    ])]
+                : [],
         };
     };
     // One predicate for "a required task is still pending", shared by the envelope
@@ -935,7 +1086,10 @@ export function createRequiredWorkLedger(init) {
         if (snap.required.length > 0 || unexplainedPlaceholder)
             reasons.add("stale_task_snapshot");
         const sufficient = reasons.size === 0;
-        const unresolvedRequired = effective.some(({ o, state }) => o.required && !TASK_RESOLVING_STATES.has(state));
+        // BAPI-1455: a command whose own terminal result was delivered is resolved,
+        // whatever its exit code; its recorded state is kept as it is.
+        const delivered = (o, state) => o.resultDelivered && DELIVERY_RESOLVABLE_KINDS.has(o.kind) && DELIVERY_RESOLVABLE_STATES.has(state);
+        const unresolvedRequired = effective.some(({ o, state }) => o.required && !isTaskResolved({ kind: o.kind, state, result_delivered: delivered(o, state) }));
         const anyConflict = effective.some(({ state }) => state === "conflict");
         let execution = unresolvedRequired || anyConflict || snap.required.length > 0 || unexplainedPlaceholder ? "incomplete" : "complete";
         if (!sufficient && execution === "complete")
@@ -948,6 +1102,7 @@ export function createRequiredWorkLedger(init) {
             state: state === "pending" ? "unknown" : state,
             required: o.required,
             input_digest: o.inputDigest,
+            ...(delivered(o, state) ? { result_delivered: true } : {}),
         }));
         const satisfied = new Set((facts.satisfiedObligations ?? [])
             .map(normalizeObligation)
@@ -979,7 +1134,7 @@ export function createRequiredWorkLedger(init) {
             };
         });
         const candidate = {
-            evidence_version: facts.verificationFacts ? COMPLETION_CONTRACT_VERSION_V2 : COMPLETION_CONTRACT_VERSION,
+            evidence_version: facts.verificationFacts?.deferred_obligation_identities !== undefined ? 3 : facts.verificationFacts ? COMPLETION_CONTRACT_VERSION_V2 : COMPLETION_CONTRACT_VERSION,
             runtime: { ...facts.runtime },
             binding: { ...binding, final_head_sha: facts.finalHeadSha },
             session_id: sessionId,
@@ -1031,9 +1186,9 @@ export function createRequiredWorkLedger(init) {
 export const CLOSURE_DEBOUNCE_MS = 1500;
 /**
  * The absolute post-result window (BAPI-1395). Once a final result is in, no
- * turn is open, and the only live required work is the worker's own background
- * Bash, stdin is closed at most this long after the window opens — whatever the
- * worker does meanwhile. Normal early closure is unchanged.
+ * turn is open, and any required work remains, stdin closes within this window.
+ * A new turn cancels it; a later final result opens a fresh window. Background
+ * activity never extends it, and the absolute deadline always takes precedence.
  */
 export const COMPLETION_WINDOW_MS = 30 * 60 * 1000;
 /**
@@ -1046,13 +1201,13 @@ export const COMPLETION_WINDOW_MS = 30 * 60 * 1000;
  * caller drains to EOF and the ledger recomputes, so a late turn still
  * invalidates the apparent closure (`late_activity_after_close`).
  *
- * The nudge: at most one, only when a turn ended while ONLY server-declared
+ * The optional-watcher nudge: at most one, only when a turn ended while ONLY server-declared
  * optional watchers are live. It is never sent while required work is live and
  * never asks for a broad stop — cancelling required work is not the executor's
  * call.
  *
  * The completion window (BAPI-1395): when the final result is in and only
- * required `bash_bg` work is live, one fixed end `min(opened + window, deadline)`
+ * any required work is live, one fixed end `min(opened + window, deadline)`
  * is set. A new worker turn cancels it; background activity does not. The one
  * nudge (shared with the optional-watcher nudge, so a job gets at most one)
  * asks the worker to stop only its own tasks that are merely waiting. Closing
@@ -1127,7 +1282,7 @@ export function createClosureSupervisor(opts) {
                 onUndelivered();
         });
     };
-    const openWindow = (bashBgIds) => {
+    const openWindow = (requiredIds) => {
         windowOpened = true;
         const now = deps.now();
         const windowEnd = Math.min(now + windowMs, opts.deadlineAtMs);
@@ -1141,7 +1296,7 @@ export function createClosureSupervisor(opts) {
             }, Math.max(0, windowEnd - now));
         }
         if (!nudged && opts.buildWindowNudge) {
-            sendNudge(opts.buildWindowNudge([...bashBgIds]), () => {
+            sendNudge(opts.buildWindowNudge([...requiredIds]), () => {
                 nudgeAwaitingReply = false;
             });
         }
@@ -1165,8 +1320,8 @@ export function createClosureSupervisor(opts) {
             nudgeAwaitingReply = false;
             return;
         }
-        if (!windowOpened && s.finalResultNoOpenTurn && s.liveRequiredBashBg.length > 0) {
-            openWindow(s.liveRequiredBashBg);
+        if (!windowOpened && s.finalResultNoOpenTurn && s.liveRequiredAfterFinal.length > 0) {
+            openWindow(s.liveRequiredAfterFinal);
             return;
         }
         if (!s.readyToClose)

package/build/executor/resume-pre-spawn.js

@@ -16,6 +16,8 @@
 import { createWorktreeForTicket } from "../worktree-core.js";
 import { ContinuationLineageMismatch, ContinuationWorktreeMissing, ExecutorNamedError, WorktreeLostBeforePush, } from "./job-errors.js";
 import { assertWorktreeOnBranch, listGitWorktrees, findWorktreeByBranch, remoteBranchExists as remoteBranchExistsDefault, } from "./worktree-inspection.js";
+import { ciFixContextError } from "./prompt-spec.js";
+import { fastForwardRetainedWorktreeToBoundHead } from "./worktree.js";
 /** The canonical WIP checkpoint commit message (executor-run, deterministic). */
 export const RESUME_WIP_COMMIT_MESSAGE = "wip: auto-checkpoint before resume";
 function asString(value) {
@@ -189,11 +191,34 @@ export async function verifyContinuationHeadLineage(worktreePath, boundHeadSha,
         throw new ExecutorNamedError(ContinuationLineageMismatch, `continuation worktree HEAD does not descend from the authorized head ${boundHeadSha.slice(0, 12)}`);
     }
 }
+/**
+ * BAPI-1514: the bound head a REFRESHED ci_fix continuation's evidence
+ * describes, or null for every other job. Non-null only when the job is a
+ * `ci_fix` continuation whose `ci_resolved_inputs.evidence_head_sha` is a full
+ * 40-hex SHA equal to both `ci_resolved_inputs.head_sha` and the binding's
+ * bound head. A legacy payload (no `evidence_head_sha`) or any mismatch is null,
+ * which keeps the retained-work protocol byte for byte (pure).
+ */
+export function readRefreshedCiFixEvidenceHead(job, binding) {
+    if (job.job_type !== "ci_fix" || binding.boundHeadSha === null)
+        return null;
+    const payload = job.payload && typeof job.payload === "object" ? job.payload : null;
+    const inputs = payload?.ci_resolved_inputs;
+    if (!inputs || typeof inputs !== "object" || Array.isArray(inputs))
+        return null;
+    const raw = inputs;
+    const evidence = typeof raw.evidence_head_sha === "string" ? raw.evidence_head_sha.trim().toLowerCase() : "";
+    const head = typeof raw.head_sha === "string" ? raw.head_sha.trim().toLowerCase() : "";
+    if (!FULL_SHA.test(evidence) || evidence !== head || evidence !== binding.boundHeadSha)
+        return null;
+    return evidence;
+}
 /**
  * Locate and verify a continuation's RETAINED worktree, then checkpoint it.
  *
  * Order: resolve the existing worktree (never recreate) -> verify its branch ->
- * verify its head lineage -> WIP-checkpoint dirty state. A missing worktree is a
+ * (BAPI-1514, refreshed ci_fix only) fast-forward a clean worktree to the bound
+ * head -> verify its head lineage -> WIP-checkpoint dirty state. A missing worktree is a
  * refusal ({@link ContinuationWorktreeMissing}), not a recreation from origin:
  * recreation cannot restore unpushed commits, and continuing without them would
  * silently discard exactly the work the continuation exists to carry. The
@@ -211,6 +236,18 @@ export async function prepareRetainedContinuationWorktree(job, binding, seams) {
         throw new ExecutorNamedError(ContinuationWorktreeMissing, `continuation for '${expectedBranch}' found no retained worktree; it is never recreated from origin because unpushed work cannot be recovered that way`);
     }
     await assertWorktreeOnBranch(seams.runCommand, worktreePath, expectedBranch);
+    // BAPI-1514: a refreshed ci_fix continuation describes its bound head. Move a
+    // clean retained worktree forward to it before the lineage proof; every
+    // outcome that did not reach the bound head falls through to that proof,
+    // which refuses unchanged. Only a moved remote tip refuses here, as the
+    // existing stale-head refusal, because the evidence no longer describes it.
+    const refreshedHead = readRefreshedCiFixEvidenceHead(job, binding);
+    if (refreshedHead !== null) {
+        const fastForward = seams.fastForwardRetainedWorktree ?? fastForwardRetainedWorktreeToBoundHead;
+        const advanced = await fastForward(worktreePath, expectedBranch, refreshedHead, seams.runCommand);
+        if (advanced.kind === "remote_moved")
+            throw ciFixContextError(job, "stale_head");
+    }
     await verifyContinuationHeadLineage(worktreePath, binding.boundHeadSha, seams);
     const checkpoint = await autoCheckpointDirtyState(worktreePath, seams, CONTINUATION_WIP_COMMIT_MESSAGE);
     return { worktreePath, branch: expectedBranch, checkpointed: checkpoint.committed };