@deksden-com/dd-flow-cli 0.9.0-beta.104 → 0.9.0-beta.105

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @deksden-com/dd-flow-cli
 
+## 0.9.0-beta.105
+
+### Patch Changes
+
+- Unify managed lifecycle correction and Stage/Work instructions across harnesses; enforce phase-specific workspace ownership; keep accepted Stage, Work, HITL, protocol, and RUN publications recoverable while moving filesystem and process work outside SQLite writer transactions. Retain exact native and physical-owner evidence through controller capture and snapshot restore.
+
 ## 0.9.0-beta.96
 
 ### Patch Changes

package/dist/build-info.json

@@ -1,8 +1,8 @@
 {
   "cli_package": "@deksden-com/dd-flow-cli",
-  "cli_version": "0.9.0-beta.104",
-  "cli_commit": "d8b1b96db830c5e56e8409dfc94837fb73638673",
-  "built_at": "2026-09-25T13:44:30.094Z",
+  "cli_version": "0.9.0-beta.105",
+  "cli_commit": "e55ba4f273ae0873e06ebe9ea75e6a6e1eb8b095",
+  "built_at": "2026-09-26T22:58:06.111Z",
   "built_with_canon": {
     "version": "4.1.1",
     "commit": "678daa038287c948ada5b2d785a6dcc925c7b891",

package/dist/cli/run-cli.js

@@ -6,7 +6,7 @@ import { randomUUID } from "node:crypto";
 import { quote } from "shell-quote";
 import { observeLifecycleCommand, observedLifecycleNativeEvent } from "../services/lifecycle-invocations.js";
 import { verifyCodexHookDelivery } from "../services/codex-hook-delivery.js";
-import { assertLifecycleInvocationCurrent, awaitLifecycleInvocation, expandLifecycleInvocationArgs, issueLifecycleInvocation, prepareLifecycleIssuance, lifecycleInvocationScope, observedLifecycleDiagnostic, observedLifecycleInvocation, resolveObservedLifecycleArgs, settleLifecycleInvocation, settleLifecyclePreparationRejection, settleLifecycleRejection, validateLifecyclePathAliases } from "../services/lifecycle-invocations.js";
+import { assertLifecycleInvocationCurrent, awaitLifecycleInvocation, bindLifecyclePublishedPacket, expandLifecycleInvocationArgs, issueLifecycleInvocation, prepareLifecycleIssuance, lifecycleInvocationScope, observedLifecycleDiagnostic, observedLifecycleInvocation, resolveObservedLifecycleArgs, retainObservedLifecycleSemantics, settleLifecycleInvocation, settleLifecyclePreparationRejection, settleLifecycleRejection, validateLifecyclePathAliases } from "../services/lifecycle-invocations.js";
 import { createContext, createRouterContext } from "../runtime/context.js";
 import { migrateStoreWriter } from "../storage/writer-migration.js";
 import { helpForArgs } from "./help.js";
@@ -147,15 +147,19 @@ export async function runCli(args, io = defaultIo, env = process.env) {
         }
         const routerContext = createRouterContext(env);
         const publicCommand = quote(["dd-flow", ...output.args]);
+        const nativeCommand = quote(["dd-flow", ...args]);
         const lifecycleCommand = parseLifecycleCommand(publicCommand);
         if (lifecycleCommand.kind === "standalone")
             validateLifecyclePathAliases(output.args, lifecycleCommand.invocation.operation);
         const observedInvocation = observedLifecycleInvocation(routerContext, publicCommand, env.DD_FLOW_DAEMON_ID);
+        const nativeEvent = env.DD_FLOW_DAEMON_ID && lifecycleCommand.kind === "standalone"
+            ? observedLifecycleNativeEvent(routerContext, nativeCommand, env.DD_FLOW_DAEMON_ID) : null;
+        const diagnostic = env.DD_FLOW_DAEMON_ID && lifecycleCommand.kind === "standalone"
+            ? observedLifecycleDiagnostic(routerContext, publicCommand, env.DD_FLOW_DAEMON_ID, observedInvocation?.id) : null;
+        if (diagnostic && (!nativeEvent || Number(diagnostic.hook_event_id) > nativeEvent.id)) {
+            throw new AppError("lifecycle_shell_syntax_invalid", `Native observer rejected the shell form: ${String(diagnostic.reason ?? "unsupported shell composition")}. Write structured input to a file and run the returned dd-flow command separately.`, 2, { ...diagnostic, phase: "prepare", effect: "no_effect", recoverable: true });
+        }
         if (!observedInvocation && !suppliedInvocationId && env.DD_FLOW_DAEMON_ID && lifecycleCommand.kind === "standalone") {
-            const diagnostic = observedLifecycleDiagnostic(routerContext, publicCommand, env.DD_FLOW_DAEMON_ID);
-            if (diagnostic)
-                throw new AppError("lifecycle_shell_syntax_invalid", `Native observer rejected the shell form: ${String(diagnostic.reason ?? "unsupported shell composition")}. Write structured input to a file and run the returned dd-flow command separately.`, 2, { ...diagnostic, phase: "prepare", effect: "no_effect", recoverable: true });
-            const nativeEvent = observedLifecycleNativeEvent(routerContext, publicCommand, env.DD_FLOW_DAEMON_ID);
             throw new AppError(nativeEvent ? "invocation_assignment_missing" : "invocation_receipt_missing", nativeEvent ? "Native call was observed, but its arguments do not match an issued lifecycle assignment" : "Managed lifecycle command has no committed native receipt", 1, { effect: "no_effect", recoverable: false });
         }
         const invocationId = observedInvocation?.id ?? suppliedInvocationId;
@@ -253,6 +257,8 @@ export async function runCli(args, io = defaultIo, env = process.env) {
             }
             else {
                 invocationSettlement = { context: dispatchContext, id: invocationId };
+                if (observedInvocation)
+                    retainObservedLifecycleSemantics(dispatchContext, invocationId, invocationArgs);
                 dispatchArgs = [...invocationArgs, "--hook-event-id", admission.eventKey];
                 preparedInput?.route?.parsed.options.set("hook-event-id", [admission.eventKey]);
                 dispatchContext.env.DD_FLOW_INVOCATION_SCOPE = JSON.stringify(lifecycleInvocationScope(dispatchContext, invocationId));
@@ -268,11 +274,20 @@ export async function runCli(args, io = defaultIo, env = process.env) {
         if (!retainedOutcome)
             preflightCliCompatibility(dispatchContext, invocationArgs, env, scopeProjectRoot);
         if (!retainedOutcome) {
-            const command = lifecycleCommand.kind === "none" ? publicCommand : quote(["dd-flow", ...dispatchArgs]);
-            const event = lifecycleCommand.kind === "none" && env.DD_FLOW_DAEMON_ID ? observedLifecycleNativeEvent(dispatchContext, command, env.DD_FLOW_DAEMON_ID) : null;
+            const command = !invocationId ? nativeCommand : quote(["dd-flow", ...dispatchArgs]);
+            const event = !invocationId ? nativeEvent : null;
             settleHook = observeLifecycleCommand(dispatchContext, command, event ?? undefined);
         }
         const result = retainedOutcome ? retainedOutcome.result : await dispatch(dispatchArgs, dispatchContext, io, scopeProjectRoot, classification, output, preparedInput);
+        if (!retainedOutcome && invocationArgs[0] === "stage" && invocationArgs[1] === "start"
+            && result && typeof result === "object" && "prompt_path" in result && typeof result.prompt_path === "string") {
+            try {
+                bindLifecyclePublishedPacket(dispatchContext, fs.readFileSync(result.prompt_path, "utf8"));
+            }
+            catch (cause) {
+                throw new AppError("invocation_packet_binding_failed", "Stage started but its published lifecycle assignments could not be retained", 1, { effect: "committed", cause: String(cause) });
+            }
+        }
         const completedHook = settleHook;
         settleHook = undefined;
         completedHook?.({ result });
@@ -303,7 +318,7 @@ export async function runCli(args, io = defaultIo, env = process.env) {
         if (!settleHook && !invocationSettlement) {
             let earlyContext;
             try {
-                const command = quote(["dd-flow", ...output.args]);
+                const command = quote(["dd-flow", ...args]);
                 const router = createRouterContext(env);
                 const event = observedLifecycleNativeEvent(router, command, env.DD_FLOW_DAEMON_ID);
                 // A correctable prepare rejection precedes the terminal command's

package/dist/harness-runtime/bin/dd-agy.mjs

@@ -19,7 +19,7 @@ async function hook(options) {
   if (identity.stale) return event === "PreToolUse" ? { decision: "deny", reason: "agy_stale_hook" } : {};
   if (event === "PreToolUse" || event === "PostToolUse") {
     const phase = event === "PreToolUse" ? "before" : "after", args = payload.toolCall?.args ?? {};
-    const normalized = { schema_id: "dd-flow/agy-tool-event@1", event_id: identity.event_id, phase, daemon_id: identity.daemon_id, conversation_id: payload.conversationId, parent_conversation_id: identity.parent_conversation_id, execution_num: payload.executionNum, step_index: payload.stepIdx, tool: payload.toolCall?.name, input: args, workspace_paths: payload.workspacePaths, transcript_path: payload.transcriptPath, model: payload.modelName, profile: identity.profile, ...(phase === "after" ? { error: payload.error ?? "" } : {}) };
+    const normalized = { schema_id: "dd-flow/agy-tool-event@1", event_id: identity.event_id, phase, daemon_id: identity.daemon_id, launch_cwd: identity.launch_cwd, conversation_id: payload.conversationId, parent_conversation_id: identity.parent_conversation_id, execution_num: payload.executionNum, step_index: payload.stepIdx, tool: payload.toolCall?.name, input: args, workspace_paths: payload.workspacePaths, transcript_path: payload.transcriptPath, model: payload.modelName, profile: identity.profile, ...(phase === "after" ? { error: payload.error ?? "" } : {}) };
     await invokeNativeHook({ bin: options["dd-flow-bin"] ?? identity.dd_flow_bin,
       args: ["agy", "event", "handle", "--project-root", options["project-root"] ?? identity.project_root, "--json"],
       payload: normalized, home: options["dd-flow-home"] ?? identity.dd_flow_home, timeoutMs: budget.remaining("admission", 15_000) });

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

@@ -28,7 +28,7 @@ async function writeJson(file, value) { const temporary = `${file}.${process.pid
 async function readState(dir) { try { return JSON.parse(await readFile(locations(dir).state, "utf8")); } catch (error) { if (error.code === "ENOENT") return null; throw error; } }
 async function removeSocket(paths) { try { if (!(await lstat(paths.socket)).isSocket()) throw new DaemonError("unsafe_socket", "refusing to replace a non-socket daemon path"); await unlink(paths.socket); } catch (error) { if (error.code !== "ENOENT") throw error; } }
 const shell = value => `'${String(value).replaceAll("'", `'"'"'`)}'`;
-function sanitizedEnv(config) { const env = { ...process.env, TMPDIR: config.temporary, DD_AGY_HOOK_NODE: process.execPath, DD_AGY_HOOK_ENTRY: config.entryPath, DD_AGY_STATE_DIR: config.stateDir, DD_AGY_DAEMON_ID: config.daemonId }; for (const key of ["GEMINI_API_KEY","GOOGLE_API_KEY","ANTHROPIC_API_KEY","OPENAI_API_KEY"]) delete env[key]; return env; }
+export function sanitizedEnv(config) { const env = { ...process.env, TMPDIR: config.temporary, DD_AGY_HOOK_NODE: process.execPath, DD_AGY_HOOK_ENTRY: config.entryPath, DD_AGY_STATE_DIR: config.stateDir, DD_AGY_DAEMON_ID: config.daemonId }; for (const key of ["GEMINI_API_KEY","GOOGLE_API_KEY","ANTHROPIC_API_KEY","OPENAI_API_KEY","DD_FLOW_DAEMON_ID"]) delete env[key]; if (config.ddFlowHome && config.daemonId) env.DD_FLOW_DAEMON_ID = config.daemonId; return env; }
 function errorPayload(error) { return { code: error.code ?? "operation_failed", message: error.message ?? String(error), retryable: error.retryable === true, ...(error.details === undefined ? {} : { details: error.details }) }; }
 async function forwardUsage(config, sessionId, result, tools, descendants) {
   if (!config.ddFlowBin || !config.projectRoot) return;
@@ -424,7 +424,7 @@ export class Runtime {
   async observeHook(event, payload, budget = null) { const conversationId = payload.conversationId ?? this.init?.conversation_id; const child = await this.childForHook(conversationId); budget?.remaining("identity"); 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)); if (stale) { await this.journal("stale_hook", { hook_event: event, conversation_id: conversationId, step_index: step }); return { stale: true }; } 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, ...(event === "PreToolUse" ? { last_pre_hook: fingerprint } : {}), ...(payload.transcriptPath ? { transcript_path: payload.transcriptPath } : {}), ...(event === "Stop" ? { stop: { fullyIdle: payload.fullyIdle === true, terminationReason: payload.terminationReason ?? null, executionNum: payload.executionNum ?? null } } : {}) }); if (!stale && event === "PreToolUse" && prior.last_pre_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 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, 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(); 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, persistence_timing: this.persistTiming ?? null }); await this.completePendingTurn(); 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 };
+    const eventId = createHash("sha256").update(JSON.stringify({ daemon: this.config.daemonId, event, conversationId, 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(); 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, persistence_timing: this.persistTiming ?? null }); await this.completePendingTurn(); return { event_id: eventId, daemon_id: this.config.daemonId, launch_cwd: this.config.cwd, 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 };
   }
   async finalizeProviderForControl() {
     const pending = this.providerFinalization;

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

@@ -31,7 +31,7 @@ function errorPayload(error) { return { code: error.code ?? "operation_failed",
 function shellQuote(value) { return `'${String(value).replace(/'/g, "'\\''")}'`; }
 
 function executable(command, args = []) { const resolved = command ?? process.env.DD_GROK_BIN ?? "grok"; return /\.[cm]?js$/.test(resolved) ? { command: process.execPath, args: [resolved, ...args] } : { command: resolved, args }; }
-function isolatedEnv(config) { return { ...process.env, HOME: config.grokHome, GROK_HOME: config.grokHome, ...(config.ddFlowHome ? { DD_FLOW_HOME: config.ddFlowHome } : {}), ...(config.resourceHome ? { DD_FLOW_RESOURCE_HOME: config.resourceHome } : {}), ...(config.authPath ? { GROK_AUTH_PATH: config.authPath } : {}) }; }
+export function isolatedEnv(config) { const env = { ...process.env, HOME: config.grokHome, GROK_HOME: config.grokHome, ...(config.ddFlowHome ? { DD_FLOW_HOME: config.ddFlowHome } : {}), ...(config.resourceHome ? { DD_FLOW_RESOURCE_HOME: config.resourceHome } : {}), ...(config.authPath ? { GROK_AUTH_PATH: config.authPath } : {}) }; delete env.DD_FLOW_DAEMON_ID; if (config.ddFlowHome && config.daemonId) env.DD_FLOW_DAEMON_ID = config.daemonId; return env; }
 function within(candidate, root) { const resolved = path.resolve(candidate); const parent = path.resolve(root); return resolved === parent || resolved.startsWith(`${parent}${path.sep}`); }
 
 async function writeIsolatedConfig(paths) {
@@ -167,8 +167,9 @@ export async function startDaemon(options) {
   const previous = await readState(paths.dir); if (previous?.shutdown_state === "clean") await authorizeRetainedDaemonResume(paths.dir, previous, options.sessionId, config); if (previous?.shutdown_state === "running" && previous.active_tree) throw new DaemonError("invalid_harness_crash", "previous daemon died with an active or unproven Session tree", false, { daemon_id: previous.daemon_id });
   await removeSocket(paths.socket, paths.dir); await mkdir(paths.home, { recursive: true, mode: 0o700 }); const importedSession = await materializeSessionArchive(paths, config.sessionArchive); const copiedAuth = await copyAuth(paths, authSource); await writeIsolatedConfig(paths); if (!noFlow) await writeHook(paths, config, absolute(options.entryPath, "dd-grok entry")); const versions = await doctor({ bin: config.bin }); if (importedSession && importedSession.grok_version !== versions.versions.grok) throw new DaemonError("session_archive_version_mismatch", "Grok Build session archive was created by a different CLI version", false, { archive_version: importedSession.grok_version, current_version: versions.versions.grok }); const configIsolation = await inspectIsolatedConfig(config);
   const resourceProcess = await registerDaemonProcess(config, { kind: "grok-daemon", owner: `grok:${path.basename(paths.dir)}`, operation: `grok-daemon:${path.basename(paths.dir)}`, stdout: paths.log, stderr: paths.log });
-  const state = { descendants: previous?.descendants ?? [], schema_id: STATE_SCHEMA, daemon_id: randomUUID(), pid: null, socket: paths.socket, started_at: new Date().toISOString(), shutdown_state: "starting", active_tree: false, recovery_status: previous?.shutdown_state === "running" ? "recovered_idle" : "clean_start", auth_status: copiedAuth ? "copied" : "absent", ...(importedSession ? { imported_session: importedSession } : {}), versions: versions.versions, config_isolation: configIsolation, config, sessions: importedSession ? [{ provider_session_id: importedSession.provider_session_id, adapter_session_id: importedSession.provider_session_id, parent_provider_session_id: null, root_provider_session_id: importedSession.provider_session_id, cwd: importedSession.source_cwd }] : (previous?.sessions ?? []), resource_process: resourceProcess };
-  await writeState(paths.state, state); const log = await open(paths.log, "a", 0o600); const child = spawn(process.execPath, [absolute(options.entryPath, "dd-grok entry"), "daemon", "serve", "--state-dir", paths.dir], { cwd: config.cwd, env: isolatedEnv(config), detached: true, stdio: ["ignore", log.fd, log.fd] }); child.unref(); await log.close();
+  const daemonId = randomUUID();
+  const state = { descendants: previous?.descendants ?? [], schema_id: STATE_SCHEMA, daemon_id: daemonId, pid: null, socket: paths.socket, started_at: new Date().toISOString(), shutdown_state: "starting", active_tree: false, recovery_status: previous?.shutdown_state === "running" ? "recovered_idle" : "clean_start", auth_status: copiedAuth ? "copied" : "absent", ...(importedSession ? { imported_session: importedSession } : {}), versions: versions.versions, config_isolation: configIsolation, config: { ...config, daemonId }, sessions: importedSession ? [{ provider_session_id: importedSession.provider_session_id, adapter_session_id: importedSession.provider_session_id, parent_provider_session_id: null, root_provider_session_id: importedSession.provider_session_id, cwd: importedSession.source_cwd }] : (previous?.sessions ?? []), resource_process: resourceProcess };
+  await writeState(paths.state, state); const log = await open(paths.log, "a", 0o600); const child = spawn(process.execPath, [absolute(options.entryPath, "dd-grok entry"), "daemon", "serve", "--state-dir", paths.dir], { cwd: config.cwd, env: isolatedEnv(state.config), detached: true, stdio: ["ignore", log.fd, log.fd] }); child.unref(); await log.close();
   try { await confirmDaemonProcess(config, resourceProcess, child); const deadline = Date.now() + 30_000; while (Date.now() < deadline) { await new Promise((resolve) => setTimeout(resolve, 100)); try { const status = await callDaemon(paths.dir, "daemon.ready", {}, 5000); if (status.ready) return status; } catch (error) { if (error.code !== "daemon_not_running" && error.code !== "daemon_timeout") throw error; } } throw new DaemonError("daemon_start_failed", "daemon did not become ready", true); }
   catch (error) { await cleanupFailedStart(config, resourceProcess, child, error); throw error; }
 }

package/dist/harness-runtime/lib/delegation-instructions.d.mts

@@ -2,6 +2,8 @@ export type DelegationWork = { work_id: string; start_command: string; launch_po
 export type DelegationInput = { harness: string; stage: string; capacity: number; works?: DelegationWork[]; totalWorks?: number; remainingWorks?: number };
 export function delegationAdapter(harness: string): string | null;
 export function delegationContract(harness: string): string;
+export const lifecycleRetryInstruction: string;
+export const stageLifecycleInstruction: string;
 export function workerDelegationTask(input: { workId: string; startCommand: string; launchPolicy?: string }): string;
 export function renderDelegationInstructions(input: DelegationInput): string;
 export function renderCapacityInstructions(input: { harness: string; maximum: number }): string;

package/dist/harness-runtime/lib/delegation-instructions.mjs

@@ -49,7 +49,14 @@ export function delegationContract(harness) {
   return `dd-flow/delegation/${key}@${key === "codex" ? 2 : 1}`;
 }
 
-export const lifecycleRetryInstruction = "If the CLI rejects the call with effect=no_effect, recoverable=true and retry_command, execute that exact retry_command in this same Session after correcting the reported input. Never invent IDs. If the native shell tool rejects the launch before the CLI starts, correct only that tool-call error and repeat the same exact command; do not change its arguments. A hook/transport failure is an infrastructure error: stop and report it without retrying. For any other failure, stop and report the exact error; do not run status as a substitute, call a hook handler, retry blindly, or finish the Work.";
+export const lifecycleRetryInstruction = "A failure is not permission to replay a lifecycle command. For proven effect=no_effect with recoverable=true and retry_command, correct the input and execute that exact issued successor. A check failure can retain receipts while leaving Work running: correct the evidenced cause first, then use the CLI's exact retry_command for an intentional fresh check attempt; never replay a check merely because Work is unsettled. If continuation.kind=repair_required, or a successful result has outcome=repair_required and a repair Work ID, end this Turn for the registered repair child; use any retry_command only after that repair settles and verification is refreshed. Unknown effects require reconciliation, never replay. A committed effect without an explicit continuation is not retryable. A native shell launch refusal before the CLI starts permits correcting only that shell-form error and retrying the same exact command. Otherwise report the primary error and stop; never invent IDs, call hooks directly, or run status as a substitute.";
+
+export const stageLifecycleInstruction = [
+  "The project root identifies this RUN; use the Stage packet's declared execution workspace and absolute artifact paths. Do not change a native Session's working directory to a workspace provisioned for a later Stage.",
+  "In a controller-managed fanout, the coordinator ends the entry Turn after the Work graph is returned; the controller dispatches children. A completed child or Work is not Stage success: settle the declared graph and Stage gate before finishing.",
+  "Execute each runtime-issued lifecycle operation as a standalone call. Invocation IDs are internal authority; never add, copy or invent one.",
+  lifecycleRetryInstruction
+].join(" ");
 
 export function workerDelegationTask({ workId, startCommand, launchPolicy }) {
   if (!workId || !startCommand) throw new Error("ready fan-out Work lacks its exact start command");

package/dist/protocol/local-files.js

@@ -62,16 +62,12 @@ export function ensureProtocolFiles(input) {
     writeState(statePath, { ...state, flow_contract: flowContract, updated_at: input.now });
     return { ...state, flow_contract: flowContract, updated_at: input.now };
 }
-export function ensureRuntimeProtocolFiles(input) {
+/** Read legacy state and prepare a registration without publishing files. */
+export function prepareRuntimeProtocolFiles(input) {
     const currentFlowContract = loadProjectFlowContract(input.projectRoot);
     const statePath = path.join(input.runtimeDir, "state.json");
     const existing = readStateIfExists(statePath);
     const flowContract = existing?.flow_contract ?? currentFlowContract;
-    ensureDir(input.runtimeDir);
-    const metadataPath = path.join(input.runtimeDir, "metadata.json");
-    if (!fs.existsSync(metadataPath)) {
-        fs.writeFileSync(metadataPath, `${JSON.stringify({ protocol_id: input.protocolId, handshake_id: input.handshakeId, project_root: input.projectRoot }, null, 2)}\n`);
-    }
     const state = existing ??
         {
             schema_version: schemaVersion,
@@ -103,9 +99,22 @@ export function ensureRuntimeProtocolFiles(input) {
             updated_at: input.now
         };
     const workspace = input.workspacePath ? { ...state.workspace, worktree_path: input.workspacePath } : state.workspace;
-    const nextState = { ...state, workspace, flow_contract: flowContract, updated_at: input.now };
-    writeState(statePath, nextState);
-    return nextState;
+    return { ...state, workspace, flow_contract: flowContract, updated_at: input.now };
+}
+/** Metadata is a retained write-once compatibility artifact, never authority. */
+export function publishRuntimeProtocolMetadata(input) {
+    ensureDir(input.runtimeDir);
+    const metadataPath = path.join(input.runtimeDir, "metadata.json");
+    if (fs.existsSync(metadataPath))
+        return;
+    const bytes = `${JSON.stringify({ protocol_id: input.protocolId, handshake_id: input.handshakeId, project_root: input.projectRoot }, null, 2)}\n`;
+    try {
+        fs.writeFileSync(metadataPath, bytes, { flag: "wx" });
+    }
+    catch (error) {
+        if (error.code !== "EEXIST")
+            throw error;
+    }
 }
 export function readState(projectRoot, protocolId) {
     return readStateFile(stateJsonPath(projectRoot, protocolId), protocolId);

package/dist/runtime/context.js

@@ -8,11 +8,11 @@ export function createRouterContext(env) {
         now: () => new Date().toISOString()
     };
 }
-export function createContext(env, mode = "initialize") {
+export function createContext(env, mode = "initialize", importPermitId) {
     const ddFlowHome = resolveDdFlowHome(env);
     return {
         ddFlowHome,
-        db: getDatabase(ddFlowHome, mode),
+        db: getDatabase(ddFlowHome, mode, importPermitId),
         env,
         now: () => new Date().toISOString()
     };

package/dist/services/cleanup.js

@@ -6,8 +6,9 @@ import { prepareJsonFile } from "../cli/input-preparation.js";
 import { projectCheckoutRoot, resolveProjectRoot, runtimeStateJsonPath } from "../storage/paths.js";
 import { appendAudit } from "./audit.js";
 import { requireProjectByRoot } from "./projects.js";
-import { protocolRunDiagnostics, readProtocolRuntimeState, repairProtocolRuntimeState, requireProtocol } from "./protocols.js";
+import { persistProtocolState, prepareProtocolRuntimeRepair, protocolRunDiagnostics, readProtocolRuntimeState, requireProtocol } from "./protocols.js";
 import { publicSessionIdentity } from "./session-identity.js";
+import { publishRunProjections } from "./runs.js";
 const actionKinds = new Set([
     "repair_protocol_state",
     "cancel_queue_job",
@@ -187,30 +188,38 @@ export function prepareCleanupApply(context, input) {
 }
 export function cleanupApply(context, input) {
     const { project, reason, plan } = input.prepared ?? prepareCleanupApply(context, input);
+    // A supplied plan can outlive its initial inspection. Refresh external
+    // workspace evidence before reserving the writer, then recheck SQL below.
+    if (input.prepared)
+        validateNoDestructiveSurprises(context, plan, input.force);
+    const prepared = prepareCleanupEffects(context, plan);
     const now = context.now();
     const results = [];
-    context.db.beginWriteTransaction();
-    let executing = false;
+    let executing = false, committed = false;
     try {
-        validateNoDestructiveSurprises(context, plan, input.force);
-        for (const action of plan.actions) {
-            executing = true;
-            results.push(applyAction(context, action, reason, input.force, now));
-        }
-        const changed = results.filter((result) => result.changed).length;
-        if (changed > 0) {
-            appendAudit(context, {
-                projectId: project.id,
-                eventType: "cleanup.applied",
-                reason,
-                forced: input.force,
-                payload: { project_id: project.id, action_count: plan.actions.length, changed, results }
-            });
-        }
-        context.db.exec("COMMIT");
+        context.db.writeTransaction(() => {
+            context.db.afterCommit(() => { committed = true; });
+            validateNoDestructiveSurprises(context, plan, input.force, false);
+            prepared.assertUnchanged();
+            for (const action of plan.actions) {
+                executing = true;
+                results.push(applyAction(context, action, reason, input.force, now, prepared));
+            }
+            const changed = results.filter((result) => result.changed).length;
+            if (changed > 0) {
+                appendAudit(context, {
+                    projectId: project.id,
+                    eventType: "cleanup.applied",
+                    reason,
+                    forced: input.force,
+                    payload: { project_id: project.id, action_count: plan.actions.length, changed, results }
+                });
+            }
+        });
     }
     catch (error) {
-        context.db.exec("ROLLBACK");
+        if (committed || error instanceof AppError && error.details.effect === "committed")
+            throw new AppError(error instanceof AppError ? error.code : "cleanup_publication_failed", error instanceof Error ? error.message : "Committed cleanup publication failed", error instanceof AppError ? error.exitCode : 1, { ...(error instanceof AppError ? error.details : {}), effect: "committed", publication_pending: true, attempted_results: results, cause: String(error) });
         if (executing)
             throw new AppError("cleanup_apply_failed", "Cleanup failed after execution began; inspect retained artifacts before retrying", 1, { effect: "unknown", database_rolled_back: true, attempted_results: results, cause: error instanceof Error ? error.message : String(error), ...(error instanceof AppError ? { cause_code: error.code } : {}) });
         throw error;
@@ -274,7 +283,7 @@ function validateCleanupPlan(value, project) {
     });
     return { project_root: project.root, project_id: project.id, actions };
 }
-function validateNoDestructiveSurprises(context, plan, force) {
+function validateNoDestructiveSurprises(context, plan, force, inspectFiles = true) {
     for (const action of plan.actions) {
         if (action.kind === "repair_protocol_state")
             requireProtocol(context, action.protocol_id, action.project_id);
@@ -284,13 +293,13 @@ function validateNoDestructiveSurprises(context, plan, force) {
                 cleanupRunIndex(run.index_json);
         }
     }
-    const destructive = plan.actions.find((action) => action.kind === "close_worktree_record" && action.worktree_path && dirtyGit(action.worktree_path));
+    const destructive = inspectFiles && plan.actions.find((action) => action.kind === "close_worktree_record" && action.worktree_path && dirtyGit(action.worktree_path));
     if (destructive && !force) {
         throw new AppError("worktree_dirty", "cleanup apply refuses dirty worktree actions without --force --reason", 1, {
             path: destructive.worktree_path
         });
     }
-    const unsafeWorktree = plan.actions.find((action) => action.kind === "close_worktree_record" && action.worktree_path && !safeCleanupWorktreePath(context, action.project_id, action.worktree_path));
+    const unsafeWorktree = inspectFiles && plan.actions.find((action) => action.kind === "close_worktree_record" && action.worktree_path && !safeCleanupWorktreePath(context, action.project_id, action.worktree_path));
     if (unsafeWorktree) {
         throw new AppError("worktree_cleanup_unsafe", "cleanup apply refuses unsafe worktree path", 1, {
             path: unsafeWorktree.worktree_path
@@ -309,12 +318,53 @@ function validateNoDestructiveSurprises(context, plan, force) {
         });
     }
 }
-function applyAction(context, action, reason, force, now) {
+function prepareCleanupEffects(context, plan) {
+    const checks = [], files = new Map();
+    const repairs = new Map();
+    const read = (sql, params) => {
+        const value = context.db.get(sql, params), encoded = JSON.stringify(value);
+        checks.push(() => { if (JSON.stringify(context.db.get(sql, params)) !== encoded)
+            throw new AppError("cleanup_plan_changed", "Cleanup target changed during preparation", 1, { effect: "no_effect" }); });
+        return value;
+    };
+    const remember = (file) => { if (file !== undefined)
+        files.set(file, fs.existsSync(file)); };
+    for (const action of plan.actions) {
+        if (action.kind === "repair_protocol_state") {
+            read("SELECT * FROM protocols WHERE project_id = ? AND id = ?", [action.project_id, action.protocol_id]);
+            const protocol = requireProtocol(context, action.protocol_id, action.project_id);
+            remember(protocol.state_path);
+            repairs.set(action, prepareProtocolRuntimeRepair(context, protocol));
+        }
+        if (action.kind === "discard_stale_run") {
+            const run = read("SELECT * FROM runs WHERE project_id = ? AND id = ?", [action.project_id, action.run_id]);
+            if (run) {
+                remember(run.runtime_path);
+                remember(run.run_dir);
+                remember(run.workspace_root);
+            }
+        }
+        if (action.kind === "close_worktree_record") {
+            const record = read("SELECT * FROM worktree_records WHERE project_id = ? AND protocol_id = ?", [action.project_id, action.protocol_id]);
+            remember(action.worktree_path ?? record?.worktree_path);
+        }
+    }
+    return { repairs, assertUnchanged: () => { for (const check of checks)
+            check(); }, exists: (file) => {
+            if (!files.has(file))
+                throw new AppError("cleanup_plan_changed", "Cleanup target has no prepared filesystem observation", 1, { path: file, effect: "no_effect" });
+            return files.get(file);
+        } };
+}
+function applyAction(context, action, reason, force, now, prepared) {
     if (action.kind === "repair_protocol_state" && action.protocol_id) {
         const protocol = requireProtocol(context, action.protocol_id, action.project_id);
         const beforePath = protocol.state_path;
-        const existed = fs.existsSync(beforePath);
-        repairProtocolRuntimeState(context, protocol);
+        const existed = prepared.exists(beforePath), repair = prepared.repairs.get(action);
+        context.db.run("UPDATE protocols SET state_path = ?, plan_path = ? WHERE project_id = ? AND id = ?", [repair.statePath, repair.planPath, action.project_id, action.protocol_id]);
+        persistProtocolState(context, { ...protocol, state_path: repair.statePath, plan_path: repair.planPath }, repair.state);
+        protocol.state_path = repair.statePath;
+        appendAudit(context, { protocolId: protocol.id, projectId: protocol.project_id, eventType: "protocol.runtime_state_repaired", payload: { protocol_id: protocol.id, path: repair.statePath, repaired_from: repair.previousStatePath, source: "sqlite" } });
         return {
             kind: action.kind,
             changed: !existed || beforePath !== protocol.state_path,
@@ -369,21 +419,19 @@ function applyAction(context, action, reason, force, now) {
         if (run.status === "discarded") {
             const index = discardedRunIndex(run.index_json, reason, now);
             context.db.run("UPDATE runs SET verdict = 'discarded', next_action = ?, index_json = ?, updated_at = ?, completed_at = COALESCE(completed_at, ?) WHERE project_id = ? AND id = ?", [reason, JSON.stringify(index), now, now, action.project_id, action.run_id]);
-            if (fs.existsSync(run.runtime_path))
-                fs.writeFileSync(run.runtime_path, `${JSON.stringify(index, null, 2)}\n`);
+            context.db.afterCommit(() => publishRunProjections(context, action.project_id, action.run_id));
             return { kind: action.kind, changed: true, run_id: action.run_id };
         }
         if (run.status !== "running") {
             return { kind: action.kind, changed: false, skipped: true, reason: `already_${run.status}`, run_id: action.run_id };
         }
-        if (fs.existsSync(run.runtime_path) || fs.existsSync(run.run_dir) || fs.existsSync(run.workspace_root)) {
+        if (prepared.exists(run.runtime_path) || prepared.exists(run.run_dir) || prepared.exists(run.workspace_root)) {
             return { kind: action.kind, changed: false, skipped: true, reason: "runtime_or_workspace_reappeared", run_id: action.run_id };
         }
         const index = discardedRunIndex(run.index_json, reason, now);
         context.db.run(`UPDATE runs SET status = 'discarded', verdict = 'discarded', next_action = ?, index_json = ?, updated_at = ?, completed_at = ?
        WHERE project_id = ? AND id = ? AND status = 'running'`, [reason, JSON.stringify(index), now, now, action.project_id, action.run_id]);
-        fs.mkdirSync(run.run_dir, { recursive: true });
-        fs.writeFileSync(run.runtime_path, `${JSON.stringify(index, null, 2)}\n`);
+        context.db.afterCommit(() => publishRunProjections(context, action.project_id, action.run_id));
         context.db.run(`UPDATE sessions SET status = 'stopped', stop_reason = ?, updated_at = ?, stopped_at = ?
        WHERE project_id = ? AND run_id = ? AND status IN ('pending', 'active', 'waiting_user', 'blocked', 'stopping')`, [reason, now, now, action.project_id, action.run_id]);
         context.db.run("UPDATE flow_session_segments SET ended_at = ? WHERE project_id = ? AND run_id = ? AND ended_at IS NULL", [now, action.project_id, action.run_id]);
@@ -425,7 +473,7 @@ function applyAction(context, action, reason, force, now) {
     }
     if (action.kind === "close_worktree_record" && action.protocol_id) {
         const worktreePath = action.worktree_path ?? context.db.get("SELECT worktree_path FROM worktree_records WHERE project_id = ? AND protocol_id = ?", [action.project_id, action.protocol_id])?.worktree_path;
-        const status = worktreePath && fs.existsSync(worktreePath) ? "kept" : "removed";
+        const status = worktreePath && prepared.exists(worktreePath) ? "kept" : "removed";
         const result = context.db.run(`UPDATE worktree_records SET status = ?, updated_at = ?, closed_at = ?
        WHERE project_id = ? AND protocol_id = ? AND status = 'active'`, [status, now, now, action.project_id, action.protocol_id]);
         return {
@@ -444,6 +492,7 @@ function discardedRunIndex(indexJson, reason, now) {
     index.verdict = "discarded";
     index.next_action = reason;
     index.updated_at = now;
+    index.runtime_revision = (typeof index.runtime_revision === "number" ? index.runtime_revision : 0) + 1;
     index.completed_at ??= now;
     index.finished_at ??= now;
     return index;

package/dist/services/code-checks.js

@@ -326,33 +326,40 @@ export function reconcileUnfinishedChecks(context, input) {
     return reconciled;
 }
 function reserveOrReuseReceipt(context, input) {
-    context.db.beginWriteTransaction();
-    try {
+    // Receipt files and artifact hashes are prepared before reserving SQLite.
+    // The compact SQL snapshot below fences races with another check settlement.
+    const snapshotSql = "SELECT id, status, exit_code, input_hash, profile_hash, command, gate, retry_of_receipt_id, receipt_path FROM check_receipts WHERE project_id = ? AND run_id = ? ORDER BY reservation_sequence, rowid";
+    const snapshot = JSON.stringify(context.db.all(snapshotSql, [input.projectId, input.runId]));
+    const receipts = checkReceipts(context, { projectId: input.projectId, runId: input.runId });
+    if (JSON.stringify(context.db.all(snapshotSql, [input.projectId, input.runId])) !== snapshot)
+        throw new AppError("check_receipt_changed", "Check receipts changed during evidence preparation", 1);
+    const prior = receipts.filter((receipt) => receipt.input_hash === input.inputHash && receipt.profile_hash === input.profileHash).at(-1) ?? null;
+    const reusablePrior = prior?.status === "passed" && checkReceiptEvidenceValid(prior);
+    const retryIds = new Set([...(input.retryReceiptId ? [input.retryReceiptId] : []), ...(input.retryReceiptIds ?? [])]);
+    const successor = retryIds.size === 1 ? receipts.find((receipt) => receipt.retry_of_receipt_id === [...retryIds][0] && receipt.input_hash === input.inputHash && receipt.profile_hash === input.profileHash) : null;
+    const reusableSuccessor = successor?.status === "passed" && checkReceiptEvidenceValid(successor);
+    return context.db.writeTransaction(() => {
         assertRunMutationAllowed(context, input.projectId, input.runId, input.generation);
-        const prior = latestApplicableReceipt(context, input);
+        if (JSON.stringify(context.db.all(snapshotSql, [input.projectId, input.runId])) !== snapshot)
+            throw new AppError("check_receipt_changed", "Check receipts changed before reservation", 1);
         if (prior?.status === "running")
             throw new AppError("check_in_progress", "A matching check invocation is still running", 1, { check_receipt_id: prior.id });
-        const retryIds = new Set([...(input.retryReceiptId ? [input.retryReceiptId] : []), ...(input.retryReceiptIds ?? [])]);
         if (retryIds.size > 1)
             throw new AppError("retry_check_invalid", "A check execution accepts exactly one retry predecessor", 2);
         const retryId = [...retryIds][0];
         if (retryId) {
             if (!input.retryReason?.trim())
                 throw new AppError("retry_check_invalid", "A check retry requires the restored-condition reason", 2, { check_receipt_id: retryId });
-            const receipts = checkReceipts(context, { projectId: input.projectId, runId: input.runId });
             const predecessor = receipts.find(receipt => receipt.id === retryId);
             if (!predecessor || !["failed", "aborted"].includes(predecessor.status) || predecessor.input_hash !== input.inputHash || predecessor.profile_hash !== input.profileHash || predecessor.command !== input.group.command || predecessor.gate !== input.group.gate)
                 throw new AppError("retry_check_invalid", "Retry predecessor does not match this exact check contract", 2, { check_receipt_id: retryId });
-            const successor = receipts.find(receipt => receipt.retry_of_receipt_id === retryId && receipt.input_hash === input.inputHash && receipt.profile_hash === input.profileHash);
             if (prior?.id !== (successor?.id ?? predecessor.id))
                 throw new AppError("retry_check_invalid", "This retry was superseded by a newer check outcome; inspect the latest receipt", 2, { check_receipt_id: retryId, latest_check_receipt_id: prior?.id ?? null, latest_status: prior?.status ?? null });
             if (successor?.status === "running")
                 throw new AppError("check_in_progress", "The requested retry is already running", 1, { check_receipt_id: successor.id, retry_of_receipt_id: retryId });
             if (successor) {
-                if (successor.status === "passed" && checkReceiptEvidenceValid(successor)) {
-                    context.db.exec("COMMIT");
+                if (reusableSuccessor)
                     return { receipt: successor };
-                }
                 throw new AppError("retry_check_invalid", "The requested retry already has a terminal outcome; choose its failed receipt for another retry", 2, { check_receipt_id: successor.id, retry_of_receipt_id: retryId, status: successor.status });
             }
         }
@@ -360,10 +367,8 @@ function reserveOrReuseReceipt(context, input) {
         // failed check again: repairing dependencies/services need not change any
         // tracked input. Lifecycle invocation replay owns command idempotency;
         // the running-receipt guard above still prevents concurrent execution.
-        if (prior?.status === "passed" && !retryIds.has(prior.id) && input.group.reusable && checkReceiptEvidenceValid(prior)) {
-            context.db.exec("COMMIT");
+        if (prior?.status === "passed" && !retryIds.has(prior.id) && input.group.reusable && reusablePrior)
             return { receipt: prior };
-        }
         let ordinal = (context.db.get("SELECT COALESCE(MAX(reservation_sequence), 0) + 1 AS sequence FROM check_receipts WHERE project_id = ? AND run_id = ?", [input.projectId, input.runId])?.sequence ?? 1);
         let localId = `RCP-${String(ordinal).padStart(3, "0")}`, id = `${input.workId ?? input.runId}/${localId}`;
         while (context.db.get("SELECT 1 FROM check_receipts WHERE id = ?", [id])) {
@@ -374,13 +379,8 @@ function reserveOrReuseReceipt(context, input) {
         const directory = path.join(input.runHome, input.artifactDir ?? "05-code", "checks", localId);
         const reserved = { id, localId, directory, evidenceDir: path.join(directory, "artifacts"), stdoutPath: path.join(directory, "stdout.log"), stderrPath: path.join(directory, "stderr.log"), receiptPath: path.join(directory, "receipt.json"), completionPath: path.join(directory, "completion.json"), group: input.group, before: input.before, profileHash: input.profileHash, inputHash: input.inputHash, epoch: input.epoch, startedAt: input.startedAt, scope: input.scope, ...(retryId ? { retryOf: retryId, retryReason: input.retryReason } : {}), ...(input.workId ? { workId: input.workId } : {}), projectId: input.projectId, runId: input.runId };
         context.db.run("INSERT INTO check_receipts (id, project_id, run_id, work_id, scope, declaration_id, check_refs_json, gate, command, input_hash, verification_epoch, reservation_sequence, retry_of_receipt_id, retry_reason, status, exit_code, stdout_path, stderr_path, receipt_path, workspace_fingerprint, before_fingerprint, after_fingerprint, profile_hash, mutation_paths_json, artifacts_json, started_at, finished_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 'running', NULL, ?, ?, ?, ?, ?, ?, ?, '[]', '[]', ?, ?)", [id, input.projectId, input.runId, input.workId ?? null, input.scope, input.group.declarations[0].id, JSON.stringify(input.group.declarations.map(checkRef).sort()), input.group.gate, input.group.command, input.inputHash, input.epoch, ordinal, reserved.retryOf ?? null, reserved.retryReason ?? null, reserved.stdoutPath, reserved.stderrPath, reserved.receiptPath, input.before.fingerprint, input.before.fingerprint, input.before.fingerprint, input.profileHash, input.startedAt, input.startedAt]);
-        context.db.exec("COMMIT");
         return { reserved };
-    }
-    catch (error) {
-        context.db.exec("ROLLBACK");
-        throw error;
-    }
+    }, "checks.reserveOrReuseReceipt");
 }
 function receiptFor(input) { return { id: input.id, local_id: input.localId, declaration_id: input.group.declarations[0].id, check_refs: input.group.declarations.map(checkRef), gate: input.group.gate, scope: input.scope, work_id: input.workId ?? null, command: input.group.command, input_hash: input.inputHash, verification_epoch: input.epoch, retry_of_receipt_id: input.retryOf ?? null, retry_reason: input.retryReason ?? null, status: input.status, exit_code: input.status === "running" ? null : input.result.exitCode, stdout_path: input.stdoutPath, stderr_path: input.stderrPath, receipt_path: input.receiptPath, completion_path: input.completionPath, required_artifacts: input.group.requiredArtifacts, inputs: input.group.inputs, workspace_fingerprint: input.before.fingerprint, before_fingerprint: input.before.fingerprint, after_fingerprint: input.after.fingerprint, profile_hash: input.profileHash, mutation_paths: input.mutationPaths, artifacts: input.artifacts, resources: { ports: input.resources }, started_at: input.startedAt, finished_at: input.status === "running" ? input.startedAt : new Date().toISOString() }; }
 function writeReceipt(file, receipt) { const temporary = `${file}.tmp-${process.pid}-${crypto.randomUUID()}`; fs.writeFileSync(temporary, `${JSON.stringify(receipt, null, 2)}\n`); fs.renameSync(temporary, file); }
@@ -653,7 +653,6 @@ function explicitInputFiles(root, inputs, ignoredRoots) {
 }
 function checkInputHash(workspaceRoot, group, profileHash, inputFingerprint) { return crypto.createHash("sha256").update(JSON.stringify({ workspace_root: path.resolve(workspaceRoot), gate: group.reusable ? null : group.gate, command: group.command, required_artifacts: group.requiredArtifacts, ports: group.ports, inputs: group.inputs, profile_hash: profileHash, environment: environmentFingerprint(workspaceRoot), input_fingerprint: inputFingerprint })).digest("hex"); }
 function bindReceipt(receipt, group) { return { ...receipt, gate: group.gate, declaration_id: group.declarations[0].id, check_refs: group.declarations.map(checkRef), required_artifacts: group.requiredArtifacts, inputs: group.inputs }; }
-function latestApplicableReceipt(context, input) { const candidates = checkReceipts(context, { projectId: input.projectId, runId: input.runId }).filter((receipt) => receipt.input_hash === input.inputHash && receipt.profile_hash === input.profileHash); return candidates.at(-1) ?? null; }
 export function checkReceiptEvidenceValid(receipt) { if (receipt.status !== "passed" || receipt.exit_code !== 0 || receipt.before_fingerprint !== receipt.after_fingerprint || !fs.existsSync(receipt.completion_path) || readCompletion(receipt.completion_path)?.exit_code !== 0)
     return false; const stored = readReceipt(receipt.receipt_path); if (!stored || stored.status !== "passed" || stored.input_hash !== receipt.input_hash || stored.profile_hash !== receipt.profile_hash)
     return false; const artifacts = collectCheckArtifacts(path.join(path.dirname(receipt.receipt_path), "artifacts"), stored.required_artifacts ?? []); return artifacts.complete && JSON.stringify(artifacts.items) === JSON.stringify(stored.artifacts ?? []); }

package/dist/services/continuation-outcome.js

@@ -12,7 +12,7 @@ export function assertNoCorrelatedRejection(context, scope) {
     const latest = new Map();
     for (const row of rows) {
         const value = JSON.parse(row.outcome_json);
-        latest.set(JSON.stringify([value.operation, value.session_id ?? null, value.work_id ?? null, value.attempt ?? null]), value);
+        latest.set(JSON.stringify([value.operation, value.session_id ?? null, value.correlation_key ?? value.fingerprint ?? value.work_id ?? null, value.attempt ?? null]), value);
     }
     for (const value of latest.values())
         if (value.error && !isRegisteredRepair(context, value.error.details.continuation, scope))

package/dist/services/controller-fanout.js

@@ -3,7 +3,7 @@ import { getVnextFanoutStatus, observeVnextNativeChildren, reconcileVnextFanout,
 import { getFlowRunVariables } from "./runs.js";
 import { dispatchVnextPlanReview } from "./vnext-plan-review.js";
 import { resolveExecutionPolicy } from "./execution-policy.js";
-import { renderDelegationInstructions } from "../harness-runtime/lib/delegation-instructions.mjs";
+import { renderDelegationInstructions, stageLifecycleInstruction } from "../harness-runtime/lib/delegation-instructions.mjs";
 import { assertWorkLaunchReady } from "./work-registry.js";
 function semanticCompletionPrompt(stage, completed) {
     const task = stage === "plan-review"
@@ -15,7 +15,7 @@ function semanticCompletionPrompt(stage, completed) {
         `All declared ${stage} child Work has settled (${completed} completed).`,
         task,
         "Then invoke the exact Stage finish command from the original authoritative packet.",
-        "Only if that command actually returns continuation.kind = repair_required has repair Work been registered; in that case end this Turn immediately so the controller can dispatch it. Otherwise follow the command's actual result.",
+        "If that command returns either outcome = repair_required with a repair Work ID, or error.details.continuation.kind = repair_required, the repair Work is already registered. End this Turn so the controller can dispatch it. Otherwise follow the command's actual result.",
         "Do not create speculative repair Work or start a successor Stage."
     ].join(" ");
 }
@@ -27,7 +27,7 @@ export function controllerStageEntryPrompt(stage, command) {
         "Read the complete authoritative packet from the command's response_file result, including worker_prompt_markdown. If a read is truncated, continue until the entire packet has been read.",
         "If the returned packet has orchestration.kind = work_fanout, this Turn is only Stage entry: acknowledge the packet and end your Turn immediately. The packet describes the whole Stage, but its graph/dispatch/finish instructions belong to later controller continuations. Do not list, start, launch or finish Work, create children, change files, run checks, or finish the Stage in this entry Turn. The controller will inspect the graph and send the next assignment with exact issued commands (or dispatch external workers itself).",
         "Otherwise perform this Stage's semantic work and stop at its boundary or a declared HITL boundary. Do not start a successor Stage.",
-        "Execute each runtime-issued lifecycle operation and target as one standalone call. Internal invocation IDs are intentionally absent; never add, copy or invent one. For a no-effect input rejection, correct the input and use its returned retry_command. If a required command is missing or no safe retry is returned, report the exact error and end the Turn so the controller can handle it."
+        stageLifecycleInstruction
     ].join("\n\n");
 }
 /** The shared controller owns this former eval-only Work-graph decision. */