@deksden-com/dd-flow-cli 0.9.0-beta.13 → 0.9.0-beta.134

package/dist/cli/runtime-maintenance-diagnostics.js

@@ -0,0 +1,46 @@
+import { channel } from "node:diagnostics_channel";
+import { AsyncLocalStorage } from "node:async_hooks";
+const requests = new AsyncLocalStorage();
+export function isRuntimeMaintenance(args) {
+    return args[0] === "runtime" && args[1] === "process" && ["register", "heartbeat", "confirm", "admission", "finish", "check-admission", "release-turn", "status"].includes(args[2] ?? "");
+}
+export const withMaintenanceDiagnosticScope = (action) => requests.run(Symbol(), action);
+/** Request-local, bounded evidence; never command bytes, paths or lease tokens. */
+export function runtimeMaintenanceDiagnostics(args, deadline, write) {
+    const started = performance.now();
+    const request = requests.getStore();
+    const option = (name) => { const at = args.indexOf(`--${name}`); return at < 0 ? undefined : args[at + 1]; };
+    const safe = (value) => typeof value === "string" && /^[A-Za-z0-9:._-]{1,128}$/.test(value) ? value : undefined;
+    const identity = { action: safe(args[2]), process_id: safe(option("id")), operation_id: safe(option("operation-id") ?? option("operation")), native_dispatch_started: false };
+    let previous = "", count = 0, committed = false;
+    const phase = (name, details = {}) => {
+        const key = `${details.store_kind ?? ""}:${name}`;
+        if (key === previous || count >= 64)
+            return;
+        previous = key;
+        count++;
+        write(`${JSON.stringify({ kind: "process_maintenance_phase", ...identity, phase: name, elapsed_ms: Math.round(performance.now() - started), ...(deadline !== undefined ? { remaining_ms: Math.max(0, deadline - Date.now()) } : {}), ...details, ...(["ack", "failed"].includes(name) ? { maintenance_effect: committed ? "committed" : name === "ack" ? "no_mutation_observed" : "unknown" } : {}) })}\n`);
+    };
+    const timing = channel("dd-flow.sqlite.ingress");
+    const log = (message) => {
+        if (requests.getStore() !== request)
+            return;
+        const record = message;
+        if (record.phase === "committed" && record.store_kind === "resource")
+            committed = true;
+        phase(record.phase, { ...(record.store_kind ? { store_kind: record.store_kind } : {}) });
+    };
+    timing.subscribe(log);
+    phase("request", { maintenance_effect: "unknown" });
+    return { phase, failure: (error) => {
+            let current = error;
+            let sqlite;
+            for (let depth = 0; current && depth < 8; depth++) {
+                sqlite = current.errcode ?? current.sqlite_extended_code ?? current.details?.sqlite_extended_code;
+                if (Number.isSafeInteger(sqlite))
+                    break;
+                current = (current.cause ?? current.details?.cause);
+            }
+            phase("failed", { ...(Number.isSafeInteger(sqlite) ? { sqlite_extended_code: sqlite } : {}) });
+        }, close: () => timing.unsubscribe(log) };
+}

package/dist/cli/runtime-maintenance-ingress.js

@@ -0,0 +1,52 @@
+import { isRuntimeMaintenance, runtimeMaintenanceDiagnostics, withMaintenanceDiagnosticScope } from "./runtime-maintenance-diagnostics.js";
+import { errorRecord, isAppError } from "../shared/errors.js";
+import { writeJson } from "../shared/json.js";
+/** Only the already-selected engine's internal JSON transport takes this path.
+ * Operator calls and richer output formats retain the ordinary engine router. */
+export function isRuntimeMaintenanceIngress(args, env) {
+    return env.DD_FLOW_ENGINE_MODE === "1" && Number.isFinite(Number(env.DD_FLOW_HOOK_DEADLINE_AT))
+        && Number(env.DD_FLOW_HOOK_DEADLINE_AT) > 0 && args.includes("--json")
+        && isRuntimeMaintenance(args)
+        && !args.some(arg => ["--help", "-h", "--progress-jsonl", "--response-file"].includes(arg) || arg.startsWith("--response-file="));
+}
+export async function runRuntimeMaintenanceIngress(args, env = process.env, io = { stdout: process.stdout, stderr: process.stderr }) {
+    return withMaintenanceDiagnosticScope(async () => {
+        const deadline = Number(env.DD_FLOW_HOOK_DEADLINE_AT);
+        // Publish evidence before loading even the maintenance service graph.
+        const diagnostics = runtimeMaintenanceDiagnostics(args, deadline, line => io.stderr.write(line));
+        let context;
+        try {
+            const [{ createContext }, { prepareCommandRoute }, { resolveCommandProjectRoot, resolveCommandPaths }, processCommands, { preflightCliCompatibility }] = await Promise.all([
+                import("../runtime/context.js"), import("./command-inputs.js"), import("../services/command-context.js"), import("./runtime-process.js"),
+                import("../services/compatibility-preflight.js")
+            ]);
+            diagnostics.phase("imports_ready");
+            const invocation = args.filter(arg => arg !== "--json");
+            const options = { databaseDeadlineAt: deadline, resourceDatabaseMode: args[2] === "register" ? "initialize" : args[2] === "status" ? "read_existing" : "prepared_existing" };
+            context = createContext({ ...env, DD_FLOW_INVOCATION_READONLY: args[2] === "status" ? "1" : undefined }, "read_existing", undefined, options);
+            const root = resolveCommandProjectRoot(context, invocation, null);
+            const routedArgs = resolveCommandPaths(context, invocation, root);
+            const route = prepareCommandRoute(routedArgs);
+            const prepared = processCommands.prepareRuntimeProcess(context, route.key, route.parsed);
+            // Preserve the common compatibility gate; this is not a second dispatch
+            // implementation or permission granted by the ingress predicate.
+            await preflightCliCompatibility(context, routedArgs, env, root);
+            const result = await processCommands.dispatchRuntimeProcess(context, args[2], route.parsed, prepared);
+            const receipt = result;
+            const expiry = receipt?.lease_expires_at ?? receipt?.process?.lease_expires_at;
+            diagnostics.phase("ack", { ...(expiry && Number.isFinite(Date.parse(expiry)) ? { lease_expires_at: expiry } : {}) });
+            writeJson(io.stdout, result);
+            return 0;
+        }
+        catch (error) {
+            diagnostics.failure(error);
+            const record = errorRecord(error);
+            writeJson(io.stderr, { ok: false, error: { ...record, details: { ...(!isAppError(error) ? { effect: "unknown" } : {}), ...record.details } } });
+            return record.exitCode;
+        }
+        finally {
+            context?.db.close?.();
+            diagnostics.close();
+        }
+    });
+}

package/dist/cli/runtime-process.js

@@ -0,0 +1,153 @@
+import { AppError } from "../shared/errors.js";
+import { requiredOption, optionalOption, optionalNumber, optionalPositiveNumber } from "./argument-values.js";
+import { prepareError } from "./input-preparation.js";
+import { recoveryGuard, assertRunMutationAllowed } from "../services/run-recovery-guard.js";
+import { recoveryRuntimeAdmission } from "../services/run-recovery-guard.js";
+import { prepareManagedProcessRegistration, prepareManagedProcessConfirmation, prepareManagedProcessHeartbeat, prepareManagedProcessFinish, prepareManagedProcessStopOperation, prepareManagedProcessReconcile, stopManagedProcess, confirmManagedProcess, finishManagedProcess, renewManagedProcess, assertManagedProcessAdmission, managedProcessRuntimeHome, managedProcessStatus, processIsAlive, reconcileExpiredManagedProcesses, registerManagedProcess } from "../services/managed-processes.js";
+import { admitRuntimeCheck, parseRuntimeBudget, reserveProviderTurn, releaseProviderTurns, prepareProviderTurnRelease } from "../services/runtime-budget.js";
+import { managedProcessBinding, resourceHome } from "../services/managed-processes.js";
+function runtimeProcessStopInput(parsed) {
+    const graceMs = optionalNumber(parsed, "grace-ms");
+    return { id: requiredOption(parsed, "id"), leaseToken: requiredOption(parsed, "lease-token"), ...(graceMs !== undefined ? { graceMs } : {}) };
+}
+function runtimeProcessRegistrationInput(context, parsed) {
+    const leaseMs = optionalPositiveNumber(parsed, "lease-ms", true);
+    const budget = parseRuntimeBudget(optionalOption(parsed, "budget-json"));
+    const kind = requiredOption(parsed, "kind");
+    const projectId = optionalOption(parsed, "project-id") ?? null, runId = optionalOption(parsed, "run") ?? null;
+    const guard = projectId && runId ? recoveryGuard(context, projectId, runId) : null;
+    const run = projectId && runId ? context.db.get("SELECT id FROM runs WHERE project_id = ? AND id = ?", [projectId, runId]) : null;
+    return {
+        ...(optionalOption(parsed, "id") ? { id: optionalOption(parsed, "id") } : {}), kind, ownerId: requiredOption(parsed, "owner"), uniqueActiveOperation: kind === "eval-observer",
+        ...(kind === "eval-observer" ? { pid: optionalPositiveNumber(parsed, "pid", true) ?? 0, ...(optionalPositiveNumber(parsed, "process-group-id", true) ? { processGroupId: optionalPositiveNumber(parsed, "process-group-id", true) } : {}) } : {}),
+        ownerPid: optionalPositiveNumber(parsed, "owner-pid", true), projectId, runId,
+        workId: optionalOption(parsed, "work") ?? null, checkId: optionalOption(parsed, "check") ?? null,
+        operationId: optionalOption(parsed, "operation") ?? null, stdoutPath: optionalOption(parsed, "stdout") ?? null,
+        stderrPath: optionalOption(parsed, "stderr") ?? null, ...(leaseMs !== undefined ? { leaseMs } : {}),
+        metadata: { ...(budget ? { budget, harness: optionalOption(parsed, "harness") ?? null } : {}), ...(projectId && runId ? { run_generation: guard?.generation ?? 0, run_admitted: Boolean(run) && !["draining", "sealed", "resuming"].includes(guard?.status ?? "") } : {}), ...(optionalOption(parsed, "dispatch-barrier") ? { dispatch_barrier: optionalOption(parsed, "dispatch-barrier") } : {}), ...(optionalOption(parsed, "role") ? { role: optionalOption(parsed, "role") } : {}), ...(optionalOption(parsed, "state-dir") ? { state_dir: optionalOption(parsed, "state-dir") } : {}), ...(optionalOption(parsed, "adapter-executable") ? { adapter_executable: optionalOption(parsed, "adapter-executable") } : {}) }
+    };
+}
+function runtimeProcessConfirmationInput(parsed) {
+    const leaseMs = optionalPositiveNumber(parsed, "lease-ms", true), processGroupId = optionalPositiveNumber(parsed, "process-group-id", true);
+    return { id: requiredOption(parsed, "id"), leaseToken: requiredOption(parsed, "lease-token"), ownerPid: optionalPositiveNumber(parsed, "owner-pid", true), pid: optionalPositiveNumber(parsed, "pid", true) ?? 0, ...(processGroupId !== undefined ? { processGroupId } : {}), ...(leaseMs !== undefined ? { leaseMs } : {}) };
+}
+function runtimeProcessHeartbeatInput(parsed) {
+    const leaseMs = optionalPositiveNumber(parsed, "lease-ms", true);
+    return { id: requiredOption(parsed, "id"), leaseToken: requiredOption(parsed, "lease-token"), ...(leaseMs !== undefined ? { leaseMs } : {}) };
+}
+function runtimeProcessFinishInput(parsed) {
+    const state = requiredOption(parsed, "state");
+    if (state !== "stopped" && state !== "failed")
+        throw new AppError("validation", "--state must be stopped or failed", 2);
+    return { id: requiredOption(parsed, "id"), leaseToken: requiredOption(parsed, "lease-token"), state, reason: optionalOption(parsed, "reason") ?? null };
+}
+export function prepareRuntimeProcess(context, key, parsed) {
+    try {
+        return prepareRuntimeProcessInput(context, key, parsed);
+    }
+    catch (error) {
+        return prepareError(error);
+    }
+}
+function prepareRuntimeProcessInput(context, key, parsed) {
+    const prepared = {};
+    if (key === "runtime process register") {
+        prepareManagedProcessRegistration(context, runtimeProcessRegistrationInput(context, parsed));
+    }
+    if (key === "runtime process heartbeat")
+        prepareManagedProcessHeartbeat(context, runtimeProcessHeartbeatInput(parsed));
+    if (key === "runtime process finish")
+        prepareManagedProcessFinish(context, runtimeProcessFinishInput(parsed));
+    if (key === "runtime process confirm")
+        prepareManagedProcessConfirmation(context, runtimeProcessConfirmationInput(parsed));
+    if (key === "runtime process stop")
+        prepareManagedProcessStopOperation(context, runtimeProcessStopInput(parsed));
+    if (key === "runtime process reconcile")
+        prepareManagedProcessReconcile(requiredOption(parsed, "owner"), optionalNumber(parsed, "grace-ms"));
+    if (key === "runtime process release-turn") {
+        prepared.providerTurnRelease = prepareProviderTurnRelease({ daemonId: requiredOption(parsed, "daemon-id"), operationId: optionalOption(parsed, "operation-id"), observationFile: optionalOption(parsed, "observation-file") });
+    }
+    return prepared;
+}
+export async function dispatchRuntimeProcess(context, action, parsed, prepared = {}) {
+    if (action === "check-admission")
+        return { ok: true, ...admitRuntimeCheck(context, requiredOption(parsed, "id"), requiredOption(parsed, "lease-token")) };
+    if (action === "stop")
+        return { ok: true, process: await stopManagedProcess(context, runtimeProcessStopInput(parsed)) };
+    if (action === "register") {
+        const process = registerManagedProcess(context, runtimeProcessRegistrationInput(context, parsed));
+        return { ok: true, process };
+    }
+    if (action === "confirm")
+        return { ok: true, process: confirmManagedProcess(context, runtimeProcessConfirmationInput(parsed)) };
+    if (action === "heartbeat") {
+        const hash = optionalOption(parsed, "registration-sha256");
+        if (hash) {
+            const record = managedProcessStatus(context).find(value => value.id === requiredOption(parsed, "id"));
+            if (!/^[a-f0-9]{64}$/.test(hash) || !record || managedProcessBinding(record, resourceHome(context)).registration_sha256 !== hash)
+                throw new AppError("process_maintenance_receipt_invalid", "Heartbeat registration changed", 1);
+        }
+        const receipt = renewManagedProcess(context, runtimeProcessHeartbeatInput(parsed));
+        return { ...receipt, ok: receipt.owned };
+    }
+    if (action === "admission") {
+        const [{ controllerHitlAdmission }, { assertCapacityOwnerAdmission }] = await Promise.all([import("../services/run-controller-adapter.js"), import("../services/codex-capacity.js")]);
+        const record = managedProcessStatus(context).find(process => process.id === requiredOption(parsed, "id"));
+        if (!record || record.lease_token !== requiredOption(parsed, "lease-token") || record.owner_id !== requiredOption(parsed, "owner") || record.state !== "running" || !record.pid || !record.pid_started_at || !processIsAlive(record))
+            throw new AppError("process_ownership_unknown", "Productive dispatch requires its current confirmed runtime owner", 1);
+        assertManagedProcessAdmission(context, record);
+        const metadata = JSON.parse(record.metadata_json);
+        if (metadata.state_dir !== requiredOption(parsed, "state-dir"))
+            throw new AppError("process_ownership_unknown", "Runtime admission belongs to another state directory", 1);
+        if (record.project_id && record.run_id) {
+            if (managedProcessRuntimeHome(record, context) !== context.ddFlowHome)
+                throw new AppError("process_runtime_scope_mismatch", "Runtime admission belongs to another or unproven flow home", 1);
+            const recovering = recoveryRuntimeAdmission(context, record, { stateDir: requiredOption(parsed, "state-dir"), daemonId: optionalOption(parsed, "daemon-id"), operationId: optionalOption(parsed, "operation-id"), operation: optionalOption(parsed, "operation"), nativeSessionId: optionalOption(parsed, "native-session-id"), promptSha256: optionalOption(parsed, "prompt-sha256") });
+            if (!recovering) {
+                if (metadata.run_admitted !== true || !Number.isSafeInteger(metadata.run_generation))
+                    throw new AppError("run_recovery_guarded", "Runtime was not admitted before the RUN fence; reconcile its launch", 1);
+                assertRunMutationAllowed(context, record.project_id, record.run_id, metadata.run_generation);
+            }
+            const run = context.db.get("SELECT status FROM runs WHERE project_id = ? AND id = ?", [record.project_id, record.run_id]);
+            const retainedHitlPrompt = recovering && ["paused", "waiting_for_user"].includes(run?.status ?? "") && ["session.prompt", "session.resume"].includes(optionalOption(parsed, "operation") ?? "") && context.db.get("SELECT 1 FROM run_recovery_bindings b JOIN run_recovery_guards g ON g.recovery_id = b.recovery_id WHERE g.project_id = ? AND g.run_id = ? AND g.generation = ? AND b.daemon_id = ? AND b.provider_session_id = ?", [record.project_id, record.run_id, metadata.run_generation, optionalOption(parsed, "daemon-id"), optionalOption(parsed, "native-session-id")]);
+            const acceptedHitlPrompt = ["paused", "waiting_for_user"].includes(run?.status ?? "") && controllerHitlAdmission(context, record, { stateDir: requiredOption(parsed, "state-dir"), operationId: optionalOption(parsed, "operation-id"), operation: optionalOption(parsed, "operation"), nativeSessionId: optionalOption(parsed, "native-session-id"), promptSha256: optionalOption(parsed, "prompt-sha256") });
+            if (!run || run.status !== "running" && !retainedHitlPrompt && !acceptedHitlPrompt && !["judge", "probe"].includes(metadata.role ?? ""))
+                throw new AppError("invalid_run_state", "Subject dispatch requires a running RUN or its retained recovery/HITL prompt", 1);
+            if (!recovering)
+                assertCapacityOwnerAdmission(context, record, optionalOption(parsed, "operation-id"), { nativeSessionId: optionalOption(parsed, "native-session-id"), promptSha256: optionalOption(parsed, "prompt-sha256") });
+        }
+        const budget = reserveProviderTurn(context, record, { operationId: optionalOption(parsed, "operation-id") ?? "", operation: optionalOption(parsed, "operation") ?? "", sessionId: optionalOption(parsed, "native-session-id"), daemonId: optionalOption(parsed, "daemon-id"), promptSha256: optionalOption(parsed, "prompt-sha256") });
+        return { ok: true, ...budget, process_id: record.id, generation: metadata.run_generation ?? null };
+    }
+    if (action === "release-turn") {
+        const record = managedProcessStatus(context).find(process => process.id === requiredOption(parsed, "id"));
+        if (!record || record.lease_token !== requiredOption(parsed, "lease-token") || record.owner_id !== requiredOption(parsed, "owner") || managedProcessRuntimeHome(record, context) !== context.ddFlowHome)
+            throw new AppError("process_ownership_unknown", "Budget release requires its retained physical owner", 1);
+        return releaseProviderTurns(context, record, { daemonId: requiredOption(parsed, "daemon-id"), operationId: optionalOption(parsed, "operation-id"), observationFile: optionalOption(parsed, "observation-file") }, prepared.providerTurnRelease);
+    }
+    if (action === "finish")
+        return { ok: finishManagedProcess(context, runtimeProcessFinishInput(parsed)) };
+    if (action === "status") {
+        const id = optionalOption(parsed, "id"), token = optionalOption(parsed, "lease-token"), hash = optionalOption(parsed, "registration-sha256");
+        if (!id && !token && !hash)
+            return { ok: true, processes: managedProcessStatus(context) };
+        if (!id || !token || !hash || !/^[a-f0-9]{64}$/.test(hash))
+            throw new AppError("usage", "Exact status requires id, lease-token and registration-sha256", 2);
+        const record = managedProcessStatus(context).find(value => value.id === id);
+        if (!record || record.lease_token !== token || managedProcessBinding(record, resourceHome(context)).registration_sha256 !== hash || record.state !== "running" || !processIsAlive(record))
+            throw new AppError("process_maintenance_receipt_invalid", "Readback binding or physical owner changed", 1);
+        assertManagedProcessAdmission(context, record);
+        const metadata = JSON.parse(record.metadata_json);
+        if (record.project_id && record.run_id) {
+            if (metadata.run_admitted !== true || !Number.isSafeInteger(metadata.run_generation))
+                throw new AppError("run_recovery_guarded", "Readback has no admitted generation", 1);
+            assertRunMutationAllowed(context, record.project_id, record.run_id, metadata.run_generation);
+            if (managedProcessRuntimeHome(record, context) !== context.ddFlowHome)
+                throw new AppError("process_runtime_scope_mismatch", "Readback belongs to another engine home", 1);
+        }
+        return { ok: true, process_id: id, lease_expires_at: record.lease_expires_at, registration_sha256: hash, readback: true };
+    }
+    if (action === "reconcile")
+        return { ok: true, processes: await reconcileExpiredManagedProcesses(context, requiredOption(parsed, "owner"), optionalNumber(parsed, "grace-ms")) };
+    throw new AppError("usage", "Usage: dd-flow runtime process <start|stop|register|confirm|heartbeat|admission|finish|status|reconcile>", 2);
+}

package/dist/cli.js

@@ -1,4 +1,19 @@
 #!/usr/bin/env node
-import { runCli } from "./cli/run-cli.js";
-const exitCode = await runCli(process.argv.slice(2));
+import { isNativeHookIngress } from "./cli/native-hook-ingress.js";
+import { isRuntimeMaintenanceIngress, runRuntimeMaintenanceIngress } from "./cli/runtime-maintenance-ingress.js";
+import { publishSetup } from './harness-runtime/lib/setup-progress.mjs';
+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 = isRuntimeMaintenanceIngress(args, process.env)
+    ? await runRuntimeMaintenanceIngress(args)
+    : managedHook
+        ? await (await import("./cli/hook-ingress.js")).runHookIngress(args)
+        : isNativeHookIngress(args) && !args.includes("--help") && !args.includes("-h")
+            ? await (await import("./cli/native-hook-ingress.js")).runNativeHookIngress(args)
+            : await (async () => {
+                publishSetup('ingress_entered');
+                const cli = await import('./cli/run-cli.js');
+                publishSetup('imports_ready');
+                return await cli.runCli(args);
+            })();
 process.exitCode = exitCode;

package/dist/domain/stage-catalog.js

@@ -3,7 +3,7 @@ export const vnextStages = [
     { id: "specify", directory: "01-specify", result: "specify.json", schema: "dd-flow/vnext-specify-result@4", next: ["protocolize"] },
     { id: "protocolize", directory: "02-protocolize", result: "protocolize-result.json", schema: "dd-flow/vnext-protocolize-result@3", next: ["plan"] },
     { id: "plan", directory: "03-plan", result: "stage-report.json", schema: "dd-flow/stage-report@2", next: ["plan-review", "code"] },
-    { id: "plan-review", directory: "04-plan-review", result: "decision.json", schema: "dd-flow/plan-review-decision@3", next: ["code"] },
+    { id: "plan-review", directory: "04-plan-review", result: "decision.json", schema: "dd-flow/plan-review-decision@4", next: ["code"] },
     { id: "code", directory: "05-code", result: "code-verification.json", schema: "dd-flow/code-verification@2", next: ["code-review", "merge"] },
     { id: "code-review", directory: "06-code-review", result: "decision.json", schema: "dd-flow/code-review-decision@3", next: ["merge"] },
     { id: "merge", directory: "07-merge", result: "stage-report.json", schema: "dd-flow/stage-report@2", next: [] }

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,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, 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"], ...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 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 = { 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); }