@deksden-com/dd-flow-cli 0.9.0-beta.15 → 0.9.0-beta.151

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

@@ -0,0 +1,86 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { SETUP_STARTUP_MS } from './setup-progress.mjs';
+
+import { checkObservedProfile } from "./model-observations.mjs";
+import { classifyRecoveryError as classifyProviderError, safeProviderError, streamRequestKey } from "./provider-overload-policy.mjs";
+
+const DEFAULT_MODEL = "gemini-3.1-pro-high";
+export const AGY_VERSION_TIMEOUT_MS = 30_000;
+// Managed binaries are immutable qualification inputs, including doctor probes.
+export const managedAgyEnv = (env = {}) => ({ ...process.env, ...env, AGY_CLI_DISABLE_AUTO_UPDATE: "true" });
+
+export class AgyError extends Error {
+  constructor(code, message, retryable = false, details) { super(message); this.code = code; this.retryable = retryable; this.details = details; }
+}
+
+export function agyTerminalFailure(result, metadata = {}) {
+  let native = typeof result.error === "object" && result.error ? result.error : { message: result.error ?? "Antigravity returned ERROR" };
+  if (typeof result.error === "string" && /^AGY_ERROR\s*[: ]/.test(result.error)) {
+    try {
+      const envelope = JSON.parse(result.error.replace(/^AGY_ERROR\s*:?\s*/, ""));
+      const error = envelope.error ?? envelope;
+      if (error && typeof error === "object" && !Array.isArray(error)) native = error;
+    } catch { /* A malformed envelope remains a native failure, never evidence. */ }
+  }
+  const category = classifyProviderError(native);
+  const legacy = { provider_quota_exhausted: "agy_provider_quota_exhausted", provider_limit_unknown: "agy_provider_limit_unknown", provider_auth_failed: "agy_provider_account", provider_failed: "agy_provider_failed" };
+  let code = result.status === "CANCELLED" ? "agy_turn_cancelled" : legacy[category] ?? category;
+  // A local generation/usage count is not a native request identity.
+  const identity = result.turn_id ?? result.request_id;
+  const turn = typeof identity === "string" && identity ? identity : null;
+  const stream = streamRequestKey(metadata.request_proof);
+  const proofMissing = result.status === "ERROR" && ["provider_capacity_transient", "provider_rate_limited", "provider_network_transient"].includes(category) && !turn && !stream;
+  if (proofMissing) code = "provider_overload_evidence_unavailable";
+  return new AgyError(code, String(native.message ?? "Antigravity returned ERROR"), ["provider_capacity_transient", "provider_rate_limited", "provider_network_transient"].includes(code), {
+    provider_result: result, ...metadata, provider_error: safeProviderError(native), native_source: "agy.result", terminal_status: result.status === "ERROR" ? "failed" : "cancelled",
+    ...(turn ? { turn_id: turn, native_turn_id: turn } : {}),
+    ...(proofMissing ? { provider_category: category, reason: "native_turn_identity_unavailable" } : {}),
+    will_retry: native.willRetry === true, native_retry_active: native.willRetry === true
+  });
+}
+
+export function executable(bin, args = []) {
+  return /\.[cm]?js$/.test(bin) ? { command: process.execPath, args: [bin, ...args] } : { command: bin, args };
+}
+
+export async function runAgy(bin, args, options = {}) {
+  const stdout = await commandText(bin, args, { cwd: options.cwd, env: managedAgyEnv(options.env), input: options.stdin ?? "", timeoutMs: options.timeoutMs, startupMs: options.startupMs ?? options.timeoutMs ?? SETUP_STARTUP_MS, phase: "native-doctor" });
+  return { stdout, stderr: "", code: 0 };
+}
+
+export function usageSnapshot(result = {}, toolCalls = {}) {
+  const usage = result.usage && typeof result.usage === "object" ? result.usage : {};
+  const numberOrNull = value => value == null || !Number.isFinite(Number(value)) ? null : Number(value);
+  return {
+    // A missing counter is unknown, not a measured zero.
+    input_tokens: numberOrNull(usage.input_tokens), output_tokens: numberOrNull(usage.output_tokens),
+    reasoning_tokens: numberOrNull(usage.thinking_tokens), cache_read_tokens: numberOrNull(usage.cache_read_tokens),
+    total_tokens: numberOrNull(usage.total_tokens), tool_calls: toolCalls
+  };
+}
+
+export function observedProfile(init = {}, requested = {}) {
+  return { provider: init.provider ?? null, model: init.model ?? null, reasoning: init.reasoning ?? null, mode: init.mode ?? null, permission_mode: init.permission_mode ?? null };
+}
+
+export function assertProfile(requested, observed) { return checkObservedProfile(requested, observed, { required: requested.permission_mode ? ["permission_mode"] : [] }); }
+
+export function agyModelArgs(model, reasoning) {
+  const encoded = /^gemini-.+-(low|medium|high)$/.exec(model)?.[1];
+  if (encoded && encoded !== reasoning) throw new AgyError("agy_profile_invalid", "Requested reasoning conflicts with the selected Gemini model");
+  return ["--model", model, ...(encoded ? [] : ["--effort", reasoning])];
+}
+
+export async function doctor(options = {}) {
+  const bin = options.bin ?? process.env.DD_AGY_BIN ?? "agy", temporary = await mkdtemp(path.join(os.tmpdir(), "dd-agy-doctor-"));
+  try {
+    const version = (await runAgy(bin, ["--version"], { timeoutMs: AGY_VERSION_TIMEOUT_MS, startupMs: options.timeoutMs ?? SETUP_STARTUP_MS })).stdout.trim();
+    const models = await runAgy(bin, [`--gemini_dir=${temporary}`, "--app_data_dir=runtime", "models"], { timeoutMs: options.timeoutMs ?? 30_000, startupMs: options.timeoutMs ?? SETUP_STARTUP_MS });
+    const modelIds = models.stdout.split(/\r?\n/).map(line => line.split(/\s+/)[0]).filter(Boolean);
+    if (!modelIds.includes(options.model ?? DEFAULT_MODEL)) throw new AgyError("agy_model_unavailable", `required Antigravity model is unavailable: ${options.model ?? DEFAULT_MODEL}`);
+    return { compatible: true, observed_runtime: { agy: version, dd_harness_contract: "dd-agy-harness@1" }, isolation: { gemini_dir: "verified", app_data_dir: "verified" }, auth: "available", models: modelIds };
+  } finally { await rm(temporary, { recursive: true, force: true }); }
+}
+import { commandText } from "./process-json.mjs";

package/dist/harness-runtime/lib/dd-codex-daemon.d.mts

@@ -0,0 +1 @@
+export function callDaemon(stateDir: string, operation: string, params?: Record<string, unknown>, timeoutMs?: number): Promise<Record<string, unknown>>;

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

@@ -0,0 +1,231 @@
+import { managedFlowEnv } from './managed-flow-env.mjs';
+import { SETUP_STARTUP_MS, startupObserver, observationDetails } from './setup-progress.mjs';
+import { callDaemonObserved } from './daemon-observation.mjs';
+import { admitNativeRequestBuffer } from "./native-streams.mjs";
+import { prepareDaemonRequest } from "./native-request-proof.mjs";
+import { captureDispatchGuard, cancelPendingDispatch } from "./dispatch-fence.mjs";
+import { createHash, randomUUID } from "node:crypto";
+import { chmod, lstat, mkdir, open, readFile, rename, unlink, writeFile } from "node:fs/promises";
+import net from "node:net";
+import { durableDaemonDispatch, completeDaemonShutdown, commitDaemonShutdown, assertDaemonDispatch, assertDaemonRestartable, trackDaemonConnections, retireDaemonEndpoint, retireFailedDaemon } from "./daemon-operations.mjs";
+import { ObservationClock } from "./observation-clock.mjs";
+import { parseCapacityOperation } from "./provider-overload-policy.mjs";
+import path from "node:path";
+import { spawn } from "node:child_process";
+import { waitForSettlement } from "./session-settlement.mjs";
+import { nativeExecutionReceipt } from "./native-children.mjs";
+import { errorRecord } from "./operation-errors.mjs";
+import { CODEX_REQUEST_TIMEOUT_MS, LATE_RESPONSE_GRACE_MS, CodexBridge, codexReadPhase, readCodexHistory, retainedCodexTurn, cancelSessionWithBridge, createSessionWithBridge, inspectSessionWithBridge, promptSessionWithBridge, startSessionWithBridge } from "./dd-codex.mjs";
+import { assertDaemonOwnership, assertStartupChild, prepareRuntimeOwner, cleanupFailedDaemonStart, confirmDaemonProcess, confirmDaemonStopped, finishDaemonProcess, scheduleDaemonProcessHeartbeat, registerDaemonProcess, startManagedBridge, stopProcessGroup } from "./managed-daemon.mjs";
+
+export function codexBridgeEnv(config, daemonId) { return { ...config.env, ...managedFlowEnv(config, daemonId) }; }
+
+const requestSchema = "dd-codex/daemon-request@1";
+const responseSchema = "dd-codex/daemon-response@1";
+const stateSchema = "dd-codex/daemon-state@1";
+const absolute = (value, label) => { if (!value || !path.isAbsolute(value)) throw Object.assign(new Error(`${label} must be an absolute path`), { code: "invalid_path" }); return path.resolve(value); };
+function locations(stateDir) { const dir = absolute(stateDir, "--state-dir"); const local = path.join(dir, "daemon.sock"); return { dir, socket: Buffer.byteLength(local) < 100 ? local : `/tmp/dd-codex-${createHash("sha256").update(dir).digest("hex").slice(0, 24)}.sock`, state: path.join(dir, "daemon.json"), log: path.join(dir, "daemon.log") }; }
+async function readState(file) { try { return JSON.parse(await readFile(file, "utf8")); } catch (error) { if (error.code === "ENOENT") return null; throw error; } }
+async function writeState(file, value) { const temp = `${file}.${process.pid}.tmp`; await writeFile(temp, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 }); await rename(temp, file); }
+async function removeSocket(socket) { try { const info = await lstat(socket); if (!info.isSocket()) throw Object.assign(new Error("refusing to remove non-socket daemon path"), { code: "unsafe_socket" }); await unlink(socket); } catch (error) { if (error.code !== "ENOENT") throw error; } }
+const errorPayload = errorRecord;
+const terminalTurn = turn => typeof turn?.id === "string" && turn.id.trim().length > 0 && ["completed", "interrupted", "failed", "cancelled"].includes(turn.status);
+export function settledCodexSession(status, latestTurn, active, historyAvailable = true) {
+  if (latestTurn && !terminalTurn(latestTurn)) return false;
+  if (status === "idle") return true;
+  if (status === "notLoaded") return terminalTurn(latestTurn) || historyAvailable && !latestTurn;
+  // `systemError` alone is not evidence that the provider stopped. A current
+  // terminal Turn plus no daemon operation is the narrow settled case.
+  return status === "systemError" && !active && terminalTurn(latestTurn);
+}
+
+async function observeCodexSessions(bridge, options, sessions, active, remember = () => {}) {
+  // Expand trusted native topology before profile/history diagnostics: an
+  // unavailable root must not hide its already discovered siblings/children.
+  for (const id of sessions) for (const child of bridge.directChildren?.(id) ?? []) {
+    if (typeof child.provider_session_id !== "string" || !child.provider_session_id.trim()) throw Object.assign(new Error("Codex child has no native identity"), { code: "invalid_session_topology" });
+    sessions.add(child.provider_session_id); remember(child.provider_session_id);
+  }
+  const unsettled = [], observations = [];
+  for (const sessionId of sessions) {
+    const observed = await inspectSessionWithBridge(bridge, { ...options, sessionId, turnId: sessionId === options.sessionId ? options.turnId : undefined });
+    for (const child of observed.descendants ?? []) { sessions.add(child.provider_session_id); remember(child.provider_session_id); }
+    const status = observed.status?.type ?? observed.status;
+    const currentId = bridge.currentTurns?.get(sessionId) ?? (sessionId === options.sessionId ? options.turnId : undefined);
+    const retained = retainedCodexTurn(bridge, sessionId, currentId);
+    const compactTurn = observed.thread?.turns?.findLast(turn => !currentId || turn?.id === currentId);
+    const stored = ["notLoaded", "systemError"].includes(status) || currentId && !terminalTurn(retained)
+      ? await readCodexHistory(bridge, "thread/turns/list", { threadId: sessionId, limit: 20, sortDirection: "desc", itemsView: "summary" }, options.readPhase) : null;
+    const hydrated = stored && !stored.available
+      ? await readCodexHistory(bridge, "thread/read", { threadId: sessionId, includeTurns: true }, options.readPhase) : null;
+    const hydratedAvailable = hydrated?.available && Array.isArray(hydrated.result.thread.turns);
+    const hydratedTurn = hydratedAvailable ? hydrated.result.thread.turns.findLast(turn => !currentId || turn?.id === currentId) : null;
+    const malformedHistory = [stored?.result?.data, hydrated?.result?.thread.turns, observed.thread?.turns].some(turns =>
+      turns?.some(turn => typeof turn?.id !== "string" || !turn.id.trim() || !["inProgress", "completed", "interrupted", "failed", "cancelled"].includes(turn.status)));
+    const latest = retained && terminalTurn(retained) ? retained
+      : malformedHistory ? { status: "unknown" }
+      : stored?.result?.data.find(turn => !currentId || turn?.id === currentId) ?? hydratedTurn ?? compactTurn ?? retained
+        ?? (currentId ? { id: currentId, status: "unknown" } : null);
+    const observedStatus = hydrated?.result?.thread.status ?? observed.status;
+    const settled = settledCodexSession(observedStatus?.type ?? observedStatus, latest, active(), (stored?.available ?? true) || hydratedAvailable);
+    if (!settled) unsettled.push(sessionId);
+    observations.push({ ...observed, status: observedStatus, settled });
+  }
+  return { sessions: unsettled.reverse(), active: Boolean(active()), observations };
+}
+
+export async function inspectCodexTree(bridge, options, { remember = () => {}, active = () => null } = {}) {
+  options = { ...options, readPhase: options.readPhase ?? codexReadPhase(bridge, options) };
+  const sessions = new Set([options.sessionId]);
+  const observed = await observeCodexSessions(bridge, options, sessions, active, remember);
+  return nativeExecutionReceipt({ ...observed.observations[0], settled: !observed.active && !observed.sessions.length, unsettled_sessions: observed.sessions, tree_session_ids: [...sessions], tree_observations: observed.observations.map(item => ({ provider_session_id: item.provider_session_id, status: item.status, settled: item.settled })) }, { daemonId: options.daemonId });
+}
+
+export async function cancelCodexTree(bridge, options, { remember = () => {}, active = () => null, timeoutMs = 5_000 } = {}) {
+  // Zero requests one best-effort cancellation/observation pass, not an
+  // invalid zero-length RPC window or permission to skip owned children.
+  const readBudget = timeoutMs === 0 ? CODEX_REQUEST_TIMEOUT_MS : timeoutMs;
+  options = { ...options, readPhase: options.readPhase ?? codexReadPhase(bridge, { ...options, timeoutMs: readBudget, livenessTimeoutMs: readBudget }) };
+  const sessions = new Set([options.sessionId]);
+  const settlement = await waitForSettlement({
+    timeoutMs, knownSessions: () => [...sessions],
+    cancel: async sessionId => {
+      try { await cancelSessionWithBridge(bridge, { ...options, sessionId, turnId: sessionId === options.sessionId ? options.turnId : undefined }); }
+      catch (error) { if (error.code !== "turn_not_active") throw error; }
+    },
+    observe: () => observeCodexSessions(bridge, options, sessions, active, remember)
+  });
+  return { harness: "codex-desktop", provider_session_id: options.sessionId, adapter_session_id: options.sessionId, cancelled: true, settled: true, tree_session_ids: [...sessions], cleanup_errors: settlement.cleanup_errors, tree_observations: settlement.observations.map(item => ({ provider_session_id: item.provider_session_id, status: item.status, settled: item.settled })) };
+}
+
+export async function callDaemon(stateDir, operation, params = {}, timeoutMs = operation === "session.create" ? params.timeoutMs ?? CODEX_REQUEST_TIMEOUT_MS + LATE_RESPONSE_GRACE_MS : 30_000) {
+  const request = prepareDaemonRequest({ schema_id: requestSchema, id: process.env.DD_EVAL_OPERATION_ID ?? randomUUID(), operation, params });
+  return await callDaemonObserved({ stateDir, socket: locations(stateDir).socket, request, responseSchema: responseSchema, harness: 'codex', timeoutMs });
+}
+
+export async function startDaemon(options) {
+  if (!options.noFlow && Boolean(options.ddFlowHome) !== Boolean(options.ddFlowBin)) throw Object.assign(new Error("--dd-flow-home and --dd-flow-bin must be provided together"), { code: "flow_context_incomplete" });
+  if (options.noFlow) options = { ...options, ddFlowHome: undefined, ddFlowBin: undefined };
+  const paths = locations(options.stateDir); const cwd = absolute(options.cwd, "--cwd"); const config = { cwd, journal: absolute(options.journal, "--journal"), bin: options.bin ?? null, ddFlowBin: options.ddFlowBin ? absolute(options.ddFlowBin, "--dd-flow-bin") : null, ddFlowHome: options.ddFlowHome ? absolute(options.ddFlowHome, "--dd-flow-home") : null, projectRoot: options.projectRoot ? absolute(options.projectRoot, "--project-root") : cwd, resourceHome: !options.noFlow && process.env.DD_FLOW_RESOURCE_HOME ? absolute(process.env.DD_FLOW_RESOURCE_HOME, "DD_FLOW_RESOURCE_HOME") : null, env: options.ddFlowHome ? { DD_FLOW_HOME: absolute(options.ddFlowHome, "--dd-flow-home"), ...(options.ddFlowBin ? { DD_FLOW_BIN: absolute(options.ddFlowBin, "--dd-flow-bin") } : {}) } : {} };
+  await prepareRuntimeOwner(config, paths.dir);
+  await mkdir(paths.dir, { recursive: true, mode: 0o700 }); await chmod(paths.dir, 0o700);
+  let previous = await readState(paths.state); assertDaemonRestartable(previous);
+  try { const status = await callDaemon(paths.dir, "daemon.status", {}, 1_000); if (JSON.stringify(status.config) !== JSON.stringify(config)) throw Object.assign(new Error("running daemon has a different configuration"), { code: "daemon_config_mismatch" }); return { ...status, already_running: true }; } catch (error) { if (!["daemon_not_running", "daemon_timeout"].includes(error.code)) throw error; }
+  previous = await readState(paths.state); assertDaemonRestartable(previous);
+  if (previous?.shutdown_state === "running") throw Object.assign(new Error("previous dd-codex daemon died; do not reuse its state directory"), { code: "invalid_harness_crash" });
+  if (previous?.shutdown_state === "clean") await authorizeRetainedDaemonResume(paths.dir, previous, options.sessionId, config);
+  await removeSocket(paths.socket); const resourceProcess = await registerDaemonProcess(config, { kind: "codex-daemon", owner: `codex:${path.basename(paths.dir)}`, operation: `codex-daemon:${path.basename(paths.dir)}`, stdout: paths.log, stderr: paths.log }); const state = { schema_id: stateSchema, daemon_id: randomUUID(), pid: null, cwd: config.cwd, journal: config.journal, config, socket: paths.socket, started_at: new Date().toISOString(), shutdown_state: "starting", sessions: previous?.sessions ?? [], resource_process: resourceProcess }; await writeState(paths.state, state);
+  const log = await open(paths.log, "a", 0o600); const child = spawn(process.execPath, [options.entryPath, "daemon", "serve", "--state-dir", paths.dir], { cwd: config.cwd, detached: true, stdio: ["ignore", log.fd, log.fd] }); child.unref(); await log.close();
+  try { await confirmDaemonProcess(config, resourceProcess, child); const startupClock = new ObservationClock({ timeoutMs: SETUP_STARTUP_MS }); const startupProgress = startupObserver(paths.dir, state.daemon_id); while (!startupClock.sample(await startupProgress())) { assertStartupChild(child, state, await readState(paths.state), paths.log); await new Promise((resolve) => setTimeout(resolve, 100)); try { return await callDaemon(paths.dir, "daemon.status", {}, 5_000); } catch (error) { if (!["daemon_not_running", "daemon_timeout"].includes(error.code)) throw error; } } throw Object.assign(new Error("daemon did not become ready"), { code: "daemon_start_failed", details: observationDetails(startupClock, "daemon-start", child.pid) }); }
+  catch (error) { await cleanupFailedDaemonStart(config, resourceProcess, child, error, () => readState(paths.state), state.daemon_id); throw error; }
+}
+export async function stopDaemon(options) { const timeoutMs = options.timeoutMs ?? 30_000; return await confirmDaemonStopped(() => callDaemon(options.stateDir, "daemon.stop", { cancelTree: options.cancelTree === true }, timeoutMs), locations(options.stateDir).socket, timeoutMs, { readState: () => readState(locations(options.stateDir).state) }); }
+
+export async function prepareCodexStop({ bridge, state, sessions, active, save, stateDir, cancelTree }) {
+  if (cancelTree) cancelPendingDispatch(bridge);
+  if (active() && !cancelTree) throw Object.assign(new Error("productive operation is running"), { code: "tree_not_settled" });
+  let revision;
+  await waitForSettlement({
+    knownSessions: () => [...sessions],
+    observe: () => { revision = state.native_execution_revision; return observeCodexSessions(bridge, state.config, sessions, active); },
+    ...(cancelTree ? { cancel: async sessionId => { try { await cancelSessionWithBridge(bridge, { ...state.config, sessionId }); } catch (error) { if (error.code !== "turn_not_active") throw error; } } } : {})
+  });
+  if (active() || state.native_execution_revision !== revision) throw Object.assign(new Error("native activity changed during settlement observation"), { code: "tree_not_settled" });
+  commitDaemonShutdown(stateDir);
+  await save({ active_tree: false });
+  return { clean: true, settled: true, native_settled: true, native_settlement: { confirmed: true, revision } };
+}
+
+export async function serveDaemon(stateDir) {
+  const paths = locations(stateDir); const state = await readState(paths.state); if (!state || state.schema_id !== stateSchema) throw Object.assign(new Error("daemon state missing"), { code: "daemon_state_missing" });
+  const bridge = new CodexBridge({ ...state.config, env: { ...codexBridgeEnv(state.config, state.daemon_id), CODEX_HOME: process.env.CODEX_HOME, DD_FLOW_CODEX_STATE_DIR: paths.dir } }); await startManagedBridge({ config: state.config, state, bridge, kind: "codex-provider", publish: snapshot => writeState(paths.state, snapshot), log: paths.log }); const sessions = new Set(state.sessions ?? []); let active = null; let server; let persist = Promise.resolve();
+  scheduleDaemonProcessHeartbeat(state.config, state.resource_process);
+  const save = (patch = {}) => { Object.assign(state, patch, { pid: process.pid, updated_at: new Date().toISOString(), sessions: [...sessions] }); const snapshot = structuredClone(state); persist = persist.catch(() => {}).then(() => writeState(paths.state, snapshot)); return persist; };
+  bridge.options.onNativeActivity = () => {
+    state.native_execution_revision = (state.native_execution_revision ?? 0) + 1;
+    if (state.active_tree !== true) void save({ active_tree: true }).catch(error => { bridge.rejectAll(error); });
+  };
+  const dispatch = async (operation, params, operationId) => {
+    const assertDispatch = captureDispatchGuard(bridge);
+    if (operation === "hook.verify") {
+      if (params.daemonId !== state.daemon_id) throw Object.assign(new Error("Hook daemon identity differs"), { code: "native_hook_unproven" });
+      return { ...bridge.verifyNativeHook(params), daemonId: state.daemon_id, ddFlowHome: state.config.ddFlowHome, projectRoot: state.config.projectRoot };
+    }
+    if (operation === "daemon.status") return { daemon_id: state.daemon_id, pid: process.pid, cwd: state.cwd, journal: state.journal, config: state.config, sessions: [...sessions], active_operation: active, active_tree: state.active_tree ?? null, shutdown_state: state.shutdown_state };
+    // The runner may need to retire an orphaned daemon after its caller was
+    // interrupted. `daemon.stop` is the one control operation that remains
+    // available while a request is marked active; callers must first prove the
+    // provider Session itself is idle.
+    if (operation === "daemon.stop") {
+      return await completeDaemonShutdown(paths.dir, state, save, async () => {
+      return await prepareCodexStop({ bridge, state, sessions, active: () => active, save, stateDir: paths.dir, cancelTree: params.cancelTree });
+      }, [
+        ["provider", () => bridge.close()],
+        ["provider_resource", () => finishDaemonProcess(state.config, state.provider_process)],
+        ["daemon_resource", () => finishDaemonProcess(state.config, state.resource_process)]
+      ]);
+    }
+    if (["session.create", "session.prompt", "session.start", "session.fork", "session.resume"].includes(operation)) assertDaemonDispatch(paths.dir);
+    if (active && !["session.inspect", "session.cancel"].includes(operation)) throw Object.assign(new Error(`${active} is in progress`), { code: "operation_busy", retryable: true });
+    if (operation === "session.create") { active = operation; try { await save({ active_operation: active, active_tree: true }); const result = await createSessionWithBridge(bridge, { ...state.config, ...params }); sessions.add(result.provider_session_id); return result; } finally { active = null; await save({ active_operation: null }); } }
+    if (operation === "session.prompt") {
+      parseCapacityOperation(operationId);
+      // Admission can wait for a permit. Observe again after it returns, not
+      // just before the caller's backoff, so no child Turn races this dispatch.
+      // Reserve before the first await: distinct operation IDs are independent
+      // journal entries and must not both pass the idle check while inspecting.
+      active = operation;
+      try {
+        await save({ active_operation: active, active_tree: true });
+        const tree = await inspectCodexTree(bridge, { ...state.config, ...params });
+        assertDispatch();
+        if (tree.settled !== true) throw Object.assign(new Error("native Session tree changed while waiting for admission"), { code: "tree_not_settled", details: { provider_session_id: params.sessionId, unsettled_sessions: tree.unsettled_sessions } });
+        if (/:capacity:[1-9]\d*:session\.prompt$|:child:[a-f0-9]+:followup:[1-9]\d*$/.test(operationId ?? ""))
+          await assertDaemonOwnership(paths.dir, { "operation-id": operationId, operation, "native-session-id": params.sessionId, "prompt-sha256": createHash("sha256").update(params.prompt ?? "").digest("hex") }, assertDispatch);
+        sessions.add(params.sessionId);
+        await save({ active_operation: active }); return await promptSessionWithBridge(bridge, { ...state.config, ...params, operationId, assertDispatch });
+      }
+      finally { active = null; await save({ active_operation: null }); }
+    }
+    if (operation === "session.start") { sessions.add(params.sessionId); active = operation; try { await save({ active_operation: active, active_tree: true }); return await startSessionWithBridge(bridge, { ...state.config, ...params, assertDispatch, operationId }); } finally { active = null; await save({ active_operation: null }); } }
+    if (operation === "session.inspect" || operation === "session.resume") {
+      const owned = new Set(sessions);
+      for (const id of owned) for (const child of bridge.directChildren?.(id) ?? []) owned.add(child.provider_session_id);
+      if (!owned.has(params.sessionId)) throw Object.assign(new Error("inspection Session is not owned by this daemon"), { code: "session_identity_mismatch" });
+      bridge.assertHookHealthy(params.sessionId);
+      try { return await inspectCodexTree(bridge, { ...state.config, ...params }, { remember: id => sessions.add(id), active: () => active }); }
+      finally { await save(); }
+    }
+    if (operation === "session.cancel") {
+      if (!sessions.has(params.sessionId)) throw Object.assign(new Error("cancellation Session is not owned by this daemon"), { code: "session_identity_mismatch" });
+      cancelPendingDispatch(bridge);
+      try { return await cancelCodexTree(bridge, { ...state.config, ...params }, { remember: id => sessions.add(id), active: () => active }); }
+      finally { await save(); }
+    }
+    throw Object.assign(new Error(`unknown operation: ${operation}`), { code: "unknown_operation" });
+  };
+  await removeSocket(paths.socket);
+  server = net.createServer(connection => {
+    connection.setEncoding("utf8"); let buffer = "", consumed = false;
+    connection.on("data", chunk => {
+      if (consumed) return;
+      buffer += chunk; if (!admitNativeRequestBuffer(buffer, connection, responseSchema)) { consumed = true; return; } const at = buffer.indexOf("\n"); if (at < 0) return; consumed = true;
+      void (async () => {
+        let request;
+        try {
+          request = JSON.parse(buffer.slice(0, at));
+          if (request.schema_id !== requestSchema || !request.id || !request.operation) throw Object.assign(new Error("invalid daemon request"), { code: "daemon_protocol" });
+          const result = await durableDaemonDispatch(paths.dir, request, () => dispatch(request.operation, request.params ?? {}, request.id), () => dispatch("session.inspect", request.params ?? {}));
+          if (result._shutdown) retireDaemonEndpoint(server);
+          connection.end(`${JSON.stringify({ schema_id: responseSchema, id: request.id, ok: true, result: { ...result, _shutdown: undefined } })}\n`);
+        } catch (error) {
+          await retireFailedDaemon(server, state, error, save);
+          connection.end(`${JSON.stringify({ schema_id: responseSchema, id: request?.id ?? null, ok: false, error: errorPayload(error) })}\n`);
+        }
+      })();
+    });
+  });
+  trackDaemonConnections(server);
+  await new Promise((resolve, reject) => { server.once("error", reject); server.listen(paths.socket, resolve); }); await chmod(paths.socket, 0o600); await save({ shutdown_state: "running", active_operation: null }); return await new Promise(() => {});
+}
+import { authorizeRetainedDaemonResume } from "./driver-recovery.mjs";

package/dist/harness-runtime/lib/dd-codex.d.mts

@@ -0,0 +1 @@
+export function terminalCodexOverload(error: unknown, expectedSessionId: string, expectedTurnId?: string): boolean;