@deksden-com/dd-flow-cli 0.9.0-beta.11 → 0.9.0-beta.110

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

@@ -0,0 +1,500 @@
+import { captureDispatchGuard, cancelPendingDispatch } from "./dispatch-fence.mjs";
+import { ToolObservations, agyToolObservation } from "./tool-observations.mjs";
+import { createHash, randomUUID } from "node:crypto";
+import { appendFile, chmod, lstat, mkdir, open, readFile, realpath, rename, unlink, writeFile } from "node:fs/promises";
+import { spawn } from "node:child_process";
+import net from "node:net";
+import { isDeepStrictEqual } from "node:util";
+import { ObservationClock } from "./observation-clock.mjs";
+import { hookBudget } from "./native-hook-command.mjs";
+import { agyWorkspaceHooks } from "./agy-hooks.mjs";
+import { durableDaemonDispatch } from "./daemon-operations.mjs";
+import path from "node:path";
+import { observeModel } from "./model-observations.mjs";
+import { AgyError, assertProfile, executable, observedProfile, runAgy, usageSnapshot } from "./dd-agy.mjs";
+import { prepareRuntimeOwner, cleanupFailedStart, cleanupFailedDaemonStart, confirmDaemonProcess, confirmDaemonStopped, finishDaemonProcess, scheduleDaemonProcessHeartbeat, registerDaemonProcess, stopProcessGroup } from "./managed-daemon.mjs";
+
+const REQUEST_SCHEMA = "dd-agy/daemon-request@1", RESPONSE_SCHEMA = "dd-agy/daemon-response@1", STATE_SCHEMA = "dd-agy/daemon-state@1";
+class DaemonError extends AgyError {}
+const absolute = (value, label) => { if (!value || !path.isAbsolute(value)) throw new DaemonError("invalid_path", `${label} must be an absolute path`); return path.resolve(value); };
+function locations(stateDir) {
+  const dir = absolute(stateDir, "--state-dir"), digest = createHash("sha256").update(dir).digest("hex").slice(0, 22), local = path.join(dir, "daemon.sock");
+  // `tsx` creates Unix-domain sockets below TMPDIR.  An evaluation path is
+  // intentionally descriptive and can exceed the platform's socket-path cap,
+  // so provider temp files must not inherit that path.
+  return { dir, socket: Buffer.byteLength(local) < 100 ? local : `/tmp/dd-agy-${digest}.sock`, state: path.join(dir, "daemon.json"), journal: path.join(dir, "events.jsonl"), log: path.join(dir, "daemon.log"), gemini: path.join(dir, "gemini"), runtime: path.join(dir, "gemini", "runtime"), config: path.join(dir, "gemini", "config"), temporary: `/tmp/dd-agy-tmp-${digest}` };
+}
+async function writeJson(file, value) { const temporary = `${file}.${process.pid}.${randomUUID()}.tmp`; await writeFile(temporary, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 }); await rename(temporary, file); }
+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 a non-socket daemon path"); await unlink(paths.socket); } catch (error) { if (error.code !== "ENOENT") throw error; } }
+const shell = value => `'${String(value).replaceAll("'", `'"'"'`)}'`;
+export function sanitizedEnv(config) { const env = { ...process.env, TMPDIR: config.temporary, DD_AGY_HOOK_NODE: process.execPath, DD_AGY_HOOK_ENTRY: config.entryPath, DD_AGY_STATE_DIR: config.stateDir, DD_AGY_DAEMON_ID: config.daemonId }; for (const key of ["GEMINI_API_KEY","GOOGLE_API_KEY","ANTHROPIC_API_KEY","OPENAI_API_KEY","DD_FLOW_DAEMON_ID"]) delete env[key]; if (config.ddFlowHome && config.daemonId) env.DD_FLOW_DAEMON_ID = config.daemonId; return env; }
+function errorPayload(error) { return { code: error.code ?? "operation_failed", message: error.message ?? String(error), retryable: error.retryable === true, ...(error.details === undefined ? {} : { details: error.details }) }; }
+async function forwardUsage(config, sessionId, result, tools, descendants) {
+  if (!config.ddFlowBin || !config.projectRoot) return;
+  const snapshot = usageSnapshot(result, tools), hasChildren = descendants.length > 0;
+  if (snapshot.total_tokens === null) return { status: "unavailable", reason: "provider_did_not_report_total_tokens" };
+  const payload = { provider_session_id: sessionId, daemon_id: config.daemonId, observed_at: new Date().toISOString(), usage_scope: hasChildren ? "unknown" : "physical_session", completeness: hasChildren ? "partial" : "complete", usage: { inputTokens: snapshot.input_tokens, outputTokens: snapshot.output_tokens, reasoningTokens: snapshot.reasoning_tokens, cacheReadInputTokens: snapshot.cache_read_tokens, totalTokens: snapshot.total_tokens }, tool_calls: snapshot.tool_calls };
+  const target = executable(config.ddFlowBin, ["agy", "usage", "ingest", "--project-root", config.projectRoot, "--json"]);
+  await new Promise((resolve, reject) => { const child = spawn(target.command, target.args, { env: { ...process.env, DD_FLOW_HOME: config.ddFlowHome }, stdio: ["pipe", "ignore", "pipe"] }); let stderr = ""; child.stderr.setEncoding("utf8").on("data", chunk => stderr += chunk); child.on("error", reject); child.on("close", code => code === 0 ? resolve() : reject(new DaemonError("agy_usage_ingest_failed", stderr.trim() || "dd-flow rejected Antigravity usage"))); child.stdin.end(`${JSON.stringify(payload)}\n`); });
+  return { status: "ingested" };
+}
+
+export async function prepare(paths, config) {
+  config.stateDir = paths.dir;
+  config.hookBinding = "environment-v1";
+  const hooks = agyWorkspaceHooks();
+  for (const dir of [paths.dir, paths.gemini, paths.runtime, paths.config, paths.temporary]) { await mkdir(dir, { recursive: true, mode: 0o700 }); await chmod(dir, 0o700); }
+  if (config.noFlow) {
+    // Technical probes still need native settlement, but must not install
+    // workspace hooks or forward any lifecycle mutation to dd-flow.
+    await writeJson(path.join(paths.config, "hooks.json"), { "dd-flow-observer": { Stop: hooks["dd-flow"].Stop } });
+    return;
+  }
+  // Native discovery follows cwd (feature worktree/reviewer clone), while
+  // projectRoot remains the stable lifecycle identity returned to dd-flow.
+  Object.assign(config, await qualifyAgyHooks(config.cwd ?? config.projectRoot, { stateDir: paths.dir }));
+  // Workspace discovery covers root and children without global duplicates.
+  await writeJson(path.join(paths.config, "hooks.json"), {});
+}
+
+export async function qualifyAgyHooks(projectRoot, { stateDir = null, install = false } = {}) {
+  const hooks = agyWorkspaceHooks();
+  // Register in workspace discovery before creating any Session: native root
+  // and children load these named hook definitions without a global duplicate.
+  // Replace our prior handlers, including the obsolete wildcard post hook,
+  // without dropping unrelated commands in a shared matcher group.
+  const workspaceConfig = path.join(absolute(projectRoot, "--project-root"), ".agents");
+  const workspaceHooks = path.join(workspaceConfig, "hooks.json");
+  let existing = {}, existingText = "";
+  try {
+    existingText = await readFile(workspaceHooks, "utf8");
+    const parsed = JSON.parse(existingText);
+    if (!parsed || Array.isArray(parsed) || typeof parsed !== "object") throw new Error("not an object");
+    existing = parsed;
+  } catch (error) {
+    if (error.code !== "ENOENT") throw new DaemonError("workspace_hooks_invalid", `cannot install Antigravity lifecycle hooks: ${error.message}`);
+    if (!install) throw new DaemonError("workspace_hooks_unqualified", "Antigravity hooks must be installed during qualification before daemon start", false, { hooks_path: workspaceHooks });
+  }
+  const isManagedHandler = handler => typeof handler?.command === "string"
+    && ((handler.command.includes("DD_AGY_HOOK_ENTRY") && handler.command.includes(" hook handle --event ") && handler.command.includes("DD_AGY_STATE_DIR")) || /(?:^|\/)dd-agy\.mjs['"]?\s+hook handle/.test(handler.command));
+  const events = ["PreToolUse", "PostToolUse", "PreInvocation", "PostInvocation", "Stop"];
+  const existingManaged = Object.entries(existing).flatMap(([name, definition]) => {
+    if (events.includes(name) && Array.isArray(definition)) return definition;
+    if (!definition || typeof definition !== "object" || Array.isArray(definition)) return [];
+    return events.flatMap(event => Array.isArray(definition[event]) ? definition[event] : []);
+  }).flatMap(item => Array.isArray(item?.hooks) ? item.hooks : [item]).filter(handler => isManagedHandler(handler) && handler.command.includes("--state-dir") && !handler.command.includes("DD_AGY_STATE_DIR"));
+  if (existingManaged.some(handler => !stateDir || !handler.command.includes(`--state-dir ${shell(stateDir)}`))) {
+    throw new DaemonError("workspace_hooks_drifted", "qualified Antigravity hook routes to another daemon state directory", false, { hooks_path: workspaceHooks, expected_state_dir: stateDir });
+  }
+  const retain = handlers => handlers.flatMap(item => {
+    if (!Array.isArray(item?.hooks)) return isManagedHandler(item) ? [] : [item];
+    const remaining = item.hooks.filter(handler => !isManagedHandler(handler));
+    return remaining.length ? [{ ...item, hooks: remaining }] : [];
+  });
+  const workspace = Object.create(null), legacy = Object.create(null);
+  for (const [name, definition] of Object.entries(existing)) {
+    // Migrate the old adapter's event-keyed workspace format.
+    if (events.includes(name) && Array.isArray(definition)) {
+      const remaining = retain(definition);
+      if (remaining.length) legacy[name] = remaining;
+      continue;
+    }
+    if (!definition || Array.isArray(definition) || typeof definition !== "object") {
+      throw new DaemonError("workspace_hooks_invalid", `invalid named hook definition: ${name}`);
+    }
+    const cleaned = { ...definition };
+    for (const event of events) if (Array.isArray(cleaned[event])) {
+      const remaining = retain(cleaned[event]);
+      if (remaining.length || cleaned[event].length === 0) cleaned[event] = remaining;
+      else delete cleaned[event];
+    }
+    workspace[name] = cleaned;
+  }
+  if (Object.keys(legacy).length) {
+    let name = "dd-flow-legacy";
+    while (Object.hasOwn(workspace, name)) name += "-retained";
+    workspace[name] = legacy;
+  }
+  const managed = workspace["dd-flow"] ?? {};
+  if (managed.enabled === false) throw new DaemonError("workspace_hooks_invalid", "dd-flow lifecycle hooks are disabled");
+  for (const [event, handlers] of Object.entries(hooks["dd-flow"])) {
+    managed[event] = [...(managed[event] ?? []), ...handlers];
+  }
+  workspace["dd-flow"] = managed;
+  const serializedWorkspace = `${JSON.stringify(workspace, null, 2)}\n`;
+  // Hook installation is a qualification/ownership boundary. Reusing the
+  // qualified command must not rewrite the project file when the pinned engine,
+  // daemon directory or workspace location changes.
+  const installed = isDeepStrictEqual(existing, JSON.parse(serializedWorkspace));
+  if (!installed && !install) throw new DaemonError("workspace_hooks_unqualified", "Antigravity hook definitions differ from the qualified contract", false, { hooks_path: workspaceHooks });
+  if (!installed) { await mkdir(workspaceConfig, { recursive: true, mode: 0o700 }); await writeFile(workspaceHooks, serializedWorkspace, { mode: 0o600 }); }
+  return { hooksSha256: createHash("sha256").update(JSON.stringify(hooks)).digest("hex"), workspaceHooksPath: workspaceHooks,
+    workspaceHooksSha256: createHash("sha256").update(installed ? existingText : serializedWorkspace).digest("hex"), workspaceHooksInstalled: installed ? "qualified_existing" : "qualified_install" };
+}
+
+export async function callDaemon(stateDir, operation, params = {}, timeoutMs = 30_000, requestId = null) {
+  const paths = locations(stateDir), request = { schema_id: REQUEST_SCHEMA, id: requestId ?? process.env.DD_EVAL_OPERATION_ID ?? randomUUID(), operation, params };
+  return await new Promise((resolve, reject) => {
+    const client = net.createConnection(paths.socket); let buffer = "", settled = false, timer, checking = false, lastActivity = Date.now();
+    const clock = new ObservationClock({ timeoutMs, onGap: gap => { void appendFile(paths.journal, `${JSON.stringify({ kind: "observation_gap", payload: { ...gap, operation_id: request.id } })}\n`, { mode: 0o600 }).catch(() => {}); } });
+    const finish = (error, result) => { if (settled) return; settled = true; if (timer) clearInterval(timer); client.destroy(); error ? reject(error) : resolve(result); };
+    const poll = Math.min(5_000, Math.max(25, Math.floor(timeoutMs / 20)));
+    timer = setInterval(async () => {
+      if (settled || checking) return;
+      checking = true;
+      try {
+        if (operation !== "session.prompt") {
+          if (clock.sample()) finish(new DaemonError("daemon_timeout", `${operation} timed out`, true));
+          return;
+        }
+        let status = null;
+        try { status = await callDaemon(stateDir, "daemon.status", {}, Math.min(timeoutMs, 5_000)); }
+        catch { /* The original RPC retains the authoritative failure. */ }
+        const observed = Date.parse(status?.last_activity_at ?? "");
+        const progressed = status?.active_tree === true && Number.isFinite(observed) && observed > lastActivity;
+        if (progressed) lastActivity = observed;
+        if (!clock.sample(progressed ? lastActivity : undefined, progressed ? lastActivity : undefined)) return;
+        finish(new DaemonError(status?.active_tree ? "subject_liveness_timeout" : "operation_observation_lost", `${operation} has no recent productive provider activity`, true, {
+          operation_id: request.id,
+          last_activity_at: status?.last_activity_at ?? null,
+          active_tree: status?.active_tree === true
+        }));
+      } finally { checking = false; }
+    }, poll);
+    client.setEncoding("utf8"); client.on("connect", () => client.write(`${JSON.stringify(request)}\n`)); client.on("data", chunk => { buffer += chunk; const index = buffer.indexOf("\n"); if (index < 0) return; try { const response = JSON.parse(buffer.slice(0, index)); response.ok ? finish(null, response.result) : finish(new DaemonError(response.error.code, response.error.message, response.error.retryable, response.error.details)); } catch (error) { finish(new DaemonError("daemon_protocol_mismatch", error.message)); } }); client.on("error", error => finish(new DaemonError("daemon_not_running", error.message, true))); client.on("end", () => finish(new DaemonError("daemon_connection_closed", `${operation} connection closed before a response`, true))); client.on("close", () => finish(new DaemonError("daemon_connection_closed", `${operation} connection closed before a response`, true)));
+  });
+}
+
+function sameConfig(state, config) { return ["cwd","journal","bin","provider","model","reasoning","mode","projectRoot","ddFlowBin","ddFlowHome","resourceHome","noFlow"].every(key => (state.config?.[key] ?? null) === (config[key] ?? null)); }
+// Called only after authorizeRetainedDaemonResume verifies the old daemon,
+// provider processes and operation ledger. Native outcomes remain historical;
+// their old liveness flags cannot describe the replacement process tree.
+export function retainedAgyState(previous, sessionId) {
+  if (!sessionId || !previous?.sessions?.some(session => session.provider_session_id === sessionId)) return {};
+  if (previous.shutdown_state !== "clean" || previous.active_tree !== false) return previous;
+  return {
+    ...previous,
+    unclaimed_activity: false,
+    retained_tree_settlement: { daemon_id: previous.daemon_id, session_id: sessionId, turn_generation: previous.turn_generation ?? 0, evidence: "verified_clean_daemon_shutdown" },
+    session_observations: (previous.session_observations ?? []).map(([id, observation]) => [id, id === sessionId ? { ...observation, retained_stop: observation.stop ?? null, stop: null } : observation]),
+    descendants: (previous.descendants ?? []).map(child => child.tree_settled === true ? child : { ...child, tree_settled: true, settlement_evidence: "prior_clean_daemon_shutdown", settlement_daemon_id: previous.daemon_id })
+  };
+}
+export async function startDaemon(options) {
+  const paths = locations(options.stateDir); await mkdir(paths.dir, { recursive: true, mode: 0o700 }); await chmod(paths.dir, 0o700);
+  const previous = await readState(paths.dir), noFlow = options.noFlow === true, cwd = await realpath(absolute(options.cwd, "--cwd")), config = { cwd, journal: options.journal ? absolute(options.journal, "--journal") : paths.journal, bin: options.bin ?? process.env.DD_AGY_BIN ?? "agy", provider: String(options.provider ?? "google"), model: String(options.model ?? "gemini-3.1-pro-high"), reasoning: String(options.reasoning ?? "high"), mode: String(options.mode ?? "accept-edits"), 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") }, entryPath: absolute(options.entryPath, "dd-agy entry"), daemonId: randomUUID(), resumeSessionId: options.sessionId ?? null, geminiDir: paths.gemini, appDataDir: "runtime", temporary: paths.temporary, noFlow };
+  await prepareRuntimeOwner(config, paths.dir);
+  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; }
+  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 Antigravity daemon died with an active or unproven tree");
+  await removeSocket(paths); await prepare(paths, config);
+  const version = (await runAgy(config.bin, ["--version"], { cwd: config.cwd, env: sanitizedEnv(config), timeoutMs: 10_000 })).stdout.trim();
+  const resourceProcess = await registerDaemonProcess(config, { kind: "agy-daemon", owner: `agy:${path.basename(paths.dir)}`, operation: `agy-daemon:${path.basename(paths.dir)}`, stdout: paths.log, stderr: paths.log });
+  const retained = retainedAgyState(previous, config.resumeSessionId);
+  await writeJson(paths.state, { schema_id: STATE_SCHEMA, daemon_id: config.daemonId, shutdown_state: "starting", active_tree: false, unclaimed_activity: retained.unclaimed_activity ?? false, retained_tree_settlement: retained.retained_tree_settlement ?? null, versions: { agy: version }, config, sessions: [], session_observations: retained.session_observations ?? [], descendants: retained.descendants ?? [], tool_calls: retained.tool_calls ?? [], completed_tool_steps: retained.completed_tool_steps ?? [], tool_identity_complete: retained.tool_identity_complete !== false, turn_generation: retained.turn_generation ?? 0, last_result: retained.last_result ?? null, resource_process: resourceProcess });
+  const log = await open(paths.log, "a", 0o600), child = spawn(process.execPath, [config.entryPath, "daemon", "serve", "--state-dir", paths.dir], { cwd: config.cwd, env: sanitizedEnv(config), detached: true, stdio: ["ignore", log.fd, log.fd] }); child.unref(); await log.close();
+  try {
+    await confirmDaemonProcess(config, resourceProcess, child);
+    const deadline = Date.now() + 30_000; while (Date.now() < deadline) { await new Promise(resolve => setTimeout(resolve, 100));
+      const persisted = await readState(paths.dir);
+      if (persisted?.shutdown_state === "failed") {
+        const failure = persisted.startup_error ?? {};
+        throw new DaemonError(failure.code ?? "daemon_start_failed", failure.message ?? "Antigravity daemon failed before becoming ready", failure.retryable === true, failure.details);
+      }
+      try { const status = await callDaemon(paths.dir, "daemon.status", {}, 1000); if (status.provider_ready) return status; } catch (error) { if (!["daemon_not_running","daemon_timeout"].includes(error.code)) throw error; }
+    }
+    throw new DaemonError("daemon_start_failed", "Antigravity daemon did not become ready", true);
+  } catch (error) {
+    await cleanupFailedDaemonStart(config, resourceProcess, child, error, () => readState(paths.dir), config.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); };
+
+export class Runtime {
+  constructor(paths, state) { this.paths = paths; this.state = state; this.config = state.config; this.child = null; this.providerProcess = state.provider_process ?? null; this.providerFinalization = Promise.resolve(); this.buffer = ""; this.init = null; this.readyPromise = null; this.active = null; this.exited = false; this.toolObservations = new ToolObservations(); for (const reason of state.tool_observation_gaps ?? []) this.toolObservations.gaps.add(reason); for (const event of state.tool_observations ?? []) this.toolObservations.add(event); if (state.tool_calls?.length && !state.tool_observations) this.toolObservations.gaps.add("legacy_tools_not_attributed"); this.turnGeneration = state.turn_generation ?? 0; this.descendants = new Map((state.descendants ?? []).map(child => [child.provider_session_id, child])); this.lastResult = state.last_result ?? null; this.sessionObservations = new Map(state.session_observations ?? []); this.startupError = null; this.persisting = Promise.resolve(); this.draining = Promise.resolve(); this.lastActivityAt = state.last_activity_at ?? null; this.usageIngest = null; this.lastProviderEvent = null; }
+  persist(patch = {}) { Object.assign(this.state, patch, { pid: process.pid, updated_at: new Date().toISOString(), last_activity_at: this.lastActivityAt, session_observations: [...this.sessionObservations], tool_observations: [...this.toolObservations.calls.values()], tool_observation_gaps: [...this.toolObservations.gaps], turn_generation: this.turnGeneration, descendants: [...this.descendants.values()], sessions: this.init ? [{ provider_session_id: this.init.conversation_id, root_provider_session_id: this.init.conversation_id, cwd: this.config.cwd }] : [] }); const snapshot = structuredClone(this.state); const queued = performance.now(); this.persisting = this.persisting.then(async () => { const started = performance.now(); await writeJson(this.paths.state, snapshot); this.persistTiming = { queue_ms: Math.round(started - queued), write_ms: Math.round(performance.now() - started) }; }); return this.persisting; }
+  async journal(kind, payload = {}) { const line = `${JSON.stringify({ schema_id: "dd-agy/daemon-event@1", event_id: randomUUID(), observed_at: new Date().toISOString(), kind, ...payload })}\n`; for (const journal of new Set([this.paths.journal, this.config.journal].filter(Boolean))) { await mkdir(path.dirname(journal), { recursive: true, mode: 0o700 }); await appendFile(journal, line, { mode: 0o600 }); } }
+  args(sessionId) { return ["--input-format", "stream-json", "--output-format", "stream-json", "--model", this.config.model, "--effort", this.config.reasoning, "--mode", this.config.mode, "--dangerously-skip-permissions", "--print-timeout", "6h", `--gemini_dir=${this.paths.gemini}`, "--app_data_dir=runtime", ...(sessionId ? ["--conversation", sessionId] : ["--new-project"])]; }
+  requireSessionIdentity(requestedId) {
+    const observedId = this.init?.conversation_id ?? null;
+    if (!requestedId || requestedId === observedId) return observedId;
+    throw new DaemonError("session_identity_mismatch", "requested Antigravity Session is not owned by this daemon", false, {
+      harness: "antigravity-cli", expected_session_id: requestedId, observed_session_id: observedId
+    });
+  }
+  markActivity() { this.lastActivityAt = new Date().toISOString(); }
+  observeProviderActivity(event) {
+    const fingerprint = createHash("sha256").update(JSON.stringify(event)).digest("hex");
+    if (this.lastProviderEvent === fingerprint) return;
+    this.lastProviderEvent = fingerprint;
+    if (["init", "step_update", "result"].includes(event.event)) this.markActivity();
+  }
+  async start(sessionId = null) {
+    if (this.child && !this.exited) {
+      await this.readyPromise;
+      this.requireSessionIdentity(sessionId);
+      return this.init;
+    }
+    await this.providerFinalization;
+    const target = executable(this.config.bin, this.args(sessionId)); this.exited = false; this.buffer = ""; this.init = null;
+    let readyResolve, readyReject; this.readyPromise = new Promise((resolve, reject) => { readyResolve = resolve; readyReject = reject; });
+    // The provider can reject before durable registration finishes.  Keep a
+    // handler attached during that small window; `start()` still returns the
+    // original rejection below.
+    void this.readyPromise.catch(() => {});
+    this.providerProcess = await registerDaemonProcess(this.config, { kind: "agy-provider", owner: `agy:${path.basename(this.paths.dir)}`, operation: `agy-provider:${path.basename(this.paths.dir)}`, stdout: this.paths.log, stderr: this.paths.log });
+    const providerProcess = this.providerProcess;
+    try { await this.persist({ provider_process: providerProcess }); }
+    catch (error) { await cleanupFailedStart(this.config, providerProcess, null, error); throw error; }
+    try { this.child = spawn(target.command, target.args, { cwd: this.config.cwd, env: sanitizedEnv(this.config), detached: true, stdio: ["pipe", "pipe", "pipe"] }); }
+    catch (error) { await cleanupFailedStart(this.config, providerProcess, null, error); throw error; }
+    const providerChild = this.child;
+    let allowProviderFinalization;
+    const providerRegistered = new Promise(resolve => { allowProviderFinalization = resolve; });
+    this.child.stdout.setEncoding("utf8").on("data", chunk => { this.buffer += chunk; this.draining = this.draining.then(() => this.drain(readyResolve)).catch(error => { readyReject(error); if (this.active) { this.active.reject(error); this.active = null; } }); });
+    this.child.stderr.setEncoding("utf8").on("data", chunk => void this.journal("stderr", { text: String(chunk).slice(0, 4000) }));
+    this.child.on("error", error => { readyReject(error); if (this.active) { this.active.reject(error); this.active = null; } });
+    // A dead leader is not yet a finalized tree: stop must also join the
+    // pending drain, process-group check and final persistence/lease writes.
+    this.providerFinalization = new Promise((resolve, reject) => {
+      this.child.on("close", (code, signal) => {
+        void this.draining.then(async () => {
+          const interrupted = Boolean(this.active); this.exited = true; const beforeInit = !this.init;
+          const error = this.startupError ?? new DaemonError(beforeInit ? "agy_init_missing" : "agy_terminal_result_missing", `Antigravity exited ${beforeInit ? "before init" : "before result"} (${code ?? signal})`);
+          if (beforeInit) readyReject(error);
+          if (this.active) { this.active.reject(error); this.active = null; }
+          const patch = beforeInit ? { shutdown_state: "failed", startup_error: errorPayload(error), provider_exit: { code, signal }, active_tree: false } : { provider_exit: { code, signal }, active_tree: interrupted };
+          await providerRegistered;
+          this.retryProviderFinalization = async (graceMs = 1_000) => {
+            try {
+              await stopProcessGroup(providerChild, graceMs);
+              await this.persist(patch);
+              await finishDaemonProcess(this.config, providerProcess, beforeInit || interrupted ? "failed" : "stopped", beforeInit || interrupted ? "provider_interrupted" : "provider_stopped");
+              this.retryProviderFinalization = null;
+            } catch (cleanup) { await this.persist({ shutdown_state: "cleanup_failed", active_tree: true, cleanup_error: errorPayload(cleanup) }); throw cleanup; }
+            finally { if (beforeInit) this.server?.close(); }
+          };
+          await this.retryProviderFinalization();
+        }).then(resolve, reject);
+      });
+    });
+    void this.providerFinalization.catch(() => {});
+    try { await confirmDaemonProcess(this.config, providerProcess, this.child); await this.persist({ provider_pid: this.child.pid }); scheduleDaemonProcessHeartbeat(this.config, providerProcess); }
+    catch (error) { await cleanupFailedStart(this.config, providerProcess, this.child, error); throw error; }
+    finally { allowProviderFinalization(); }
+    let readyTimer;
+    try { return await Promise.race([this.readyPromise, new Promise((_, reject) => { readyTimer = setTimeout(() => reject(new DaemonError("agy_init_timeout", "Antigravity init timed out", true)), 30_000); })]); }
+    finally { clearTimeout(readyTimer); }
+  }
+  async drain(readyResolve) { let index; while ((index = this.buffer.indexOf("\n")) >= 0) { const line = this.buffer.slice(0, index).trim(); this.buffer = this.buffer.slice(index + 1); if (!line) continue; let event; try { event = JSON.parse(line); } catch { await this.journal("invalid_json", { line: line.slice(0, 1000) }); continue; }
+    // Record an early provider rejection before journalling: a short-lived
+    // child can close while the asynchronous write is still pending.
+    if (!this.init && event.event === "result" && event.result?.status === "ERROR") this.startupError = new DaemonError("agy_provider_rejected", String(event.result.error ?? "Antigravity rejected the Session before initialization"), false, { provider_result: event.result });
+    this.observeProviderActivity(event); await this.journal("provider_event", { event }); if (event.event === "init") { this.init = { conversation_id: event.conversation_id, ...(event.init ?? {}) }; if (!this.init.conversation_id) throw new DaemonError("agy_init_missing", "Antigravity init has no conversation ID"); const requested = { provider: this.config.provider, model: this.config.model, reasoning: this.config.reasoning, mode: this.config.mode, permission_mode: "always-proceed" }; this.profile = assertProfile(requested, observedProfile(this.init, requested)); await observeModel({ journal: this.config.journal, harness: "antigravity-cli", sessionId: this.init.conversation_id, requested, observed: this.profile.observed, source: "native.init" }); await this.persist({ shutdown_state: "running", active_tree: false }); readyResolve(this.init); } else if (event.event === "step_update") this.observeStep(event.step_update ?? {}); else if (event.event === "result") { if (this.startupError) throw this.startupError; await this.finishTurn(event.result ?? {}); } } }
+  observeStep(step) { const sessionId = step.conversation_id ?? this.init?.conversation_id; const observation = this.sessionObservations.get(sessionId) ?? {}; if (Number.isInteger(step.step_index) && step.step_index > (observation.last_step_index ?? -1)) this.childActivity(sessionId); if (Number.isInteger(step.step_index)) this.sessionObservations.set(sessionId, { ...observation, last_step_index: Math.max(observation.last_step_index ?? -1, step.step_index) }); this.toolObservations.add(agyToolObservation(step, this.init?.conversation_id)); for (const child of step.subagent_info?.subagents ?? []) if (child.conversation_id) { const prior = this.descendants.get(child.conversation_id); this.descendants.set(child.conversation_id, { ...prior, provider_session_id: child.conversation_id, parent_provider_session_id: sessionId ?? null, role: child.role ?? null, subagent_type: child.type_name ?? null, log_uri: child.log_uri ?? null, workspace_uris: child.workspace_uris ?? [], status: prior?.status ?? "unknown" }); } }
+  toolSnapshot() { const summary = this.toolObservations.summary(); const failures_by_name = {}; for (const event of this.toolObservations.calls.values()) if (event.status === "failed") failures_by_name[event.name] = (failures_by_name[event.name] ?? 0) + 1; return { ...summary, by_name: summary.by_tool, failures_by_name }; }
+  async finishTurn(result) {
+    if (result.status === "RUNNING") { await this.persist({ active_tree: true }); return; }
+    if (!["SUCCESS", "ERROR", "CANCELLED"].includes(result.status)) throw new DaemonError("agy_terminal_result_invalid", "Antigravity result has no recognized terminal status", false, { provider_result: result });
+    if (result.conversation_id && result.conversation_id !== this.init?.conversation_id) {
+      await this.journal("foreign_terminal_observed", { conversation_id: result.conversation_id, result });
+      const child = this.descendants.get(result.conversation_id);
+      if (child) {
+        this.descendants.set(result.conversation_id, { ...child, status: result.status === "SUCCESS" ? "completed" : result.status === "ERROR" ? "failed" : "cancelled" });
+        await this.completePendingTurn();
+      }
+      return;
+    }
+    const current = this.active;
+    // The ordered stream returns one result per input. Model usage counters
+    // are not request IDs: native command rejections can report zero turns.
+    // prompt() drains earlier events before accepting another input.
+    if (!current && this.lastResult) { await this.journal("stale_terminal_observed", { result }); return; }
+    this.lastResult = result; this.markActivity();
+    const rootStop = this.sessionObservations.get(this.init?.conversation_id)?.stop;
+    const pendingTerminal = current && result.status === "SUCCESS";
+    if (pendingTerminal) current.terminalResult = result;
+    if (pendingTerminal && rootStop?.fullyIdle === true) for (const [id, descendant] of this.descendants) if (descendant.status === "unknown") this.descendants.set(id, { ...descendant, status: "settled_by_root", settlement_evidence: "root_fully_idle_stop" });
+    const terminalReceipt = pendingTerminal ? this.receipt(result) : null;
+    await this.persist({ active_tree: pendingTerminal ? !terminalReceipt.settled : result.status === "RUNNING" || rootStop?.fullyIdle === false, last_result: result });
+    try { this.usageIngest = await forwardUsage(this.config, result.conversation_id ?? this.init.conversation_id, result, this.toolSnapshot(), [...this.descendants.values()]); }
+    catch (error) { this.usageIngest = { status: "failed", error: error.message ?? String(error) }; await this.journal("usage_ingest_failed", this.usageIngest); }
+    if (!current) return;
+    if (this.active !== current) return;
+    if (result.status === "ERROR" || result.status === "CANCELLED") {
+      this.active = null;
+      const message = String(result.error ?? "Antigravity returned ERROR"); const normalized = message.toLowerCase();
+      const code = result.status === "CANCELLED" ? "agy_turn_cancelled" : /quota|insufficient.?credit|billing|usage limit/.test(normalized) ? "agy_provider_quota_exhausted"
+        : /rate.?limit|too many requests|\b429\b/.test(normalized) ? "agy_provider_rate_limited"
+          : /auth|unauthori[sz]ed|forbidden|account/.test(normalized) ? "agy_provider_account"
+            : "agy_provider_failed";
+      return current.reject(new DaemonError(code, message, ["agy_provider_quota_exhausted", "agy_provider_rate_limited"].includes(code), { provider_result: result, provider_error_scope: current.previousError && current.previousError === result.error ? "repeated_conversation_error" : "terminal_result", usage_ingest: this.usageIngest }));
+    }
+    await this.completePendingTurn();
+  }
+  async completePendingTurn() {
+    await this.observeHookFailures();
+    const current = this.active;
+    if (!current?.terminalResult || current.terminalResult !== this.lastResult) return;
+    await this.persist({ active_tree: !this.receipt().settled });
+    // Hooks can invalidate the tree while persistence is pending. Never
+    // publish a proof captured before that asynchronous boundary.
+    if (this.active !== current) return;
+    const receipt = this.receipt();
+    if (!receipt.settled) { await this.persist({ active_tree: true }); return; }
+    this.active = null;
+    current.resolve(receipt);
+  }
+  receipt(result = this.lastResult) {
+    const assistantText = typeof result?.response === "string" ? result.response : typeof result?.text === "string" ? result.text : null;
+    const root = this.init?.conversation_id; const observation = this.sessionObservations.get(root);
+    const treeSettled = [...this.descendants.values()].every(child => child.tree_settled === true || ["completed", "failed", "cancelled", "settled_by_root"].includes(child.status));
+    // A terminal root result is the provider's authoritative end-of-turn
+    // observation when AGY does not emit a root Stop hook.  A received
+    // non-idle Stop still wins, and every discovered child must be terminal.
+    const rootSettled = observation?.stop?.fullyIdle !== false;
+    const terminalPending = this.active?.terminalResult === result;
+    return { harness: "antigravity-cli", runtime_family: "antigravity", provider_session_id: root ?? null, adapter_session_id: root ?? null, cwd: this.config.cwd, profile: this.profile, result, ...(assistantText === null ? {} : { assistant_text: assistantText }), usage: usageSnapshot(result ?? {}, this.toolSnapshot()), usage_ingest: this.usageIngest, descendants: [...this.descendants.values()], transcript_path: observation?.transcript_path ?? null, settled: Boolean(!this.state.unclaimed_activity && (!this.active || terminalPending) && result && ["SUCCESS", "ERROR", "CANCELLED"].includes(result.status) && treeSettled && rootSettled) };
+  }
+  async zeroUsage() { await forwardUsage(this.config, this.init.conversation_id, { usage: {} }, this.toolSnapshot(), []); }
+  async prompt(text, assertDispatch = captureDispatchGuard(this), operationId = null) {
+    if (!text) throw new DaemonError("prompt_required", "prompt is required");
+    await this.start(); await this.draining;
+    if (this.active) throw new DaemonError("operation_in_progress", "an Antigravity turn is already running");
+    if (this.state.last_hook_rejection && !this.receipt().settled) throw new DaemonError("tree_not_settled", "Rejected hook does not prove that the prior Antigravity tree stopped", false, { primary_error: this.state.last_hook_rejection });
+    if (this.state.unclaimed_activity || (this.lastResult && !this.receipt().settled)) throw new DaemonError("tree_not_settled", "the prior Antigravity agent tree is not fully settled");
+    let resolveTurn, rejectTurn;
+    const reply = new Promise((resolve, reject) => { resolveTurn = resolve; rejectTurn = reject; });
+    // Cancellation can reject while admission persistence is still pending.
+    void reply.catch(() => {});
+    const current = { resolve: resolveTurn, reject: rejectTurn, generation: ++this.turnGeneration, operationId, previousError: this.lastResult?.error ?? null };
+    // Reserve before persistence so different operation IDs cannot overlap.
+    this.active = current;
+    this.hookRequests = new Map();
+    const root = this.init?.conversation_id, prior = this.sessionObservations.get(root) ?? {};
+    this.sessionObservations.set(root, { ...prior, step_floor: prior.last_step_index ?? null, stop: null, last_hook: null });
+    this.lastProviderEvent = null;
+    try {
+      await this.persist({ active_tree: true, last_hook_rejection: null });
+      assertDispatch();
+      if (this.active !== current) throw new DaemonError("operation_cancelled", "prompt reservation was superseded");
+      this.child.stdin.write(`${JSON.stringify({ event: "user", message: { content: text } })}\n`, error => {
+        if (error) { if (this.active === current) this.active = null; current.reject(error); }
+      });
+    } catch (error) { if (this.active === current) this.active = null; current.reject(error); }
+    return await reply;
+  }
+  childActivity(sessionId) {
+    if (sessionId === this.init?.conversation_id && !this.active) this.state.unclaimed_activity = true;
+    const child = this.descendants.get(sessionId);
+    if (!child) return;
+    this.descendants.set(sessionId, { ...child, previous_terminal_status: child.status === "unknown" ? child.previous_terminal_status : child.status, status: "unknown", tree_settled: false, settlement_evidence: null, settlement_daemon_id: null, activity_generation: this.turnGeneration });
+  }
+  async childForHook(conversationId) {
+    if (conversationId === this.init?.conversation_id) return null;
+    const deadline = Date.now() + 1_000;
+    while (!this.descendants.has(conversationId) && Date.now() < deadline) await new Promise(resolve => setTimeout(resolve, 10));
+    const child = this.descendants.get(conversationId);
+    if (!child) throw new DaemonError("agy_child_identity_unconfirmed", "Antigravity hook has no confirmed native parent", true, { conversation_id: conversationId });
+    if (child.parent_provider_session_id !== this.init?.conversation_id) throw new DaemonError("agy_child_parent_unqualified", "Nested Antigravity worker is not a direct child of the controlled Session", false, { conversation_id: conversationId, parent_conversation_id: child.parent_provider_session_id });
+    return child;
+  }
+  async rejectHook(error, event, payload, current = this.active) {
+    if (current && this.active !== current) return;
+    const rejection = this.state.last_hook_rejection && this.state.last_hook_rejection.turn_generation === current?.generation ? this.state.last_hook_rejection : { code: error.code ?? "agy_hook_rejected", message: error.message ?? String(error), details: error.details, event, conversation_id: payload.conversationId ?? null, tool: payload.toolCall?.name ?? null, daemon_id: this.config.daemonId, operation_id: current?.operationId ?? null, turn_generation: current?.generation ?? null };
+    this.state.last_hook_rejection = rejection;
+    if (current && this.active === current) { this.active = null; current.reject(new DaemonError(rejection.code, rejection.message, false, rejection)); }
+    try { await this.journal("hook_rejected", { rejection }); await this.persist({ last_hook_rejection: rejection }); }
+    catch (storageError) { rejection.receipt_error = { code: storageError.code, message: storageError.message }; }
+  }
+  async observeHookFailures() {
+    for (const [requestId, binding] of this.hookRequests ?? []) {
+      if (binding.current !== this.active || !this.active) continue;
+      let failure;
+      try { failure = JSON.parse(await readFile(path.join(this.paths.dir, "hook-failures", `${requestId}.json`), "utf8")); }
+      catch (error) { if (error.code === "ENOENT") continue; failure = { code: "native_hook_receipt_invalid", message: error.message }; }
+      if (failure.request_id !== undefined && failure.request_id !== requestId) continue;
+      await this.rejectHook(Object.assign(new Error(failure.message ?? "Native hook failed"), { code: failure.code, details: failure.details }), binding.event, binding.payload, binding.current);
+    }
+  }
+  async observeHook(event, payload, budget = null) { const conversationId = payload.conversationId ?? this.init?.conversation_id; const child = await this.childForHook(conversationId); budget?.remaining("identity"); const prior = this.sessionObservations.get(conversationId) ?? {}; const execution = Number.isInteger(payload.executionNum) ? payload.executionNum : null; const step = Number.isInteger(payload.stepIdx) ? payload.stepIdx : null; const floor = prior.step_floor; const stale = step !== null && ((Number.isInteger(floor) && step <= floor) || (child && Number.isInteger(prior.last_step_index) && step < prior.last_step_index)); if (stale) { await this.journal("stale_hook", { hook_event: event, conversation_id: conversationId, step_index: step }); return { stale: true }; } const fingerprint = createHash("sha256").update(JSON.stringify({ event, payload })).digest("hex"); if (!stale && prior.last_hook !== fingerprint) this.markActivity(); if (conversationId && !stale) this.sessionObservations.set(conversationId, { ...prior, ...(step !== null ? { last_step_index: Math.max(prior.last_step_index ?? -1, step) } : {}), last_hook: fingerprint, ...(event === "PreToolUse" ? { last_pre_hook: fingerprint } : {}), ...(payload.transcriptPath ? { transcript_path: payload.transcriptPath } : {}), ...(event === "Stop" ? { stop: { fullyIdle: payload.fullyIdle === true, terminationReason: payload.terminationReason ?? null, executionNum: payload.executionNum ?? null } } : {}) }); if (!stale && event === "PreToolUse" && prior.last_pre_hook !== fingerprint) this.childActivity(conversationId); if (child && !stale && event === "Stop" && payload.fullyIdle === true) this.descendants.set(conversationId, { ...this.descendants.get(conversationId), tree_settled: true, settlement_evidence: "child_fully_idle_stop" }); const terminalPending = this.active?.terminalResult === this.lastResult; if (!child && !stale && event === "Stop" && payload.fullyIdle === true && (!this.active || terminalPending) && ["SUCCESS", "ERROR", "CANCELLED"].includes(this.lastResult?.status)) for (const [id, descendant] of this.descendants) if (descendant.status === "unknown") this.descendants.set(id, { ...descendant, status: "settled_by_root", settlement_evidence: "root_fully_idle_stop" }); const parent = child?.parent_provider_session_id ?? null;
+    const observed = payload.model ? observedProfile(payload) : {};
+    await observeModel({ journal: this.config.journal, harness: "antigravity-cli", sessionId: conversationId, parentSessionId: parent, requested: this.config, observed, source: "native.hook", evidence: payload.model ? "configured" : "unavailable", reason: payload.model ? null : "hook_omits_current_model" });
+    const eventId = createHash("sha256").update(JSON.stringify({ daemon: this.config.daemonId, event, conversationId, fully_idle: payload.fullyIdle ?? null, termination_reason: payload.terminationReason ?? null, execution: payload.executionNum ?? null, step: payload.stepIdx ?? null, tool: payload.toolCall?.name ?? null, args: payload.toolCall?.args ?? null })).digest("hex"); await this.persist(); await this.journal("hook", { stale, hook_event: event, event_id: eventId, conversation_id: conversationId, turn_generation: this.turnGeneration, execution_num: execution, step_index: step, termination_reason: payload.terminationReason ?? null, fully_idle: payload.fullyIdle ?? null, persistence_timing: this.persistTiming ?? null }); await this.completePendingTurn(); return { event_id: eventId, daemon_id: this.config.daemonId, launch_cwd: this.config.cwd, parent_conversation_id: parent, profile: observed, requested_profile: { provider: this.config.provider, model: this.config.model, reasoning: this.config.reasoning, mode: this.config.mode }, project_root: this.config.projectRoot, dd_flow_bin: this.config.ddFlowBin, dd_flow_home: this.config.ddFlowHome };
+  }
+  async finalizeProviderForControl() {
+    const pending = this.providerFinalization;
+    try { await pending; }
+    catch (error) {
+      // A leaderless group may have exited naturally since the last check.
+      // Only control may recheck it; startup never retries failed cleanup.
+      if (this.providerFinalization !== pending) return await this.providerFinalization;
+      if (error.code !== "process_group_ownership_unknown" || !this.retryProviderFinalization) throw error;
+      this.providerFinalization = this.retryProviderFinalization(5_000);
+      await this.providerFinalization;
+    }
+  }
+  async cancel() { cancelPendingDispatch(this); if (!this.child) return { ...this.receipt(), settled: Boolean(this.exited) }; if (!this.exited) { try { process.kill(-this.child.pid, "SIGINT"); } catch (error) { if (error.code !== "ESRCH") throw error; } const deadline = Date.now() + 5000; while (!this.exited && Date.now() < deadline) await new Promise(resolve => setTimeout(resolve, 100)); if (!this.exited) await stopProcessGroup(this.child, 5_000); } await this.finalizeProviderForControl(); await this.persist({ active_tree: false }); return { ...this.receipt(), cancelled: true, settled: Boolean(this.exited) };
+  }
+  async close(cancelTree) { if (cancelTree) cancelPendingDispatch(this); if (!cancelTree && (this.active || this.state.active_tree || this.state.unclaimed_activity || (this.lastResult && !this.receipt().settled))) throw new DaemonError("tree_not_settled", "Antigravity root or child tree is still running"); if (cancelTree) await this.cancel(); else if (this.child && !this.exited) this.child.stdin.end(); const deadline = Date.now() + 5000; while (!this.exited && Date.now() < deadline) await new Promise(resolve => setTimeout(resolve, 100)); if (!this.exited) await this.cancel(); await this.providerFinalization; }
+  async abortProvider(reason) {
+    const child = this.child, providerProcess = this.providerProcess;
+    await stopProcessGroup(child);
+    await this.finalizeProviderForControl();
+    await finishDaemonProcess(this.config, providerProcess, "failed", reason);
+  }
+  async finishResource(state = "stopped", reason = "daemon_stopped") { await finishDaemonProcess(this.config, this.state.resource_process, state, reason); }
+}
+
+export async function serveDaemon(stateDir) {
+  const paths = locations(stateDir), state = await readState(paths.dir); if (!state?.config) throw new DaemonError("daemon_state_missing", "Antigravity daemon state is missing");
+  scheduleDaemonProcessHeartbeat(state.config, state.resource_process);
+  const runtime = new Runtime(paths, state); await removeSocket(paths); const server = net.createServer(socket => { let buffer = ""; socket.on("error", () => {}); socket.setEncoding("utf8"); socket.on("data", chunk => { buffer += chunk; const index = buffer.indexOf("\n"); if (index < 0) return; let request; try { request = JSON.parse(buffer.slice(0, index)); } catch (error) { socket.end(`${JSON.stringify({ schema_id: RESPONSE_SCHEMA, ok: false, error: errorPayload(error) })}\n`); return; } void durableDaemonDispatch(paths.dir, request, () => dispatch(runtime, request), () => dispatch(runtime, { operation: "session.inspect", params: request.params ?? {} })).then(result => socket.end(`${JSON.stringify({ schema_id: RESPONSE_SCHEMA, id: request.id, ok: true, result })}\n`), error => socket.end(`${JSON.stringify({ schema_id: RESPONSE_SCHEMA, id: request.id, ok: false, error: errorPayload(error) })}\n`)); }); }); runtime.server = server;
+  await new Promise((resolve, reject) => { server.once("error", reject); server.listen(paths.socket, resolve); }); await chmod(paths.socket, 0o600);
+  try { await runtime.start(state.config.resumeSessionId); runtime.requireSessionIdentity(state.config.resumeSessionId); }
+  catch (error) {
+    await runtime.abortProvider("daemon_start_failed");
+    await runtime.persist({ shutdown_state: "failed", startup_error: errorPayload(error), active_tree: false }); await runtime.finishResource("failed", "daemon_start_failed");
+    await new Promise(resolve => server.close(resolve));
+    throw error;
+  }
+  await new Promise(resolve => server.once("close", resolve));
+}
+
+async function dispatch(runtime, request) {
+  if (request.schema_id !== REQUEST_SCHEMA) throw new DaemonError("daemon_protocol_mismatch", "unsupported dd-agy request schema"); const params = request.params ?? {};
+  if (request.operation === "daemon.status") { await runtime.observeHookFailures(); return { daemon_id: runtime.config.daemonId, shutdown_state: runtime.state.shutdown_state, active_tree: runtime.state.active_tree, active_operation: runtime.active?.operationId ?? null, last_hook_rejection: runtime.state.last_hook_rejection ?? null, last_activity_at: runtime.lastActivityAt, provider_ready: Boolean(runtime.init && !runtime.exited), pid: process.pid, provider_pid: runtime.child?.pid ?? null, versions: runtime.state.versions, config: runtime.config, sessions: runtime.state.sessions ?? [], receipt: runtime.receipt() }; }
+  if (request.operation === "session.create") { if (params.sessionId) throw new DaemonError("invalid_create", "create does not accept a Session ID"); if (params.prompt) throw new DaemonError("invalid_create", "create does not execute a prompt; use session.prompt"); await runtime.start(); await runtime.zeroUsage(); return runtime.receipt(); }
+  if (request.operation === "session.prompt") { const assertDispatch = captureDispatchGuard(runtime); await runtime.start(params.sessionId ?? null); runtime.requireSessionIdentity(params.sessionId); return await runtime.prompt(params.prompt, assertDispatch, request.id); }
+  if (request.operation === "session.inspect") { runtime.requireSessionIdentity(params.sessionId); return runtime.receipt(); }
+  if (request.operation === "session.resume") { await runtime.start(params.sessionId ?? runtime.init?.conversation_id ?? null); runtime.requireSessionIdentity(params.sessionId); return runtime.receipt(); }
+  if (request.operation === "session.cancel") { runtime.requireSessionIdentity(params.sessionId); return await runtime.cancel(); }
+  if (request.operation === "hook.observe") {
+    // Check the process binding before correlating a request with an active
+    // turn. A stale/foreign daemon must not poison an unrelated operation.
+    if (runtime.config.hookBinding === "environment-v1" && params.daemonId !== runtime.config.daemonId) throw new DaemonError("agy_hook_binding_invalid", "Antigravity hook binding does not name this daemon", false, { expected_daemon_id: runtime.config.daemonId, observed_daemon_id: params.daemonId ?? null });
+    const current = runtime.active, budget = hookBudget(25_000, params.deadlineAt);
+    runtime.hookRequests ??= new Map();
+    if (/^[A-Za-z0-9-]{1,128}$/.test(request.id)) runtime.hookRequests.set(request.id, { current, event: params.event, payload: { conversationId: params.payload?.conversationId, toolCall: { name: params.payload?.toolCall?.name } } });
+    try {
+      const result = await budget.run(async () => {
+        if (runtime.hookRequests.has(request.id) && current?.operationId) {
+          const directory = path.join(runtime.paths.dir, "operations", createHash("sha256").update(current.operationId).digest("hex"), "hooks");
+          await mkdir(directory, { recursive: true, mode: 0o700 });
+          await writeJson(path.join(directory, `${request.id}.json`), { schema_id: "dd-flow/hook-request@1", request_id: request.id, daemon_id: runtime.config.daemonId, operation_id: current.operationId, turn_generation: current.generation, event: params.event, conversation_id: params.payload?.conversationId ?? null, tool: params.payload?.toolCall?.name ?? null });
+        }
+        budget.remaining("observation");
+        return await runtime.observeHook(params.event, params.payload ?? {}, budget);
+      }, "observation");
+      await runtime.observeHookFailures(); budget.remaining("observation");
+      if (current && runtime.state.last_hook_rejection?.turn_generation === current.generation) throw Object.assign(new Error(runtime.state.last_hook_rejection.message), runtime.state.last_hook_rejection);
+      return result;
+    }
+    catch (error) { await runtime.rejectHook(error, params.event, params.payload ?? {}, current); throw error; }
+  }
+  if (request.operation === "daemon.stop") { await runtime.close(params.cancelTree === true); await runtime.persist({ shutdown_state: "clean", active_tree: false }); await runtime.finishResource(); setImmediate(() => runtime.server?.close()); return { stopped: true, clean: true, settled: true, daemon_id: runtime.config.daemonId }; }
+  throw new DaemonError("unknown_operation", `unknown dd-agy daemon operation: ${request.operation}`);
+}
+import { authorizeRetainedDaemonResume } from "./driver-recovery.mjs";

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

@@ -0,0 +1,59 @@
+import { spawn } from "node:child_process";
+import { mkdtemp, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+import { checkObservedProfile } from "./model-observations.mjs";
+
+const DEFAULT_MODEL = "gemini-3.1-pro-high";
+
+export class AgyError extends Error {
+  constructor(code, message, retryable = false, details) { super(message); this.code = code; this.retryable = retryable; this.details = details; }
+}
+
+export function executable(bin, args = []) {
+  return /\.[cm]?js$/.test(bin) ? { command: process.execPath, args: [bin, ...args] } : { command: bin, args };
+}
+
+export async function runAgy(bin, args, options = {}) {
+  const target = executable(bin, args);
+  return await new Promise((resolve, reject) => {
+    const child = spawn(target.command, target.args, { cwd: options.cwd, env: options.env ?? process.env, stdio: ["pipe", "pipe", "pipe"] });
+    let stdout = "", stderr = "", settled = false;
+    const timer = setTimeout(() => { child.kill("SIGTERM"); finish(new AgyError("agy_timeout", `${args[0] ?? "agy"} timed out`, true)); }, options.timeoutMs ?? 30_000);
+    const finish = (error, value) => { if (settled) return; settled = true; clearTimeout(timer); error ? reject(error) : resolve(value); };
+    child.stdout.setEncoding("utf8").on("data", chunk => stdout += chunk);
+    child.stderr.setEncoding("utf8").on("data", chunk => stderr += chunk);
+    child.on("error", error => finish(error));
+    child.on("close", code => code === 0 ? finish(null, { stdout, stderr, code }) : finish(new AgyError("agy_cli_failed", stderr.trim() || stdout.trim() || `agy exited ${code}`, false, { exit_code: code })));
+    child.stdin.end(options.stdin ?? "");
+  });
+}
+
+export function usageSnapshot(result = {}, toolCalls = {}) {
+  const usage = result.usage && typeof result.usage === "object" ? result.usage : {};
+  const numberOrNull = value => value == null || !Number.isFinite(Number(value)) ? null : Number(value);
+  return {
+    // A missing counter is unknown, not a measured zero.
+    input_tokens: numberOrNull(usage.input_tokens), output_tokens: numberOrNull(usage.output_tokens),
+    reasoning_tokens: numberOrNull(usage.thinking_tokens), cache_read_tokens: numberOrNull(usage.cache_read_tokens),
+    total_tokens: numberOrNull(usage.total_tokens), tool_calls: toolCalls
+  };
+}
+
+export function observedProfile(init = {}, requested = {}) {
+  return { provider: init.provider ?? null, model: init.model ?? null, reasoning: init.reasoning ?? null, mode: init.mode ?? null, permission_mode: init.permission_mode ?? null };
+}
+
+export function assertProfile(requested, observed) { return checkObservedProfile(requested, observed, { required: requested.permission_mode ? ["permission_mode"] : [] }); }
+
+export async function doctor(options = {}) {
+  const bin = options.bin ?? process.env.DD_AGY_BIN ?? "agy", temporary = await mkdtemp(path.join(os.tmpdir(), "dd-agy-doctor-"));
+  try {
+    const version = (await runAgy(bin, ["--version"], { timeoutMs: 10_000 })).stdout.trim();
+    const models = await runAgy(bin, [`--gemini_dir=${temporary}`, "--app_data_dir=runtime", "models"], { timeoutMs: options.timeoutMs ?? 30_000 });
+    const modelIds = models.stdout.split(/\r?\n/).map(line => line.split(/\s+/)[0]).filter(Boolean);
+    if (!modelIds.includes(options.model ?? DEFAULT_MODEL)) throw new AgyError("agy_model_unavailable", `required Antigravity model is unavailable: ${options.model ?? DEFAULT_MODEL}`);
+    return { compatible: true, observed_runtime: { agy: version, dd_harness_contract: "dd-agy-harness@1" }, isolation: { gemini_dir: "verified", app_data_dir: "verified" }, auth: "available", models: modelIds };
+  } finally { await rm(temporary, { recursive: true, force: true }); }
+}

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

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