@deksden-com/dd-flow-cli 0.9.0-beta.14 → 0.9.0-beta.141

package/dist/harness-runtime/OPENCODE-LICENSE.txt

@@ -0,0 +1,24 @@
+OpenCode 2.0.28 Promise client/plugin assets are copied unmodified by the build.
+Source: https://github.com/anomalyco/opencode/tree/v2.0.28
+
+MIT License
+
+Copyright (c) 2025 opencode
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

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

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+import { adapterTimeoutOptions } from "../lib/adapter-timeouts.mjs";
+import { durableDaemonStart, inspectDaemonOperation, interruptDaemonOperation, settleDaemonOperation } from "../lib/daemon-operations.mjs";
+import { readFile } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import path from "node:path";
+import { writeJsonAtomic } from "../lib/runner-events.mjs";
+import { hookBudget, invokeNativeHook, readNativeHookInput } from "../lib/native-hook-command.mjs";
+import { doctor } from "../lib/dd-agy.mjs";
+import { callDaemon, qualifyAgyHooks, 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 hook(options) {
+  const budget = hookBudget(), requestId = randomUUID();
+  const payload = JSON.parse(await readNativeHookInput(process.stdin, budget) || "{}"), event = options.event;
+  try {
+  const observationMs = budget.remaining("observation");
+  const identity = await callDaemon(options["state-dir"], "hook.observe", { event, payload, daemonId: options["daemon-id"], deadlineAt: budget.deadlineAt }, observationMs, requestId);
+  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, 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) });
+  }
+  return event === "PreToolUse" ? { decision: "allow" } : {};
+  } catch (error) {
+    // A failed socket cannot be used to report its own failure. The daemon
+    // reads only receipts matching request IDs it actually accepted this turn.
+    const correctable = event === "PreToolUse" && error.code === "lifecycle_shell_syntax_invalid" && error.details?.effect === "no_effect"
+      && error.details?.recoverable === true && error.details?.disposition === "pre_cli_shell_refusal";
+    try { await writeJsonAtomic(path.join(options["state-dir"], "hook-failures", `${requestId}.json`), { request_id: requestId, observed_at: new Date().toISOString(), code: error.code ?? "agy_hook_rejected", message: error.message,
+      details: { ...error.details, effect: correctable ? "no_effect" : "unknown", ...(correctable ? { native_pre_cli_refusal: true } : {}) } }); }
+    catch (storage) { process.stderr.write(`${JSON.stringify({ code: error.code, receipt_error: storage.message })}\n`); }
+    throw error;
+  }
+}
+
+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, ...adapterTimeoutOptions(options, family === "session" ? command : null) }; let result;
+  if (family === "doctor") result = await doctor(common);
+  else if (family === "hooks" && ["install", "check"].includes(command)) result = await qualifyAgyHooks(common.projectRoot, { stateDir: common.stateDir, install: command === "install" });
+  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"], livenessTimeoutMs: common.livenessTimeoutMs, ...(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 | hooks install|check | 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"}: ${error.message ?? "Native hook refused this tool call"}` })}\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,27 @@
+#!/usr/bin/env node
+import { adapterTimeoutOptions } from "../lib/adapter-timeouts.mjs";
+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";
+import { errorRecord } from "../lib/operation-errors.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, operation) { 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, ...adapterTimeoutOptions(options, operation) }; }
+try {
+  const { positional, options } = parse(process.argv.slice(2)); const [family, command, modifier] = positional; const shared = common(options, family === "session" ? command : null); 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) { const failure = errorRecord(error); process.stderr.write(`${JSON.stringify({ ok: false, error: failure.message, code: failure.code, ...(failure.details ? { details: failure.details } : {}), ...(failure.cause ? { cause: failure.cause } : {}) })}\n`); process.exit(1); }

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

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+import { adapterTimeoutOptions } from "../lib/adapter-timeouts.mjs";
+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";
+import { hookBudget, readNativeHookInput } from "../lib/native-hook-command.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 }; }
+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, ...adapterTimeoutOptions(options, family === "session" ? command : null, "droid-cli") };
+  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 budget = hookBudget(); const payload = JSON.parse(await readNativeHookInput(process.stdin, budget)); const eventId = randomUUID(); result = await callDaemon(config.stateDir, "hook.observe", { payload, eventId, deadlineAt: budget.deadlineAt }, budget.remaining("observation"), 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"], livenessTimeoutMs: config.livenessTimeoutMs, ...(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,40 @@
+#!/usr/bin/env node
+import { adapterTimeoutOptions } from "../lib/adapter-timeouts.mjs";
+import { durableDaemonStart, inspectDaemonOperation, interruptDaemonOperation, settleDaemonOperation } from "../lib/daemon-operations.mjs";
+import { hookBudget, invokeNativeHook, readNativeHookInput, writeNativeHookFailure } 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";
+import { errorRecord } from "../lib/operation-errors.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, operation) { 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, ...adapterTimeoutOptions(options, operation) }; }
+async function hook(options) {
+  const budget = hookBudget();
+  const stdin = await readNativeHookInput(process.stdin, budget); const payload = JSON.parse(stdin || "{}"); const identity = await callDaemon(options["state-dir"], "hook.resolve", { sessionId: payload.sessionId ?? payload.session_id, payload }, budget.remaining("identity"));
+  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"];
+  try { return await invokeNativeHook({ bin: command, args, home: options["dd-flow-home"], payload: enriched, timeoutMs: budget.remaining("admission", 15_000) }); }
+  catch (error) {
+    if (identity.nativeHookBinding) error.details = { ...error.details, native_hook_binding: identity.nativeHookBinding };
+    try {
+      await writeNativeHookFailure(options["state-dir"], identity.nativeHookBinding, error, hookBudget(1_000, null));
+      if (identity.nativeHookBinding) await callDaemon(options["state-dir"], "hook.failed", { requestId: identity.nativeHookBinding.request_id }, 1_000);
+    } catch (storage) { process.stderr.write(`${JSON.stringify({ code: error.code, receipt_error: storage.message })}\n`); }
+    throw error;
+  }
+}
+
+try {
+  const { positional, options } = parse(process.argv.slice(2)); const [family, command, modifier] = positional; const shared = common(options, family === "session" ? command : null); 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.stderr.write(`${JSON.stringify({ native_hook_failure: errorRecord(error), bound: Boolean(error.details?.native_hook_binding) })}\n`); process.stdout.write(`${JSON.stringify({ decision: "deny", reason: error.message })}\n`); process.exit(2); } const failure = errorRecord(error); process.stderr.write(`${JSON.stringify({ ok: false, error: failure.message, ...failure })}\n`); process.exit(1); }

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

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+import { adapterTimeoutOptions } from "../lib/adapter-timeouts.mjs";
+import { durableDaemonStart, inspectDaemonOperation, interruptDaemonOperation, settleDaemonOperation } from "../lib/daemon-operations.mjs";
+import { readFile } from "node:fs/promises";
+import { callDaemon, doctor, openCodeProfileOptions, 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, ...openCodeProfileOptions(options), authPath: options["auth-path"], configPath: options["config-path"], projectRoot: options["project-root"], ddFlowBin: options["dd-flow-bin"], ddFlowHome: options["dd-flow-home"], noFlow: options["no-flow"] === true, sessionArchive: options["session-archive"], ...adapterTimeoutOptions(options, family === "session" ? command : null) }; 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 doctor(common);
+  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 = { livenessTimeoutMs: common.livenessTimeoutMs, 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,87 @@
+#!/usr/bin/env node
+import { adapterTimeoutOptions } from "../lib/adapter-timeouts.mjs";
+import { durableDaemonStart, inspectDaemonOperation, interruptDaemonOperation, settleDaemonOperation } from "../lib/daemon-operations.mjs";
+import { hookBudget, invokeNativeHook, readNativeHookInput, writeNativeHookFailure } 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";
+import { errorRecord } from "../lib/operation-errors.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, operation) {
+  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,
+    ...adapterTimeoutOptions(options, operation),
+  };
+}
+
+async function hook(options) {
+  const budget = hookBudget();
+  const payload = JSON.parse((await readNativeHookInput(process.stdin, budget)) || "{}");
+  const identity = await callDaemon(options["state-dir"], "hook.resolve", { sessionId: payload.session_id ?? payload.sessionId, payload }, budget.remaining("identity"));
+  const command = options["dd-flow-bin"]; const args = ["zcode", "hook", "handle", "--project-root", options["project-root"], "--json"];
+
+  try { return await invokeNativeHook({ bin: command, args, home: options["dd-flow-home"], timeoutMs: budget.remaining("admission", 15_000), payload: { ...payload, _meta: { ...(payload._meta ?? {}), ddZcode: identity } } }); }
+  catch (error) {
+    if (identity.nativeHookBinding) error.details = { ...error.details, native_hook_binding: identity.nativeHookBinding };
+    try {
+      // The 25s work budget leaves this bounded 2s evidence tail inside the
+      // qualified 30s native hook limit, even after the work deadline expired.
+      await writeNativeHookFailure(options["state-dir"], identity.nativeHookBinding, error, hookBudget(1_000, null));
+      if (identity.nativeHookBinding) await callDaemon(options["state-dir"], "hook.failed", { requestId: identity.nativeHookBinding.request_id }, 1_000);
+    } catch (storage) { process.stderr.write(`${JSON.stringify({ code: error.code, receipt_error: storage.message })}\n`); }
+    throw error;
+  }
+}
+
+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, family === "session" ? command : null);
+  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.stderr.write(`${JSON.stringify({ native_hook_failure: errorRecord(error), bound: Boolean(error.details?.native_hook_binding) })}\n`); process.stdout.write(`${JSON.stringify({ decision: "deny", reason: error.message })}\n`); process.exit(2); }
+  const failure = errorRecord(error); process.stderr.write(`${JSON.stringify({ ok: false, error: failure.message, ...failure })}\n`); process.exit(1);
+}

package/dist/harness-runtime/lib/adapter-timeouts.d.mts

@@ -0,0 +1,5 @@
+export const NATIVE_OPERATION_WAIT_CONTRACT: "native-operation-wait@1";
+export function canonicalNativeOperation(harness: string, operation: string): string;
+export function nativeOperationWait(harness: string, operation: string): "native-work" | "control";
+export function validateDaemonWait(harness: string, operation: string, duration: number | null): void;
+export function adapterTimeoutOptions(options: Record<string, unknown>, operation?: string | null, harness?: string): { timeoutMs?: number; livenessTimeoutMs?: number; requestTimeoutMs?: number };

package/dist/harness-runtime/lib/adapter-timeouts.mjs

@@ -0,0 +1,34 @@
+// Public work flags express silence, never the lifetime of a native Turn.
+import { validateObservationDuration } from "./observation-clock.mjs";
+export const NATIVE_OPERATION_WAIT_CONTRACT = "native-operation-wait@1";
+// Grok's resume only inspects its retained native Session. Other adapters
+// materialize that Session, so their original operation remains productive.
+export function canonicalNativeOperation(harness, operation) {
+  return ["grok", "grok-acp"].includes(harness) && operation === "session.resume" ? "session.inspect" : operation;
+}
+// Only Droid's start waits for the full Turn. Codex start returns acceptance;
+// the other bundled adapters do not expose start as a productive operation.
+export function nativeOperationWait(harness, operation) {
+  operation = canonicalNativeOperation(harness, operation);
+  return operation === "session.prompt" || ["droid", "droid-cli"].includes(harness) && operation === "session.start" ? "native-work" : "control";
+}
+export function validateDaemonWait(harness, operation, duration) {
+  if (duration === null && nativeOperationWait(harness, operation) === "native-work") return;
+  validateObservationDuration(duration, "daemon control duration");
+}
+
+export function adapterTimeoutOptions(options, operation, harness) {
+  const duration = name => {
+    if (options[name] === undefined) return undefined;
+    const ms = Number(options[name]) * 1_000;
+    if (!Number.isInteger(ms) || ms < 1 || ms > 2_147_483_647) throw Object.assign(new Error(`--${name} requires positive finite seconds within the timer range`), { code: "invalid_timeout" });
+    return ms;
+  };
+  const timeoutMs = duration("timeout"), livenessTimeoutMs = duration("liveness-timeout"), requestTimeoutMs = duration("request-timeout");
+  if (operation === "prompt" || nativeOperationWait(harness, `session.${operation}`) === "native-work") {
+    if (timeoutMs !== undefined && livenessTimeoutMs !== undefined && timeoutMs !== livenessTimeoutMs) throw Object.assign(new Error("--timeout and --liveness-timeout must agree for session.prompt"), { code: "invalid_timeout" });
+    if (requestTimeoutMs !== undefined) throw Object.assign(new Error("--request-timeout cannot limit a productive prompt"), { code: "invalid_timeout" });
+    return { timeoutMs: undefined, livenessTimeoutMs: livenessTimeoutMs ?? timeoutMs };
+  }
+  return { timeoutMs, livenessTimeoutMs, requestTimeoutMs };
+}

package/dist/harness-runtime/lib/agy-hooks.d.mts

@@ -0,0 +1 @@
+export function agyWorkspaceHooks(): Record<string, unknown>;

package/dist/harness-runtime/lib/agy-hooks.mjs

@@ -0,0 +1,9 @@
+// Qualified hooks are stable; only the launching process selects its pinned
+// entrypoint and daemon. Keep this document shared with product-file policy.
+export function agyWorkspaceHooks() {
+  const command = '"${DD_AGY_HOOK_NODE:?missing AGY hook binding}" "${DD_AGY_HOOK_ENTRY:?missing AGY hook binding}" hook handle --event __EVENT__ --state-dir "${DD_AGY_STATE_DIR:?missing AGY hook binding}" --daemon-id "${DD_AGY_DAEMON_ID:?missing AGY hook binding}" --json';
+  return { "dd-flow": {
+    PreToolUse: [{ matcher: "^run_command$", hooks: [{ type: "command", command: command.replace("__EVENT__", "PreToolUse"), timeout: 30 }] }],
+    Stop: [{ type: "command", command: command.replace("__EVENT__", "Stop"), timeout: 30 }]
+  } };
+}

package/dist/harness-runtime/lib/daemon-observation.d.mts

@@ -0,0 +1,2 @@
+export function recoverDaemonReply(root: string, id: string, options?: { timeoutMs?: number | null; signal?: AbortSignal; binding?: Record<string, unknown>; onProgress?: (value: Record<string, unknown>) => void; onOutcome?: (value: Record<string, unknown>) => void; onPendingSettlement?: (value: Record<string, unknown>) => Promise<void>; observationClock?: import("./observation-clock.mjs").ObservationClock }): Promise<Record<string, unknown>>;
+export function retainedDaemonReply(root: string, id: string, binding?: Record<string, unknown>): Promise<{ ready: boolean; outcome: unknown; value?: unknown; settlement?: Record<string, unknown> | null; reason?: string } | null>;

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

@@ -0,0 +1,163 @@
+import net from 'node:net';
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { hashJson, writeJsonAtomic } from './runner-events.mjs';
+import { ObservationClock } from './observation-clock.mjs';
+import { canonicalNativeOperation, nativeOperationWait, validateDaemonWait } from './adapter-timeouts.mjs';
+import { assertNativeLine, retainNativeReplyBuffer } from './native-streams.mjs';
+import { operationDirectory, readOperationRecord, readOperationProgress, readOperationWaiting, suspendOperationClock } from './operation-progress.mjs';
+
+const productive = new Set(['session.create', 'session.prompt', 'session.start', 'session.fork', 'session.resume']);
+const fault = (code, message, details) => Object.assign(new Error(message), { code, retryable: false, details });
+export async function retainedDaemonReply(root, id, binding = {}) {
+  const requested = await readOperationRecord(root, id, 'requested.json');
+  if (!requested) return null;
+  if (requested.operation_id !== id || Object.entries(binding).some(([key, value]) => (requested[key] ?? null) !== (value ?? null))) throw fault('operation_conflict', 'retained operation differs from dispatched request', { operation_id: id });
+  const terminal = await readOperationRecord(root, id, 'result.json');
+  if (!terminal) return null;
+  if (['operation_id','daemon_id','operation','params_sha256','owner_id','generation'].some(field=>Object.hasOwn(terminal,field)&&(terminal[field] ?? null)!==(requested[field] ?? null))) throw fault('operation_conflict','native outcome binding differs from original operation',{operation_id:id});
+  if (terminal.state !== 'completed') throw Object.assign(new Error(terminal.error?.message ?? 'native operation failed'), terminal.error);
+  if (Number.isSafeInteger(requested.generation)) try {
+    const fence = JSON.parse(await readFile(path.join(root,'operation-fence.json'),'utf8'));
+    if (fence.daemon_id === requested.daemon_id && fence.generation > requested.generation) throw fault('operation_cancelled','continuation is fenced by newer control',{operation_id:id,native_result:terminal.result});
+  } catch(error) { if (error.code !== 'ENOENT') throw error; }
+  const settlement = await readOperationRecord(root, id, 'settlement.json');
+  try {
+    const daemon = JSON.parse(await readFile(path.join(root,'daemon.json'),'utf8'));
+    if ((daemon.daemon_id ?? daemon.config?.daemonId ?? null)!==requested.daemon_id || (daemon.config?.runtime_owner?.owner_id ?? null)!==(requested.owner_id ?? null) || ['stopping','clean','unclean','cleanup_failed','failed'].includes(daemon.shutdown_state)) return {ready:false,outcome:terminal.result,settlement,reason:'daemon_authority_changed'};
+    if (requested.owner_id) try { process.kill(daemon.pid,0); } catch { return {ready:false,outcome:terminal.result,settlement,reason:'daemon_owner_dead'}; }
+  } catch(error) { if(error.code!=='ENOENT') throw error; if(requested.daemon_id || requested.owner_id) return {ready:false,outcome:terminal.result,settlement,reason:'daemon_absent'}; }
+  if (!['settled', 'not_required'].includes(settlement?.state)) return { ready: false, outcome: terminal.result, settlement };
+  return { ready: true, outcome: terminal.result, settlement, value: settlement.state === 'not_required' ? terminal.result : { ...terminal.result, settlement } };
+}
+export async function recoverDaemonReply(root, id, { timeoutMs = 30_000, signal, binding = {}, onProgress = () => {}, onOutcome = () => {}, onPendingSettlement, observationClock } = {}) {
+  const saved = observationClock ? null : await readOperationRecord(root, id, 'observer-recovery.json') ?? await readOperationRecord(root, id, 'observer-transport.json');
+  signal?.throwIfAborted();
+  const clock = observationClock ?? new ObservationClock({ timeoutMs: saved?.timeout_ms ?? timeoutMs, saved });
+  let lastSequence = clock.progress ?? 0, lastSaved = 0, latestProgress, settlementAttempted = false, settlementError;
+  const exhaustedCursor = clock.progress;
+  let exhausted = clock.observationLost || clock.elapsed >= clock.timeoutMs;
+  for (;;) {
+    signal?.throwIfAborted();
+    const retained = await retainedDaemonReply(root, id, binding);
+    signal?.throwIfAborted();
+    if (retained) {
+      onOutcome(retained.outcome);
+      signal?.throwIfAborted();
+      if (retained.ready) return retained.value;
+    }
+    const progress = await readOperationProgress(root, id, binding);
+    signal?.throwIfAborted();
+    if (progress && progress.sequence > lastSequence) {
+      lastSequence = progress.sequence;
+      const observedAt = Date.parse(progress.observed_at);
+      // The outer cursor counts diagnostics, not durable sequences. A handoff
+      // may recognize a higher sequence with the same already-observed event.
+      if (clock.progressAt === null || observedAt > clock.progressAt) {
+        latestProgress={cursor:progress.sequence,observed_at:observedAt}; onProgress(progress);
+      }
+    }
+    const waiting = await readOperationWaiting(root,id,binding);
+    signal?.throwIfAborted();
+    if (waiting) suspendOperationClock(clock);
+    const sampled = waiting ? false : clock.sample(latestProgress);
+    if (clock.progress !== exhaustedCursor && clock.elapsed < clock.timeoutMs && !clock.observationLost) exhausted = false;
+    const expired = !waiting && (exhausted || sampled);
+    if ((expired || Date.now() - lastSaved >= 1_000) && await readOperationRecord(root,id,'requested.json')) { await writeJsonAtomic(path.join(operationDirectory(root,id),'observer-recovery.json'),clock.state()); lastSaved = Date.now(); }
+    if (expired) {
+      const final = await retainedDaemonReply(root, id, binding);
+      signal?.throwIfAborted();
+      if (final?.ready) return final.value;
+      throw fault(final ? 'settlement_reconciliation_required' : 'operation_observation_lost', 'original operation has no dispatch-ready reply', { operation_id: id, native_outcome: final ? 'completed' : 'unknown', native_result: final?.outcome, settlement: final?.settlement, reason:final?.reason, ...(settlementError ? { settlement_error:settlementError } : {}), state_dir: root });
+    }
+    if (retained && onPendingSettlement && !settlementAttempted && !retained.reason) {
+      settlementAttempted = true;
+      try { await onPendingSettlement(retained); } catch (error) { settlementError = {code:error.code,message:error.message}; }
+      signal?.throwIfAborted();
+      continue;
+    }
+    await new Promise(resolve => setTimeout(resolve, Math.min(100, timeoutMs / 4)));
+  }
+}
+export async function callDaemonObserved({ stateDir, socket, request, responseSchema, harness, timeoutMs }) {
+  request = { ...request, operation: canonicalNativeOperation(harness, request.operation) };
+  validateDaemonWait(harness, request.operation, timeoutMs);
+  assertNativeLine(JSON.stringify(request), 'request');
+  const durable = productive.has(request.operation);
+  const binding = { operation: request.operation, params_sha256: hashJson({ operation: request.operation, params: request.params ?? {} }) };
+  let initialDaemon;
+  if (durable) try {
+    const state = JSON.parse(await readFile(path.join(stateDir,'daemon.json'),'utf8'));
+    initialDaemon = state.daemon_id ?? state.config?.daemonId ?? null;
+    binding.owner_id = state.config?.runtime_owner?.owner_id ?? null;
+  } catch (error) { if (error.code !== 'ENOENT') throw error; }
+  // Reject a reused ID with different inputs before opening a transport.
+  // Otherwise its retained progress can win the race with the daemon's
+  // conflict reply and misclassify a valid old receipt as corrupt progress.
+  if (durable) await retainedDaemonReply(stateDir, request.id, {
+    ...binding, ...(initialDaemon === undefined ? {} : { daemon_id: initialDaemon })
+  });
+  const savedClock = durable ? await readOperationRecord(stateDir,request.id,'observer-transport.json') : null;
+  return await new Promise((resolve, reject) => {
+    const client = net.createConnection(socket);
+    let buffer = '', done = false, polling = false, pollFlight, lastSequence = savedClock?.cursor ?? 0, frozenDaemon = initialDaemon, disconnected = false, latestProgress, lastSaved = 0;
+    const bound = () => ({ ...binding, ...(frozenDaemon === undefined ? {} : { daemon_id: frozenDaemon }) });
+    const nativeWork = nativeOperationWait(harness, request.operation) === 'native-work';
+    let clock = nativeWork ? null : new ObservationClock({ timeoutMs, saved: savedClock });
+    const finish = (error, result) => { if (done) return; done = true; clearInterval(timer); client.destroy(); void Promise.resolve(pollFlight).then(() => error ? reject(error) : resolve(result)); };
+    const reconcile = async error => {
+      if (done) return;
+      try {
+        const reply = durable ? await retainedDaemonReply(stateDir, request.id, bound()) : null;
+        if (reply?.ready) return finish(null, reply.value);
+        if (reply) error = fault('settlement_reconciliation_required', 'native outcome retained; dispatch readiness is not confirmed', { operation_id: request.id, native_outcome: 'completed', native_result: reply.outcome, settlement: reply.settlement, reason:reply.reason, state_dir: stateDir });
+        else if (durable) error = fault(error.code, error.message, { ...error.details, operation_id: request.id, native_outcome: 'unknown', state_dir: stateDir });
+        finish(error);
+      } catch (cause) { finish(cause); }
+    };
+    const poll = () => {
+      if (done || polling) return pollFlight; polling = true;
+      pollFlight = (async () => {
+      try {
+        const progress = durable ? await readOperationProgress(stateDir, request.id, { ...binding, ...(frozenDaemon === undefined ? {} : { daemon_id: frozenDaemon }) }) : null;
+        if (done) return;
+        if (progress && progress.sequence > lastSequence) {
+          frozenDaemon ??= progress.daemon_id; lastSequence = progress.sequence;
+          binding.generation ??= progress.generation;
+          latestProgress = {cursor:progress.sequence,observed_at:Date.parse(progress.observed_at)};
+          process.stderr.write(`${JSON.stringify({ kind: 'operation_progress', ...progress })}\n`);
+        }
+        if (durable && disconnected) {
+          const reply = await retainedDaemonReply(stateDir, request.id, bound());
+          if (reply?.ready) return finish(null, reply.value);
+        }
+        const waiting = durable && await readOperationWaiting(stateDir,request.id,bound());
+        if (done) return;
+        if (clock && waiting) suspendOperationClock(clock);
+        const expired = !waiting && clock?.sample(latestProgress ?? (durable ? undefined : buffer.length || undefined));
+        if (durable && clock && (expired || Date.now()-lastSaved>=1_000) && await readOperationRecord(stateDir,request.id,'requested.json')) { await writeJsonAtomic(path.join(operationDirectory(stateDir,request.id),'observer-transport.json'),clock.state()); lastSaved=Date.now(); }
+        if (expired) await reconcile(fault('daemon_timeout', `${request.operation} timed out`));
+      } catch (error) { finish(error); } finally { polling = false; }
+      })();
+      return pollFlight;
+    };
+    const timer = setInterval(poll, Math.max(1, Math.min(100, (timeoutMs ?? 400) / 4)));
+    client.setEncoding('utf8'); client.on('connect', () => client.write(`${JSON.stringify(request)}\n`));
+    const lost = error => { if (durable) { disconnected = true; clock ??= new ObservationClock({timeoutMs: timeoutMs ?? 30_000,saved:savedClock}); void poll(); } else void reconcile(error); };
+    client.on('error', error => lost(fault('daemon_not_running', error.message)));
+    client.on('end', () => lost(fault('daemon_connection_closed', 'daemon closed before reply')));
+    client.on('close', () => lost(fault('daemon_connection_closed', 'daemon closed before reply')));
+    client.on('data', chunk => { void (async () => {
+      buffer += chunk; if (!retainNativeReplyBuffer(buffer, finish)) return;
+      const at = buffer.indexOf('\n'); if (at < 0) return;
+      try {
+        const response = JSON.parse(buffer.slice(0, at));
+        if (response.schema_id !== responseSchema || response.id !== request.id) throw fault('operation_observation_lost', 'daemon reply identity mismatch');
+        if (!response.ok) return finish(Object.assign(new Error(response.error?.message ?? 'daemon operation failed'), response.error));
+        if (durable && (binding.owner_id && !response.result?.settlement || response.result?.settlement && !['settled','not_required'].includes(response.result.settlement.state))) { disconnected = true; clock ??= new ObservationClock({timeoutMs:savedClock?.timeout_ms ?? timeoutMs ?? 30_000,saved:savedClock}); void poll(); return; }
+        if (durable) { const retained=await retainedDaemonReply(stateDir,request.id,bound()); if(retained) { if(retained.ready) return finish(null,retained.value); disconnected=true; clock ??= new ObservationClock({timeoutMs:timeoutMs ?? 30_000,saved:savedClock}); void poll(); return; } return void reconcile(fault('operation_observation_lost','productive native reply has no durable original receipt')); }
+        finish(null, response.result);
+      } catch (error) { void reconcile(error.code ? error : Object.assign(fault('operation_observation_lost', 'daemon reply could not be decoded', {native_outcome:'unknown'}), {cause:error})); }
+    })(); });
+  });
+}

package/dist/harness-runtime/lib/daemon-operations.d.mts

@@ -0,0 +1 @@
+export function inspectDaemonOperation(root: string, id: string): Promise<Record<string, unknown>>;