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

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

@@ -0,0 +1,627 @@
+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 { openCodeToolObservation, journalToolObservations } from "./tool-observations.mjs";
+import { ObservationClock } from "./observation-clock.mjs";
+import { createHash, randomBytes, randomUUID } from "node:crypto";
+import { appendFile, chmod, lstat, mkdir, open, readFile, realpath, unlink, writeFile } from "node:fs/promises";
+import { spawn } from "node:child_process";
+import net from "node:net";
+import { durableDaemonDispatch, completeDaemonShutdown, commitDaemonShutdown, trackDaemonConnections, retireDaemonEndpoint, retireFailedDaemon, assertDaemonDispatch, assertDaemonRestartable } from "./daemon-operations.mjs";
+import { waitForSettlement } from "./session-settlement.mjs";
+import { nativeExecutionReceipt } from "./native-children.mjs";
+import { errorRecord, isProvenShellCorrection, reportedError } from "./operation-errors.mjs";
+import { checkObservedProfile, observeModel } from "./model-observations.mjs";
+import os from "node:os";
+import path from "node:path";
+import { parse as parseJsonc } from "jsonc-parser";
+import { writeJsonAtomic } from "./runner-events.mjs";
+import { OpenCodeClient, OpenCodeError, historyDigest, usageSnapshot, nativeModel } from "./dd-opencode.mjs";
+import { safeProviderError } from "./provider-overload-policy.mjs";
+import { acceptNativeHookRequest, hookBudget, readNativeHookFailures } from "./native-hook-command.mjs";
+import { assertStartupChild, retainStartupFailure, prepareRuntimeOwner, cleanupFailedStart, cleanupFailedDaemonStart, confirmDaemonProcess, confirmDaemonStopped, finishDaemonProcess, scheduleDaemonProcessHeartbeat, registerDaemonProcess, stopProcessGroup } from "./managed-daemon.mjs";
+
+const REQUEST_SCHEMA = "dd-opencode/daemon-request@1", RESPONSE_SCHEMA = "dd-opencode/daemon-response@1", STATE_SCHEMA = "dd-opencode/daemon-state@2", ARCHIVE_SCHEMA = "dd-opencode/session-archive@2";
+class DaemonError extends Error { constructor(code, message, retryable = false, details) { super(message); this.code = code; this.retryable = retryable; this.details = details; } }
+const absolute = (value, label) => { if (!value || !path.isAbsolute(value)) throw new DaemonError("invalid_path", `${label} must be an absolute path`); return path.resolve(value); };
+export function openCodeProfileOptions(options) {
+  for (const [native, shared] of [["variant", "reasoning"], ["agent", "mode"]]) {
+    if (options[native] !== undefined && options[shared] !== undefined && options[native] !== options[shared]) throw new DaemonError("profile_conflict", `--${native} and --${shared} disagree`);
+  }
+  return { variant: options.variant ?? options.reasoning, agent: options.agent ?? options.mode };
+}
+export async function doctor(options) {
+  if (options.stateDir) return await callDaemon(options.stateDir, "daemon.doctor");
+  const output = (await run(options.bin ?? process.env.DD_OPENCODE_BIN ?? "opencode", ["--version"], { cwd: options.cwd ?? process.cwd() })).trim();
+  const version = output.match(/(?:^|\s)v?(2\.\d+\.\d+(?:[-+][\w.-]+)?)(?:\s|$)/)?.[1];
+  if (!version) throw new DaemonError("unsupported_version", "dd-opencode supports OpenCode v2 only");
+  return { compatible: true, native_protocol: 2, observed_runtime: { opencode: version }, productive_hooks: false, profile_observation: "pending_native_session" };
+}
+function locations(stateDir) { const dir = absolute(stateDir, "--state-dir"), local = path.join(dir, "daemon.sock"); return { dir, socket: Buffer.byteLength(local) < 100 ? local : `/tmp/dd-opencode-${createHash("sha256").update(dir).digest("hex").slice(0, 20)}.sock`, state: path.join(dir, "daemon.json"), journal: path.join(dir, "events.jsonl"), log: path.join(dir, "daemon.log"), data: path.join(dir, "xdg-data"), config: path.join(dir, "xdg-config"), cache: path.join(dir, "xdg-cache"), archive: path.join(dir, "import.json"), db: path.join(dir, "native.db"), xdgState: path.join(dir, "xdg-state") }; }
+const writeJson = writeJsonAtomic;
+async function readState(dir) { try { return JSON.parse(await readFile(locations(dir).state, "utf8")); } catch (error) { if (error.code === "ENOENT") return null; throw error; } }
+async function removeSocket(paths) { try { if (!(await lstat(paths.socket)).isSocket()) throw new DaemonError("unsafe_socket", "refusing to replace non-socket daemon path"); await unlink(paths.socket); } catch (error) { if (error.code !== "ENOENT") throw error; } }
+function executable(bin, args = []) { return /\.[cm]?js$/.test(bin) ? { command: process.execPath, args: [bin, ...args] } : { command: bin, args }; }
+export function isolatedEnv(config) {
+  const env = { ...process.env };
+  for (const name of ["OPENCODE_CONFIG", "OPENCODE_CONFIG_CONTENT", "OPENCODE_PASSWORD", "OPENCODE_PTY_HANDOFF", "OPENCODE_SERVER", "OPENCODE_SIMULATE"]) delete env[name];
+  return { ...env, XDG_DATA_HOME: config.dataHome, XDG_CONFIG_HOME: config.configHome, XDG_CACHE_HOME: config.cacheHome,
+    XDG_STATE_HOME: config.stateHome, OPENCODE_DB: config.database, OPENCODE_CONFIG_DIR: config.adapterDir,
+    OPENCODE_CONFIG_PROJECT_DISABLE: "1", OPENCODE_SERVER_PASSWORD: config.password,
+    ...managedFlowEnv(config),
+    DD_OPENCODE_PLUGIN_SHA256: config.pluginSha256 ?? "none" };
+}
+export async function run(bin, args, config, options = {}) {
+  const { stdin, timeoutMs = 30_000, startupMs = options.timeoutMs ?? SETUP_STARTUP_MS } = options;
+  return await commandText(bin, args, { cwd: config.cwd, env: isolatedEnv(config), input: stdin ?? null, timeoutMs, startupMs, phase: args.includes('--version') ? 'native-version' : 'native-utility' });
+}
+async function forwardUsage(config, sessionId, snapshot) {
+  if (!config.ddFlowBin) return;
+  const payload = { provider_session_id: sessionId, daemon_id: config.daemonId, observed_at: new Date().toISOString(), usage_scope: "physical_session", completeness: snapshot.completeness, usage: { inputTokens: snapshot.input_tokens, outputTokens: snapshot.output_tokens, reasoningTokens: snapshot.reasoning_tokens, cacheReadInputTokens: snapshot.cached_input_tokens, cacheWriteInputTokens: snapshot.cache_write_tokens, totalTokens: snapshot.total_tokens, ...(snapshot.cost_usd === null ? {} : { costUsd: snapshot.cost_usd }) }, tool_calls: snapshot.tool_calls };
+  await run(config.ddFlowBin, ["opencode", "usage", "ingest", "--project-root", config.projectRoot, "--json"], config, { stdin: `${JSON.stringify(payload)}\n` });
+}
+async function freePort() { return await new Promise((resolve, reject) => { const server = net.createServer(); server.once("error", reject); server.listen(0, "127.0.0.1", () => { const port = server.address().port; server.close(() => resolve(port)); }); }); }
+const errorPayload = errorRecord;
+
+async function writePlugin(paths, config) {
+  const directory = path.join(paths.config, "opencode", "plugins"); await mkdir(directory, { recursive: true, mode: 0o700 });
+  const source = `import { makeOpenCodePlugin } from ${JSON.stringify(new URL("./opencode-plugin.mjs", import.meta.url).href)};\nexport default makeOpenCodePlugin(${JSON.stringify({ stateDir: paths.dir, daemonId: config.daemonId, version: config.version, ddFlowBin: config.ddFlowBin, nodeBin: process.execPath, ddFlowHome: config.ddFlowHome, projectRoot: config.projectRoot, resourceHome: config.resourceHome })});\n`;
+  const checksum = createHash("sha256").update(source).digest("hex"); await writeFile(path.join(directory, "dd-flow.js"), source, { mode: 0o600 }); return checksum;
+}
+async function prepare(paths, config, authSource) {
+  for (const dir of [paths.data, paths.config, paths.cache, paths.xdgState, path.join(paths.config, "opencode")]) { await mkdir(dir, { recursive: true, mode: 0o700 }); await chmod(dir, 0o700); }
+  const authTarget = path.join(paths.data, "opencode", "auth.json"); await mkdir(path.dirname(authTarget), { recursive: true, mode: 0o700 });
+  try { const source = JSON.parse(await readFile(authSource, "utf8")); const selected = !Array.isArray(source) && source[config.provider];
+    if (selected) { await writeJson(authTarget, { [config.provider]: selected }); config.authStatus = "selected_portable"; }
+    else config.authStatus = "absent";
+  } catch (error) { if (error.code !== "ENOENT") throw error; config.authStatus = "absent"; }
+  let portable = {}, policies, permissions = [{ action: "*", resource: "*", effect: "allow" }], agentRestrictions = {};
+  try { const errors = [], source = parseJsonc(await readFile(config.configSource, "utf8"), errors, { allowTrailingComma: true }); if (errors.length || !source || typeof source !== "object" || Array.isArray(source)) throw new Error("invalid config");
+    portable = Object.fromEntries(["provider", "providers", "permission", "tools"].filter(key => source[key] !== undefined).map(key => [key, source[key]]));
+    // Explicit operator policies outrank our permissive empty-home defaults.
+    // Let v2 normalize legacy permission fields instead of guessing mappings.
+    if (source.permissions !== undefined || source.permission !== undefined || source.tools !== undefined) permissions = source.permissions ?? [];
+    policies = source.experimental?.policies;
+    for (const [name, agents] of [["agent", source.agent], ["agents", source.agents]]) {
+      const selected = agents?.[config.agent];
+      if (selected) agentRestrictions[name] = { [config.agent]: Object.fromEntries(["permission", "permissions", "tools"].filter(key => selected[key] !== undefined).map(key => [key, selected[key]])) };
+    }
+  }
+  catch (error) { if (error.code !== "ENOENT") throw new DaemonError("opencode_config_invalid", "Portable OpenCode provider config must be valid JSON"); }
+  const generatedConfig = { ...portable, ...agentRestrictions, permissions,
+    agents: { ...agentRestrictions.agents, "dd-flow-worker": { ...agentRestrictions.agent?.[config.agent], ...agentRestrictions.agents?.[config.agent], mode: "subagent", system: "Execute the assigned dd-flow Work. Follow the issued lifecycle instructions. Do not spawn descendants.", model: `${config.provider}/${config.model}${config.variant !== "default" ? `#${config.variant}` : ""}` } },
+    experimental: { subagent_depth: 1, ...(policies ? { policies } : {}) } };
+  const configPath = path.join(paths.config, "opencode", "opencode.json");
+  await writeJson(configPath, generatedConfig);
+  config.workerLaunchConfig = { locator: configPath, sha256: createHash('sha256').update(await readFile(configPath)).digest('hex'), primary_agent: config.agent, subagent: 'dd-flow-worker', max_depth: 1 };
+  config.pluginSha256 = await writePlugin(paths, config);
+}
+async function bootstrapCredentials(config, client) {
+  let source;
+  try { source = JSON.parse(await readFile(config.authSource, "utf8")); }
+  catch (error) { if (error.code === "ENOENT") return "absent"; throw new DaemonError("opencode_credentials_invalid", "Portable credentials are not valid JSON"); }
+  const entry = Array.isArray(source) ? source.find(item => item.integrationID === config.provider && item.active === true) : null;
+  const legacy = !Array.isArray(source) ? source[config.provider] : null;
+  const value = entry?.value ?? (legacy?.type === "api" ? { type: "key", key: legacy.key } : null);
+  // OAuth/external entries imported by the native v1 migration are retained;
+  // v2 exports use native credential values, never a copied user database.
+  let selected = (await client.call("credential.list")).find(item => item.integrationID === config.provider && item.active);
+  if (value && JSON.stringify(selected?.value) !== JSON.stringify(value)) {
+    if (selected) await client.call("credential.update", { id: selected.id, value }, { productive: true });
+    else await client.call("credential.create", { integrationID: config.provider, label: "dd-flow portable", value, activate: true }, { productive: true });
+    selected = (await client.call("credential.list")).find(item => item.integrationID === config.provider && item.active);
+    if (!selected || JSON.stringify(selected.value) !== JSON.stringify(value)) throw new DaemonError("opencode_credentials_unproven", "Private credential readback did not confirm the selected entry");
+  }
+  if ((entry || legacy) && !selected) throw new DaemonError("opencode_credentials_unproven", "Selected portable credential is not active in the private server");
+  return selected ? "active_private" : "absent";
+}
+async function importArchive(config, client, onProgress = async () => {}) {
+  if (!config.sessionArchive) return null;
+  const manifest = JSON.parse(await readFile(config.sessionArchive, "utf8"));
+  if (manifest.schema_id !== ARCHIVE_SCHEMA || !manifest.payload || !/^2\./.test(manifest.opencode_version)) throw new DaemonError("invalid_session_archive", "Use the archived v1 engine for legacy OpenCode archives");
+  const payload = JSON.parse(Buffer.from(manifest.payload, "base64").toString("utf8"));
+  const transfers = payload.sessions, root = manifest.provider_session_id;
+  if (!Array.isArray(transfers) || !transfers.length || transfers[0]?.info?.id !== root || new Set(transfers.map(item => item.info?.id)).size !== transfers.length)
+    throw new DaemonError("invalid_session_archive", "Archive does not contain a unique native Session tree");
+  const records = [], imported = new Set();
+  for (const transfer of transfers) {
+    if (!transfer.info?.id || !Array.isArray(transfer.messages) || transfer.info.id !== root && !imported.has(transfer.info.parentID))
+      throw new DaemonError("invalid_session_archive", "Archive child is not in the native parent-first tree");
+    imported.add(transfer.info.id);
+  }
+  for (const transfer of transfers) {
+    const info = await client.import({ ...transfer, info: { ...transfer.info, location: { directory: config.cwd } } });
+    if (info?.id !== transfer.info.id || info.location?.directory !== config.cwd || (info.parentID ?? null) !== (transfer.info.parentID ?? null))
+      throw new DaemonError("session_import_unproven", "OpenCode import did not preserve native identity/location");
+    records.push({ provider_session_id: info.id, parent_provider_session_id: info.id === root ? null : info.parentID, root_provider_session_id: root, cwd: config.cwd });
+    await onProgress(info.id);
+  }
+  return records;
+}
+
+export async function callDaemon(stateDir, operation, params = {}, timeoutMs = 30_000) {
+  const state = await readState(stateDir);
+  if (state && state.schema_id !== STATE_SCHEMA) throw new DaemonError("legacy_opencode_state", "Use archive/opencode-v1-final-beta134 for v1 states; the v2 adapter cannot dispatch to a legacy daemon", false, { effect: "no_effect" });
+  const request = prepareDaemonRequest({ schema_id: REQUEST_SCHEMA, id: process.env.DD_EVAL_OPERATION_ID ?? randomUUID(), operation, params });
+  return await callDaemonObserved({ stateDir, socket: locations(stateDir).socket, request, responseSchema: RESPONSE_SCHEMA, harness: 'opencode', timeoutMs });
+}
+function sameConfig(state, config) { return ["cwd","journal","bin","provider","model","variant","agent","projectRoot","ddFlowBin","ddFlowHome","sessionArchive","resourceHome","noFlow","configSource","authSource"].every(key => (state.config?.[key] ?? null) === (config[key] ?? null)); }
+export async function startDaemon(options) {
+  const paths = locations(options.stateDir);
+  const previous = await readState(paths.dir);
+  if (previous && previous.schema_id !== STATE_SCHEMA) throw new DaemonError("legacy_opencode_state", "Use archive/opencode-v1-final-beta134 for v1 states; start v2 in a fresh state directory");
+  await mkdir(paths.dir, { recursive: true, mode: 0o700 }); await chmod(paths.dir, 0o700);
+  const daemonId = randomUUID(), noFlow = options.noFlow === true, cwd = await realpath(absolute(options.cwd, "--cwd")); const config = { cwd, journal: options.journal ? absolute(options.journal, "--journal") : paths.journal, bin: options.bin ?? process.env.DD_OPENCODE_BIN ?? "opencode", provider: String(options.provider ?? ""), model: String(options.model ?? ""), variant: String(options.variant ?? "default"), agent: String(options.agent ?? "build"), projectRoot: noFlow ? cwd : await realpath(absolute(options.projectRoot, "--project-root")), 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 ? absolute(process.env.DD_FLOW_RESOURCE_HOME, "DD_FLOW_RESOURCE_HOME") : null), env: noFlow ? {} : { DD_FLOW_HOME: absolute(options.ddFlowHome, "--dd-flow-home") }, sessionArchive: options.sessionArchive ? absolute(options.sessionArchive, "--session-archive") : null, dataHome: paths.data, configHome: paths.config, cacheHome: paths.cache, stateHome: paths.xdgState, database: paths.db, adapterDir: path.join(paths.config, "opencode"), configSource: options.configPath ?? process.env.DD_OPENCODE_CONFIG_SOURCE ?? path.join(process.env.XDG_CONFIG_HOME ?? path.join(os.homedir(), ".config"), "opencode", "opencode.json"), password: randomBytes(24).toString("hex"), daemonId, noFlow };
+  await prepareRuntimeOwner(config, paths.dir);
+  config.authSource = options.authPath ? absolute(options.authPath, "--auth-path") : path.join(os.homedir(), ".local", "share", "opencode", "auth.json");
+  if (!options.configPath && !process.env.DD_OPENCODE_CONFIG_SOURCE) {
+    try { await lstat(config.configSource); } catch (error) { if (error.code === "ENOENT") config.configSource += "c"; else throw error; }
+  }
+  config.configSource = absolute(config.configSource, "--config-path");
+  assertDaemonRestartable(previous);
+  if (!config.provider || !config.model) throw new DaemonError("profile_required", "--provider and --model are required");
+  try { const status = await callDaemon(paths.dir, "daemon.status", {}, 1000); if (!sameConfig(status, config)) throw new DaemonError("daemon_config_mismatch", "a daemon is already running with different configuration"); return { ...status, already_running: true }; } catch (error) { if (!["daemon_not_running","daemon_timeout"].includes(error.code)) throw error; }
+  assertDaemonRestartable(await readState(paths.dir));
+  if (previous?.shutdown_state === "clean") await authorizeRetainedDaemonResume(paths.dir, previous, options.sessionId, config); if (previous?.shutdown_state === "running" && previous.active_tree) throw new DaemonError("invalid_harness_crash", "previous daemon died with an active or unproven Session tree");
+  await removeSocket(paths); const authSource = config.authSource;
+  const version = (await run(config.bin, ["--version"], config)).trim(); config.version = version.match(/(?:^|\s)v?(2\.\d+\.\d+(?:[-+][\w.-]+)?)(?:\s|$)/)?.[1];
+  if (!config.version) throw new DaemonError("unsupported_version", "dd-opencode supports OpenCode v2 only; v1 remains at archive/opencode-v1-final-beta134");
+  await prepare(paths, config, authSource);
+  const resourceProcess = await registerDaemonProcess(config, { kind: "opencode-daemon", owner: `opencode:${path.basename(paths.dir)}`, operation: `opencode-daemon:${path.basename(paths.dir)}`, stdout: paths.log, stderr: paths.log });
+  const state = { schema_id: STATE_SCHEMA, native_protocol: 2, daemon_id: daemonId, shutdown_state: "starting", active_tree: false, auth_status: config.authStatus, versions: { opencode: config.version }, config, sessions: previous?.sessions ?? [], operations: previous?.operations ?? {}, resource_process: resourceProcess }; await writeJson(paths.state, state);
+  const log = await open(paths.log, "a", 0o600), entry = absolute(options.entryPath, "dd-opencode entry"); const child = spawn(process.execPath, [entry, "daemon", "serve", "--state-dir", paths.dir], { cwd: config.cwd, env: isolatedEnv(config), 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.dir), paths.log);
+    await new Promise(resolve => setTimeout(resolve, 100)); try { return await callDaemon(paths.dir, "daemon.status", {}, 1000); } catch (error) { if (!["daemon_not_running","daemon_timeout"].includes(error.code)) throw error; }
+  } throw Object.assign(new DaemonError("daemon_start_failed", "daemon did not become ready", true), { details: observationDetails(startupClock, 'daemon-start', child.pid) }); }
+  catch (error) { await cleanupFailedDaemonStart(config, resourceProcess, child, error, () => readState(paths.dir), daemonId); throw error; }
+}
+export const stopDaemon = async 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(options.stateDir) }); };
+
+export class Runtime {
+  constructor(paths, state, client, child, providerProcess) { this.paths = paths; this.state = state; this.client = client; this.child = child; this.providerProcess = providerProcess; this.sessions = new Map();
+    for (const record of state.sessions ?? []) {
+      if (typeof record?.provider_session_id !== "string" || !record.provider_session_id || this.sessions.has(record.provider_session_id))
+        throw new DaemonError("session_identity_mismatch", "OpenCode retained Session identity is invalid or duplicated");
+      this.sessions.set(record.provider_session_id, record);
+    }
+    this.active = null; this.persisting = Promise.resolve(); }
+  persist(patch = {}) { Object.assign(this.state, patch, { pid: process.pid, sessions: [...this.sessions.values()] }); const snapshot = structuredClone(this.state); this.persisting = this.persisting.catch(() => {}).then(() => writeJson(this.paths.state, snapshot)); return this.persisting; }
+  retainSession(info, root) {
+    const id = info.id, parent = info.fork ? null : info.parentID ?? null, retained = this.sessions.get(id);
+    if (typeof id !== "string" || !id || typeof info.directory !== "string" || !path.isAbsolute(info.directory)
+      || retained && ((retained.parent_provider_session_id ?? null) !== parent
+        || retained.adapter_session_id && retained.adapter_session_id !== id
+        || retained.root_provider_session_id && retained.root_provider_session_id !== root))
+      throw new DaemonError("session_identity_mismatch", "OpenCode retained Session identity changed");
+    // Cwd is observed routing authority, not ownership identity: a moved owned
+    // Session must remain observable/cancellable. requireSettled fences dispatch.
+    const record = { provider_session_id: id, adapter_session_id: id, parent_provider_session_id: parent, root_provider_session_id: root, cwd: info.directory };
+    this.sessions.set(id, record); return record;
+  }
+  async journal(operation, result) { const line = `${JSON.stringify({ schema_id: "dd-opencode/daemon-event@1", event_id: randomUUID(), observed_at: new Date().toISOString(), operation, active_tree: this.state.active_tree, session_id: result?.provider_session_id ?? null })}\n`; for (const journal of new Set([this.paths.journal, this.state.config.journal].filter(Boolean))) { await mkdir(path.dirname(journal), { recursive: true, mode: 0o700 }); await appendFile(journal, line, { mode: 0o600 }); } }
+  async childTree(id, seen = new Set()) {
+    if (seen.has(id)) throw new DaemonError("session_identity_mismatch", "OpenCode native topology contains a cycle");
+    seen.add(id); const direct = await this.ownedChildren(id), nested = [];
+    for (const child of direct) {
+      if (!child.id || child.parentID !== id) throw new DaemonError("session_identity_mismatch", "OpenCode child has a foreign native parent");
+      nested.push(child, ...await this.childTree(child.id, seen));
+    }
+    return nested;
+  }
+  async ownedChildren(id) {
+    const direct = await this.client.children(id), children = new Map();
+    if (!Array.isArray(direct)) throw new DaemonError("native_child_observation_unavailable", "OpenCode child inventory is unavailable");
+    for (const child of direct) children.set(child.id, child);
+    for (const record of this.sessions.values()) if (record.parent_provider_session_id === id && !children.has(record.provider_session_id)) {
+      let child;
+      try { child = await this.client.inspect(record.provider_session_id); }
+      catch (cause) { throw new DaemonError("native_child_observation_unavailable", "Retained OpenCode child disappeared without completion proof", false, { provider_session_id: record.provider_session_id, cause: errorPayload(cause) }); }
+      if (child?.id !== record.provider_session_id) throw new DaemonError("session_identity_mismatch", "OpenCode retained child read returned another Session");
+      children.set(child.id, child);
+    }
+    for (const child of children.values()) if (!child.id || child.parentID !== id || child.fork) throw new DaemonError("session_identity_mismatch", "OpenCode child has a foreign native parent");
+    return [...children.values()];
+  }
+  async revision(id) {
+    if (!this.client.logs) return null;
+    const { watermark } = await this.client.logs(id);
+    return JSON.stringify([id, watermark]);
+  }
+  async describe(id, refreshes = 1) {
+    const before = new Map([[id, await this.revision(id)]]);
+    const [info, messages, children] = await Promise.all([this.client.inspect(id), this.client.messages(id), this.childTree(id)]);
+    const parent = info.fork ? null : info.parentID ?? null, existing = this.sessions.get(id);
+    if (info.id !== id || !existing && (!parent || !this.sessions.has(parent) || info.fork)
+      || existing && (existing.parent_provider_session_id ?? null) !== parent) throw new DaemonError("foreign_session", "OpenCode Session is not in the retained owned tree");
+    const record = this.retainSession(info, parent ? this.sessions.get(parent)?.root_provider_session_id ?? parent : existing?.root_provider_session_id ?? id);
+    for (const child of children) {
+      const retained = this.sessions.get(child.id);
+      if (child.fork || retained && retained.parent_provider_session_id !== child.parentID) throw new DaemonError("session_identity_mismatch", "OpenCode child ancestry changed");
+      this.retainSession(child, record.root_provider_session_id);
+    }
+    const pending = new Map(), histories = new Map([[id, messages]]);
+    for (const child of children) before.set(child.id, await this.revision(child.id));
+    const statuses = await this.client.statuses();
+    for (const session of [id, ...children.map(child => child.id)]) {
+      if (session !== id) histories.set(session, await this.client.messages(session));
+      const value = this.client.pending ? await this.client.pending(session) : { inbox: [], forms: [], permissions: [] };
+      pending.set(session, { ...value, shells: this.client.shells ? (await this.client.shells(session)).filter(shell => shell.status === "running") : [] });
+    }
+    const changed = new Set(), unavailable = new Set();
+    for (const [session, seq] of before) {
+      const after = await this.revision(session);
+      if (seq === null || after === null) { unavailable.add(session); changed.add(session); }
+      else if (after !== seq) changed.add(session);
+    }
+    // Re-read one raced snapshot inside this request, without a new clock or
+    // quiet sleep. An absent fence has no reconciliation authority.
+    if (changed.size && !unavailable.size && refreshes > 0) return this.describe(id, refreshes - 1);
+    const currentMessages = session => { const history = histories.get(session); return history.slice(history.findLastIndex(message => message.info.role === "user") + 1); };
+    const busy = session => changed.has(session) || Boolean(statuses[session] && statuses[session].type !== "idle") || Object.values(pending.get(session)).some(items => items.length > 0)
+      || currentMessages(session).some(message => (message.parts ?? []).some(part => part.type === "tool" && ["pending", "running", "streaming"].includes(part.state?.status)));
+    for (const child of children) {
+      const history = histories.get(child.id);
+      const index = history.findLastIndex(message => message.info.role === "user" && message.info.sessionID === child.id);
+      const terminal = index >= 0 && history.slice(index + 1).findLast(message => message.info.role === "idle" && message.info.sessionID === child.id);
+      if (!terminal || busy(child.id)) { Object.assign(child, { status: changed.has(child.id) ? "unknown" : busy(child.id) ? "running" : "idle", native_turn_items: { observed: Boolean(terminal) && !changed.has(child.id), possible_effects: true, pending: busy(child.id) } }); continue; }
+      const outcome = terminal.info.outcome;
+      if (!["succeeded", "failed", "interrupted"].includes(outcome)) continue;
+      Object.assign(child, { status: outcome === "succeeded" ? "completed" : outcome === "failed" ? "failed" : "cancelled",
+        terminal_turn_id: history[index].info.id, native_source: "opencode.v2.session.execution",
+        native_turn_items: { observed: true, possible_effects: true, pending: false },
+        ...(terminal.info.error ? { provider_error: safeProviderError(terminal.info.error) } : {}) });
+    }
+    const unsettledChildren = children.filter(child => busy(child.id)).map(child => child.id), status = changed.has(id) ? "unknown" : busy(id) ? "busy" : "idle";
+    const lastAssistant = messages.findLast(message => message.info?.role === "assistant");
+    const inputIndex = messages.findLastIndex(message => message.info.role === "user");
+    const idle = messages.slice(inputIndex + 1).findLast(message => message.info.role === "idle");
+    const treeIds = [id, ...children.map(child => child.id)];
+    await this.observeModels(id, messages, parent);
+    this.journaledTools ??= new Map();
+    if (this.state.config.journal) journalToolObservations(this.state.config.journal, messages.flatMap(message => (message.parts ?? []).map(part => openCodeToolObservation(part, id, message.info?.id))), this.journaledTools);
+    const receipt = { ...record, observed_profile: { provider: lastAssistant?.info?.providerID ?? info.model?.providerID ?? null, model: lastAssistant?.info?.modelID ?? info.model?.id ?? null, reasoning: lastAssistant?.info?.variant ?? info.model?.variant ?? "default", mode: info.agent ?? null },
+      assistant_text: (lastAssistant?.parts ?? []).filter(part => part.type === "text").map(part => part.text ?? "").join(""), info, status,
+      route_conformance: { matches: [info, ...children].every(session => session.directory && path.resolve(session.directory) === path.resolve(this.state.config.cwd)), expected: this.state.config.cwd, actual: info.directory ?? null, actual_provenance: "native_session_readback" },
+      route_violations: [info, ...children].filter(session => !session.directory || path.resolve(session.directory) !== path.resolve(this.state.config.cwd)).map(session => ({ provider_session_id: session.id, expected: this.state.config.cwd, actual: session.directory ?? null, actual_provenance: "native_session_readback" })),
+      settled: status === "idle" && !unsettledChildren.length, unsettled_children: unsettledChildren,
+      tree_session_ids: treeIds, unsettled_sessions: treeIds.filter(busy),
+      tree_observations: treeIds.map(session => ({ provider_session_id: session, status: changed.has(session) ? "unknown" : busy(session) ? "running" : "idle", settled: !busy(session) })),
+      ...(changed.size ? { native_settlement: { confirmed: false, state: "unproven", reason: "native_revision_fence_unavailable_or_changed" } } : {}),
+      terminal_turn_id: idle && inputIndex >= 0 ? messages[inputIndex].info.id : null,
+      terminal_status: idle?.info.outcome === "failed" ? "failed" : idle?.info.outcome === "succeeded" ? "completed" : idle?.info.outcome ?? null,
+      native_turn_items: { observed: Boolean(idle), possible_effects: messages.slice(inputIndex + 1).some(message => message.parts.some(part => part.type === "tool")),
+        pending: busy(id) },
+      children, pending: pending.get(id), usage: usageSnapshot(messages, id), history_sha256: historyDigest(messages), message_count: messages.length };
+    return nativeExecutionReceipt(receipt, { daemonId: this.state.daemon_id, revision: before.get(id) ?? 0 });
+  }
+  async observeModels(id, messages, parent = null) {
+    this.modelMessages ??= new Set();
+    for (const message of messages ?? []) {
+      const info = message.info;
+      if (info?.role !== "assistant" || !info.id || this.modelMessages.has(info.id)) continue;
+      if (info.sessionID && info.sessionID !== id) throw new DaemonError("session_identity_mismatch", "native message belongs to another Session");
+      await observeModel({ journal: this.state.config.journal ?? this.paths.journal, harness: "opencode-server", sessionId: id, parentSessionId: parent,
+        requested: { ...this.state.config, reasoning: this.state.config.variant, mode: parent ? "dd-flow-worker" : this.state.config.agent },
+        nativeAgentRole: this.state.config.workerLaunchConfig ? { name: info.mode ?? null, kind: parent ? 'subagent' : 'primary', parent_session_id: parent,
+          launch: { ...this.state.config.workerLaunchConfig, root_session_id: this.sessions.get(id)?.root_provider_session_id ?? null } } : null,
+        observed: { provider: info.providerID, model: info.modelID, reasoning: info.variant, mode: info.mode }, source: { method: "session/message", message_id: info.id, event_sha256: createHash("sha256").update(`${id}:${info.id}:${info.modelID}`).digest("hex") }, evidence: "response" });
+      this.modelMessages.add(info.id);
+    }
+  }
+  async requireSettled(id) {
+    const value = await this.describe(id);
+    if (!value.route_conformance.matches) throw new DaemonError("invocation_directory_mismatch", "Owned OpenCode Session has an unexpected workspace", false, { effect: "no_effect", ...value.route_violations[0], native_outcome: value.terminal_status, settled: value.settled });
+    if (!value.settled) throw new DaemonError("tree_not_settled", "OpenCode Session is not idle", false, { session_id: id, status: value.status });
+    const config = this.state.config;
+    if (config.provider && config.model) checkObservedProfile({ ...config, reasoning: config.variant, mode: value.parent_provider_session_id ? "dd-flow-worker" : config.agent }, value.observed_profile);
+    return value;
+  }
+  async reconcileUsage(observed) { const errors = []; try { await forwardUsage(this.state.config, observed.provider_session_id, observed.usage); } catch (error) { errors.push({ session_id: observed.provider_session_id, phase: "usage", ...errorPayload(error) }); } for (const child of observed.children.filter(item => (item.parentID ?? observed.provider_session_id) === observed.provider_session_id)) { try { errors.push(...await this.reconcileUsage(await this.describe(child.id))); } catch (error) { errors.push({ session_id: child.id, phase: "usage_child", ...errorPayload(error) }); } } return errors; }
+  async productive(name, task) {
+    assertDaemonDispatch(this.paths?.dir);
+    if (this.active) throw new DaemonError("operation_busy", `${this.active} is already running`, true);
+    this.active = name; let result, completed = false; const priorActive = this.state.active_tree;
+    try {
+      await this.persist({ active_tree: true, active_operation: name });
+      assertDaemonDispatch(this.paths?.dir);
+      result = await task(); completed = true;
+      await this.persist({ active_tree: !result?.settled, active_operation: null });
+      await this.journal(name, result); return result;
+    } catch (cause) {
+      const error = completed ? new DaemonError("operation_observation_lost", "OpenCode returned but its durable observation could not be saved; do not resend", false, { result, cause: errorPayload(cause) }) : cause;
+      const failures = [];
+      try { await this.persist({ active_tree: error.details?.effect === "no_effect" && error.details?.native_turn_items?.possible_effects !== true ? priorActive : true, active_operation: null }); } catch (secondary) { failures.push(errorPayload(secondary)); }
+      try { await this.journal(`${name}.failed`, null); } catch (secondary) { failures.push(errorPayload(secondary)); }
+      if (failures.length) error.details = { ...error.details, observation_errors: failures };
+      throw error;
+    } finally { this.active = null; }
+  }
+  async cancelTree(id, seen = new Set()) {
+    if (!this.sessions.has(id)) throw new DaemonError("foreign_session", "cannot cancel a Session without daemon ownership");
+    if (seen.has(id)) return [];
+    const retained = this.sessions.get(id), errors = [];
+    let native;
+    try { native = await this.client.inspect(id); }
+    catch (error) { errors.push({ session_id: id, phase: "inspect", ...errorPayload(error) }); }
+    if (native) {
+      if (native.id !== id || (retained.parent_provider_session_id ?? null) !== (native.fork ? null : native.parentID ?? null)) throw new DaemonError("session_identity_mismatch", "OpenCode cancellation Session ancestry changed");
+      try { this.retainSession(native, retained.root_provider_session_id ?? id); }
+      catch (error) { errors.push({ session_id: id, phase: "retain", ...errorPayload(error) }); }
+    }
+    seen.add(id);
+    let children = [];
+    try { children = await this.ownedChildren(id); } catch (error) { errors.push({ session_id: id, phase: "children", ...errorPayload(error) });
+      children = [...this.sessions.values()].filter(record => record.parent_provider_session_id === id).map(record => ({ id: record.provider_session_id, parentID: id, directory: record.cwd })); }
+    for (const child of children) {
+      if (child.parentID !== id || child.fork || this.sessions.has(child.id) && this.sessions.get(child.id).parent_provider_session_id !== id) {
+        errors.push({ session_id: child.id, phase: "identity", code: "session_identity_mismatch" }); continue;
+      }
+      try { this.retainSession(child, this.sessions.get(id)?.root_provider_session_id ?? id); errors.push(...await this.cancelTree(child.id, seen)); }
+      catch (error) { errors.push({ session_id: child.id, phase: "cancel_child", ...errorPayload(error) }); }
+    }
+    try { await this.client.abort(id); } catch (error) { errors.push({ session_id: id, phase: "abort", ...errorPayload(error) }); }
+    return errors;
+  }
+  async observeHookFailures(current = this.nativeHookOperation) {
+    if (!current || this.nativeHookOperation !== current) return;
+    if (current.reading) return await current.reading;
+    current.reading = readNativeHookFailures(this.paths.dir, current.requests, current, error => this.retainHookFailure(current, error));
+    try { await current.reading; } finally { current.reading = null; }
+  }
+  retainHookFailure(current, error) {
+    if (this.nativeHookOperation !== current || isProvenShellCorrection(error)) return;
+    error.details = { ...error.details, provider_session_id: current.sessionId, native_outcome: "unknown", native_turn_items: { observed: true, possible_effects: true, pending: true } };
+    current.failure ??= error;
+  }
+  async dispatch(operation, params, operationId = null) {
+    const assertDispatch = captureDispatchGuard(this);
+    if (["session.create", "session.prompt", "session.start", "session.fork", "session.resume", "session.archive"].includes(operation)) assertDaemonDispatch(this.paths.dir);
+    if (operation === "daemon.status") { const { password, ...config } = this.state.config; return { daemon_id: this.state.daemon_id, pid: process.pid, socket: this.paths.socket, versions: this.state.versions, auth_status: this.state.auth_status, shutdown_state: this.state.shutdown_state, active_tree: this.state.active_tree, active_operation: this.active, sessions: [...this.sessions.values()], config }; }
+    if (operation === "hook.resolve") {
+      const current = this.nativeHookOperation, sessionId = params.sessionId, payload = params.payload;
+      if (!current || !sessionId || typeof payload?.input?.command !== "string" || typeof payload.tool_call_id !== "string" || !payload.tool_call_id || typeof payload.message_id !== "string" || !payload.message_id || !["before", "after"].includes(payload.phase))
+        throw new DaemonError("native_hook_unproven", "OpenCode hook has no exact active operation");
+      let owned = sessionId === current.sessionId || this.sessions.get(sessionId)?.root_provider_session_id === current.sessionId;
+      try {
+        const tree = await this.childTree(current.sessionId);
+        if (sessionId !== current.sessionId && !tree.some(child => child.id === sessionId && !child.fork)) throw new DaemonError("foreign_session", "OpenCode hook Session is outside the owned native tree");
+        owned = true;
+        const native = await this.client.inspect(sessionId), retained = this.sessions.get(sessionId), child = tree.find(item => item.id === sessionId);
+        if (native.id !== sessionId || child && (native.parentID !== child.parentID || native.fork) || retained && (retained.parent_provider_session_id ?? null) !== (native.fork ? null : native.parentID ?? null)) throw new DaemonError("native_hook_identity_conflict", "OpenCode hook Session ancestry changed");
+        if (!native.directory) throw new DaemonError("native_hook_unproven", "OpenCode hook Session directory is unavailable");
+        if (payload.input.workdir !== undefined && typeof payload.input.workdir !== "string") throw new DaemonError("native_hook_unproven", "OpenCode hook workdir must be a string");
+        if (this.nativeHookOperation !== current) throw new DaemonError("native_hook_unproven", "OpenCode operation changed during hook identity observation");
+        const accepted = await acceptNativeHookRequest(this.paths.dir, { daemon_id: this.state.daemon_id, operation_id: current.operationId, turn_generation: current.generation,
+          provider_session_id: sessionId, root_provider_session_id: current.sessionId, tool_call_id: `${payload.message_id}:${payload.tool_call_id}`, event: payload.phase === "after" ? "PostToolUse" : "PreToolUse",
+          command_sha256: createHash("sha256").update(payload.input.command).digest("hex"), native_cwd: path.resolve(native.directory, payload.input.workdir ?? ".") }, current);
+        if (this.nativeHookOperation !== current) throw new DaemonError("native_hook_unproven", "OpenCode operation changed during hook acceptance");
+        current.requests.set(accepted.request_id, { current, binding: accepted }); return { nativeHookBinding: accepted, nativeSession: {
+          id: native.id, directory: native.directory, parentID: native.parentID, projectID: native.projectID,
+          model: { providerID: native.model?.providerID, id: native.model?.id, variant: native.model?.variant }
+        } };
+      } catch (error) {
+        if (owned) this.retainHookFailure(current, error);
+        throw error;
+      }
+    }
+    if (operation === "hook.verify") {
+      const current = this.nativeHookOperation, binding = params.binding;
+      if (!current || binding?.operation_id !== current.operationId || binding?.turn_generation !== current.generation
+        || JSON.stringify(current.requests.get(binding?.request_id)?.binding) !== JSON.stringify(binding)) throw new DaemonError("native_hook_unproven", "OpenCode hook generation is no longer current");
+      return { current: true };
+    }
+    if (operation === "hook.failed") {
+      if (params.failure) {
+        await this.dispatch("hook.verify", { binding: params.binding });
+        if (JSON.stringify(params.failure.details?.native_hook_binding) !== JSON.stringify(params.binding) || !params.failure.details?.receipt_error || typeof params.failure.code !== "string" || typeof params.failure.message !== "string") throw new DaemonError("native_hook_receipt_invalid", "OpenCode fallback hook error is not bound");
+        this.retainHookFailure(this.nativeHookOperation, reportedError(params.failure, "Native hook failed"));
+      }
+      await this.observeHookFailures(); return { observed: true };
+    }
+    if (operation === "daemon.doctor") {
+      const info = await this.client.health();
+      if (info.pid !== this.child?.pid || info.version !== this.state.versions.opencode) throw new DaemonError("foreign_server", "OpenCode endpoint is not the owned process");
+      await this.client.call("model.list", { location: { directory: this.state.config.cwd } });
+      const plugins = await this.client.call("plugin.list", { location: { directory: this.state.config.cwd } });
+      const pluginID = this.state.config.noFlow ? "dd-flow-security" : "dd-flow";
+      if (!plugins.data.some(plugin => plugin.id === pluginID && plugin.state?.status === "active")) throw new DaemonError("opencode_plugin_missing", "Owned v2 plugin is not active");
+      return { compatible: true, native_protocol: 2, observed_runtime: this.state.versions, productive_hooks: !this.state.config.noFlow, versions: this.state.versions, plugin_sha256: this.state.config.pluginSha256, auth_status: this.state.auth_status };
+    }
+    if (operation === "session.create") return this.productive(operation, async () => {
+      const info = await this.client.create(params.title, this.state.config);
+      const created = { provider_session_id: info.id, adapter_session_id: info.id, parent_provider_session_id: info.parentID ?? null, root_provider_session_id: info.id, cwd: info.directory };
+      this.sessions.set(info.id, created);
+      try {
+        const result = await this.describe(info.id);
+        result.usage_ingest_errors = await this.reconcileUsage(result);
+        return result;
+      } catch (error) {
+        // The Session exists even if its optional post-create observation is
+        // temporarily unavailable.  Preserve the identity; a later inspect
+        // owns any profile/topology proof required before a prompt.
+        return { ...created, settled: false, settlement_observation_error: errorPayload(error) };
+      }
+    });
+    if (["session.inspect", "session.resume", "session.prompt", "session.fork", "session.archive"].includes(operation) && !this.sessions.has(params.sessionId)) {
+      const native = await this.client.inspect(params.sessionId);
+      if (!native.parentID || !this.sessions.has(native.parentID) || native.fork) throw new DaemonError("foreign_session", "Session is not a member of the retained owned tree");
+    }
+    if (operation === "session.inspect" || operation === "session.resume") { const result = await this.describe(params.sessionId); await this.persist(); return result; }
+    if (operation === "session.prompt") { await this.requireSettled(params.sessionId); return this.productive(operation, async () => {
+      this.state.operations ??= {}; const key = operationId ?? randomUUID(), retained = this.state.operations[key];
+      const current = { operationId: key, sessionId: params.sessionId, generation: (this.state.hook_generation ?? 0) + 1, requests: new Map(), failure: null };
+      this.state.hook_generation = current.generation; this.nativeHookOperation = current;
+      const checkHookFailures = async () => { await this.observeHookFailures(current); if (this.nativeHookOperation !== current) throw new DaemonError("native_hook_unproven", "OpenCode prompt generation changed"); if (current.failure) throw current.failure; };
+      let reply;
+      try { assertDispatch(); reply = await this.client.prompt(params.sessionId, { prompt: params.prompt, messageId: retained?.message_id ?? `msg_${randomUUID().replaceAll("-", "")}`, retained,
+      save: async receipt => { this.state.operations[key] = receipt; await this.persist(); },
+      assertDispatch, checkHookFailures, livenessTimeoutMs: params.livenessTimeoutMs ?? this.client.timeoutMs,
+      onDispatched: () => this.journal("native_dispatch", { operation_id: operationId, provider_session_id: params.sessionId }),
+      onModelMessages: (id, messages, parent) => this.observeModels(id, messages, parent),
+      onObservationError: error => observeModel({ journal: this.state.config.journal ?? this.paths.journal, harness: "opencode-server", sessionId: params.sessionId, requested: this.state.config, source: "native.message_observer", evidence: "unavailable", reason: error.code ?? "observation_unavailable" })
+    }); await checkHookFailures(); }
+      finally { current.requests.clear(); if (this.nativeHookOperation === current) this.nativeHookOperation = null; }
+      const assistant_text = reply.parts.filter(part => part.type === "text").map(part => part.text ?? "").join("");
+      const expectedAgent = this.sessions.get(params.sessionId)?.parent_provider_session_id ? "dd-flow-worker" : this.state.config.agent;
+      const reply_profile = { provider: reply.info.providerID ?? null, model: reply.info.modelID ?? null, reasoning: reply.info.variant ?? null, mode: reply.info.mode ?? null };
+      checkObservedProfile({ ...this.state.config, reasoning: this.state.config.variant, mode: expectedAgent }, reply_profile);
+      let result;
+      try { result = await this.describe(params.sessionId); }
+      catch (error) { return { provider_session_id: params.sessionId, adapter_session_id: params.sessionId, assistant_text, response_message_id: reply.info.id, terminal_turn_id: reply.admission_message_id, terminal_status: "completed", native_outcome: "succeeded", observed_profile: reply_profile, settled: false, settlement_observation_error: errorPayload(error) }; }
+      result.assistant_text = assistant_text;
+      if (!result.route_conformance.matches) throw new DaemonError("invocation_directory_mismatch", "Owned OpenCode Session moved during execution", false, { ...result.route_violations[0], native_outcome: result.terminal_status, settled: result.settled, result });
+      result.response_message_id = reply.info.id;
+      result.observed_profile = { ...reply_profile, mode: result.info.agent ?? reply_profile.mode };
+      checkObservedProfile({ ...this.state.config, reasoning: this.state.config.variant, mode: expectedAgent }, result.observed_profile); result.usage_ingest_errors = await this.reconcileUsage(result); return result; }); }
+    if (operation === "session.fork") { const source = await this.requireSettled(params.sessionId); return this.productive(operation, async () => {
+      const info = await this.client.fork(params.sessionId, params.messageId);
+      const created = { provider_session_id: info.id, adapter_session_id: info.id, parent_provider_session_id: info.fork ? null : info.parentID ?? params.sessionId, root_provider_session_id: info.fork ? info.id : this.sessions.get(params.sessionId)?.root_provider_session_id ?? params.sessionId, cwd: info.directory };
+      this.sessions.set(info.id, created);
+      try {
+        const fork = await this.describe(info.id);
+        if (info.fork?.sessionID !== params.sessionId || params.messageId && info.fork?.boundary?.messageID !== params.messageId) throw new DaemonError("fork_continuity_failed", "OpenCode did not confirm the requested native fork boundary");
+        return { ...fork, fork_receipt: { source_provider_session_id: params.sessionId, source_history_sha256: source.history_sha256, fork_history_sha256: fork.history_sha256, boundary: info.fork.boundary, native_boundary_proven: true } };
+      } catch (error) {
+        // A native fork is materialized already.  Do not lose its identity or
+        // retry it, but never let an unproven history prefix become usable.
+        return { ...created, settled: false, fork_receipt: { source_provider_session_id: params.sessionId, source_history_sha256: source.history_sha256, history_prefix_proven: false }, fork_continuity_error: errorPayload(error) };
+      }
+    }); }
+    if (operation === "session.cancel") {
+      if (!this.sessions.has(params.sessionId)) throw new DaemonError("foreign_session", "cannot cancel a Session without daemon ownership");
+      cancelPendingDispatch(this);
+      const cancellation_errors = await this.cancelTree(params.sessionId); let result;
+      try { result = await this.describe(params.sessionId); }
+      catch (error) { result = { provider_session_id: params.sessionId, settled: false, inspection_error: errorPayload(error) }; }
+      result = { ...result, cancellation_errors };
+      await this.persist({ active_tree: Boolean(this.active) || !result.settled }); await this.journal(operation, result); return result;
+    }
+    if (operation === "session.archive") { const observed = await this.requireSettled(params.sessionId); const sessions = [];
+      for (const id of [params.sessionId, ...observed.children.map(child => child.id)]) sessions.push(await this.client.export(id));
+      const payload = JSON.stringify({ sessions }); const manifest = { schema_id: ARCHIVE_SCHEMA, native_protocol: 2, provider_session_id: params.sessionId, source_cwd: observed.cwd, opencode_version: this.state.versions.opencode, history_sha256: observed.history_sha256, exported_at: new Date().toISOString(), payload: Buffer.from(payload).toString("base64") }; const file = absolute(params.archiveFile, "--archive-file"); await mkdir(path.dirname(file), { recursive: true, mode: 0o700 }); await writeJson(file, manifest); return { archive_file: file, ...manifest, payload: undefined, sha256: createHash("sha256").update(await readFile(file)).digest("hex") }; }
+    if (operation === "daemon.stop") {
+      return await completeDaemonShutdown(this.paths.dir, this.state, patch => this.persist(patch), async () => {
+      if (params.cancelTree) cancelPendingDispatch(this);
+      await waitForSettlement({
+        knownSessions: () => [...this.sessions.keys()],
+        observe: async () => {
+          const busy = [];
+          for (const session of this.sessions.values()) if (!(await this.describe(session.provider_session_id)).settled) busy.push(session.provider_session_id);
+          return { sessions: busy.reverse(), active: Boolean(this.active), active_operation: this.active };
+        },
+        ...(params.cancelTree ? { cancel: id => this.cancelTree(id) } : {})
+      });
+      // Fresh native observation, not a prior productive result, owns the idle proof.
+      commitDaemonShutdown(this.paths.dir);
+      await this.persist({ active_tree: false });
+      return { clean: true, settled: true, native_settled: true };
+      }, [
+        ["provider", () => stopProcessGroup(this.child)],
+        ["provider_resource", () => finishDaemonProcess(this.state.config, this.providerProcess)],
+        ["daemon_resource", () => finishDaemonProcess(this.state.config, this.state.resource_process)]
+      ]);
+    }
+    throw new DaemonError("unknown_operation", `unknown daemon operation: ${operation}`);
+  }
+}
+
+/** Read-only readiness probes share the startup quiet window. A repeated
+ * ServiceUnavailable response is not activation progress. */
+export async function awaitOpenCodeStartup(client, state, child, { timeoutMs = SETUP_STARTUP_MS, publish = async () => {} } = {}) {
+  const clock = new ObservationClock({ timeoutMs });
+  let phase = "server", attempt = 0; const observedPhases = new Set();
+  const mark = async value => {
+    if (state.startup_phase === value) return;
+    state.startup_phase = value; await publish(state);
+    if (!observedPhases.has(value)) { observedPhases.add(value); clock.sample(value); }
+  };
+  const remaining = () => {
+    if (clock.sample()) throw new DaemonError("daemon_start_failed", "OpenCode startup made no further progress", false, observationDetails(clock, "native-readiness", child?.pid));
+    if (child && (child.exitCode !== null || child.signalCode !== null)) throw new DaemonError("opencode_unavailable", "Owned OpenCode process exited during startup", false, { exit_code: child.exitCode, signal: child.signalCode });
+    return Math.max(1, Math.ceil(clock.timeoutMs - clock.elapsed));
+  };
+  client.readObservation = () => ({ timeoutMs: remaining() });
+  try {
+    while (true) {
+      remaining();
+      try {
+        if (phase === "server") {
+          const identity = await client.health({ timeoutMs: remaining() });
+          if (identity.pid !== child?.pid || identity.version !== state.versions.opencode) throw new DaemonError("foreign_server", "OpenCode startup returned another server");
+          await mark("owned_server_ready"); phase = "location";
+        }
+        if (phase === "location") {
+          await client.call("model.list", { location: { directory: state.config.cwd } });
+          await mark("location_models_ready"); phase = "plugin";
+        }
+        const plugins = await client.call("plugin.list", { location: { directory: state.config.cwd } });
+        if (!Array.isArray(plugins?.data)) throw new DaemonError("opencode_configuration_invalid", "OpenCode returned invalid plugin readiness");
+        const id = state.config.noFlow ? "dd-flow-security" : "dd-flow", plugin = plugins.data.find(value => value.id === id);
+        if (["failed", "error", "missing", "disabled"].includes(plugin?.state?.status)) throw new DaemonError("opencode_plugin_failed", "Required owned plugin failed activation", false, { plugin_id: id, status: plugin.state.status });
+        if (plugin?.state?.status === "active") { await mark("required_plugin_active"); return { remaining, clock }; }
+        // A status transition of this required plugin is real new evidence.
+        if (["loading", "activating", "registered"].includes(plugin?.state?.status)) await mark(`required_plugin_${plugin.state.status}`);
+      } catch (error) {
+        const transient = error.code === "opencode_unavailable" && error.retryable === true
+          // Safe pre-identity reads use the normalized observation category,
+          // not a version-specific SDK error wrapper. No productive RPC here.
+          && (phase === "server" || error.details?.native_type === "ServiceUnavailableError");
+        if (!transient) throw error;
+      }
+      const pause = Math.min([250, 500, 1000, 2000][Math.min(attempt++, 3)], remaining());
+      await new Promise(resolve => setTimeout(resolve, pause));
+    }
+  } catch (error) { delete client.readObservation; throw error; }
+}
+
+export async function serveDaemon(stateDir) {
+  const paths = locations(stateDir), state = await readState(paths.dir); if (state?.schema_id !== STATE_SCHEMA) throw new DaemonError("daemon_state_missing", "daemon state is missing");
+  let child, providerProcess;
+  try {
+    const port = await freePort(), target = executable(state.config.bin, ["serve", "--hostname", "127.0.0.1", "--port", String(port)]);
+    providerProcess = await registerDaemonProcess(state.config, { kind: "opencode-provider", owner: `opencode:${path.basename(paths.dir)}`, operation: `opencode-provider:${path.basename(paths.dir)}`, stdout: paths.log, stderr: paths.log });
+    child = spawn(target.command, target.args, { cwd: state.config.cwd, env: isolatedEnv(state.config), detached: true, stdio: ["ignore", "inherit", "inherit"] });
+    await confirmDaemonProcess(state.config, providerProcess, child);
+    scheduleDaemonProcessHeartbeat(state.config, state.resource_process);
+    scheduleDaemonProcessHeartbeat(state.config, providerProcess);
+    state.provider_process = providerProcess; state.provider_pid = child.pid; await writeJson(paths.state, state);
+    const client = new OpenCodeClient({ baseUrl: `http://127.0.0.1:${port}`, password: state.config.password, directory: state.config.cwd });
+    const startup = await awaitOpenCodeStartup(client, state, child, { publish: snapshot => writeJson(paths.state, snapshot) });
+    state.auth_status = await bootstrapCredentials(state.config, client);
+    state.startup_phase = "credentials_ready"; await writeJson(paths.state, state); startup.clock.sample(state.startup_phase);
+    const imported = await importArchive(state.config, client, async id => { state.startup_phase = `session_imported:${id}`; await writeJson(paths.state, state); startup.clock.sample(state.startup_phase); }); if (imported) state.sessions.push(...imported);
+    startup.remaining(); delete client.readObservation;
+    await chmod(state.config.database, 0o600);
+    const runtime = new Runtime(paths, state, client, child, providerProcess); await removeSocket(paths);
+    const server = net.createServer(connection => {
+      connection.setEncoding("utf8"); let buffer = "", consumed = false;
+      connection.on("data", chunk => {
+        if (consumed) return;
+        buffer += chunk; if (!admitNativeRequestBuffer(buffer, connection, RESPONSE_SCHEMA)) { 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));
+            const result = await durableDaemonDispatch(paths.dir, request, () => runtime.dispatch(request.operation, request.params ?? {}, request.id), () => runtime.dispatch("session.inspect", request.params ?? {}));
+            if (result._shutdown) retireDaemonEndpoint(server);
+            connection.end(`${JSON.stringify({ schema_id: RESPONSE_SCHEMA, id: request.id, ok: true, result: { ...result, _shutdown: undefined } })}\n`);
+          } catch (error) {
+            await retireFailedDaemon(server, state, error, patch => runtime.persist(patch));
+            connection.end(`${JSON.stringify({ schema_id: RESPONSE_SCHEMA, id: request?.id ?? null, ok: false, error: errorPayload(error) })}\n`);
+          }
+        })();
+      });
+    });
+    trackDaemonConnections(server); runtime.server = server;
+    await new Promise((resolve, reject) => { server.once("error", reject); server.listen(paths.socket, resolve); }); await chmod(paths.socket, 0o600); await runtime.persist({ shutdown_state: "running", active_tree: false, server_port: port }); return await new Promise(() => {});
+  } catch (error) {
+    await cleanupFailedStart(state.config, providerProcess, child, error);
+    await retainStartupFailure({ state, publish: snapshot => writeJson(paths.state, snapshot), log: paths.log, error }); throw error;
+  }
+}
+import { authorizeRetainedDaemonResume } from "./driver-recovery.mjs";
+import { commandText } from "./process-json.mjs";