@deksden-com/dd-flow-cli 0.9.0-beta.22 → 0.9.0-beta.24

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

@@ -0,0 +1,387 @@
+import { spawn } from "node:child_process";
+import { appendFile, mkdir, readFile } from "node:fs/promises";
+import path from "node:path";
+import readline from "node:readline";
+import { stopProcessGroup } from "./managed-daemon.mjs";
+import { ObservationClock, observedTimeout } from "./observation-clock.mjs";
+import { observeModel } from "./model-observations.mjs";
+
+// Minimal JSON-RPC wrapper around the public Codex app-server protocol.  It is
+// intentionally one-shot: the provider owns durable Threads, while the caller
+// owns the runner journal and can safely resume after a process restart.
+function fail(message, code) { const error = new Error(message); if (code) error.code = code; throw error; }
+function required(value, label) { if (typeof value !== "string" || !value.trim()) fail(`${label} is required`); return value.trim(); }
+function absolute(value, label) { const resolved = path.resolve(required(value, label)); if (!path.isAbsolute(resolved)) fail(`${label} must be absolute`); return resolved; }
+function now() { return new Date().toISOString(); }
+
+export function parseCodexCliVersion(value) {
+  const match = String(value).trim().match(/^codex-cli\s+(\S+)$/m);
+  if (!match) fail("Codex CLI did not report its version", "codex_version_unavailable");
+  return match[1];
+}
+
+function commandText(bin, args) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(bin, args, { stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = ""; let stderr = "";
+    child.stdout.setEncoding("utf8").on("data", (chunk) => { stdout += chunk; });
+    child.stderr.setEncoding("utf8").on("data", (chunk) => { stderr += chunk; });
+    child.on("error", reject);
+    child.on("exit", (code) => code === 0 ? resolve(stdout) : reject(Object.assign(new Error(`Codex CLI version failed: ${stderr.trim() || code}`), { code: "codex_version_unavailable" })));
+  });
+}
+
+class Journal {
+  constructor(file) { this.file = file ? absolute(file, "--journal") : null; this.pending = this.file ? mkdir(path.dirname(this.file), { recursive: true }) : Promise.resolve(); this.order = 0; }
+  write(kind, payload) { if (!this.file) return; this.pending = this.pending.then(() => appendFile(this.file, `${JSON.stringify({ order: ++this.order, observed_at: now(), kind, payload })}\n`)); }
+  flush() { return this.pending; }
+}
+
+export class CodexBridge {
+  constructor(options = {}) { this.options = options; this.nextId = 1; this.pending = new Map(); this.turns = new Map(); this.finalMessages = new Map(); this.descendants = new Map(); this.journal = new Journal(options.journal); this.stderr = ""; this.requestedProfiles = new Map(); this.modelObservations = Promise.resolve(); }
+
+  async start() {
+    const bin = this.options.bin ?? process.env.DD_CODEX_BIN ?? "codex";
+    this.child = spawn(bin, ["app-server"], { cwd: this.options.cwd ? absolute(this.options.cwd, "--cwd") : process.cwd(), env: { ...process.env, ...(this.options.env ?? {}) }, detached: process.platform !== "win32", stdio: ["pipe", "pipe", "pipe"] });
+    this.child.stderr.setEncoding("utf8").on("data", (chunk) => { this.stderr += String(chunk); this.journal.write("stderr", { text: String(chunk) }); });
+    this.child.on("error", (error) => this.rejectAll(error));
+    this.child.on("exit", (code) => this.rejectAll(Object.assign(new Error(`Codex app-server exited ${code}${this.stderr.trim() ? `: ${this.stderr.trim()}` : ""}`), { code: "bridge_exited" })));
+    readline.createInterface({ input: this.child.stdout }).on("line", (line) => this.receive(line));
+    await this.request("initialize", { clientInfo: { name: "dd-codex", version: "0.1.0" }, capabilities: { optOutNotificationMethods: [], experimentalApi: true } });
+  }
+
+  receive(line) {
+    let message; try { message = JSON.parse(line); } catch { this.journal.write("malformed", { line }); return; }
+    this.observeTopology(message);
+    if (["model/rerouted", "thread/settings/updated"].includes(message.method)) {
+      const params = message.params ?? {}, id = params.threadId;
+      let root = id; const seen = new Set();
+      while (root && !this.requestedProfiles.has(root) && !seen.has(root)) { seen.add(root); root = this.descendants.get(root)?.parent_provider_session_id; }
+      if (root && this.requestedProfiles.has(root)) {
+        const settings = params.threadSettings ?? {};
+        const rerouted = message.method === "model/rerouted";
+        this.modelObservations = this.modelObservations.then(() => observeModel({ journal: this.options.journal, harness: "codex-desktop", sessionId: id,
+          parentSessionId: this.descendants.get(id)?.parent_provider_session_id ?? null, requested: this.requestedProfiles.get(root),
+          observed: { model: rerouted ? params.toModel : settings.model, provider: settings.modelProvider, reasoning: settings.effort },
+          source: message.method, evidence: rerouted ? "response" : "configured", reason: params.reason ?? null, previousModel: params.fromModel ?? null
+        })).catch(error => { this.modelObservationError = error; this.rejectAll(error); });
+      }
+    }
+    if (message.id === undefined && (message.method?.startsWith("item/") || message.method === "turn/started" || message.method === "thread/tokenUsage/updated")) {
+      this.activity ??= new Map();
+      const visited = new Set();
+      let id = message.params?.threadId;
+      while (id && !visited.has(id)) {
+        visited.add(id); this.activity.set(id, (this.activity.get(id) ?? 0) + 1);
+        id = this.descendants.get(id)?.parent_provider_session_id;
+      }
+    }
+    // app-server currently returns complete turns even for `includeTurns:
+    // false`.  The individual item notifications are already journalled, so
+    // retain a compact read receipt instead of writing the same transcript on
+    // every status poll.
+    const request = message.id !== undefined ? this.pending.get(message.id) : null;
+    if (request?.method === "thread/read") {
+      const thread = message.result?.thread ?? message.result ?? {};
+      this.journal.write("inbound", { jsonrpc: message.jsonrpc, id: message.id, result: { thread: {
+        id: thread.id ?? null, status: thread.status ?? null, model: thread.model ?? null, modelProvider: thread.modelProvider ?? null, reasoningEffort: thread.reasoningEffort ?? null, updatedAt: thread.updatedAt ?? null,
+        turns: Array.isArray(thread.turns) ? thread.turns.map((turn) => ({ id: turn?.id ?? null, status: turn?.status ?? null, startedAt: turn?.startedAt ?? null, completedAt: turn?.completedAt ?? null })) : []
+      } } });
+    } else this.journal.write("inbound", message);
+    if (message.id !== undefined && message.method) { void this.answerRequest(message); return; }
+    if (message.id !== undefined) {
+      const pending = this.pending.get(message.id); if (!pending) return;
+      clearTimeout(pending.timer); this.pending.delete(message.id);
+      message.error ? pending.reject(Object.assign(new Error(message.error.message ?? JSON.stringify(message.error)), { code: "rpc_error", details: message.error })) : pending.resolve(message.result ?? {});
+      return;
+    }
+    if (message.method === "turn/completed") this.turns.set(message.params?.turn?.id ?? message.params?.threadId, { status: "completed", value: message.params });
+    if (message.method === "turn/started") this.turns.set(message.params?.turn?.id ?? message.params?.threadId, { status: "running", value: message.params });
+    const threadId = message.params?.threadId;
+    if (threadId && message.method === "item/started") this.finalMessages.delete(threadId);
+    if (threadId && message.method === "item/completed" && message.params?.item?.type === "agentMessage") this.finalMessages.set(threadId, { item: message.params.item, completedAt: Date.now() });
+  }
+
+  // Collaboration child Threads are provider facts.  Keep only objects that
+  // explicitly carry both a thread id and parent-thread id; this deliberately
+  // ignores model prose and unrelated turn/item identifiers.
+  observeTopology(value, depth = 0) {
+    if (!value || typeof value !== "object" || depth > 8) return;
+    if (Array.isArray(value)) { for (const item of value) this.observeTopology(item, depth + 1); return; }
+    const id = value.threadId ?? value.id ?? null;
+    const parent = value.parentThreadId ?? value.parent_thread_id ?? null;
+    if (typeof id === "string" && id && typeof parent === "string" && parent) {
+      this.descendants.set(id, { provider_session_id: id, parent_provider_session_id: parent, status: value.status?.type ?? value.status ?? "unknown", source: "codex.app_server" });
+    }
+    for (const child of Object.values(value)) this.observeTopology(child, depth + 1);
+  }
+
+  directChildren(sessionId) {
+    return [...this.descendants.values()].filter((child) => child.parent_provider_session_id === sessionId);
+  }
+
+  async answerRequest(message) {
+    // Eval runs are non-interactive. A request is evidence for the runner, not
+    // permission to continue. Do not silently approve a tool or elicitation.
+    // A JSON-RPC error is deliberately used instead of inventing a generic
+    // `{ decision: "deny" }` payload: app-server request methods have distinct
+    // result schemas, while every one must fail closed in a non-interactive
+    // eval.  The runner can classify this journalled request as infrastructure
+    // or unexpected interaction without corrupting the provider protocol.
+    const error = { code: -32001, message: `dd-codex refuses interactive request: ${message.method}` };
+    this.journal.write("request_refused", { method: message.method, params: message.params, error });
+    this.send({ jsonrpc: "2.0", id: message.id, error });
+  }
+
+  request(method, params = {}, timeoutMs = this.options.timeoutMs ?? 120_000) {
+    const id = this.nextId++;
+    return new Promise((resolve, reject) => {
+      const timer = observedTimeout(() => { this.pending.delete(id); reject(Object.assign(new Error(`${method} timed out`), { code: "rpc_timeout" })); }, timeoutMs, { onGap: gap => this.journal.write("observation_gap", { ...gap, method, request_id: id }) });
+      this.pending.set(id, { resolve, reject, timer, method }); this.send({ jsonrpc: "2.0", id, method, params });
+    });
+  }
+  send(value) { this.journal.write("outbound", value); this.child.stdin.write(`${JSON.stringify(value)}\n`); }
+  rejectAll(error) { for (const pending of this.pending.values()) { clearTimeout(pending.timer); pending.reject(error); } this.pending.clear(); }
+  async close() {
+    if (!this.child) return;
+    this.child.stdin.end();
+    await Promise.race([new Promise((resolve) => this.child.once("exit", resolve)), new Promise((resolve) => setTimeout(resolve, 2_000))]);
+    await stopProcessGroup(this.child, 2_000);
+    await this.modelObservations;
+    await this.journal.flush();
+  }
+}
+
+async function withBridge(options, action) { const bridge = new CodexBridge(options); try { await bridge.start(); return await action(bridge); } finally { await bridge.close(); } }
+function profile(options) { return { harness: "codex-desktop", model: options.model ?? null, reasoning: options.reasoning ?? null }; }
+function threadId(result) { const id = result?.thread?.id ?? result?.threadId; return required(id, "Codex thread id"); }
+function directChildren(bridge, sessionId) { return typeof bridge?.directChildren === "function" ? bridge.directChildren(sessionId) : []; }
+
+export async function doctor(options = {}) {
+  const codex_cli = parseCodexCliVersion(await commandText(options.bin ?? process.env.DD_CODEX_BIN ?? "codex", ["--version"]));
+  return await withBridge(options, async () => ({ harness: "codex-desktop", app_server: "available", observed_runtime: { codex_cli, dd_harness_contract: "dd-codex-harness@1" }, requested_profile: profile(options), observed_at: now() }));
+}
+
+async function observeCodexProfile(bridge, options, id, observed, source) {
+  bridge.requestedProfiles?.set(id, profile(options));
+  await bridge.modelObservations;
+  if (bridge.modelObservationError) throw bridge.modelObservationError;
+  await observeModel({ journal: options.journal ?? bridge.options?.journal, harness: "codex-desktop", sessionId: id,
+    parentSessionId: bridge.descendants?.get(id)?.parent_provider_session_id ?? null, requested: profile(options), observed, source });
+  return observed;
+}
+
+export async function createSession(options) {
+  return await withBridge(options, async (bridge) => await createSessionWithBridge(bridge, options));
+}
+
+export async function createSessionWithBridge(bridge, options) {
+  const cwd = absolute(options.cwd, "--cwd");
+  // dd-codex is the eval-only adapter. Its CODEX_HOME is generated by
+  // dd-flow, so trust only that managed PreToolUse hook for this thread and
+  // do not load user plugin hooks into the isolated evaluator.
+  const result = await bridge.request("thread/start", {
+    cwd,
+    model: options.model ?? null,
+    approvalPolicy: "never",
+    sandbox: "danger-full-access",
+    ephemeral: false,
+    config: { bypass_hook_trust: true, "features.plugins": false }
+  });
+  // ThreadStartParams has no reasoning-effort field.  The first turn applies
+  // it, so reporting the Desktop default here would be a false profile drift.
+  return { harness: "codex-desktop", provider_session_id: threadId(result), adapter_session_id: threadId(result), requested_profile: profile(options), observed_profile: await observeCodexProfile(bridge, options, threadId(result), { model: result.model ?? null, reasoning: result.reasoningEffort ?? null, provider: result.modelProvider ?? null }, "thread/start.response"), cwd: result.cwd ?? cwd };
+}
+
+export async function promptSession(options) {
+  return await withBridge(options, async (bridge) => await promptSessionWithBridge(bridge, options));
+}
+
+export async function startSession(options) {
+  return await withBridge(options, async (bridge) => await startSessionWithBridge(bridge, options));
+}
+
+export async function startSessionWithBridge(bridge, options) {
+  const sessionId = required(options.sessionId, "--session-id"); const cwd = absolute(options.cwd, "--cwd"); const prompt = required(options.prompt, "--prompt");
+  await ensureThreadLoaded(bridge, sessionId, options, cwd);
+  bridge.requestedProfiles?.set(sessionId, profile(options));
+  bridge.finalMessages?.delete(sessionId);
+  options.assertDispatch?.();
+  const started = await bridge.request("turn/start", { threadId: sessionId, input: [{ type: "text", text: prompt }], cwd, model: options.model ?? null, effort: options.reasoning ?? null, approvalPolicy: "never", sandboxPolicy: { type: "dangerFullAccess" } }, options.timeoutMs ?? 30_000);
+  const turn = started?.turn ?? started; const turnId = turn?.id ?? null;
+  if (typeof turnId !== "string" || !turnId) throw new Error("Codex did not return a Turn id");
+  return { harness: "codex-desktop", provider_session_id: sessionId, adapter_session_id: sessionId, turn_id: turnId, status: "started", requested_profile: profile(options), observed_profile: { model: null, reasoning: null } };
+}
+
+export async function promptSessionWithBridge(bridge, options) {
+  const sessionId = required(options.sessionId, "--session-id"); const cwd = absolute(options.cwd, "--cwd"); const prompt = required(options.prompt, "--prompt");
+  await ensureThreadLoaded(bridge, sessionId, options, cwd);
+  // A final-message fallback belongs only to the Turn that produced it.  A
+  // new Turn may start before app-server emits its first item notification;
+  // clearing here prevents the previous receipt from completing the new Turn.
+  bridge.requestedProfiles?.set(sessionId, profile(options));
+  bridge.finalMessages?.delete(sessionId);
+  options.assertDispatch?.();
+  const started = await bridge.request("turn/start", { threadId: sessionId, input: [{ type: "text", text: prompt }], cwd, model: options.model ?? null, effort: options.reasoning ?? null, approvalPolicy: "never", sandboxPolicy: { type: "dangerFullAccess" } }, options.timeoutMs ?? 1_800_000);
+  const turn = started?.turn ?? started; const turnId = turn?.id ?? null;
+  const completed = await waitForTurn(bridge, sessionId, turnId, options.timeoutMs ?? 1_800_000, options, cwd);
+  const thread = await readCompletedThread(bridge, sessionId);
+  const assistantText = latestAssistantText(thread) ?? latestAssistantText(completed);
+  return { harness: "codex-desktop", provider_session_id: sessionId, adapter_session_id: sessionId, turn_id: turnId, status: "completed", turn: completed, ...(thread ? { thread } : {}), descendants: directChildren(bridge, sessionId), ...(assistantText ? { assistant_text: assistantText } : {}), requested_profile: profile(options), observed_profile: await observeCodexProfile(bridge, options, sessionId, { model: thread?.model ?? null, reasoning: thread?.reasoningEffort ?? null, provider: thread?.modelProvider ?? null }, "thread/read.after_turn") };
+}
+
+async function ensureThreadLoaded(bridge, sessionId, options, cwd) {
+  const value = await bridge.request("thread/read", { threadId: sessionId, includeTurns: false }, 10_000);
+  const thread = value?.thread ?? value;
+  if (thread?.status?.type !== "notLoaded") return;
+  await bridge.request("thread/resume", {
+    threadId: sessionId,
+    cwd,
+    model: options.model ?? null,
+    approvalPolicy: "never",
+    sandbox: "danger-full-access",
+    config: { bypass_hook_trust: true, "features.plugins": false }
+  }, 30_000);
+}
+
+async function waitForTurn(bridge, sessionId, turnId, timeoutMs, options, cwd) {
+  const clock = new ObservationClock({ timeoutMs, onGap: gap => bridge.journal?.write("observation_gap", { ...gap, session_id: sessionId, turn_id: turnId }) });
+  // app-server can briefly expose the new Turn as `interrupted` between the
+  // turn/start response and its turn/started notification. Give that snapshot
+  // one event-loop grace window before treating failure as authoritative.
+  const failureNotBefore = Date.now() + 1_000;
+  let nextStoredReadAt = Date.now();
+  while (!clock.sample(bridge.activity?.get(sessionId))) {
+    const known = bridge.turns.get(turnId) ?? bridge.turns.get(sessionId); if (known?.status === "completed") return terminalTurn(known.value, turnId, bridge);
+    if (Date.now() >= nextStoredReadAt) {
+      const stored = await readTurn(bridge, sessionId, turnId, false);
+      if (stored?.turn && isAuthoritativeTerminal(bridge, turnId, stored.turn.status, stored.threadStatus, failureNotBefore)) return terminalTurn({ turn: stored.turn }, turnId, bridge);
+      // A loaded app-server can retain a stale `active` Thread state after a
+      // provider-side interruption. The persisted turn page is independent of
+      // that live subscription and is the compact authority for its terminal
+      // status; unlike `includeTurns`, it never hydrates the whole history.
+      const persisted = await readPersistedTurn(bridge, sessionId, turnId);
+      if (persisted && isAuthoritativeTerminal(bridge, turnId, persisted.status, stored?.threadStatus, failureNotBefore)) return terminalTurn({ turn: persisted }, turnId, bridge);
+      // Desktop may unload an idle Thread immediately after an interrupted
+      // Turn. Reload it once before polling again: otherwise the compact
+      // status remains `notLoaded` forever and hides the terminal Turn.
+      if (stored?.threadStatus === "notLoaded") {
+        await ensureThreadLoaded(bridge, sessionId, options, cwd);
+        const hydrated = await readTurn(bridge, sessionId, turnId, true);
+        if (hydrated?.turn && isAuthoritativeTerminal(bridge, turnId, hydrated.turn.status, hydrated.threadStatus, failureNotBefore)) return terminalTurn({ turn: hydrated.turn }, turnId, bridge);
+      }
+      // Some app-server versions correctly omit turns for a compact read.
+      // Once the thread is idle, hydrate exactly once to recover the terminal
+      // turn instead of waiting for the global timeout.
+      if (stored?.threadStatus === "idle") {
+        const hydrated = await readTurn(bridge, sessionId, turnId, true);
+        // "idle" only describes the Thread.  Some app-server builds retain
+        // an inProgress Turn after emitting the final agent message; treating
+        // that stale Turn as terminal incorrectly aborts an otherwise usable
+        // worker session.
+        if (hydrated?.turn && isAuthoritativeTerminal(bridge, turnId, hydrated.turn.status, hydrated.threadStatus, failureNotBefore)) return terminalTurn({ turn: hydrated.turn }, turnId, bridge);
+      }
+      // Some app-server builds emit a final agent message but omit both the
+      // terminal event and the compact turn record. Wait briefly, hydrate once,
+      // then preserve that message as the terminal receipt if still omitted.
+      const final = bridge.finalMessages?.get(sessionId);
+      // Agent messages are streamed as completed items while a Turn is still
+      // reasoning and calling tools.  They are terminal evidence only after
+      // app-server reports the Thread idle.
+      if (final && stored?.threadStatus === "idle" && Date.now() - final.completedAt >= 1_000) {
+        const hydrated = await readTurn(bridge, sessionId, turnId, true);
+        if (hydrated?.turn && isAuthoritativeTerminal(bridge, turnId, hydrated.turn.status, hydrated.threadStatus, failureNotBefore)) return terminalTurn({ turn: hydrated.turn }, turnId, bridge);
+        return terminalTurn({ turn: { id: turnId, status: "completed", synthetic: true, final_message: final.item } }, turnId, bridge);
+      }
+      nextStoredReadAt = Date.now() < failureNotBefore ? failureNotBefore : Date.now() + 15_000;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 250));
+  }
+  fail("Codex turn timed out", "turn_timeout");
+}
+
+function terminalTurn(value, turnId, bridge) {
+  // A terminal event may arrive while an older snapshot RPC is in flight.
+  const observed = bridge.turns.get(turnId);
+  if (observed?.status === "completed") value = observed.value;
+  const turn = value?.turn ?? value;
+  if (turn?.status && turn.status !== "completed") fail(`Codex turn ${turnId ?? "unknown"} ended as ${turn.status}`, "turn_interrupted");
+  return value;
+}
+
+function isTerminalTurnStatus(status) { return ["completed", "failed", "interrupted", "cancelled"].includes(status); }
+function isAuthoritativeTerminal(bridge, turnId, status, threadStatus, failureNotBefore) {
+  if (!isTerminalTurnStatus(status)) return false;
+  if (status === "completed") return true;
+  if (Date.now() < failureNotBefore) return false;
+  return !(bridge.turns.get(turnId)?.status === "running" && threadStatus === "active");
+}
+
+async function readTurn(bridge, sessionId, turnId, includeTurns) {
+  if (!turnId) return null;
+  try {
+    const result = await bridge.request("thread/read", { threadId: sessionId, includeTurns }, 10_000);
+    const thread = result?.thread ?? result;
+    return { turn: Array.isArray(thread?.turns) ? thread.turns.find((turn) => turn?.id === turnId) ?? null : null, threadStatus: thread?.status?.type ?? null };
+  } catch { return null; }
+}
+
+async function readPersistedTurn(bridge, sessionId, turnId) {
+  try {
+    const result = await bridge.request("thread/turns/list", { threadId: sessionId, limit: 20, sortDirection: "desc", itemsView: "summary" }, 10_000);
+    return Array.isArray(result?.data) ? result.data.find((turn) => turn?.id === turnId) ?? null : null;
+  } catch { return null; }
+}
+
+async function readCompletedThread(bridge, sessionId) {
+  for (let attempt = 0; attempt < 8; attempt += 1) {
+    try { const result = await bridge.request("thread/read", { threadId: sessionId, includeTurns: true }, 10_000); return result?.thread ?? result; }
+    catch (error) { bridge.journal.write("thread_read_retry", { session_id: sessionId, attempt, error: error.message }); await new Promise((resolve) => setTimeout(resolve, 150)); }
+  }
+  return null;
+}
+
+function latestAssistantText(value) {
+  const messages = value?.messages ?? value?.items ?? value?.turn?.items ?? [];
+  if (!Array.isArray(messages)) return null;
+  for (const message of [...messages].reverse()) {
+    if (message?.role !== "assistant" && message?.type !== "agentMessage") continue;
+    const parts = message.content ?? message.parts ?? [];
+    if (typeof message.text === "string") return message.text;
+    if (Array.isArray(parts)) {
+      const text = parts.map((part) => typeof part?.text === "string" ? part.text : typeof part?.content === "string" ? part.content : "").filter(Boolean).join("\n");
+      if (text) return text;
+    }
+  }
+  return null;
+}
+
+export async function inspectSession(options) {
+  return await withBridge(options, async (bridge) => await inspectSessionWithBridge(bridge, options));
+}
+
+export async function inspectSessionWithBridge(bridge, options) {
+  const sessionId = required(options.sessionId, "--session-id"); const value = await bridge.request("thread/read", { threadId: sessionId, includeTurns: false }); const thread = value?.thread ?? value;
+  return { harness: "codex-desktop", provider_session_id: sessionId, adapter_session_id: sessionId, status: thread.status ?? null, thread, descendants: directChildren(bridge, sessionId), requested_profile: profile(options), observed_profile: await observeCodexProfile(bridge, options, sessionId, { model: thread.model ?? null, reasoning: thread.reasoningEffort ?? null, provider: thread.modelProvider ?? null }, "thread/read") };
+}
+
+export async function cancelSession(options) {
+  return await withBridge(options, async (bridge) => await cancelSessionWithBridge(bridge, options));
+}
+
+export async function cancelSessionWithBridge(bridge, options) {
+  const sessionId = required(options.sessionId, "--session-id");
+  let turnId = options.turnId ?? null;
+  if (!turnId) {
+    const result = await bridge.request("thread/read", { threadId: sessionId, includeTurns: true }, 10_000);
+    const thread = result?.thread ?? result;
+    turnId = [...(thread?.turns ?? [])].reverse().find((turn) => turn?.status === "inProgress")?.id ?? null;
+  }
+  if (!turnId) fail("Codex Session has no active Turn to interrupt", "turn_not_active");
+  await bridge.request("turn/interrupt", { threadId: sessionId, turnId });
+  // Interrupt acknowledgement is not a provider terminal receipt. Reconcile
+  // observes the Thread before the runner records terminal cancellation.
+  return { harness: "codex-desktop", provider_session_id: sessionId, adapter_session_id: sessionId, turn_id: turnId, cancelled: true, settled: false };
+}
+
+export async function promptFromFile(file) { return await readFile(absolute(file, "--prompt-file"), "utf8"); }

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

@@ -0,0 +1,123 @@
+import { createHash, randomUUID } from "node:crypto";
+import { chmod, lstat, mkdir, open, unlink, realpath } from "node:fs/promises";
+import { spawn } from "node:child_process";
+import net from "node:net";
+import os from "node:os";
+import { DroidError, DroidRuntime, absolute, droidPaths, droidVersion, prepareDroidHome, readJson, removeDroidAuth, processSnapshot } from "./dd-droid.mjs";
+import { durableDaemonDispatch, inspectDaemonOperation } from "./daemon-operations.mjs";
+import { observedTimeout } from "./observation-clock.mjs";
+import { writeJsonAtomic } from "./runner-events.mjs";
+import { errorRecord } from "./operation-errors.mjs";
+import { cleanupFailedStart, confirmDaemonProcess, confirmDaemonStopped, finishDaemonProcess, heartbeatDaemonProcess, registerDaemonProcess } from "./managed-daemon.mjs";
+
+const REQUEST = "dd-droid/daemon-request@1", RESPONSE = "dd-droid/daemon-response@1";
+async function removeSocket(file) { try { if (!(await lstat(file)).isSocket()) throw new DroidError("unsafe_socket", "Refusing to replace non-socket daemon path"); await unlink(file); } catch (error) { if (error.code !== "ENOENT") throw error; } }
+export async function callDaemon(stateDir, operation, params = {}, timeoutMs = 30_000, operationId = process.env.DD_EVAL_OPERATION_ID ?? randomUUID()) {
+  const paths = droidPaths(stateDir), request = { schema_id: REQUEST, id: operationId, operation, params };
+  return await new Promise((resolve, reject) => {
+    const client = net.createConnection(paths.socket); let buffer = "", settled = false;
+    const finish = (error, value) => { if (settled) return; settled = true; clearTimeout(timer); client.destroy(); error ? reject(error) : resolve(value); };
+    const timer = operation === "session.prompt" ? null : observedTimeout(() => finish(new DroidError("daemon_timeout", `${operation} response was not observed`, { operation_id: operationId })), timeoutMs);
+    client.setEncoding("utf8"); client.on("connect", () => client.write(`${JSON.stringify(request)}\n`));
+    client.on("error", error => finish(new DroidError("daemon_not_running", error.message)));
+    client.on("end", () => finish(new DroidError("daemon_connection_closed", "Droid daemon closed the connection before its reply")));
+    client.on("close", () => finish(new DroidError("daemon_connection_closed", "Droid daemon connection closed")));
+    client.on("data", chunk => { buffer += chunk; const index = buffer.indexOf("\n"); if (index < 0) return; try { const response = JSON.parse(buffer.slice(0, index)); if (response.schema_id !== RESPONSE || response.id !== operationId) throw new DroidError("daemon_protocol", "Droid daemon returned an unrelated response"); response.ok ? finish(null, response.result) : finish(Object.assign(new Error(response.error.message), response.error)); } catch (error) { finish(error); } });
+  });
+}
+function sameConfig(a, b) { return ["cwd", "bin", "model", "reasoning", "mode", "provider", "ddFlowBin", "ddFlowHome", "resourceHome", "projectRoot", "noFlow"].every(key => a?.[key] === b[key]); }
+export async function startDaemon(options) {
+  const paths = droidPaths(options.stateDir), noFlow = options.noFlow === true || (!options.ddFlowBin && !options.ddFlowHome);
+  const config = { stateDir: paths.dir, home: paths.home, bin: options.bin ?? process.env.DD_DROID_BIN ?? "droid", cwd: absolute(options.cwd, "--cwd"), projectRoot: absolute(options.projectRoot ?? options.cwd, "--project-root"), journal: absolute(options.journal ?? `${paths.dir}/events.jsonl`, "--journal"), entryPath: absolute(options.entryPath, "adapter entry"), authHome: absolute(options.authHome ?? os.homedir(), "auth home"), model: options.model ?? "gpt-5.6-sol", reasoning: options.reasoning ?? "high", mode: options.mode ?? "auto-high", provider: options.provider ?? "openai", noFlow, ddFlowBin: noFlow ? null : absolute(options.ddFlowBin, "--dd-flow-bin"), ddFlowHome: noFlow ? null : absolute(options.ddFlowHome, "--dd-flow-home"), resourceHome: noFlow ? null : process.env.DD_FLOW_RESOURCE_HOME ?? null, inactivityMs: options.timeoutMs ?? 600_000 };
+  config.cwd = await realpath(config.cwd); config.projectRoot = await realpath(config.projectRoot);
+  if (config.mode !== "auto-high") throw new DroidError("droid_mode_unsupported", "The qualified Droid profile requires auto-high");
+  await mkdir(paths.dir, { recursive: true, mode: 0o700 }); await chmod(paths.dir, 0o700);
+  try { const live = await callDaemon(paths.dir, "daemon.status", {}, 1_000); if (!sameConfig(live.config, config)) throw new DroidError("daemon_config_mismatch", "Droid daemon already uses another configuration"); return { ...live, already_running: true }; } catch (error) { if (!["daemon_not_running", "daemon_timeout"].includes(error.code)) throw error; }
+  const previous = await readJson(paths.state);
+  if (previous) {
+    const rows = await processSnapshot();
+    if (rows.some(row => !row.zombie && ([previous.pid, previous.provider_pid].includes(row.pid) || previous.owned_processes?.some(old => old.pid === row.pid && old.started === row.started)))) throw new DroidError("invalid_harness_crash", "Previous daemon or provider ownership remains; refusing another owner");
+  }
+  if (["clean", "unclean"].includes(previous?.shutdown_state)) await authorizeRetainedDaemonResume(paths.dir, previous, options.sessionId, config);
+  if (previous && !["failed", "starting", "clean"].includes(previous.shutdown_state)) throw new DroidError("invalid_harness_crash", "Previous Droid ownership must be reconciled before another daemon starts");
+  config.daemonId = randomUUID(); config.version = await droidVersion(config.bin);
+  await removeSocket(paths.socket); const home = await prepareDroidHome(config); Object.assign(config, home);
+  const resource = await registerDaemonProcess(config, { kind: "droid-daemon", owner: `droid:${config.daemonId}`, operation: `droid-daemon:${config.daemonId}`, stdout: paths.log, stderr: paths.log });
+  await writeJsonAtomic(paths.state, { schema_id: "dd-droid/daemon-state@1", config, daemon_id: config.daemonId, shutdown_state: "starting", sessions: previous?.sessions ?? [], root_session_id: previous?.root_session_id ?? null, descendants: previous?.descendants ?? [], last_result: previous?.last_result ?? null, resource_process: resource });
+  const log = await open(paths.log, "a", 0o600); const child = spawn(process.execPath, [config.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, resource, child);
+    const deadline = Date.now() + 30_000;
+    while (Date.now() < deadline) { await new Promise(resolve => setTimeout(resolve, 100)); const saved = await readJson(paths.state); if (saved?.startup_error) throw Object.assign(new Error(saved.startup_error.message), saved.startup_error); try { return await callDaemon(paths.dir, "daemon.status", {}, 1_000); } catch (error) { if (!["daemon_not_running", "daemon_timeout"].includes(error.code)) throw error; } }
+    throw new DroidError("daemon_start_failed", "Droid daemon did not become ready");
+  } catch (error) { await cleanupFailedStart(config, resource, child, error); throw error; }
+}
+export async function stopDaemon(options) { return await confirmDaemonStopped(() => callDaemon(options.stateDir, "daemon.stop", { cancelTree: options.cancelTree === true }, 30_000), droidPaths(options.stateDir).socket, 30_000); }
+export async function serveDaemon(stateDir) {
+  const paths = droidPaths(stateDir), state = await readJson(paths.state); if (!state?.config) throw new DroidError("daemon_state_missing", "Missing Droid daemon state");
+  let saving = Promise.resolve(), busy = null, stopping = false;
+  const save = patch => { Object.assign(state, patch, { pid: process.pid, updated_at: new Date().toISOString() }); const snapshot = structuredClone(state); saving = saving.then(() => writeJsonAtomic(paths.state, snapshot)); return saving; };
+  const runtime = new DroidRuntime(state.config, state, save);
+  const dispatch = async request => {
+    const params = request.params ?? {}, operation = request.operation;
+    if (operation === "daemon.status") { let observationError; try { await runtime.refreshTopology(); } catch (error) { observationError = errorRecord(error); } return { observation_error: observationError ?? null, daemon_id: state.daemon_id, pid: process.pid, config: state.config, shutdown_state: state.shutdown_state, provider_ready: Boolean(runtime.child && !runtime.closed), active_operation: busy, active_tree: Boolean(runtime.active || runtime.workingState !== "idle" || runtime.topologyIncomplete || [...runtime.topology.values()].some(child => !["completed", "cancelled", "failed"].includes(child.status))), sessions: runtime.rootId ? [runtime.rootId] : [], provider_pid: runtime.closed ? null : runtime.child?.pid }; }
+    if (operation === "hook.observe") return await runtime.observeHook(params.payload, params.eventId);
+    if (operation === "session.inspect") return await runtime.inspect(params.sessionId);
+    if (operation === "session.cancel") {
+      runtime.requireIdentity(params.sessionId); const cleanup = await runtime.closeTree(true); let inspected;
+      try { inspected = await runtime.inspect(params.sessionId, { ignoreActive: true }); }
+      catch (error) { inspected = { harness: "droid-cli", provider_session_id: params.sessionId, descendants: [...runtime.topology.values()], inspection_error: errorRecord(error) }; }
+      return { ...inspected, cancelled: true, settled: cleanup.settled, cleanup };
+    }
+    if (operation === "daemon.stop") {
+      if (stopping) throw new DroidError("operation_busy", "Droid shutdown is already in progress");
+      if (!params.cancelTree && (busy || (runtime.rootId && !(await runtime.inspect(runtime.rootId)).settled))) throw new DroidError("tree_not_settled", "Droid still owns unfinished work");
+      stopping = true;
+      try {
+        const cleanup = await runtime.closeTree(params.cancelTree === true);
+        if (runtime.rootId) try { await runtime.inspect(runtime.rootId, { ignoreActive: true }); } catch (error) { cleanup.inspection_error = errorRecord(error); }
+        // Native evidence failures remain visible, but cannot strand copied
+        // credentials or the daemon after the owned process tree is gone.
+        await removeDroidAuth(state.config); const clean = !cleanup.forced && !cleanup.topology_error && !cleanup.inspection_error;
+        await save({ shutdown_state: clean ? "clean" : "unclean", active_tree: false, cleanup }); await finishDaemonProcess(state.config, state.resource_process);
+        return { stopped: true, clean, settled: true, cleanup, _shutdown: true };
+      }
+      catch (error) { stopping = false; await save({ shutdown_state: "cleanup_failed", cleanup_error: errorRecord(error) }); throw error; }
+    }
+    if (busy || stopping) throw new DroidError("operation_busy", "Another Droid operation is active");
+    busy = operation; await save({ active_operation: busy });
+    try {
+      if (operation === "session.create") { if (params.prompt) throw new DroidError("invalid_create", "create does not execute a prompt"); return await runtime.create(request.id); }
+      if (operation === "session.resume") return await runtime.resume(params.sessionId);
+      if (["session.prompt", "session.start"].includes(operation)) return await runtime.prompt(params.sessionId, params.prompt, request.id);
+      throw new DroidError("unknown_operation", `Unknown Droid operation: ${operation}`);
+    } finally { busy = null; await save({ active_operation: null }); }
+  };
+  await removeSocket(paths.socket);
+  const server = net.createServer(socket => { socket.setEncoding("utf8"); let buffer = "", consumed = false; socket.on("error", () => {}); socket.on("data", chunk => { if (consumed) return; buffer += chunk; 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 !== REQUEST || typeof request.id !== "string" || typeof request.operation !== "string") throw new DroidError("daemon_protocol", "Malformed Droid daemon request"); let result;
+      if (request.operation === "operation.inspect") {
+        result = await inspectDaemonOperation(paths.dir, request.params?.operationId);
+        if (!["completed", "failed"].includes(result.state)) {
+          const recovered = await runtime.recoverOperation(request.params.operationId);
+          if (recovered) {
+            const terminal = { state: "completed", finished_at: new Date().toISOString(), result: recovered };
+            await writeJsonAtomic(`${paths.dir}/operations/${createHash("sha256").update(request.params.operationId).digest("hex")}/result.json`, terminal);
+            result = { ...result, ...terminal };
+          }
+        }
+      } else result = await durableDaemonDispatch(paths.dir, request, () => dispatch(request)); const { _shutdown, ...receipt } = result;
+      // Close the listening endpoint before replying. `server.close()` keeps
+      // this already accepted connection alive, so the caller receives its
+      // durable stop receipt while the Unix pathname is atomically retired.
+      // Unlinking it from the request handler races that final response and
+      // can leave a stop caller observing the socket for its whole timeout.
+      if (_shutdown) server.close();
+      socket.end(`${JSON.stringify({ schema_id: RESPONSE, id: request.id, ok: true, result: receipt })}\n`);
+      } catch (error) { socket.end(`${JSON.stringify({ schema_id: RESPONSE, id: request?.id, ok: false, error: errorRecord(error) })}\n`); } })();
+  }); });
+  try { await runtime.start(); await heartbeatDaemonProcess(state.config, state.resource_process); await save({ shutdown_state: "running" }); await new Promise((resolve, reject) => { server.once("error", reject); server.listen(paths.socket, resolve); }); await chmod(paths.socket, 0o600); }
+  catch (error) { let cleanup; try { cleanup = await runtime.closeTree(true); await removeDroidAuth(state.config); } catch (failure) { await save({ shutdown_state: "cleanup_failed", startup_error: errorRecord(error), cleanup_error: errorRecord(failure) }); throw error; } await save({ shutdown_state: "failed", startup_error: errorRecord(error), cleanup }); await finishDaemonProcess(state.config, state.resource_process, "failed", "startup_failed"); throw error; }
+  await new Promise(resolve => server.once("close", resolve));
+}
+import { authorizeRetainedDaemonResume } from "./driver-recovery.mjs";