@deksden-com/dd-flow-cli 0.9.0-beta.33 → 0.9.0-beta.35

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @deksden-com/dd-flow-cli
 
+## 0.9.0-beta.35
+
+### Patch Changes
+
+- Wait for npm registry propagation and verify the annotated tag created by Changesets before completing a guarded release.
+- Keep AGY native outcomes separate from settlement, invalidate old child settlement on new activity, and reserve productive operations before persistence across adapters.
+- Retain process-local native Stop observation in no-flow technical probes without installing project hooks or forwarding flow mutations.
+- Publish Work receipts after the authoritative SQL commit with resumable publication intents; preserve conflicting bytes, resume partial retries, and retain non-restorable diagnostic snapshots when receipts disagree.
+- Freeze the release source/canon tuple, reconcile uncertain publication, verify the isolated and exact global consumer, and retain phase receipts without creating another version on retry.
+
+## 0.9.0-beta.34
+
+### Patch Changes
+
+- Create and verify the immutable annotated Git tag as part of the guarded release publication.
+
 ## 0.9.0-beta.33
 
 ### Patch Changes

package/dist/build-info.json

@@ -1,8 +1,8 @@
 {
   "cli_package": "@deksden-com/dd-flow-cli",
-  "cli_version": "0.9.0-beta.33",
-  "cli_commit": "29017c402962ffd27f468a1e88e44947f6513c0b",
-  "built_at": "2026-09-07T19:23:48.837Z",
+  "cli_version": "0.9.0-beta.35",
+  "cli_commit": "e2ed74f88c272aa8269bd8be56b1f1d73467f4d7",
+  "built_at": "2026-09-07T21:56:49.561Z",
   "built_with_canon": {
     "version": "4.0.6",
     "commit": "c6fc50cb3b5526ea0162ee4454d1ee36f17be2da",

package/dist/harness-runtime/lib/dd-agy-daemon.mjs

@@ -36,9 +36,15 @@ async function forwardUsage(config, sessionId, result, tools, descendants) {
   return { status: "ingested" };
 }
 
-async function prepare(paths, config) {
+export async function prepare(paths, config) {
   for (const dir of [paths.dir, paths.gemini, paths.runtime, paths.config, paths.temporary]) { await mkdir(dir, { recursive: true, mode: 0o700 }); await chmod(dir, 0o700); }
-  if (config.noFlow) return;
+  if (config.noFlow) {
+    // Technical probes still need native settlement, but must not install
+    // workspace hooks or forward any lifecycle mutation to dd-flow.
+    const command = `${shell(process.execPath)} ${shell(config.entryPath)} hook handle --event Stop --state-dir ${shell(paths.dir)} --json`;
+    await writeJson(path.join(paths.config, "hooks.json"), { "dd-flow-observer": { Stop: [{ type: "command", command, timeout: 30 }] } });
+    return;
+  }
   const command = `${shell(process.execPath)} ${shell(config.entryPath)} hook handle --event __EVENT__ --state-dir ${shell(paths.dir)} --project-root ${shell(config.projectRoot)} --dd-flow-bin ${shell(config.ddFlowBin)} --dd-flow-home ${shell(config.ddFlowHome)} --json`;
   const hooks = { "dd-flow": {
     PreToolUse: [{ matcher: "*", hooks: [{ type: "command", command: command.replace("__EVENT__", "PreToolUse"), timeout: 30 }] }],
@@ -92,7 +98,7 @@ export async function callDaemon(stateDir, operation, params = {}, timeoutMs = 3
         const observed = Date.parse(status?.last_activity_at ?? "");
         const progressed = status?.active_tree === true && Number.isFinite(observed) && observed > lastActivity;
         if (progressed) lastActivity = observed;
-        if (!clock.sample(progressed ? lastActivity : undefined)) return;
+        if (!clock.sample(progressed ? lastActivity : undefined, progressed ? lastActivity : undefined)) return;
         finish(new DaemonError(status?.active_tree ? "subject_liveness_timeout" : "operation_observation_lost", `${operation} has no recent productive provider activity`, true, {
           operation_id: request.id,
           last_activity_at: status?.last_activity_at ?? null,
@@ -204,7 +210,7 @@ export class Runtime {
     // child can close while the asynchronous write is still pending.
     if (!this.init && event.event === "result" && event.result?.status === "ERROR") this.startupError = new DaemonError("agy_provider_rejected", String(event.result.error ?? "Antigravity rejected the Session before initialization"), false, { provider_result: event.result });
     this.observeProviderActivity(event); await this.journal("provider_event", { event }); if (event.event === "init") { this.init = { conversation_id: event.conversation_id, ...(event.init ?? {}) }; if (!this.init.conversation_id) throw new DaemonError("agy_init_missing", "Antigravity init has no conversation ID"); const requested = { provider: this.config.provider, model: this.config.model, reasoning: this.config.reasoning, mode: this.config.mode, permission_mode: "always-proceed" }; this.profile = assertProfile(requested, observedProfile(this.init, requested)); await observeModel({ journal: this.config.journal, harness: "antigravity-cli", sessionId: this.init.conversation_id, requested, observed: this.profile.observed, source: "native.init" }); await this.persist({ shutdown_state: "running", active_tree: false }); readyResolve(this.init); } else if (event.event === "step_update") this.observeStep(event.step_update ?? {}); else if (event.event === "result") { if (this.startupError) throw this.startupError; await this.finishTurn(event.result ?? {}); } } }
-  observeStep(step) { const sessionId = step.conversation_id ?? this.init?.conversation_id; const observation = this.sessionObservations.get(sessionId) ?? {}; if (Number.isInteger(step.step_index)) this.sessionObservations.set(sessionId, { ...observation, last_step_index: Math.max(observation.last_step_index ?? -1, step.step_index) }); if (step.step_type === "tool" && ["DONE", "ERROR"].includes(step.state)) { const stepId = step.step_id ?? step.stepId ?? step.id ?? step.tool_call_id ?? step.toolCallId ?? (Number.isInteger(step.step_index) ? `${sessionId}:${step.step_index}` : null); const duplicate = stepId && this.completedToolSteps.has(String(stepId)); if (!duplicate) { if (stepId) this.completedToolSteps.add(String(stepId)); else this.toolIdentityComplete = false; const name = step.tool_name ?? step.tool_info?.name ?? "unknown", current = this.toolCalls.get(name) ?? { total: 0, failures: 0 }; current.total += 1; if (step.state === "ERROR" || step.tool_info?.error) current.failures += 1; this.toolCalls.set(name, current); } } for (const child of step.subagent_info?.subagents ?? []) if (child.conversation_id) { const prior = this.descendants.get(child.conversation_id); this.descendants.set(child.conversation_id, { provider_session_id: child.conversation_id, parent_provider_session_id: this.init?.conversation_id ?? null, role: child.role ?? null, subagent_type: child.type_name ?? null, log_uri: child.log_uri ?? null, workspace_uris: child.workspace_uris ?? [], status: prior?.status ?? "unknown" }); } }
+  observeStep(step) { const sessionId = step.conversation_id ?? this.init?.conversation_id; const observation = this.sessionObservations.get(sessionId) ?? {}; if (Number.isInteger(step.step_index) && step.step_index > (observation.last_step_index ?? -1)) this.childActivity(sessionId); if (Number.isInteger(step.step_index)) this.sessionObservations.set(sessionId, { ...observation, last_step_index: Math.max(observation.last_step_index ?? -1, step.step_index) }); if (step.step_type === "tool" && ["DONE", "ERROR"].includes(step.state)) { const stepId = step.step_id ?? step.stepId ?? step.id ?? step.tool_call_id ?? step.toolCallId ?? (Number.isInteger(step.step_index) ? `${sessionId}:${step.step_index}` : null); const duplicate = stepId && this.completedToolSteps.has(String(stepId)); if (!duplicate) { if (stepId) this.completedToolSteps.add(String(stepId)); else this.toolIdentityComplete = false; const name = step.tool_name ?? step.tool_info?.name ?? "unknown", current = this.toolCalls.get(name) ?? { total: 0, failures: 0 }; current.total += 1; if (step.state === "ERROR" || step.tool_info?.error) current.failures += 1; this.toolCalls.set(name, current); } } for (const child of step.subagent_info?.subagents ?? []) if (child.conversation_id) { const prior = this.descendants.get(child.conversation_id); this.descendants.set(child.conversation_id, { ...prior, provider_session_id: child.conversation_id, parent_provider_session_id: this.init?.conversation_id ?? null, role: child.role ?? null, subagent_type: child.type_name ?? null, log_uri: child.log_uri ?? null, workspace_uris: child.workspace_uris ?? [], status: prior?.status ?? "unknown" }); } }
   toolSnapshot() { const byName = {}, failuresByName = {}; let total = 0, failures = 0; for (const [name, value] of this.toolCalls) { byName[name] = value.total; failuresByName[name] = value.failures; total += value.total; failures += value.failures; } return { total, failures, by_name: byName, failures_by_name: failuresByName, completeness: this.toolIdentityComplete ? "complete" : "partial" }; }
   async finishTurn(result) {
     if (result.status === "RUNNING") { await this.persist({ active_tree: true }); return; }
@@ -245,7 +251,7 @@ export class Runtime {
   receipt(result = this.lastResult) {
     const assistantText = typeof result?.response === "string" ? result.response : typeof result?.text === "string" ? result.text : null;
     const root = this.init?.conversation_id; const observation = this.sessionObservations.get(root);
-    const treeSettled = [...this.descendants.values()].every(child => ["completed", "failed", "cancelled", "settled_by_root"].includes(child.status));
+    const treeSettled = [...this.descendants.values()].every(child => child.tree_settled === true || ["completed", "failed", "cancelled", "settled_by_root"].includes(child.status));
     // A terminal root result is the provider's authoritative end-of-turn
     // observation when AGY does not emit a root Stop hook.  A received
     // non-idle Stop still wins, and every discovered child must be terminal.
@@ -254,7 +260,36 @@ export class Runtime {
     return { harness: "antigravity-cli", runtime_family: "antigravity", provider_session_id: root ?? null, adapter_session_id: root ?? null, cwd: this.config.cwd, profile: this.profile, result, ...(assistantText === null ? {} : { assistant_text: assistantText }), usage: usageSnapshot(result ?? {}, this.toolSnapshot()), usage_ingest: this.usageIngest, descendants: [...this.descendants.values()], transcript_path: observation?.transcript_path ?? null, settled: Boolean((!this.active || terminalPending) && result && ["SUCCESS", "ERROR", "CANCELLED"].includes(result.status) && treeSettled && rootSettled) };
   }
   async zeroUsage() { await forwardUsage(this.config, this.init.conversation_id, { usage: {} }, this.toolSnapshot(), []); }
-  async prompt(text, assertDispatch = captureDispatchGuard(this)) { if (!text) throw new DaemonError("prompt_required", "prompt is required"); await this.start(); await this.draining; if (this.active) throw new DaemonError("operation_in_progress", "an Antigravity turn is already running"); if (this.lastResult && !this.receipt().settled) throw new DaemonError("tree_not_settled", "the prior Antigravity agent tree is not fully settled"); const root = this.init?.conversation_id; const prior = this.sessionObservations.get(root) ?? {}; this.turnGeneration++; this.sessionObservations.set(root, { ...prior, step_floor: prior.last_step_index ?? null, stop: null, last_hook: null }); this.lastProviderEvent = null; await this.persist({ active_tree: true }); return await new Promise((resolve, reject) => { assertDispatch(); this.active = { resolve, reject, generation: this.turnGeneration, previousError: this.lastResult?.error ?? null }; this.child.stdin.write(`${JSON.stringify({ event: "user", message: { content: text } })}\n`, error => { if (error) { this.active = null; reject(error); } }); }); }
+  async prompt(text, assertDispatch = captureDispatchGuard(this)) {
+    if (!text) throw new DaemonError("prompt_required", "prompt is required");
+    await this.start(); await this.draining;
+    if (this.active) throw new DaemonError("operation_in_progress", "an Antigravity turn is already running");
+    if (this.lastResult && !this.receipt().settled) throw new DaemonError("tree_not_settled", "the prior Antigravity agent tree is not fully settled");
+    let resolveTurn, rejectTurn;
+    const reply = new Promise((resolve, reject) => { resolveTurn = resolve; rejectTurn = reject; });
+    // Cancellation can reject while admission persistence is still pending.
+    void reply.catch(() => {});
+    const current = { resolve: resolveTurn, reject: rejectTurn, generation: ++this.turnGeneration, previousError: this.lastResult?.error ?? null };
+    // Reserve before persistence so different operation IDs cannot overlap.
+    this.active = current;
+    const root = this.init?.conversation_id, prior = this.sessionObservations.get(root) ?? {};
+    this.sessionObservations.set(root, { ...prior, step_floor: prior.last_step_index ?? null, stop: null, last_hook: null });
+    this.lastProviderEvent = null;
+    try {
+      await this.persist({ active_tree: true });
+      assertDispatch();
+      if (this.active !== current) throw new DaemonError("operation_cancelled", "prompt reservation was superseded");
+      this.child.stdin.write(`${JSON.stringify({ event: "user", message: { content: text } })}\n`, error => {
+        if (error) { if (this.active === current) this.active = null; current.reject(error); }
+      });
+    } catch (error) { if (this.active === current) this.active = null; current.reject(error); }
+    return await reply;
+  }
+  childActivity(sessionId) {
+    const child = this.descendants.get(sessionId);
+    if (!child) return;
+    this.descendants.set(sessionId, { ...child, previous_terminal_status: child.status === "unknown" ? child.previous_terminal_status : child.status, status: "unknown", tree_settled: false, settlement_evidence: null, activity_generation: this.turnGeneration });
+  }
   async childForHook(conversationId) {
     if (conversationId === this.init?.conversation_id) return null;
     const deadline = Date.now() + 1_000;
@@ -263,7 +298,7 @@ export class Runtime {
     if (!child) throw new DaemonError("agy_child_identity_unconfirmed", "Antigravity hook has no confirmed native parent", true, { conversation_id: conversationId });
     return child;
   }
-  async observeHook(event, payload) { const conversationId = payload.conversationId ?? this.init?.conversation_id; const child = await this.childForHook(conversationId); const prior = this.sessionObservations.get(conversationId) ?? {}; const execution = Number.isInteger(payload.executionNum) ? payload.executionNum : null; const step = Number.isInteger(payload.stepIdx) ? payload.stepIdx : null; const floor = prior.step_floor; const stale = step !== null && Number.isInteger(floor) && step <= floor; const fingerprint = createHash("sha256").update(JSON.stringify({ event, payload })).digest("hex"); if (!stale && prior.last_hook !== fingerprint) this.markActivity(); if (conversationId && !stale) this.sessionObservations.set(conversationId, { ...prior, last_hook: fingerprint, ...(payload.transcriptPath ? { transcript_path: payload.transcriptPath } : {}), ...(event === "Stop" ? { stop: { fullyIdle: payload.fullyIdle === true, terminationReason: payload.terminationReason ?? null, executionNum: payload.executionNum ?? null } } : {}) }); if (child && !stale && event === "Stop" && payload.fullyIdle === true) this.descendants.set(conversationId, { ...child, status: "completed" }); const terminalPending = this.active?.terminalResult === this.lastResult; if (!child && !stale && event === "Stop" && payload.fullyIdle === true && (!this.active || terminalPending) && ["SUCCESS", "ERROR", "CANCELLED"].includes(this.lastResult?.status)) for (const [id, descendant] of this.descendants) if (descendant.status === "unknown") this.descendants.set(id, { ...descendant, status: "settled_by_root", settlement_evidence: "root_fully_idle_stop" }); const settled = terminalPending ? this.receipt(this.lastResult) : null; const completed = settled?.settled ? this.active : null; if (completed) this.active = null; const parent = child?.parent_provider_session_id ?? null;
+  async observeHook(event, payload) { const conversationId = payload.conversationId ?? this.init?.conversation_id; const child = await this.childForHook(conversationId); const prior = this.sessionObservations.get(conversationId) ?? {}; const execution = Number.isInteger(payload.executionNum) ? payload.executionNum : null; const step = Number.isInteger(payload.stepIdx) ? payload.stepIdx : null; const floor = prior.step_floor; const stale = step !== null && ((Number.isInteger(floor) && step <= floor) || (child && Number.isInteger(prior.last_step_index) && step < prior.last_step_index)); const fingerprint = createHash("sha256").update(JSON.stringify({ event, payload })).digest("hex"); if (!stale && prior.last_hook !== fingerprint) this.markActivity(); if (conversationId && !stale) this.sessionObservations.set(conversationId, { ...prior, ...(step !== null ? { last_step_index: Math.max(prior.last_step_index ?? -1, step) } : {}), last_hook: fingerprint, ...(payload.transcriptPath ? { transcript_path: payload.transcriptPath } : {}), ...(event === "Stop" ? { stop: { fullyIdle: payload.fullyIdle === true, terminationReason: payload.terminationReason ?? null, executionNum: payload.executionNum ?? null } } : {}) }); if (child && !stale && event === "PreToolUse" && prior.last_hook !== fingerprint) this.childActivity(conversationId); if (child && !stale && event === "Stop" && payload.fullyIdle === true) this.descendants.set(conversationId, { ...this.descendants.get(conversationId), tree_settled: true, settlement_evidence: "child_fully_idle_stop" }); const terminalPending = this.active?.terminalResult === this.lastResult; if (!child && !stale && event === "Stop" && payload.fullyIdle === true && (!this.active || terminalPending) && ["SUCCESS", "ERROR", "CANCELLED"].includes(this.lastResult?.status)) for (const [id, descendant] of this.descendants) if (descendant.status === "unknown") this.descendants.set(id, { ...descendant, status: "settled_by_root", settlement_evidence: "root_fully_idle_stop" }); const settled = terminalPending ? this.receipt(this.lastResult) : null; const completed = settled?.settled ? this.active : null; if (completed) this.active = null; const parent = child?.parent_provider_session_id ?? null;
     const observed = payload.model ? observedProfile(payload) : {};
     await observeModel({ journal: this.config.journal, harness: "antigravity-cli", sessionId: conversationId, parentSessionId: parent, requested: this.config, observed, source: "native.hook", evidence: payload.model ? "configured" : "unavailable", reason: payload.model ? null : "hook_omits_current_model" });
     const eventId = createHash("sha256").update(JSON.stringify({ daemon: this.config.daemonId, event, conversationId, turn_generation: this.turnGeneration, fully_idle: payload.fullyIdle ?? null, termination_reason: payload.terminationReason ?? null, execution: payload.executionNum ?? null, step: payload.stepIdx ?? null, tool: payload.toolCall?.name ?? null, args: payload.toolCall?.args ?? null })).digest("hex"); await this.persist(completed ? { active_tree: false } : {}); await this.journal("hook", { stale, hook_event: event, event_id: eventId, conversation_id: conversationId, turn_generation: this.turnGeneration, execution_num: execution, step_index: step, termination_reason: payload.terminationReason ?? null, fully_idle: payload.fullyIdle ?? null }); completed?.resolve(settled); return { event_id: eventId, daemon_id: this.config.daemonId, parent_conversation_id: parent, profile: observed, requested_profile: { provider: this.config.provider, model: this.config.model, reasoning: this.config.reasoning, mode: this.config.mode }, project_root: this.config.projectRoot, dd_flow_bin: this.config.ddFlowBin, dd_flow_home: this.config.ddFlowHome };

package/dist/harness-runtime/lib/dd-codex-daemon.mjs

@@ -87,9 +87,9 @@ export async function serveDaemon(stateDir) {
       return { stopped: true, clean: true, _shutdown: true };
     }
     if (active && !["session.inspect", "session.cancel"].includes(operation)) throw Object.assign(new Error(`${active} is in progress`), { code: "operation_busy", retryable: true });
-    if (operation === "session.create") { active = operation; await save({ active_operation: active }); try { const result = await createSessionWithBridge(bridge, { ...state.config, ...params }); sessions.add(result.provider_session_id); return result; } finally { active = null; await save({ active_operation: null }); } }
-    if (operation === "session.prompt") { sessions.add(params.sessionId); active = operation; await save({ active_operation: active }); try { return await promptSessionWithBridge(bridge, { ...state.config, ...params, assertDispatch }); } finally { active = null; await save({ active_operation: null }); } }
-    if (operation === "session.start") { sessions.add(params.sessionId); active = operation; await save({ active_operation: active }); try { return await startSessionWithBridge(bridge, { ...state.config, ...params, assertDispatch }); } finally { active = null; await save({ active_operation: null }); } }
+    if (operation === "session.create") { active = operation; try { await save({ active_operation: active }); const result = await createSessionWithBridge(bridge, { ...state.config, ...params }); sessions.add(result.provider_session_id); return result; } finally { active = null; await save({ active_operation: null }); } }
+    if (operation === "session.prompt") { sessions.add(params.sessionId); active = operation; try { await save({ active_operation: active }); return await promptSessionWithBridge(bridge, { ...state.config, ...params, assertDispatch }); } finally { active = null; await save({ active_operation: null }); } }
+    if (operation === "session.start") { sessions.add(params.sessionId); active = operation; try { await save({ active_operation: active }); return await startSessionWithBridge(bridge, { ...state.config, ...params, assertDispatch }); } finally { active = null; await save({ active_operation: null }); } }
     if (operation === "session.inspect") return await inspectSessionWithBridge(bridge, { ...state.config, ...params });
     if (operation === "session.cancel") { if (!sessions.has(params.sessionId)) throw Object.assign(new Error("cancellation Session is not owned by this daemon"), { code: "session_identity_mismatch" }); cancelPendingDispatch(bridge); return await cancelSessionWithBridge(bridge, { ...state.config, ...params }); }
     throw Object.assign(new Error(`unknown operation: ${operation}`), { code: "unknown_operation" });

package/dist/harness-runtime/lib/dd-droid-daemon.mjs

@@ -85,8 +85,9 @@ export async function serveDaemon(stateDir) {
       catch (error) { stopping = false; await save({ shutdown_state: "cleanup_failed", cleanup_error: errorRecord(error) }); throw error; }
     }
     if (busy || stopping) throw new DroidError("operation_busy", "Another Droid operation is active");
-    busy = operation; await save({ active_operation: busy });
+    busy = operation;
     try {
+      await save({ active_operation: busy });
       if (operation === "session.create") { if (params.prompt) throw new DroidError("invalid_create", "create does not execute a prompt"); return await runtime.create(request.id); }
       if (operation === "session.resume") return await runtime.resume(params.sessionId);
       if (["session.prompt", "session.start"].includes(operation)) return await runtime.prompt(params.sessionId, params.prompt, request.id);

package/dist/harness-runtime/lib/dd-grok-daemon.mjs

@@ -241,7 +241,7 @@ export class Runtime {
     return running;
   }
   async requireSettled() { const running = await this.refreshTree(); if (running.length) throw new DaemonError("tree_not_settled", "daemon still owns a running Session tree", false, { sessions: running }); }
-  async productive(name, task) { if (this.active) throw new DaemonError("operation_busy", `${this.active} is already running`, true); this.active = name; for (const session of this.sessions.values()) session.native_root_receipt = null; await this.persist({ active_tree: true, active_operation: name }); try { const result = await task(); this.track(result); const session = this.sessions.get(result.provider_session_id); if (session && (["session.create", "session.fork"].includes(name) || ["end_turn", "cancelled"].includes(result.turn?.stopReason))) session.native_root_receipt = { kind: name === "session.prompt" ? result.turn.stopReason : "created", daemon_id: this.state.daemon_id }; await this.persist({ active_tree: this.rootRunning(result) || this.running(result).length > 0, active_operation: null }); return { ...result, descendants: this.topology(result.provider_session_id) }; } catch (error) { await this.persist({ active_tree: true, active_operation: null }); throw error; } finally { this.active = null; } }
+  async productive(name, task) { if (this.active) throw new DaemonError("operation_busy", `${this.active} is already running`, true); this.active = name; for (const session of this.sessions.values()) session.native_root_receipt = null; try { await this.persist({ active_tree: true, active_operation: name }); const result = await task(); this.track(result); const session = this.sessions.get(result.provider_session_id); if (session && (["session.create", "session.fork"].includes(name) || ["end_turn", "cancelled"].includes(result.turn?.stopReason))) session.native_root_receipt = { kind: name === "session.prompt" ? result.turn.stopReason : "created", daemon_id: this.state.daemon_id }; await this.persist({ active_tree: this.rootRunning(result) || this.running(result).length > 0, active_operation: null }); return { ...result, descendants: this.topology(result.provider_session_id) }; } catch (error) { await this.persist({ active_tree: true, active_operation: null }); throw error; } finally { this.active = null; } }
   async dispatch(operation, params) {
     const assertDispatch = captureDispatchGuard(this);
     if (operation === "daemon.status") { let observationError; if (!this.active) try { await this.refreshTree(); } catch (error) { observationError = errorPayload(error); } return { observation_error: observationError ?? null, daemon_id: this.state.daemon_id, pid: process.pid, socket: this.paths.socket, versions: this.state.versions, config_isolation: this.state.config_isolation, shutdown_state: this.state.shutdown_state, recovery_status: this.state.recovery_status, auth_status: this.state.auth_status, active_tree: this.state.active_tree, active_operation: this.active, sessions: [...this.sessions.values()], config: this.state.config }; }

package/dist/harness-runtime/lib/dd-opencode-daemon.mjs

@@ -62,7 +62,7 @@ export async function startDaemon(options) {
 }
 export const stopDaemon = async options => { const timeoutMs = options.timeoutMs ?? 30_000; return await confirmDaemonStopped(() => callDaemon(options.stateDir, "daemon.stop", { cancelTree: options.cancelTree === true }, timeoutMs), locations(options.stateDir).socket, timeoutMs); };
 
-class Runtime {
+export class Runtime {
   constructor(paths, state, client, child, providerProcess) { this.paths = paths; this.state = state; this.client = client; this.child = child; this.providerProcess = providerProcess; this.sessions = new Map((state.sessions ?? []).map(x => [x.provider_session_id, x])); this.active = null; this.persisting = Promise.resolve(); }
   persist(patch = {}) { Object.assign(this.state, patch, { pid: process.pid, sessions: [...this.sessions.values()] }); const snapshot = structuredClone(this.state); this.persisting = this.persisting.then(async () => { await writeJson(this.paths.state, snapshot); await heartbeatDaemonProcess(snapshot.config, snapshot.resource_process).catch(() => {}); await heartbeatDaemonProcess(snapshot.config, this.providerProcess).catch(() => {}); }); return this.persisting; }
   async journal(operation, result) { const line = `${JSON.stringify({ schema_id: "dd-opencode/daemon-event@1", event_id: randomUUID(), observed_at: new Date().toISOString(), operation, active_tree: this.state.active_tree, session_id: result?.provider_session_id ?? null })}\n`; for (const journal of new Set([this.paths.journal, this.state.config.journal].filter(Boolean))) { await mkdir(path.dirname(journal), { recursive: true, mode: 0o700 }); await appendFile(journal, line, { mode: 0o600 }); } }
@@ -82,7 +82,7 @@ class Runtime {
   }
   async requireSettled(id) { const value = await this.describe(id); if (!value.settled) throw new DaemonError("tree_not_settled", "OpenCode Session is not idle", false, { session_id: id, status: value.status }); return value; }
   async reconcileUsage(observed) { await forwardUsage(this.state.config, observed.provider_session_id, observed.usage); for (const child of observed.children.filter(item => (item.parentID ?? observed.provider_session_id) === observed.provider_session_id)) await this.reconcileUsage(await this.describe(child.id)); }
-  async productive(name, task) { if (this.active) throw new DaemonError("operation_busy", `${this.active} is already running`, true); this.active = name; await this.persist({ active_tree: true, active_operation: name }); try { const result = await task(); await this.persist({ active_tree: !result?.settled, active_operation: null }); await this.journal(name, result); return result; } catch (error) { await this.persist({ active_tree: true, active_operation: null }); await this.journal(`${name}.failed`, null); throw error; } finally { this.active = null; } }
+  async productive(name, task) { if (this.active) throw new DaemonError("operation_busy", `${this.active} is already running`, true); this.active = name; try { await this.persist({ active_tree: true, active_operation: name }); const result = await task(); await this.persist({ active_tree: !result?.settled, active_operation: null }); await this.journal(name, result); return result; } catch (error) { await this.persist({ active_tree: true, active_operation: null }); await this.journal(`${name}.failed`, null); throw error; } finally { this.active = null; } }
   async cancelTree(id, seen = new Set()) {
     if (seen.has(id)) return [];
     seen.add(id);

package/dist/harness-runtime/lib/dd-zcode-daemon.mjs

@@ -198,7 +198,7 @@ export async function stopDaemon(options) {
   return await confirmDaemonStopped(() => callDaemon(options.stateDir, "daemon.stop", { cancelTree: options.cancelTree === true }, timeoutMs), socket, timeoutMs);
 }
 
-class DaemonRuntime {
+export class DaemonRuntime {
   constructor(paths, state, bridge, initialized) {
     this.paths = paths; this.state = state; this.bridge = bridge; this.initialized = initialized;
     this.sessions = new Map((state.sessions ?? []).map((item) => [item.provider_session_id, item]));
@@ -250,8 +250,8 @@ class DaemonRuntime {
     if (this.activeProductive) throw new DaemonError("operation_busy", `${this.activeProductive} is already running`, true);
     this.activeProductive = name;
     this.activeGeneration = this.controlGeneration ?? 0;
-    await this.persist({ active_tree: true, active_operation: name });
     try {
+      await this.persist({ active_tree: true, active_operation: name });
       const result = await task();
       this.track(result);
       const running = this.treeRunning(result);

package/dist/harness-runtime/lib/observation-clock.mjs

@@ -7,7 +7,7 @@ export class ObservationClock {
     this.lastWall = wall(); this.lastMono = monotonic(); this.elapsed = 0;
     this.progress = undefined;
   }
-  sample(progress) {
+  sample(progress, progressAt) {
     const wall = this.wall(), mono = this.monotonic();
     const delta = mono - this.lastMono, wallDelta = wall - this.lastWall;
     const gap = delta > this.gapMs || wallDelta > this.gapMs || delta < 0 || wallDelta < 0;
@@ -18,7 +18,10 @@ export class ObservationClock {
       this.elapsed = 0;
     } else this.elapsed += delta;
     this.lastWall = wall; this.lastMono = mono;
-    if (progress !== undefined && progress !== this.progress) { this.progress = progress; this.elapsed = 0; }
+    if (progress !== undefined && progress !== this.progress) {
+      this.progress = progress;
+      this.elapsed = !gap && Number.isFinite(progressAt) ? Math.max(0, Math.min(this.timeoutMs, wall - progressAt)) : 0;
+    }
     return this.elapsed >= this.timeoutMs;
   }
 }

package/dist/services/eval-snapshots.js

@@ -8,7 +8,7 @@ import { resolveProjectRoot } from "../storage/paths.js";
 import { registerProject, requireProjectByRoot } from "./projects.js";
 import { getFlowRunStatus, startFlowRun } from "./runs.js";
 import { readVnextFlowDefinition } from "./vnext-specify.js";
-import { assertRunWorkResultArtifacts } from "./work-registry.js";
+import { assertRunWorkResultArtifacts, runWorkResultArtifactIssues } from "./work-registry.js";
 /** Capture the only flow boundary which exists before `stage start --bootstrap` creates a RUN. */
 export function createEvalBootstrapSnapshot(context, input) {
     const projectRoot = resolveProjectRoot(input.projectRoot);
@@ -81,7 +81,8 @@ function captureEvalRunSnapshot(context, input) {
     const project = requireProjectByRoot(context, projectRoot);
     const status = getFlowRunStatus(context, { projectRoot, runId: input.runId });
     assertDedicatedHome(context, project.id, input.runId);
-    assertRunWorkResultArtifacts(context, project.id, input.runId);
+    if (!input.incomplete)
+        assertRunWorkResultArtifacts(context, project.id, input.runId);
     const recovery = typeof input.recoveryId === "string";
     if (recovery) {
         const guard = context.db.get("SELECT status, recovery_id FROM run_recovery_guards WHERE project_id = ? AND run_id = ? AND recovery_id = ?", [project.id, input.runId, input.recoveryId]);
@@ -130,6 +131,26 @@ function captureEvalRunSnapshot(context, input) {
     });
     const projectGit = snapshotProjectGit(projectRoot, output);
     const workspace = snapshotWorkspace(workspaceRoot, projectRoot, output);
+    // Compare the copied files with the copied SQLite receipt, not a later read
+    // of the live database. Incomplete captures retain contradictions as evidence.
+    const copiedContext = createContext({ ...context.env, DD_FLOW_HOME: path.join(output, "runtime") }, "read_existing");
+    let receiptIssues;
+    try {
+        receiptIssues = runWorkResultArtifactIssues(copiedContext, project.id, input.runId, file => {
+            const roots = [[context.ddFlowHome, "runtime"], [workspaceRoot, workspace.kind === "git_worktree" ? "workspace" : "project"], [projectRoot, "project"]];
+            for (const [source, payload] of roots) {
+                const relative = path.relative(source, file);
+                if (relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative))
+                    return path.join(output, payload, relative);
+            }
+            throw new AppError("snapshot_receipt_path_invalid", "Work receipt is outside captured payloads", 1, { result_path: file });
+        });
+    }
+    finally {
+        copiedContext.db.close?.();
+    }
+    if (!input.incomplete && receiptIssues.length)
+        throw new AppError("snapshot_work_receipt_inconsistent", "Copied Work result does not match its authoritative receipt", 1, { issues: receiptIssues });
     const manifest = {
         schema_id: "dd-flow/eval-run-snapshot@5",
         run_id: input.runId,
@@ -140,6 +161,7 @@ function captureEvalRunSnapshot(context, input) {
         stage_entry: input.incomplete || recovery || input.candidate ? null : input.stageEntry,
         ...(input.incomplete ? { consistency: "sqlite_read_snapshot_files_copied_nonatomically", active_child_work_count: activeChildren, restorable: false } : recovery ? { recovery_id: input.recoveryId, consistency: "sealed_writer_barrier_required", active_child_work_count: activeChildren, restorable: "same-runtime-or-explicit-restore" } : {}),
         created_at: context.now(),
+        work_result_integrity: { valid: receiptIssues.length === 0, issues: receiptIssues },
         runtime_sha256: treeHash(path.join(output, "runtime")),
         project_sha256: treeHash(path.join(output, "project")),
         project_git: projectGit,

package/dist/services/run-recovery.js

@@ -8,6 +8,7 @@ import { appendFlowRunTimelineEvent } from "./runs.js";
 import { verifyRecoverySnapshot } from "./eval-snapshots.js";
 import { findRecentMatchingHookEvent, hookSessionIdentity, recoveryAcceptMatchKey } from "./hooks.js";
 import { flowCommand } from "./stage-pause.js";
+import { materializePendingWorkResults } from "./work-registry.js";
 function recoveryPacketReceipt(binding) {
     if (!binding.packet_json || !binding.packet_sha256 || crypto.createHash("sha256").update(binding.packet_json).digest("hex") !== binding.packet_sha256)
         throw new AppError("recovery_packet_missing", "Recovery requires its original verified Work packet", 1);
@@ -119,6 +120,7 @@ export function sealRunRecovery(context, input) {
         return { ok: true, recovery: { ...guard, settlement: JSON.parse(guard.settlement_json ?? "{}") }, reused: true };
     if (guard.status !== "draining")
         throw new AppError("recovery_invalid_state", "Recovery is not draining", 1, { recovery_id: guard.recovery_id, status: guard.status });
+    materializePendingWorkResults(context, project.id, run.id);
     const now = context.now();
     const updated = context.db.run("UPDATE run_recovery_guards SET status = 'sealed', settlement_json = ?, sealed_at = ?, updated_at = ? WHERE recovery_id = ? AND status = 'draining' AND generation = (SELECT MAX(generation) FROM run_recovery_guards WHERE project_id = ? AND run_id = ?)", [JSON.stringify(settlement), now, now, guard.recovery_id, project.id, run.id]);
     if (updated.changes !== 1)

package/dist/services/work-registry.js

@@ -182,15 +182,90 @@ export function listWorks(context, input) {
         }) };
 }
 export function showWork(context, id) { const work = requireWork(context, id); const sessions = context.db.all("SELECT ws.id, ws.work_id, ws.session_id, ws.hook_event_id, ws.status, ws.prompt_path, ws.result_path, ws.created_at, ws.completed_at, s.harness AS harness_id, COALESCE(s.provider_session_id, s.session_id) AS native_session_id FROM work_sessions ws LEFT JOIN sessions s ON s.project_id = ? AND s.session_id = ws.session_id WHERE ws.work_id = ? ORDER BY ws.created_at", [work.project_id, work.work_id]); return { work: { ...work, short_id: shortWorkId(work.work_id), payload: parsePayload(work), payload_json: undefined, depends_on: parseDependencies(work), sessions: sessions.map(({ session_id, harness_id, native_session_id, ...session }) => ({ ...session, ...(harness_id && native_session_id ? { session: publicSessionIdentity({ harness: harness_id, provider_session_id: native_session_id, session_id }) } : {}) })) } }; }
-/** DB rows are authoritative; reject snapshots that would preserve a rewritten Work receipt. */
-export function assertRunWorkResultArtifacts(context, projectId, runId) {
+/** Inspect materializations without changing either the accepted receipt or conflicting bytes. */
+export function runWorkResultArtifactIssues(context, projectId, runId, materializedPath = (file) => file) {
     const works = context.db.all(`SELECT w.work_id, w.result, (SELECT ws.result_path FROM work_sessions ws WHERE ws.work_id = w.work_id ORDER BY ws.created_at DESC LIMIT 1) AS result_path FROM works w WHERE w.project_id = ? AND w.run_id = ? AND w.result_schema IS NOT NULL AND w.result IS NOT NULL AND w.status = 'completed'`, [projectId, runId]);
+    const issues = [];
     for (const work of works) {
-        if (!work.result_path || !fs.existsSync(work.result_path))
-            throw new AppError("work_result_artifact_missing", "Completed structured Work has no retained result artifact", 1, { work_id: work.work_id, result_path: work.result_path });
-        const actual = fs.readFileSync(work.result_path, "utf8");
+        const file = work.result_path ? materializedPath(work.result_path) : null;
+        const actual = file && fs.existsSync(file) ? fs.readFileSync(file, "utf8") : null;
         if (actual !== work.result)
-            throw new AppError("work_result_artifact_drift", "Completed Work result artifact no longer matches its authoritative receipt", 1, { work_id: work.work_id, result_path: work.result_path, expected_sha256: crypto.createHash("sha256").update(work.result).digest("hex"), actual_sha256: crypto.createHash("sha256").update(actual).digest("hex") });
+            issues.push({ code: actual === null ? "work_result_artifact_missing" : "work_result_artifact_drift", work_id: work.work_id, result_path: work.result_path, expected_sha256: crypto.createHash("sha256").update(work.result).digest("hex"), actual_sha256: actual === null ? null : crypto.createHash("sha256").update(actual).digest("hex") });
+    }
+    return issues;
+}
+export function assertRunWorkResultArtifacts(context, projectId, runId) {
+    const issue = runWorkResultArtifactIssues(context, projectId, runId)[0];
+    if (issue)
+        throw new AppError(issue.code, issue.code === "work_result_artifact_missing" ? "Completed structured Work has no retained result artifact" : "Completed Work result artifact no longer matches its authoritative receipt", 1, issue);
+}
+function receiptIntentPath(resultPath, sessionId) {
+    return `${resultPath}.pending-${crypto.createHash("sha256").update(sessionId).digest("hex")}`;
+}
+function receiptFileHash(file) {
+    return fs.existsSync(file) ? crypto.createHash("sha256").update(fs.readFileSync(file)).digest("hex") : null;
+}
+function publishReceiptFile(file, contents) {
+    const temporary = `${file}.tmp-${crypto.randomUUID()}`;
+    try {
+        fs.writeFileSync(temporary, contents);
+        const descriptor = fs.openSync(temporary, "r");
+        try {
+            fs.fsyncSync(descriptor);
+        }
+        finally {
+            fs.closeSync(descriptor);
+        }
+        fs.renameSync(temporary, file);
+        const directory = fs.openSync(path.dirname(file), "r");
+        try {
+            fs.fsyncSync(directory);
+        }
+        finally {
+            fs.closeSync(directory);
+        }
+    }
+    finally {
+        fs.rmSync(temporary, { force: true });
+    }
+}
+/** Replay only a prepared publication whose exact receipt was committed in SQLite. */
+export function materializePendingWorkResults(context, projectId, runId) {
+    context.db.exec("BEGIN IMMEDIATE");
+    try {
+        const rows = context.db.all(`SELECT w.work_id, w.result, w.status, ws.id, ws.result_path FROM works w JOIN work_sessions ws ON ws.work_id = w.work_id AND ws.status = w.status WHERE w.project_id = ? AND w.run_id = ? AND w.parent_work_id IS NOT NULL AND w.result IS NOT NULL AND w.status IN ('completed', 'failed', 'cancelled') AND ws.result_path IS NOT NULL`, [projectId, runId]);
+        for (const row of rows) {
+            const intentPath = receiptIntentPath(row.result_path, row.id);
+            if (!fs.existsSync(intentPath))
+                continue;
+            const intent = JSON.parse(fs.readFileSync(intentPath, "utf8"));
+            const digest = crypto.createHash("sha256").update(row.result).digest("hex");
+            if (intent.work_id !== row.work_id || intent.work_session_id !== row.id || intent.status !== row.status || intent.result_sha256 !== digest)
+                throw new AppError("work_result_publication_conflict", "Pending result publication does not identify the committed receipt", 1, { work_id: row.work_id, intent_path: intentPath });
+            const actual = receiptFileHash(row.result_path);
+            if (actual !== digest && actual !== intent.previous_sha256)
+                throw new AppError("work_result_artifact_drift", "Result changed after its publication was prepared; preserve it for diagnosis", 1, { work_id: row.work_id, actual_sha256: actual, expected_sha256: digest });
+            if (fs.existsSync(row.result_path)) {
+                const previous = fs.readFileSync(row.result_path);
+                if (!previous.equals(Buffer.from(row.result))) {
+                    const retained = `${row.result_path}.conflict-${crypto.createHash("sha256").update(previous).digest("hex")}`;
+                    try {
+                        fs.writeFileSync(retained, previous, { flag: "wx", flush: true });
+                    }
+                    catch (error) {
+                        if (error.code !== "EEXIST" || !fs.readFileSync(retained).equals(previous))
+                            throw error;
+                    }
+                }
+            }
+            publishReceiptFile(row.result_path, row.result);
+            fs.unlinkSync(intentPath);
+        }
+        context.db.exec("COMMIT");
+    }
+    catch (error) {
+        context.db.exec("ROLLBACK");
+        throw error;
     }
 }
 export function mutateWorkDeps(context, input) {
@@ -357,6 +432,8 @@ export function startBoundWork(context, work, run, identity, hookEventId) {
     const generation = assertRunMutationAllowed(context, work.project_id, work.run_id);
     if (work.status !== "created")
         throw new AppError("invalid_work_state", "Work is not created", 2, { work_id: work.work_id, status: work.status });
+    if (fs.existsSync(path.join(requireRunHome(run), "works", work.work_id, ".retry.json")))
+        throw new AppError("work_retry_incomplete", "Complete the interrupted Work retry before starting its next attempt", 1, { work_id: work.work_id });
     const now = context.now();
     const linkId = `WS-${crypto.randomUUID()}`;
     const directory = path.join(requireRunHome(run), "works", work.work_id);
@@ -409,12 +486,74 @@ export function finishFanInWork(context, id, result) { const work = requireWork(
     throw new AppError("active_child_work", "Fan-in Work still has active children", 2, { work_id: work.work_id }); const now = context.now(); context.db.run("UPDATE works SET status = 'completed', result = ?, completed_at = ?, updated_at = ? WHERE work_id = ?", [result, now, now, work.work_id]); context.db.run("UPDATE work_sessions SET status = 'completed', completed_at = COALESCE(completed_at, ?), updated_at = ? WHERE work_id = ? AND status = 'running'", [now, now, work.work_id]); refreshRunWorkProjection(context, work.project_id, work.run_id); appendFlowRunTimelineEvent(context, work.project_id, work.run_id, { type: "work_completed", work_id: work.work_id, fan_in: true }); return { ok: true, work_id: work.work_id, status: "completed", fan_in: true }; }
 export function failWork(context, id, reason) { return settle(context, id, "failed", reason); }
 export function cancelWork(context, id, reason) { return settle(context, id, "cancelled", reason); }
-export function retryWork(context, id, reason) { const work = requireWork(context, id); assertRunMutationAllowed(context, work.project_id, work.run_id); id = work.work_id; if (work.status !== "failed")
-    throw new AppError("invalid_work_state", "Only failed Work may be retried", 2); const run = requireRun(context, work.project_id, work.run_id); const directory = path.join(requireRunHome(run), "works", id); const attempts = path.join(directory, "attempts"); const number = fs.existsSync(attempts) ? fs.readdirSync(attempts).filter((entry) => /^ATT-\d{3}$/.test(entry)).length + 1 : 1; const archive = path.join(attempts, `ATT-${String(number).padStart(3, "0")}`); fs.mkdirSync(archive, { recursive: true }); for (const file of ["prompt.md", "result.json", "context.json"]) {
-    const source = path.join(directory, file);
-    if (fs.existsSync(source))
-        fs.renameSync(source, path.join(archive, file));
-} context.db.run("UPDATE works SET status = 'created', result = NULL, started_at = NULL, completed_at = NULL, updated_at = ? WHERE work_id = ?", [context.now(), id]); refreshRunWorkProjection(context, work.project_id, work.run_id); return { ok: true, work_id: id, archived_attempt: path.relative(requireRunHome(run), archive).split(path.sep).join("/"), reason }; }
+export function retryWork(context, id, reason) {
+    const work = requireWork(context, id);
+    const run = requireRun(context, work.project_id, work.run_id);
+    const directory = path.join(requireRunHome(run), "works", work.work_id);
+    const journal = path.join(directory, ".retry.json");
+    let archive = "";
+    context.db.exec("BEGIN IMMEDIATE");
+    try {
+        assertRunMutationAllowed(context, work.project_id, work.run_id);
+        const current = requireWork(context, work.work_id);
+        const pending = fs.existsSync(journal) ? JSON.parse(fs.readFileSync(journal, "utf8")) : null;
+        if (pending && (pending.work_id !== work.work_id || !/^ATT-\d{3,}$/.test(pending.archive) || pending.entries.some(file => !["prompt.md", "result.json", "context.json"].includes(file))))
+            throw new AppError("work_retry_invalid", "Retry journal does not identify this Work", 1);
+        if (current.status !== "failed" && !(pending && current.status === "created"))
+            throw new AppError("invalid_work_state", "Only failed Work may be retried", 2);
+        const attempts = path.join(directory, "attempts");
+        let number = 1;
+        while (fs.existsSync(path.join(attempts, `ATT-${String(number).padStart(3, "0")}`)))
+            number += 1;
+        const prepared = pending ?? { work_id: work.work_id, archive: `ATT-${String(number).padStart(3, "0")}`, entries: ["prompt.md", "result.json", "context.json"].filter(file => fs.existsSync(path.join(directory, file))), result_sha256: current.result === null ? null : crypto.createHash("sha256").update(current.result).digest("hex") };
+        archive = path.join(attempts, prepared.archive);
+        if (current.status === "failed") {
+            if (prepared.result_sha256 !== (current.result === null ? null : crypto.createHash("sha256").update(current.result).digest("hex")))
+                throw new AppError("work_retry_conflict", "Failed Work receipt changed during retry", 1);
+            fs.mkdirSync(archive, { recursive: true });
+            if (!pending)
+                publishReceiptFile(journal, JSON.stringify(prepared));
+            const receipt = path.join(archive, "accepted-receipt.json");
+            const receiptBytes = JSON.stringify({ work_id: current.work_id, status: current.status, result: current.result, result_sha256: prepared.result_sha256 });
+            if (fs.existsSync(receipt) && fs.readFileSync(receipt, "utf8") !== receiptBytes)
+                throw new AppError("work_retry_conflict", "Archived receipt differs from failed Work", 1);
+            if (!fs.existsSync(receipt))
+                publishReceiptFile(receipt, receiptBytes);
+            for (const file of prepared.entries) {
+                const source = path.join(directory, file), target = path.join(archive, file);
+                if (fs.existsSync(source)) {
+                    if (fs.existsSync(target))
+                        throw new AppError("archive_conflict", "Both live and archived Work artifact exist; preserve both", 1, { source, target });
+                    fs.renameSync(source, target);
+                }
+                else if (!fs.existsSync(target))
+                    throw new AppError("archive_artifact_missing", "Work artifact is absent from both retry locations", 1, { source, target });
+            }
+            for (const folder of [archive, directory]) {
+                const descriptor = fs.openSync(folder, "r");
+                try {
+                    fs.fsyncSync(descriptor);
+                }
+                finally {
+                    fs.closeSync(descriptor);
+                }
+            }
+            for (const column of ["prompt_path", "result_path"]) {
+                const file = column === "prompt_path" ? "prompt.md" : "result.json";
+                context.db.run(`UPDATE work_sessions SET ${column} = ? WHERE work_id = ? AND ${column} = ?`, [path.join(archive, file), work.work_id, path.join(directory, file)]);
+            }
+            context.db.run("UPDATE works SET status = 'created', result = NULL, started_at = NULL, completed_at = NULL, updated_at = ? WHERE work_id = ? AND status = 'failed'", [context.now(), work.work_id]);
+        }
+        context.db.exec("COMMIT");
+    }
+    catch (error) {
+        context.db.exec("ROLLBACK");
+        throw error;
+    }
+    fs.rmSync(journal, { force: true });
+    refreshRunWorkProjection(context, work.project_id, work.run_id);
+    return { ok: true, work_id: work.work_id, archived_attempt: path.relative(requireRunHome(run), archive).split(path.sep).join("/"), reason };
+}
 async function settle(context, id, status, result, progress) {
     const work = requireWork(context, id);
     assertRunMutationAllowed(context, work.project_id, work.run_id);
@@ -461,10 +600,10 @@ async function settle(context, id, status, result, progress) {
         assertRunMutationAllowed(context, work.project_id, work.run_id);
         if (link && !context.db.get("SELECT 1 FROM work_sessions WHERE id = ? AND status = 'running'", [link.id]))
             throw new AppError("work_generation_stale", "Work Session was interrupted or superseded while checks ran", 1, { work_id: id });
+        if (link?.result_path && work.parent_work_id !== null)
+            publishReceiptFile(receiptIntentPath(link.result_path, link.id), JSON.stringify({ work_id: work.work_id, work_session_id: link.id, status, result_sha256: crypto.createHash("sha256").update(result).digest("hex"), previous_sha256: receiptFileHash(link.result_path) }));
         context.db.run("UPDATE works SET status = ?, result = ?, completed_at = ?, updated_at = ? WHERE work_id = ?", [status, result, now, now, id]);
         if (link) {
-            if (link.result_path && work.parent_work_id !== null)
-                fs.writeFileSync(link.result_path, result);
             context.db.run("UPDATE work_sessions SET status = ?, completed_at = ?, updated_at = ? WHERE id = ?", [status, now, now, link.id]);
             const stillRunning = context.db.get("SELECT 1 FROM work_sessions WHERE session_id = ? AND status = 'running' LIMIT 1", [link.session_id]);
             if (!stillRunning)
@@ -476,6 +615,7 @@ async function settle(context, id, status, result, progress) {
         context.db.exec("ROLLBACK");
         throw error;
     }
+    materializePendingWorkResults(context, work.project_id, work.run_id);
     settleRecoveryWork(context, work.work_id, status);
     refreshRunWorkProjection(context, work.project_id, work.run_id);
     const newlyReady = context.db.all(`SELECT ${workColumns} FROM works WHERE project_id = ? AND run_id = ? AND status = 'created' ORDER BY created_at, work_id`, [work.project_id, work.run_id]).filter((candidate) => isReady(context, candidate)).map((candidate) => ({ work_id: candidate.work_id, launch_policy: candidate.launch_policy, start_command: workStartCommand(context, candidate) }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deksden-com/dd-flow-cli",
-  "version": "0.9.0-beta.33",
+  "version": "0.9.0-beta.35",
   "description": "Mechanical runtime CLI for dd-flow workflows.",
   "type": "module",
   "bin": {