@deksden-com/dd-flow-cli 0.9.0-beta.10 → 0.9.0-beta.100

package/dist/cli.js

@@ -1,4 +1,8 @@
 #!/usr/bin/env node
-import { runCli } from "./cli/run-cli.js";
-const exitCode = await runCli(process.argv.slice(2));
+const args = process.argv.slice(2);
+const managedHook = Boolean(process.env.DD_FLOW_CODEX_STATE_DIR) && args.slice(0, 3).join(" ") === "codex hook handle" && !args.includes("--help") && !args.includes("-h");
+const exitCode = managedHook
+    ? await (await import("./cli/hook-ingress.js")).runHookIngress(args)
+    : await (await import("./cli/run-cli.js")).runCli(args);
 process.exitCode = exitCode;
+export {};

package/dist/harness-runtime/DD-ZCODE.md

@@ -0,0 +1,99 @@
+# dd-zcode integration boundary
+
+`bin/dd-zcode.mjs`, `lib/dd-zcode.mjs` and `lib/dd-zcode-daemon.mjs` implement the
+dd-flow adapter over ACP. The maintained bridge is
+[deksden-com/zcode-acp](https://github.com/deksden-com/zcode-acp), based on upstream
+[william0wang/zcode-acp](https://github.com/william0wang/zcode-acp).
+
+| Owner | Responsibility |
+| --- | --- |
+| Upstream bridge | ZCode protocol compatibility, ACP transport, native event translation and general session mechanics. |
+| Downstream bridge extensions | Expose native identity, evidence and control primitives missing upstream; preserve native errors and side-effect semantics. |
+| dd-zcode | Requested/observed profile checks, native-to-dd-flow identity mapping, event normalization, lifecycle forwarding, execution daemon ownership, cancellation/settlement verification and usage forwarding. |
+| dd-flow services | Durable lifecycle decisions, Work/RUN state and usage ingestion/accounting. |
+| dd-eval | Qualify the complete tuple, pin profiles/artifacts and run/monitor evaluations. |
+
+Native turn completion is evidence, not proof of semantic Work success. A
+closed transport is not proof that its native descendants stopped. The adapter
+must retain causal errors, missing observations and usage completeness rather
+than turn them into successful/zero-valued results.
+
+The bridge marks heuristic ACP completion with
+`_meta.zcodeCompletionEvidence: "inferred"` and exhausted failed turns with
+`"failed"`. dd-zcode rejects these before any post-turn materializing read:
+inferred means `native_outcome_unknown` (not retryable automatically), failed
+means `zcode_turn_not_completed`. This additive evidence does not change the
+acceptance of already-qualified immutable older tuples. Native allocation
+notifications are causal identity evidence, not authorization to replay a turn.
+
+## Bridge contract
+
+The identity check uses `--dd-harness-version` (`dd-zcode-harness@1` for existing
+qualified builds, `dd-zcode-harness@2` for the qualified v0.46.7 bridge) and
+`--dd-harness-commit`, alongside native and bridge versions. This is the current
+mechanism, not a general capability negotiation protocol. `zcodeLifecycleQualification`
+also admits exact native-binary SHA / bridge-commit tuples; a new tuple requires
+behavioral evidence before admission. Merely changing an allowlist is not that
+evidence.
+
+The adapter consumes `zcode/session/resolve`, `read`, `subagents`, `usage`,
+`close`, `resident` and `retainedSubagents`, plus standard/existing session
+operations. Resolution must preserve the session's trusted workspace.
+Residency and retained-tree reads after close must not implicitly resume it.
+Cancellation must target owned sessions and verify resulting tree state.
+Profile facts must come from native readback. Session updates supply tool events.
+The adapter forwards a standalone public lifecycle command to `dd-flow zcode
+event handle`; native Session/tool identity binds it to the one exact issued
+assignment in that daemon scope. The command never exposes the runtime-owned
+invocation ID. Its shell inherits `DD_FLOW_DAEMON_ID`, finds the assignment and
+waits for the committed receipt before any lifecycle mutation can execute.
+
+The execution-scoped daemon preserves the live native handles needed for
+background children. Inspection remains available during productive operations;
+a lost owner cannot be repaired by pretending retained topology is a live tree.
+Keep process identity, native identity and adapter control locator distinct.
+
+## Usage and contract @2
+
+The @2 bridge returns native usage unchanged. `lib/zcode-usage.mjs` reads native
+session evidence and computes request counters in the adapter. It deduplicates
+identified requests, rejects conflicting/invalid measurements and records read
+failures as incomplete evidence. Full history is required for cumulative usage;
+turn-liveness history limits must not be applied here. Immutable @1 bridges
+remain supported through their existing measured projection. All adapter usage
+paths use the same helper; dd-flow services still own accounting deltas.
+
+Contract support does not admit a new binary/commit tuple automatically. The
+v0.46.7 @2 tuple is admitted for native SHA `500ae84f…f466` or the ZCode
+Desktop 3.14.3 SHA `b1df2ef3…dad529`, with bridge commit `f4d47b5…2833`.
+The latter passed the published beta.99 public-command probe on 2026-09-23:
+root and two concurrent child Work starts/finishes, plus same-child continuation,
+all with durable native identity receipts. Preserve that
+fail-closed distinction when preparing later evals.
+
+Future consumer-only retry, recovery, readiness and accounting rules belong
+here or in the owning dd-flow service. Bridge changes are justified when native
+access or protocol mechanics cannot be implemented through its public interface.
+Review existing patches individually; do not claim that all policy has already
+been extracted from the bridge.
+
+## Verification and operations
+
+Relevant adapter regressions include `test/zcode-invocation-observer.test.ts`;
+select the additional daemon, usage and lifecycle tests affected by a change.
+Bridge tests check transport facts; adapter tests check their interpretation;
+live qualification checks the actual installed tuple. Release the adapter with
+dd-flow when adapter code or qualification admission changes. A bridge-only
+update does not inherently require an adapter release, but current exact-commit
+admission may require one.
+
+Follow the [ZCode upgrade runbook](https://github.com/deksden-com/dd-eval/blob/main/runbooks/update-zcode.md)
+for release discovery, qualification, rollout and rollback. Fork patch maintenance
+is documented in the fork itself. Neither procedure is duplicated here.
+
+Adapter changes use short-lived `feat/`, `fix/` or `docs/` branches from `main`,
+reviewed with affected checks before integration (normally squash merge).
+Releases identify verified immutable artifacts, not moving main HEAD. See the
+[cross-repository Git workflow](https://github.com/deksden-com/dd-eval/blob/main/runbooks/git-workflow.md)
+for upgrade ordering, candidate acceptance and hotfixes. Branch-protection
+configuration is separate from this documented policy.

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

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+import { durableDaemonStart, inspectDaemonOperation, interruptDaemonOperation, settleDaemonOperation } from "../lib/daemon-operations.mjs";
+import { readFile } from "node:fs/promises";
+import { invokeNativeHook } from "../lib/native-hook-command.mjs";
+import { doctor } from "../lib/dd-agy.mjs";
+import { callDaemon, serveDaemon, startDaemon, stopDaemon } from "../lib/dd-agy-daemon.mjs";
+
+function parse(argv) { const positional = [], options = {}; for (let i = 0; i < argv.length; i += 1) { const token = argv[i]; if (!token.startsWith("--")) { positional.push(token); continue; } const key = token.slice(2); if (["json","cancel-tree","tree","no-flow"].includes(key)) options[key] = true; else { if (argv[i + 1] === undefined) throw new Error(`--${key} requires a value`); options[key] = argv[++i]; } } return { positional, options }; }
+const prompt = async options => options["prompt-file"] ? await readFile(options["prompt-file"], "utf8") : options.prompt;
+async function stdin() { let value = ""; process.stdin.setEncoding("utf8"); for await (const chunk of process.stdin) value += chunk; return value; }
+async function hook(options) {
+  const payload = JSON.parse(await stdin() || "{}"), event = options.event;
+  const identity = await callDaemon(options["state-dir"], "hook.observe", { event, payload }, 10_000);
+  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 ?? "" } : {}) };
+    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 });
+  }
+  return event === "PreToolUse" ? { decision: "allow" } : {};
+}
+
+try {
+  const { positional, options } = parse(process.argv.slice(2)), [family, command, modifier] = positional; const common = { journal: options.journal, stateDir: options["state-dir"], cwd: options.cwd, bin: options["agy-bin"], provider: options.provider, model: options.model, reasoning: options.reasoning, mode: options.mode, projectRoot: options["project-root"], ddFlowBin: options["dd-flow-bin"], ddFlowHome: options["dd-flow-home"], noFlow: options["no-flow"] === true, timeoutMs: options.timeout ? Number(options.timeout) * 1000 : undefined }; let result;
+  if (family === "doctor") result = await doctor(common);
+  else if (family === "daemon" && command === "start") result = await durableDaemonStart({ ...common, sessionId: options["session-id"], entryPath: process.argv[1] }, startDaemon);
+  else if (family === "daemon" && command === "serve") { await serveDaemon(common.stateDir); process.exit(0); }
+  else if (family === "daemon" && command === "status") result = await callDaemon(common.stateDir, "daemon.status");
+  else if (family === "daemon" && command === "operation" && modifier === "interrupt") result = await interruptDaemonOperation(common.stateDir, options["operation-id"], { control_id: options["control-id"], stop_operation_id: options["stop-operation-id"], daemon_id: options["daemon-id"], session_id: options["session-id"], evidence: options.evidence ? JSON.parse(options.evidence) : null });
+  else if (family === "daemon" && command === "operation" && modifier === "settle") result = await settleDaemonOperation(common.stateDir, options["operation-id"]);
+  else if (family === "daemon" && command === "operation") result = await inspectDaemonOperation(common.stateDir, options["operation-id"]);
+  else if (family === "daemon" && command === "stop") result = await stopDaemon({ stateDir: common.stateDir, cancelTree: options["cancel-tree"], timeoutMs: common.timeoutMs });
+  else if (family === "hook" && command === "handle") { process.stdout.write(`${JSON.stringify(await hook(options))}\n`); process.exit(0); }
+  else if (family === "session") { if (command === "fork") throw Object.assign(new Error("Antigravity native headless fork is unsupported; use deterministic_replay"), { code: "agy_headless_fork_unsupported" }); const operation = command === "status" ? "inspect" : command; result = await callDaemon(common.stateDir, `session.${operation}`, { sessionId: options["session-id"], ...(command === "create" || command === "prompt" ? { prompt: await prompt(options) } : {}), tree: options.tree === true }, common.timeoutMs ?? 1_800_000); }
+  else throw new Error("usage: dd-agy doctor | daemon start|status|stop | session create|prompt|inspect|resume|cancel|fork [options] --json");
+  process.stdout.write(`${JSON.stringify({ ok: true, ...result })}\n`);
+} catch (error) { if (process.argv.includes("hook") && process.argv.includes("handle")) { process.stdout.write(`${JSON.stringify({ decision: "deny", reason: error.code ?? "agy_hook_rejected" })}\n`); process.exit(0); } process.stderr.write(`${JSON.stringify({ ok: false, error: error.message, ...(error.code ? { code: error.code, retryable: error.retryable === true, details: error.details } : {}) })}\n`); process.exit(1); }

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

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+import { durableDaemonStart, inspectDaemonOperation, interruptDaemonOperation, settleDaemonOperation } from "../lib/daemon-operations.mjs";
+import { cancelSession, createSession, doctor, inspectSession, promptFromFile, promptSession, startSession } from "../lib/dd-codex.mjs";
+import { callDaemon, serveDaemon, startDaemon, stopDaemon } from "../lib/dd-codex-daemon.mjs";
+
+function parse(argv) { const positional = []; const options = {}; for (let i = 0; i < argv.length; i += 1) { const token = argv[i]; if (!token.startsWith("--")) { positional.push(token); continue; } const key = token.slice(2); if (["json", "cancel-tree", "no-flow"].includes(key)) { options[key] = true; continue; } const value = argv[++i]; if (value === undefined) throw new Error(`--${key} requires a value`); options[key] = value; } return { positional, options }; }
+function common(options) { return { bin: options["codex-bin"], journal: options.journal, stateDir: options["state-dir"], cwd: options.cwd, sessionId: options["session-id"], turnId: options["turn-id"], model: options.model, reasoning: options.reasoning, ddFlowBin: options["dd-flow-bin"], ddFlowHome: options["dd-flow-home"], projectRoot: options["project-root"], noFlow: options["no-flow"] === true, timeoutMs: options.timeout ? Number(options.timeout) * 1000 : undefined }; }
+try {
+  const { positional, options } = parse(process.argv.slice(2)); const [family, command, modifier] = positional; const shared = common(options); let result;
+  if (family === "doctor") result = await doctor(shared);
+  else if (family === "daemon" && command === "start") result = await durableDaemonStart({ ...shared, entryPath: process.argv[1] }, startDaemon);
+  else if (family === "daemon" && command === "serve") { await serveDaemon(shared.stateDir); process.exit(0); }
+  else if (family === "daemon" && command === "status") result = await callDaemon(shared.stateDir, "daemon.status");
+  else if (family === "daemon" && command === "operation" && modifier === "interrupt") result = await interruptDaemonOperation(shared.stateDir, options["operation-id"], { control_id: options["control-id"], stop_operation_id: options["stop-operation-id"], daemon_id: options["daemon-id"], session_id: options["session-id"], evidence: options.evidence ? JSON.parse(options.evidence) : null });
+  else if (family === "daemon" && command === "operation" && modifier === "settle") result = await settleDaemonOperation(shared.stateDir, options["operation-id"]);
+  else if (family === "daemon" && command === "operation") result = await inspectDaemonOperation(shared.stateDir, options["operation-id"]);
+  else if (family === "daemon" && command === "stop") result = await stopDaemon({ ...shared, cancelTree: options["cancel-tree"] });
+  else if (family === "session" && command === "create") result = shared.stateDir ? await callDaemon(shared.stateDir, "session.create", shared) : await createSession(shared);
+  else if (family === "session" && command === "prompt") result = shared.stateDir ? await callDaemon(shared.stateDir, "session.prompt", { ...shared, prompt: options["prompt-file"] ? await promptFromFile(options["prompt-file"]) : options.prompt }, shared.timeoutMs ?? 1_800_000) : await promptSession({ ...shared, prompt: options["prompt-file"] ? await promptFromFile(options["prompt-file"]) : options.prompt });
+  else if (family === "session" && command === "start") result = shared.stateDir ? await callDaemon(shared.stateDir, "session.start", { ...shared, prompt: options["prompt-file"] ? await promptFromFile(options["prompt-file"]) : options.prompt }, shared.timeoutMs ?? 30_000) : await startSession({ ...shared, prompt: options["prompt-file"] ? await promptFromFile(options["prompt-file"]) : options.prompt });
+  else if (family === "session" && ["inspect", "status", "resume"].includes(command)) result = shared.stateDir ? await callDaemon(shared.stateDir, command === "resume" ? "session.resume" : "session.inspect", shared) : await inspectSession(shared);
+  else if (family === "session" && command === "cancel") result = shared.stateDir ? await callDaemon(shared.stateDir, "session.cancel", shared) : await cancelSession(shared);
+  else throw new Error("usage: dd-codex doctor | daemon start|status|stop | session create|start|prompt|inspect|status|resume|cancel [--json]");
+  process.stdout.write(`${JSON.stringify({ ok: true, ...result })}\n`);
+} catch (error) { process.stderr.write(`${JSON.stringify({ ok: false, error: error.message, ...(error.code ? { code: error.code } : {}) })}\n`); process.exit(1); }

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

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+import { durableDaemonStart, inspectDaemonOperation, interruptDaemonOperation, settleDaemonOperation } from "../lib/daemon-operations.mjs";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import os from "node:os";
+import path from "node:path";
+import { DROID_CONTRACT, DROID_PROTOCOL, DroidRuntime, droidVersion } from "../lib/dd-droid.mjs";
+import { callDaemon, serveDaemon, startDaemon, stopDaemon } from "../lib/dd-droid-daemon.mjs";
+import { errorRecord } from "../lib/operation-errors.mjs";
+
+function parse(argv) { const positional = [], options = {}; for (let i = 0; i < argv.length; i++) { const word = argv[i]; if (!word.startsWith("--")) { positional.push(word); continue; } const key = word.slice(2); if (["json", "cancel-tree", "tree", "no-flow"].includes(key)) options[key] = true; else { if (argv[i + 1] === undefined) throw new Error(`${word} requires a value`); options[key] = argv[++i]; } } return { positional, options }; }
+async function input() { let text = ""; for await (const chunk of process.stdin) text += chunk; return text; }
+try {
+  const { positional: [family, command, modifier], options } = parse(process.argv.slice(2));
+  const config = { stateDir: options["state-dir"], sessionId: options["session-id"], cwd: options.cwd, projectRoot: options["project-root"], bin: options["droid-bin"] ?? "droid", entryPath: process.argv[1], journal: options.journal, authHome: options["auth-home"], model: options.model, provider: options.provider, reasoning: options.reasoning, mode: options.mode, ddFlowBin: options["dd-flow-bin"], ddFlowHome: options["dd-flow-home"], noFlow: options["no-flow"] === true, timeoutMs: options.timeout ? Number(options.timeout) * 1_000 : undefined };
+  let result;
+  if (family === "doctor") {
+    const dir = await mkdtemp(path.join(os.tmpdir(), "dd-droid-doctor-"));
+    const runtime = new DroidRuntime({ ...config, stateDir: dir, home: path.join(dir, "home"), cwd: config.cwd ?? process.cwd(), journal: path.join(dir, "events.jsonl"), daemonId: randomUUID(), ddFlowHome: null, ddFlowBin: null }, {}, async () => {});
+    try { await runtime.start(); result = { harness: "droid-cli", observed_runtime: { droid: await droidVersion(config.bin), factory_protocol: runtime.protocol, dd_harness_contract: DROID_CONTRACT }, models: runtime.models.map(model => model.id ?? model.modelId), capabilities: { native_children: true, tree_cancel: true, selective_child_cancel: false, native_fork: false }, protocol_expected: DROID_PROTOCOL }; }
+    finally { await runtime.closeTree(true); await rm(dir, { recursive: true, force: true }); }
+  } else if (family === "daemon" && command === "start") result = await durableDaemonStart(config, startDaemon);
+  else if (family === "daemon" && command === "serve") { await serveDaemon(config.stateDir); process.exit(0); }
+  else if (family === "daemon" && command === "status") result = await callDaemon(config.stateDir, "daemon.status");
+  else if (family === "daemon" && command === "operation" && modifier === "interrupt") result = await interruptDaemonOperation(config.stateDir, options["operation-id"], { control_id: options["control-id"], stop_operation_id: options["stop-operation-id"], daemon_id: options["daemon-id"], session_id: options["session-id"], evidence: options.evidence ? JSON.parse(options.evidence) : null });
+  else if (family === "daemon" && command === "operation" && modifier === "settle") result = await settleDaemonOperation(config.stateDir, options["operation-id"]);
+  else if (family === "daemon" && command === "operation") result = await inspectDaemonOperation(config.stateDir, options["operation-id"]);
+  else if (family === "daemon" && command === "stop") result = await stopDaemon({ stateDir: config.stateDir, cancelTree: options["cancel-tree"] });
+  else if (family === "hook" && command === "handle") { const payload = JSON.parse(await input()); const eventId = randomUUID(); result = await callDaemon(config.stateDir, "hook.observe", { payload, eventId }, 25_000, eventId); }
+  else if (family === "session") { if (command === "fork") throw new Error("Droid fork is not qualified for this adapter"); const prompt = options["prompt-file"] ? await readFile(options["prompt-file"], "utf8") : options.prompt; result = await callDaemon(config.stateDir, `session.${command === "status" ? "inspect" : command}`, { sessionId: options["session-id"], ...(config.noFlow ? { noFlow: true } : {}), ...(prompt ? { prompt } : {}) }); }
+  else throw new Error("usage: dd-droid doctor | daemon start|status|operation|stop | session create|resume|prompt|inspect|cancel");
+  process.stdout.write(`${JSON.stringify(family === "hook" ? { ...(result.hookSpecificOutput ? { hookSpecificOutput: result.hookSpecificOutput } : {}), ...(typeof result.continue === "boolean" ? { continue: result.continue } : {}), ...(result.stopReason ? { stopReason: result.stopReason } : {}) } : { ok: true, ...result })}\n`);
+} catch (error) { process.stderr.write(`${JSON.stringify({ ok: false, error: errorRecord(error) })}\n`); process.exitCode = process.argv[2] === "hook" ? 2 : 1; }

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

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+import { durableDaemonStart, inspectDaemonOperation, interruptDaemonOperation, settleDaemonOperation } from "../lib/daemon-operations.mjs";
+import { invokeNativeHook } from "../lib/native-hook-command.mjs";
+import { cancelSession, createSession, doctor, forkSession, inspectSession, promptFromFile, promptSession } from "../lib/dd-grok.mjs";
+import { callDaemon, serveDaemon, startDaemon, stopDaemon } from "../lib/dd-grok-daemon.mjs";
+
+function parse(argv) { const positional = []; const options = {}; for (let index = 0; index < argv.length; index += 1) { const token = argv[index]; if (!token.startsWith("--")) { positional.push(token); continue; } const key = token.slice(2); if (["json", "cancel-tree", "no-flow"].includes(key)) { options[key] = true; continue; } const value = argv[++index]; if (value === undefined) throw new Error(`--${key} requires a value`); options[key] = value; } return { positional, options }; }
+function common(options) { return { bin: options["grok-bin"], journal: options.journal, stateDir: options["state-dir"], cwd: options.cwd, sessionId: options["session-id"], model: options.model, reasoning: options.reasoning, mode: options.mode ?? "bypassPermissions", authPath: options["auth-path"], authMethodId: options["auth-method-id"], ddFlowBin: options["dd-flow-bin"], ddFlowHome: options["dd-flow-home"], projectRoot: options["project-root"], sessionArchive: options["session-archive"], noFlow: options["no-flow"] === true, timeoutMs: options.timeout ? Number(options.timeout) * 1000 : undefined }; }
+async function readStdin() { let value = ""; process.stdin.setEncoding("utf8"); for await (const chunk of process.stdin) value += chunk; return value; }
+async function hook(options) {
+  const stdin = await readStdin(); const payload = JSON.parse(stdin || "{}"); const identity = await callDaemon(options["state-dir"], "hook.resolve", { sessionId: payload.sessionId ?? payload.session_id });
+  const enriched = { ...payload, _meta: { ...(payload._meta ?? {}), ddGrok: identity } }; const args = ["grok", "event", "handle", "--project-root", options["project-root"], "--json"]; const command = options["dd-flow-bin"];
+  return invokeNativeHook({ bin: command, args, home: options["dd-flow-home"], payload: enriched });
+}
+
+try {
+  const { positional, options } = parse(process.argv.slice(2)); const [family, command, modifier] = positional; const shared = common(options); let result;
+  if (family === "doctor") result = await doctor(shared);
+  else if (family === "daemon" && command === "start") result = await durableDaemonStart({ ...shared, entryPath: process.argv[1] }, startDaemon);
+  else if (family === "daemon" && command === "serve") { await serveDaemon(shared.stateDir); process.exit(0); }
+  else if (family === "daemon" && command === "status") result = await callDaemon(shared.stateDir, "daemon.status");
+  else if (family === "daemon" && command === "operation" && modifier === "interrupt") result = await interruptDaemonOperation(shared.stateDir, options["operation-id"], { control_id: options["control-id"], stop_operation_id: options["stop-operation-id"], daemon_id: options["daemon-id"], session_id: options["session-id"], evidence: options.evidence ? JSON.parse(options.evidence) : null });
+  else if (family === "daemon" && command === "operation" && modifier === "settle") result = await settleDaemonOperation(shared.stateDir, options["operation-id"]);
+  else if (family === "daemon" && command === "operation") result = await inspectDaemonOperation(shared.stateDir, options["operation-id"]);
+  else if (family === "daemon" && command === "stop") result = await stopDaemon({ stateDir: shared.stateDir, cancelTree: options["cancel-tree"], timeoutMs: shared.timeoutMs });
+  else if (family === "hook" && command === "handle") { process.stdout.write(`${JSON.stringify(await hook(options))}\n`); process.exit(0); }
+  else if (family === "session") { const params = { ...shared, ...(command === "create" || command === "prompt" ? { prompt: options["prompt-file"] ? await promptFromFile(options["prompt-file"]) : options.prompt } : {}), ...(command === "fork" ? { target: JSON.parse(options["target-json"] ?? "null") } : {}), ...(command === "archive" ? { archiveDir: options["archive-dir"] } : {}) }; if (shared.stateDir) result = await callDaemon(shared.stateDir, `session.${command === "status" ? "inspect" : command}`, params, shared.timeoutMs ?? 1_800_000); else if (command === "create") result = await createSession(params); else if (command === "prompt") result = await promptSession(params); else if (["inspect", "status", "resume"].includes(command)) result = await inspectSession(params); else if (command === "cancel") result = await cancelSession(params); else if (command === "fork") result = await forkSession(params); else throw new Error(`unknown session command: ${command}`); }
+  else throw new Error("usage: dd-grok doctor | daemon start|status|stop | session create|prompt|inspect|status|resume|cancel|fork|archive [options] --json");
+  process.stdout.write(`${JSON.stringify({ ok: true, ...result })}\n`);
+} catch (error) { if (process.argv[2] === "hook") { process.stdout.write(`${JSON.stringify({ decision: "deny", reason: error.message })}\n`); process.exit(2); } process.stderr.write(`${JSON.stringify({ ok: false, error: error.message, ...(error.code ? { code: error.code, retryable: error.retryable === true, details: error.details } : {}) })}\n`); process.exit(1); }

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

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+import { durableDaemonStart, inspectDaemonOperation, interruptDaemonOperation, settleDaemonOperation } from "../lib/daemon-operations.mjs";
+import { readFile } from "node:fs/promises";
+import { callDaemon, serveDaemon, startDaemon, stopDaemon } from "../lib/dd-opencode-daemon.mjs";
+
+function parse(argv) { const positional = [], options = {}; for (let i = 0; i < argv.length; i += 1) { const token = argv[i]; if (!token.startsWith("--")) { positional.push(token); continue; } const key = token.slice(2); if (["json","cancel-tree","no-flow"].includes(key)) options[key] = true; else { if (argv[i + 1] === undefined) throw new Error(`--${key} requires a value`); options[key] = argv[++i]; } } return { positional, options }; }
+const prompt = async options => options["prompt-file"] ? await readFile(options["prompt-file"], "utf8") : options.prompt;
+try {
+  const { positional, options } = parse(process.argv.slice(2)), [family, command, modifier] = positional; const common = { journal: options.journal, stateDir: options["state-dir"], sessionId: options["session-id"], cwd: options.cwd, bin: options["opencode-bin"], provider: options.provider, model: options.model, variant: options.variant, agent: options.agent, authPath: options["auth-path"], projectRoot: options["project-root"], ddFlowBin: options["dd-flow-bin"], ddFlowHome: options["dd-flow-home"], noFlow: options["no-flow"] === true, sessionArchive: options["session-archive"], timeoutMs: options.timeout ? Number(options.timeout) * 1000 : undefined }; let result;
+  if (family === "daemon" && command === "start") result = await durableDaemonStart({ ...common, entryPath: process.argv[1] }, startDaemon);
+  else if (family === "daemon" && command === "serve") { await serveDaemon(common.stateDir); process.exit(0); }
+  else if (family === "daemon" && command === "status") result = await callDaemon(common.stateDir, "daemon.status");
+  else if (family === "daemon" && command === "operation" && modifier === "interrupt") result = await interruptDaemonOperation(common.stateDir, options["operation-id"], { control_id: options["control-id"], stop_operation_id: options["stop-operation-id"], daemon_id: options["daemon-id"], session_id: options["session-id"], evidence: options.evidence ? JSON.parse(options.evidence) : null });
+  else if (family === "daemon" && command === "operation" && modifier === "settle") result = await settleDaemonOperation(common.stateDir, options["operation-id"]);
+  else if (family === "daemon" && command === "operation") result = await inspectDaemonOperation(common.stateDir, options["operation-id"]);
+  else if (family === "doctor") result = await callDaemon(common.stateDir, "daemon.doctor");
+  else if (family === "daemon" && command === "stop") result = await stopDaemon({ stateDir: common.stateDir, cancelTree: options["cancel-tree"], timeoutMs: common.timeoutMs });
+  else if (family === "session") { const operation = command === "status" ? "inspect" : command; const params = { sessionId: options["session-id"], title: options.title, messageId: options["message-id"], archiveFile: options["archive-file"], ...(command === "prompt" ? { prompt: await prompt(options) } : {}) }; result = await callDaemon(common.stateDir, `session.${operation}`, params, common.timeoutMs ?? 1_800_000); }
+  else throw new Error("usage: dd-opencode daemon start|status|stop | session create|prompt|inspect|fork|cancel|archive [options] --json");
+  process.stdout.write(`${JSON.stringify({ ok: true, ...result })}\n`);
+} catch (error) { process.stderr.write(`${JSON.stringify({ ok: false, error: error.message, ...(error.code ? { code: error.code, retryable: error.retryable === true, details: error.details } : {}) })}\n`); process.exit(1); }

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

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+import { durableDaemonStart, inspectDaemonOperation, interruptDaemonOperation, settleDaemonOperation } from "../lib/daemon-operations.mjs";
+import { invokeNativeHook } from "../lib/native-hook-command.mjs";
+import { cancelChild, cancelSession, createSession, doctor, forkSession, inspectSession, promptFromFile, promptSession } from "../lib/dd-zcode.mjs";
+import { callDaemon, serveDaemon, startDaemon, stopDaemon } from "../lib/dd-zcode-daemon.mjs";
+
+function parse(argv) {
+  const positional = []; const options = {};
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (!token.startsWith("--")) { positional.push(token); continue; }
+    const key = token.slice(2); if (["json", "cancel-tree", "no-flow"].includes(key)) { options[key] = true; continue; }
+    const value = argv[++index]; if (value === undefined) throw new Error(`--${key} requires a value`); options[key] = value;
+  }
+  return { positional, options };
+}
+
+function common(options) {
+  const seconds = (name) => {
+    if (options[name] === undefined) return undefined;
+    const value = Number(options[name]);
+    if (!Number.isFinite(value) || value <= 0) throw new Error(`--${name} must be a positive finite number of seconds`);
+    return value * 1000;
+  };
+  return {
+    bin: options["zcode-acp-bin"], zcodePath: options["zcode-path"], journal: options.journal,
+    stateDir: options["state-dir"],
+    cwd: options.cwd, sessionId: options["session-id"], adapterSessionId: options["adapter-session-id"], provider: options.provider,
+    childSessionId: options["child-session-id"],
+    model: options.model, reasoning: options.reasoning, mode: options.mode,
+    permission: options.permission ?? "deny", ddFlowBin: options["dd-flow-bin"],
+    ddFlowHome: options["dd-flow-home"], projectRoot: options["project-root"], noFlow: options["no-flow"] === true,
+    env: options["dd-flow-home"] ? { DD_FLOW_HOME: options["dd-flow-home"] } : undefined,
+    timeoutMs: seconds("timeout"),
+    livenessTimeoutMs: seconds("liveness-timeout"),
+    requestTimeoutMs: seconds("request-timeout"),
+  };
+}
+
+async function readStdin() { let value = ""; process.stdin.setEncoding("utf8"); for await (const chunk of process.stdin) value += chunk; return value; }
+async function hook(options) {
+  const payload = JSON.parse((await readStdin()) || "{}");
+  const identity = await callDaemon(options["state-dir"], "hook.resolve", { sessionId: payload.session_id ?? payload.sessionId });
+  const command = options["dd-flow-bin"]; const args = ["zcode", "hook", "handle", "--project-root", options["project-root"], "--json"];
+
+  return invokeNativeHook({ bin: command, args, home: options["dd-flow-home"], payload: { ...payload, _meta: { ...(payload._meta ?? {}), ddZcode: identity } } });
+}
+
+try {
+  const { positional, options } = parse(process.argv.slice(2)); const [family, command, modifier] = positional; let result;
+  const answers = options["answers-file"] ? JSON.parse(await promptFromFile(options["answers-file"])) : undefined;
+  const shared = common(options);
+  if (family === "doctor") result = await doctor(shared);
+  else if (family === "daemon" && command === "start") result = await durableDaemonStart({ ...shared, entryPath: process.argv[1] }, startDaemon);
+  else if (family === "daemon" && command === "serve") { await serveDaemon(shared.stateDir); process.exit(0); }
+  else if (family === "daemon" && command === "status") result = await callDaemon(shared.stateDir, "daemon.status");
+  else if (family === "daemon" && command === "operation" && modifier === "interrupt") result = await interruptDaemonOperation(shared.stateDir, options["operation-id"], { control_id: options["control-id"], stop_operation_id: options["stop-operation-id"], daemon_id: options["daemon-id"], session_id: options["session-id"], evidence: options.evidence ? JSON.parse(options.evidence) : null });
+  else if (family === "daemon" && command === "operation" && modifier === "settle") result = await settleDaemonOperation(shared.stateDir, options["operation-id"]);
+  else if (family === "daemon" && command === "operation") result = await inspectDaemonOperation(shared.stateDir, options["operation-id"]);
+  else if (family === "daemon" && command === "stop") result = await stopDaemon({ stateDir: shared.stateDir, cancelTree: options["cancel-tree"], timeoutMs: shared.timeoutMs });
+  else if (family === "hook" && command === "handle") { process.stdout.write(`${JSON.stringify(await hook(options))}\n`); process.exit(0); }
+  else if (family === "session") {
+    const params = { ...shared, answers, ...(command === "create" || command === "prompt" ? { prompt: options["prompt-file"] ? await promptFromFile(options["prompt-file"]) : options.prompt } : {}), ...(command === "fork" ? { target: JSON.parse(options["target-json"] ?? "null") } : {}) };
+    // The daemon owns the durable native-request deadline. A disposable RPC
+    // wait must not manufacture a second provider timeout.
+    const operation = `session.${command === "status" ? "inspect" : command}`;
+    const rpcTimeout = command === "prompt" && shared.timeoutMs === undefined
+      ? null
+      : (shared.timeoutMs ?? 1_800_000);
+    if (shared.stateDir) result = await callDaemon(shared.stateDir, operation, params, rpcTimeout);
+    else if (command === "create") result = await createSession(params);
+    else if (command === "prompt") result = await promptSession(params);
+    else if (["inspect", "status", "resume"].includes(command)) result = await inspectSession(params);
+    else if (command === "cancel") result = await cancelSession(params);
+    else if (command === "cancel-child") result = await cancelChild(params);
+    else if (command === "fork") result = await forkSession(params);
+    else throw new Error(`unknown session command: ${command}`);
+  } else throw new Error("usage: dd-zcode doctor | daemon start|status|stop | hook handle | session create|prompt|inspect|status|resume|cancel|cancel-child|fork [options] --json");
+  process.stdout.write(`${JSON.stringify({ ok: true, ...result })}\n`);
+} catch (error) {
+  if (process.argv[2] === "hook") { process.stdout.write(`${JSON.stringify({ decision: "deny", reason: error.message })}\n`); process.exit(2); }
+  process.stderr.write(`${JSON.stringify({ ok: false, error: error.message, ...(error.code ? { code: error.code, retryable: error.retryable === true, details: error.details } : {}) })}\n`); process.exit(1);
+}

package/dist/harness-runtime/lib/daemon-operations.mjs

@@ -0,0 +1,215 @@
+import { createHash } from "node:crypto";
+import { mkdir, readFile, link, unlink, open } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import path from "node:path";
+import { hashJson, writeJsonAtomic } from "./runner-events.mjs";
+import { errorRecord, isObservationLoss, reportedError } from "./operation-errors.mjs";
+import { assertDaemonOwnership, budgetObservationScope, releaseBudgetObservation, completeBudgetOperation } from "./managed-daemon.mjs";
+import { readModelObservations, modelAttribution } from "./model-observations.mjs";
+
+const productive = new Set(["session.create", "session.prompt", "session.start", "session.fork", "session.resume"]);
+const controls = new Map();
+const dispatchGenerations = new Map();
+
+async function controlDispatch(root, request, action) {
+  const key = request.operation === "daemon.stop" ? `stop:${request.params?.cancelTree === true}` : `cancel:${request.params?.sessionId ?? ""}`;
+  let pending = controls.get(root);
+  if (!pending) { pending = new Map(); controls.set(root, pending); }
+  if (pending.has(key)) return await pending.get(key);
+  // Preserve the adapter's identity check for every distinct cancel target.
+  // A stop arriving after cancel waits for its attempts before verification.
+  const predecessors = key.startsWith("stop:") ? [...pending.values()] : [];
+  const promise = (async () => { await Promise.allSettled(predecessors); return await action(); })();
+  pending.set(key, promise);
+  try { return await promise; }
+  finally { pending.delete(key); if (!pending.size) controls.delete(root); }
+}
+function location(root, id) {
+  if (typeof id !== "string" || !id) throw Object.assign(new Error("operation id is required"), { code: "operation_id_required" });
+  return path.join(root, "operations", createHash("sha256").update(id).digest("hex"));
+}
+async function read(file) { try { return JSON.parse(await readFile(file, "utf8")); } catch (error) { if (error.code === "ENOENT") return null; throw error; } }
+
+export async function inspectDaemonOperation(root, id) {
+  if (typeof root !== "string" || !path.isAbsolute(root)) throw Object.assign(new Error("operation observation requires an absolute state directory"), { code: "invalid_path" });
+  const directory = location(root, id);
+  const requested = await read(path.join(directory, "requested.json"));
+  if (!requested) throw Object.assign(new Error("daemon operation is not recorded"), { code: "operation_not_found", details: { operation_id: id } });
+  const settlement = await read(path.join(directory, "settlement.json"));
+  return { ...requested, ...(await read(path.join(directory, "result.json")) ?? await read(path.join(directory, "interrupted.json")) ?? await read(path.join(directory, "observation-lost.json")) ?? { state: "running" }), ...(settlement ? { settlement } : {}) };
+}
+
+/** Retry only the bookkeeping that follows a durable productive receipt.
+ * This is intentionally separate from dispatch: it never invokes a native
+ * prompt/create/fork operation, so recovery cannot duplicate agent work. */
+export async function settleDaemonOperation(root, id) {
+  const current = await inspectDaemonOperation(root, id);
+  if (current.state !== "completed") return current;
+  if (current.settlement?.state === "settled") return current;
+  let settlement;
+  try {
+    settlement = await completeBudgetOperation(root, {
+      id: current.operation_id,
+      operation: current.operation,
+      params: { sessionId: current.session_id ?? undefined }
+    }, current.result);
+  } catch (error) {
+    settlement = { state: "pending", reason: "settlement_error", observed_at: new Date().toISOString(), error: errorRecord(error) };
+  }
+  try { await writeSettlement(root, id, settlement); }
+  catch (error) {
+    settlement = { state: "blocked", reason: "settlement_storage_error", observed_at: new Date().toISOString(), error: errorRecord(error) };
+  }
+  return { ...current, settlement };
+}
+
+/** A sealed whole-tree stop is the only authority that may turn an unknown
+ * productive request into a terminal interruption.  This is deliberately a
+ * journal operation: a closed daemon cannot be asked to manufacture a reply. */
+export async function interruptDaemonOperation(root, id, barrier) {
+  if (!barrier || typeof barrier !== "object" || typeof barrier.control_id !== "string" || !barrier.control_id) throw Object.assign(new Error("interruption requires a sealed control identity"), { code: "stop_barrier_invalid" });
+  const current = await inspectDaemonOperation(root, id);
+  if (["completed", "failed", "interrupted"].includes(current.state)) return current;
+  if (!(["running", "awaiting_provider"].includes(current.state)) || !productive.has(current.operation)) throw Object.assign(new Error("only an observed productive operation may be interrupted"), { code: "operation_not_interruptible" });
+  // A lazy session/create is allowed to have no ACP/native session id yet.
+  // The owned daemon identity plus the sealed stop operation is the authority
+  // in that case; never manufacture a session id merely to satisfy the check.
+  const barrierSession = barrier.session_id ?? null;
+  const currentSession = current.session_id ?? null;
+  if (barrier.daemon_id !== current.daemon_id || barrierSession !== currentSession) throw Object.assign(new Error("interruption barrier belongs to another daemon operation"), { code: "stop_barrier_mismatch" });
+  const value = { state: "interrupted", outcome: "interrupted", observed_at: new Date().toISOString(), interrupted_by: { control_id: barrier.control_id, stop_operation_id: barrier.stop_operation_id, evidence: barrier.evidence ?? null }, error: { code: "operation_interrupted", message: "Operation was interrupted after the owned native tree was stopped", cause: current.error ?? null } };
+  const saved = await writeTerminal(root, id, value);
+  if (saved.state !== "interrupted" || saved.interrupted_by?.control_id !== barrier.control_id) throw Object.assign(new Error("operation already has a conflicting terminal outcome"), { code: "operation_terminal_conflict" });
+  return await inspectDaemonOperation(root, id);
+}
+
+/** At-most-once dispatch and a durable terminal reply, including when the socket
+ * observer disconnects. Recovery reads this receipt; it never resends a prompt. */
+export async function durableDaemonDispatch(root, request, action, observe) {
+  if (request.operation === "operation.inspect") return await inspectDaemonOperation(root, request.params?.operationId);
+  if (request.operation === "daemon.status") {
+    const result = await action();
+    if (!result?.config?.journal) return result;
+    try { return { ...result, model_attribution: modelAttribution(await readModelObservations(result.config.journal)) }; }
+    catch (error) { return { ...result, model_observation_error: errorRecord(error) }; }
+  }
+  if (request.operation === "session.inspect") {
+    const scope = await budgetObservationScope(root, request.params?.sessionId);
+    const result = await action();
+    let settlement;
+    if (!scope?.operationIds.length) settlement = { state: "not_required" };
+    else if (result?.settled !== true) settlement = { state: "pending", reason: "tree_unsettled" };
+    else try {
+      await releaseBudgetObservation(scope, result);
+      settlement = { state: "settled", operation_ids: scope.operationIds, source: "inspection" };
+    } catch (error) {
+      settlement = { state: "pending", reason: "settlement_error", observed_at: new Date().toISOString(), error: errorRecord(error) };
+    }
+    return settlement.state === "not_required" || !result || typeof result !== "object" || Array.isArray(result) ? result : { ...result, settlement };
+  }
+  const control = ["daemon.stop", "session.cancel"].includes(request.operation);
+  if (!productive.has(request.operation) && !control) return await action();
+  const generation = dispatchGenerations.get(root) ?? 0;
+  if (control) dispatchGenerations.set(root, generation + 1);
+  const assertCurrent = () => { if (generation !== (dispatchGenerations.get(root) ?? 0)) throw Object.assign(new Error("control cancelled a queued productive dispatch"), { code: "operation_cancelled" }); };
+  const result = await journalDispatch(root, request, async () => {
+    // Persist before admission so a racing fence can observe the writer.
+    if (!control) await assertDaemonOwnership(root, { "operation-id": request.id, operation: request.operation, "native-session-id": request.params?.sessionId, "prompt-sha256": typeof request.params?.prompt === "string" ? createHash("sha256").update(request.params.prompt).digest("hex") : undefined }, assertCurrent);
+    if (!control) assertCurrent();
+    return control ? await controlDispatch(root, request, action) : await action();
+  });
+  if (control) return result;
+  let settlement;
+  try {
+    settlement = await completeBudgetOperation(root, request, result, observe);
+  } catch (error) {
+    settlement = { state: "pending", reason: "settlement_error", observed_at: new Date().toISOString(), error: errorRecord(error) };
+  }
+  try { await writeSettlement(root, request.id, settlement); }
+  catch (error) {
+    settlement = { state: "blocked", reason: "settlement_storage_error", observed_at: new Date().toISOString(), error: errorRecord(error) };
+  }
+  return settlement?.state === "not_required" || !result || typeof result !== "object" || Array.isArray(result)
+    ? result
+    : { ...result, settlement };
+}
+
+async function writeSettlement(root, id, value) {
+  const directory = location(root, id);
+  await writeJsonAtomic(path.join(directory, "settlement.json"), value);
+}
+
+/** Startup has no registered daemon yet. Its existing native implementation
+ * owns registration/admission; only the CLI entrypoint uses this journal path. */
+export async function durableDaemonStart(options, action) {
+  const root = options.stateDir;
+  if (typeof root !== "string" || !path.isAbsolute(root)) throw Object.assign(new Error("daemon startup requires an absolute state directory"), { code: "invalid_path" });
+  // Keep only configuration locations, never inherited credentials. The owned
+  // scope can reuse this exact adapter launch after retiring the old daemon.
+  const launch = { schema_id: "dd-flow/native-launch@1", executable: options.entryPath ?? null, args: process.argv.slice(2), cwd: process.cwd(), runtime_owner: process.env.DD_FLOW_RUNTIME_OWNER ?? null,
+    env: Object.fromEntries(["CODEX_HOME", "DD_FLOW_CONFIG_HOME", "DD_FLOW_HOME", "DD_FLOW_BIN", "DD_FLOW_RESOURCE_HOME"].map(key => [key, process.env[key] ?? null])) };
+  const request = { id: process.env.DD_EVAL_OPERATION_ID ?? randomUUID(), operation: "daemon.start", params: { ...options, runtimeOwner: process.env.DD_FLOW_RUNTIME_OWNER ?? null, resourceHome: process.env.DD_FLOW_RESOURCE_HOME ?? null, launch } };
+  return await journalDispatch(root, request, () => action(options));
+}
+
+async function journalDispatch(root, request, action) {
+  const directory = location(root, request.id), fingerprint = hashJson({ operation: request.operation, params: request.params ?? {} });
+  await mkdir(directory, { recursive: true, mode: 0o700 });
+  // Publish a complete request atomically and exclusively. Writing directly with
+  // wx exposes a partially written JSON document to a concurrent observer.
+  const temporary = path.join(directory, `requested-${randomUUID()}.json`);
+  const daemon = await read(path.join(root, "daemon.json"));
+  const startup = request.operation === "daemon.start";
+  const daemonId = daemon?.daemon_id ?? daemon?.config?.daemonId ?? null;
+  await writeJsonAtomic(temporary, { schema_id: "dd-flow/daemon-operation@1", operation_id: request.id, operation: request.operation, session_id: request.params?.sessionId ?? null, daemon_id: startup ? null : daemonId, ...(startup ? { predecessor_daemon_id: daemonId, launch: request.params?.launch } : {}), params_sha256: fingerprint, requested_at: new Date().toISOString() });
+  try {
+    await link(temporary, path.join(directory, "requested.json"));
+  } catch (error) {
+    if (error.code !== "EEXIST") throw error;
+    const saved = await inspectDaemonOperation(root, request.id);
+    if (saved.params_sha256 !== fingerprint) throw Object.assign(new Error("operation id was reused with different parameters"), { code: "operation_conflict", details: { operation_id: request.id } });
+    if (saved.state === "completed") return saved.result;
+    if (["failed", "interrupted"].includes(saved.state)) throw reportedError(saved.error, "provider operation failed");
+    throw Object.assign(new Error("provider operation has no confirmed terminal result; inspect the existing operation instead of resending it"), { code: "operation_observation_lost", details: { operation_id: request.id, receipt_directory: directory } });
+  } finally { await unlink(temporary); }
+  let result;
+  try {
+    result = await action();
+  }
+  catch (error) {
+    const unknown = isObservationLoss(error);
+    if (unknown) await writeJsonAtomic(path.join(directory, "observation-lost.json"), { state: "awaiting_provider", observed_at: new Date().toISOString(), error: errorRecord(error) });
+    else {
+      const terminal = await writeTerminal(root, request.id, { state: "failed", observed_at: new Date().toISOString(), error: errorRecord(error) });
+      if (terminal.state !== "failed") throw reportedError(terminal.error, "provider operation did not retain this failure");
+    }
+    throw error;
+  }
+  try {
+    const terminal = await writeTerminal(root, request.id, { state: "completed", ...(startup ? { started_daemon_id: result?.daemon_id ?? null } : {}), finished_at: new Date().toISOString(), result });
+    if (terminal.state !== "completed") throw reportedError(terminal.error, "provider operation was terminalized before its late reply arrived");
+  } catch (cause) {
+    if (cause?.code === "operation_interrupted" || cause?.code === "operation_terminal_conflict") throw cause;
+    throw Object.assign(new Error("provider returned but the durable reply could not be saved; do not resend the operation"), { code: "operation_observation_lost", cause, details: { operation_id: request.id, receipt_directory: directory } });
+  }
+  return result;
+}
+
+/** `result.json` is the one exclusive terminal slot. Old interrupted.json
+ * files remain readable for compatibility, but new writes never race them. */
+async function writeTerminal(root, id, value) {
+  const file = path.join(location(root, id), "result.json");
+  const temporary = `${file}.${randomUUID()}.tmp`;
+  const handle = await open(temporary, "wx", 0o600);
+  try { await handle.writeFile(`${JSON.stringify(value, null, 2)}\n`); await handle.sync(); }
+  finally { await handle.close(); }
+  try {
+    await link(temporary, file);
+    return value;
+  } catch (error) {
+    if (error.code !== "EEXIST") throw error;
+    const saved = await read(file);
+    if (!saved || !["completed", "failed", "interrupted"].includes(saved.state)) throw Object.assign(new Error("operation terminal record is invalid"), { code: "operation_terminal_conflict" });
+    return saved;
+  } finally { await unlink(temporary); }
+}