@platless/axom-cli 0.3.13 → 0.6.36

package/dist/axom-patch/cli/qoder/dist/axom-acp-compat.mjs

@@ -0,0 +1,1591 @@
+// src/entry.ts
+import { homedir } from "node:os";
+
+// src/background/backgroundTerminalFold.ts
+var MAX_TASKS = 512;
+var MAX_RESULT = 128 * 1024;
+var MAX_RESULTS = 4 * 1024 * 1024;
+var CHILD_ROW_LIMIT = 4096;
+var TERMINALS = /* @__PURE__ */ new Set(["completed", "failed", "cancelled"]);
+function object(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function address(value) {
+  return typeof value === "string" && /^[a-zA-Z0-9_-]{1,160}$/.test(value) ? value : void 0;
+}
+function own(record2, key) {
+  return Object.hasOwn(record2, key) ? record2[key] : void 0;
+}
+function put(record2, key, value) {
+  Object.defineProperty(record2, key, { value, enumerable: true, writable: true, configurable: true });
+}
+function utf8Length(text) {
+  let bytes = 0;
+  for (let index = 0; index < text.length; index += 1) {
+    const code = text.charCodeAt(index);
+    if (code < 128) bytes += 1;
+    else if (code < 2048) bytes += 2;
+    else if (code >= 55296 && code <= 56319 && index + 1 < text.length && text.charCodeAt(index + 1) >= 56320 && text.charCodeAt(index + 1) <= 57343) {
+      bytes += 4;
+      index += 1;
+    } else bytes += 3;
+  }
+  return bytes;
+}
+function rootRowFacts(row, context) {
+  if (row.sessionId !== context.nativeSessionId || row.cwd !== context.cwd || row.isSidechain !== false) return [];
+  const content = object(row.message).content;
+  if (!Array.isArray(content)) return [];
+  const facts = [];
+  if (context.restoreCalls && row.type === "assistant") {
+    for (const block of content.map(object)) {
+      const input = object(block.input), id3 = address(block.id);
+      if (block.type === "tool_use" && block.name === "Agent" && id3 && input.run_in_background === true && typeof input.prompt === "string" && (input.subagent_type == null || typeof input.subagent_type === "string")) {
+        facts.push({ kind: "call", toolUseId: id3, input });
+      }
+    }
+    return facts;
+  }
+  if (row.type !== "user") return facts;
+  const output = object(row.toolUseResult);
+  if (output.isAsync === true && output.status === "async_launched") {
+    const results = content.map(object).filter((c) => c.type === "tool_result");
+    const id3 = results.length === 1 ? address(results[0].tool_use_id) : void 0;
+    const agent = address(output.agentId);
+    if (id3) facts.push({ kind: "launch", toolUseId: id3, ...agent ? { agentId: agent } : {} });
+    return facts;
+  }
+  if (row.isMeta !== true || object(row.origin).kind !== "task-notification") return facts;
+  for (const block of content.map(object)) {
+    if (block.type !== "text" || typeof block.text !== "string" || !block.text.startsWith("[SYSTEM NOTIFICATION - NOT USER INPUT]\n")) continue;
+    const match = block.text.match(/<task-notification>\n<task-id>([a-zA-Z0-9_-]{1,160})<\/task-id>\n<tool-use-id>([a-zA-Z0-9_-]{1,160})<\/tool-use-id>\n(?:<output-file>[^\n]*<\/output-file>\n)?<status>(completed|failed|cancelled)<\/status>\n<summary>[^\n]*<\/summary>\n<result>([\s\S]*)<\/result>\n(?:<usage>[^\n]*<\/usage>\n)?<\/task-notification>\s*$/);
+    if (match && utf8Length(match[4]) <= MAX_RESULT) {
+      facts.push({ kind: "terminal", toolUseId: match[2], taskId: match[1], state: match[3], result: match[4] });
+    }
+  }
+  return facts;
+}
+function newTerminalRepairData(options) {
+  return {
+    nativeSessionId: options.nativeSessionId,
+    restoreCalls: options.restoreCalls === true,
+    includeProcess: options.includeProcess === true,
+    calls: {},
+    callCount: 0,
+    launches: [],
+    terminals: [],
+    delivered: {},
+    pendingProcesses: {},
+    resultBytes: 0,
+    childRows: {},
+    polledProcesses: {}
+  };
+}
+var TerminalRepairFold = class {
+  constructor(data) {
+    this.data = data;
+  }
+  data;
+  call(id3) {
+    return own(this.data.calls, id3);
+  }
+  agentOf(id3) {
+    return this.data.launches.find(([toolUseId]) => toolUseId === id3)?.[1];
+  }
+  /** Every ACP event the session routes or emits (live or load history): learns the certified Agent calls. */
+  observe(event) {
+    if (event.acpSessionId && event.acpSessionId !== this.data.nativeSessionId || !["tool_call", "tool_call_update"].includes(event.eventName)) return;
+    const payload = event.payload;
+    const id3 = address(payload.toolCallId);
+    if (!id3) return;
+    let call = this.call(id3);
+    const input = object(payload.rawInput);
+    const meta = object(object(payload._meta).qoder);
+    const backgroundOpening = input.run_in_background === true && typeof input.prompt === "string" && (input.subagent_type == null || typeof input.subagent_type === "string") && payload.kind === "think" && meta.toolName === "Agent";
+    if (!call && backgroundOpening && this.data.callCount < MAX_TASKS) {
+      call = {
+        input,
+        invocationComplete: false,
+        nativeTerminal: false,
+        process: this.data.includeProcess && meta.version === 1 && meta.source === "native-acp-patch"
+      };
+      put(this.data.calls, id3, call);
+      this.data.callCount += 1;
+    }
+    if (!call) return;
+    const update = event.eventName === "tool_call_update";
+    const processInput = update && !Object.hasOwn(payload, "rawInput") ? call.input : input;
+    const processKind = update && !Object.hasOwn(payload, "kind") ? "think" : payload.kind;
+    const processOpening = processInput.run_in_background === true && typeof processInput.prompt === "string" && (processInput.subagent_type == null || typeof processInput.subagent_type === "string") && processKind === "think";
+    if (processOpening && meta.toolName === "Agent" && this.data.includeProcess && meta.version === 1 && meta.source === "native-acp-patch" && !call.nativeTerminal && !Object.hasOwn(this.data.delivered, id3)) call.process = true;
+    if (payload.status === "completed") call.invocationComplete = true;
+    const output = object(payload.rawOutput);
+    if (output.kind === "agent-result" && (TERMINALS.has(String(output.state)) || output.state === "error")) {
+      call.nativeTerminal = true;
+      this.forget(id3, call);
+    }
+  }
+  /** A known call has no result yet: the reader keeps polling the root transcript. */
+  active() {
+    return Object.entries(this.data.calls).some(([id3, call]) => !Object.hasOwn(this.data.delivered, id3) && !call.nativeTerminal);
+  }
+  /** This call's child transcript is still followed. */
+  wantsProcess(toolUseId) {
+    const call = this.call(toolUseId);
+    return call !== void 0 && call.process && !Object.hasOwn(this.data.delivered, toolUseId) && !call.nativeTerminal;
+  }
+  /** Fold one fact; returns the ACP events to emit now (a child row's, or the results a poll's end publishes). */
+  apply(fact) {
+    const data = this.data;
+    switch (fact.kind) {
+      case "call":
+        if (data.restoreCalls && !this.call(fact.toolUseId) && data.callCount < MAX_TASKS) {
+          put(data.calls, fact.toolUseId, { input: fact.input, invocationComplete: false, nativeTerminal: false, process: false });
+          data.callCount += 1;
+        }
+        return [];
+      case "launch": {
+        const call = this.call(fact.toolUseId);
+        if (data.restoreCalls && call) call.invocationComplete = true;
+        if (fact.agentId && data.launches.length < MAX_TASKS && this.agentOf(fact.toolUseId) === void 0) {
+          data.launches.push([fact.toolUseId, fact.agentId]);
+        }
+        return [];
+      }
+      case "terminal": {
+        const bytes = utf8Length(fact.result);
+        if (bytes <= MAX_RESULT && data.resultBytes + bytes <= MAX_RESULTS && data.terminals.length < MAX_TASKS && !data.terminals.some((terminal2) => terminal2.toolUseId === fact.toolUseId)) {
+          data.resultBytes += bytes;
+          data.terminals.push({ toolUseId: fact.toolUseId, taskId: fact.taskId, state: fact.state, result: fact.result });
+        }
+        return [];
+      }
+      case "child": {
+        if (!this.wantsProcess(fact.toolUseId) || this.agentOf(fact.toolUseId) === void 0) return [];
+        let seen = own(data.childRows, fact.toolUseId);
+        if (!seen) put(data.childRows, fact.toolUseId, seen = []);
+        if (seen.includes(fact.uuid) || seen.length >= CHILD_ROW_LIMIT) return [];
+        seen.push(fact.uuid);
+        return [...fact.events];
+      }
+      case "child_status":
+        if (!this.wantsProcess(fact.toolUseId) || this.agentOf(fact.toolUseId) === void 0) return [];
+        if (fact.caughtUp) delete data.pendingProcesses[fact.toolUseId];
+        else put(data.pendingProcesses, fact.toolUseId, true);
+        put(data.polledProcesses, fact.toolUseId, true);
+        return [];
+      case "poll_end":
+        return this.publish();
+    }
+  }
+  publish() {
+    const data = this.data;
+    const events = [];
+    for (const terminal2 of data.terminals) {
+      const id3 = terminal2.toolUseId;
+      const call = this.call(id3), agentId = this.agentOf(id3);
+      if (call?.nativeTerminal) terminal2.result = "";
+      if (Object.hasOwn(data.delivered, id3) || Object.hasOwn(data.pendingProcesses, id3) || !call?.invocationComplete || call.nativeTerminal || !agentId || call.process && !Object.hasOwn(data.polledProcesses, id3)) continue;
+      put(data.delivered, id3, true);
+      events.push({ eventName: "tool_call_update", payload: {
+        name: "Agent",
+        kind: "think",
+        toolCallId: id3,
+        rawInput: call.input,
+        status: "completed",
+        rawOutput: { kind: "agent-result", state: terminal2.state, agentId, result: terminal2.result },
+        content: [{ type: "content", content: { type: "text", text: terminal2.result } }],
+        _meta: { qoder: { toolName: "Agent" }, axomNativeTerminalRepair: {
+          patch: "qoder-background-terminal",
+          nativeSessionId: data.nativeSessionId,
+          taskId: terminal2.taskId,
+          source: "native-task-notification"
+        } }
+      } });
+      terminal2.result = "";
+      this.forget(id3, call);
+    }
+    return events;
+  }
+  /**
+   * A delivered or natively finished call is never published and its child never followed again
+   * (`wantsProcess` is false for good), so what only those two read goes: the input (read by
+   * `publish` alone), the child rows' uuids and status. The call entry itself stays — `observe` must
+   * not register the same id afresh — and so do the launch and result entries, whose presence is what
+   * keeps a restarted reader's repeats from being taken as new.
+   */
+  forget(id3, call) {
+    call.input = {};
+    delete this.data.childRows[id3];
+    delete this.data.pendingProcesses[id3];
+    delete this.data.polledProcesses[id3];
+  }
+};
+
+// src/background/poller.ts
+import { isAbsolute, join as join4, resolve as resolve2 } from "node:path";
+
+// src/history.ts
+import { dirname as dirname2, join as join2 } from "node:path";
+import { TextDecoder as TextDecoder2 } from "node:util";
+
+// src/subwork.ts
+var object2 = (v) => v && typeof v === "object" && !Array.isArray(v) ? v : {};
+var isSubworkId = (v) => typeof v === "string" && v.length > 0 && v.length <= 256 && !/[\x00-\x1f\x7f]/.test(v);
+function newSubworkData() {
+  return { calls: {}, count: 0 };
+}
+function resultText(value) {
+  if (typeof value === "string") return value;
+  if (Array.isArray(value)) {
+    const texts = value.filter((v2) => object2(v2).type === "text").map((v2) => object2(v2).text).filter((v2) => typeof v2 === "string");
+    return texts.length ? texts.join("\n") : void 0;
+  }
+  const v = object2(value);
+  if (v.kind === "agent-result") return resultText(v.content ?? v.result);
+  return void 0;
+}
+var SubworkBoundary = class {
+  constructor(root, data = newSubworkData()) {
+    this.root = root;
+    this.data = data;
+  }
+  root;
+  data;
+  get(toolId) {
+    return Object.hasOwn(this.data.calls, toolId) ? this.data.calls[toolId] : void 0;
+  }
+  child(toolId) {
+    return `qoder-agent:${this.root}:${toolId}`;
+  }
+  map(event) {
+    if (event.acpSessionId && event.acpSessionId !== this.root) return [event];
+    const p = event.payload, q = object2(object2(p._meta).qoder), input = object2(p.rawInput);
+    const marked = q.version === 1 && ["native-acp-patch", "sdk", "correction"].includes(String(q.source));
+    const toolId = p.toolCallId;
+    let call = isSubworkId(toolId) ? this.get(toolId) : void 0;
+    const parent = marked && q.route !== "unknown" && isSubworkId(q.parentToolUseId) ? q.parentToolUseId : void 0;
+    const events = [];
+    if (!call && marked && p.kind === "think" && q.toolName === "Agent" && isSubworkId(toolId) && typeof input.prompt === "string" && (input.subagent_type == null || typeof input.subagent_type === "string") && (input.run_in_background === void 0 || typeof input.run_in_background === "boolean") && ["tool_call", "tool_call_update"].includes(event.eventName) && this.data.count < 4096) {
+      call = {
+        child: this.child(toolId),
+        ...parent ? { parent: this.child(parent) } : {},
+        background: input.run_in_background === true,
+        ended: false,
+        streamedText: ""
+      };
+      Object.defineProperty(this.data.calls, toolId, { value: call, enumerable: true, writable: true, configurable: true });
+      this.data.count += 1;
+      events.push({ eventName: "subagent_spawned", payload: {
+        subagentSessionId: call.child,
+        name: typeof input.description === "string" && input.description.trim() ? input.description : input.subagent_type ?? "Agent",
+        task: input.prompt,
+        capabilities: {}
+      }, ...call.parent ? { acpSessionId: call.parent } : {} });
+      events.push({ eventName: "user_message_chunk", payload: { content: { type: "text", text: input.prompt } }, acpSessionId: call.child });
+    }
+    if (call && ["tool_call", "tool_call_update"].includes(event.eventName)) {
+      if (call.ended) return events;
+      const output = object2(p.rawOutput);
+      const state = output.kind === "agent-result" ? output.state : void 0;
+      const terminal2 = state === "completed" ? "completed" : ["error", "failed"].includes(String(state)) ? "failed" : state === "cancelled" ? "cancelled" : ["failed", "cancelled"].includes(String(p.status)) ? p.status : !call.background && p.status === "completed" ? "completed" : void 0;
+      if (terminal2) {
+        const text = resultText(p.rawOutput);
+        if (text !== void 0 && !call.streamedText.endsWith(text)) events.push({
+          eventName: "agent_message_chunk",
+          payload: { content: { type: "text", text } },
+          acpSessionId: call.child
+        });
+        events.push({
+          eventName: "subagent_state_update",
+          payload: { subagentSessionId: call.child, state: terminal2 },
+          ...call.parent ? { acpSessionId: call.parent } : {}
+        });
+        call.ended = true;
+        call.streamedText = "";
+      }
+      return events;
+    }
+    if (parent) {
+      const owner = this.get(parent), content = object2(p.content);
+      if (owner && !owner.ended && event.eventName === "agent_message_chunk" && content.type === "text" && typeof content.text === "string") {
+        owner.streamedText += content.text;
+      }
+      return [{ ...event, acpSessionId: this.child(parent) }];
+    }
+    return [event];
+  }
+};
+
+// src/foregroundOutput.ts
+function record(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function newForegroundOutputData() {
+  return { pending: {} };
+}
+var ForegroundOutputBoundary = class {
+  constructor(nativeSessionId, data = newForegroundOutputData()) {
+    this.nativeSessionId = nativeSessionId;
+    this.data = data;
+  }
+  nativeSessionId;
+  data;
+  accept(event) {
+    if (event.acpSessionId && event.acpSessionId !== this.nativeSessionId) return true;
+    const p = event.payload, input = record(p.rawInput), pending = this.data.pending;
+    if (event.eventName === "tool_call" && p.kind === "think" && record(record(p._meta).qoder).toolName === "Agent" && typeof p.toolCallId === "string" && typeof input.prompt === "string" && (input.run_in_background === void 0 || input.run_in_background === false)) {
+      Object.defineProperty(pending, p.toolCallId, { value: true, enumerable: true, writable: true, configurable: true });
+    }
+    if (event.eventName === "tool_call_update" && typeof p.toolCallId === "string" && ["completed", "failed", "cancelled"].includes(String(p.status)) && Object.hasOwn(pending, p.toolCallId)) delete pending[p.toolCallId];
+    return Object.keys(pending).length === 0 || !["agent_message_chunk", "agent_thought_chunk"].includes(event.eventName) || typeof p.messageId === "string" || p._meta != null;
+  }
+  endTurn() {
+    for (const id3 of Object.keys(this.data.pending)) delete this.data.pending[id3];
+  }
+};
+
+// src/checkpoint.ts
+import { constants } from "node:fs";
+import { link, lstat, mkdir, open, readFile, readdir, realpath, rename, unlink } from "node:fs/promises";
+import { createHash, randomUUID } from "node:crypto";
+import { dirname, join, parse, resolve, sep } from "node:path";
+var MAX_CHECKPOINT = 16 * 1024 * 1024;
+var id = (s) => typeof s === "string" && s.length > 0 && s.length <= 256 && !/[\x00-\x1f\x7f]/.test(s);
+var childId = (s) => typeof s === "string" && s.length > 0 && s.length <= 512 && !/[\x00-\x1f\x7f]/.test(s);
+var obj = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+function insist(ok, message) {
+  if (!ok)
+    throw new Error(`Qoder recovery ${message}`);
+}
+function newRecoveryData(root, cwd, releaseId) {
+  return { schema: 1, root, cwd, releaseId, foreground: newForegroundOutputData(), subwork: newSubworkData(), background: newTerminalRepairData({ nativeSessionId: root, restoreCalls: true, includeProcess: true }) };
+}
+function validateRecoveryData(value, identity) {
+  insist(obj(value) && value.schema === 1, "schema invalid");
+  insist(value.root === identity.root && value.cwd === identity.cwd && value.releaseId === identity.releaseId, "identity/release mismatch");
+  const dict = (v, n, label, validate) => {
+    insist(obj(v), `${label} shape`);
+    const entries = Object.entries(v);
+    insist(entries.length <= n, `${label} bound`);
+    for (const [k, x] of entries)
+      insist(id(k) && validate(x, k), `${label} entry`);
+    return entries.length;
+  };
+  const flags = (v, n, label) => dict(v, n, label, (x) => x === true);
+  insist(obj(value.foreground), "foreground shape");
+  flags(value.foreground.pending, 4096, "foreground");
+  const s = value.subwork;
+  insist(obj(s), "subwork shape");
+  const count = dict(s.calls, 4096, "subwork", (x, k) => obj(x) && x.child === `qoder-agent:${identity.root}:${k}` && childId(x.child) && (x.parent === void 0 || childId(x.parent) && x.parent.startsWith(`qoder-agent:${identity.root}:`)) && typeof x.background === "boolean" && typeof x.ended === "boolean" && typeof x.streamedText === "string" && Buffer.byteLength(x.streamedText) <= MAX_CHECKPOINT);
+  insist(s.count === count, "subwork count bound");
+  const b = value.background;
+  insist(obj(b) && b.nativeSessionId === identity.root && typeof b.restoreCalls === "boolean" && typeof b.includeProcess === "boolean", "background identity/shape");
+  const calls = dict(b.calls, MAX_TASKS, "background calls", (x, k) => !!address(k) && obj(x) && obj(x.input) && typeof x.invocationComplete === "boolean" && typeof x.nativeTerminal === "boolean" && typeof x.process === "boolean");
+  insist(b.callCount === calls, "background callCount bound");
+  insist(Array.isArray(b.launches) && b.launches.length <= MAX_TASKS && b.launches.every((x) => Array.isArray(x) && x.length === 2 && address(x[0]) && address(x[1])) && new Set(b.launches.map((x) => x[0])).size === b.launches.length, "background launches");
+  insist(Array.isArray(b.terminals) && b.terminals.length <= MAX_TASKS, "background terminals");
+  let bytes = 0;
+  const seen = /* @__PURE__ */ new Set();
+  for (const t of b.terminals) {
+    insist(obj(t) && address(t.toolUseId) && address(t.taskId) && ["completed", "failed", "cancelled"].includes(t.state) && typeof t.result === "string" && Buffer.byteLength(t.result) <= MAX_RESULT && !seen.has(t.toolUseId), "background terminal");
+    seen.add(t.toolUseId);
+    bytes += Buffer.byteLength(t.result);
+  }
+  insist(Number.isSafeInteger(b.resultBytes) && b.resultBytes >= bytes && b.resultBytes <= MAX_RESULTS, "background resultBytes bound");
+  for (const key of ["delivered", "pendingProcesses", "polledProcesses"])
+    flags(b[key], MAX_TASKS, `background ${key}`);
+  dict(b.childRows, MAX_TASKS, "background childRows", (x, k) => !!address(k) && Array.isArray(x) && x.length <= CHILD_ROW_LIMIT && x.every(address) && new Set(x).size === x.length);
+}
+function missing(error) {
+  return error.code === "ENOENT";
+}
+async function verifiedDirectory(path, create = false) {
+  const absolute = resolve(path), root = parse(absolute).root;
+  let current = root;
+  for (const part of absolute.slice(root.length).split(sep).filter(Boolean)) {
+    current = join(current, part);
+    let stat;
+    try {
+      stat = await lstat(current);
+    } catch (error) {
+      if (!create || !missing(error))
+        throw error;
+      try {
+        await mkdir(current, { mode: 448 });
+      } catch (e) {
+        if (e.code !== "EEXIST")
+          throw e;
+      }
+      stat = await lstat(current);
+    }
+    insist(!stat.isSymbolicLink() && stat.isDirectory(), "symlink or non-directory component");
+  }
+  insist(await realpath(absolute) === absolute, "directory realpath changed");
+}
+async function assertRegularOrMissing(path) {
+  try {
+    const s = await lstat(path);
+    insist(!s.isSymbolicLink() && s.isFile(), "symlink/nonregular file");
+  } catch (e) {
+    if (!missing(e))
+      throw e;
+  }
+}
+async function scanFileSnapshot(path, max, consume) {
+  await verifiedDirectory(dirname(path));
+  await assertRegularOrMissing(path);
+  const file = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+  try {
+    const before = await file.stat();
+    insist(before.isFile() && before.size <= max, `file size exceeds ${max === MAX_CHECKPOINT ? "16 MiB" : max}`);
+    let offset = 0;
+    while (offset < before.size) {
+      const chunk = Buffer.alloc(Math.min(64 * 1024, before.size - offset));
+      const { bytesRead } = await file.read(chunk, 0, chunk.length, offset);
+      insist(bytesRead > 0, "file changed while reading");
+      offset += bytesRead;
+      consume(chunk.subarray(0, bytesRead));
+    }
+    const after = await file.stat(), named = await lstat(path);
+    insist(before.dev === after.dev && before.ino === after.ino && after.size >= before.size && named.dev === before.dev && named.ino === before.ino && !named.isSymbolicLink() && (after.size > before.size || after.mtimeMs === before.mtimeMs), "file replaced while reading");
+    await verifiedDirectory(dirname(path));
+    return { capturedBytes: before.size, fileIdentity: `${before.dev}:${before.ino}` };
+  } finally {
+    await file.close();
+  }
+}
+async function readFileSnapshot(path, max) {
+  const chunks = [];
+  const snapshot = await scanFileSnapshot(path, max, (chunk) => chunks.push(chunk));
+  return { bytes: Buffer.concat(chunks, snapshot.capturedBytes), fileIdentity: snapshot.fileIdentity };
+}
+async function readBoundedFile(path, max) {
+  return (await readFileSnapshot(path, max)).bytes;
+}
+async function openRecoveryStore(options) {
+  insist(/^[a-zA-Z0-9_-]{1,160}$/.test(options.root) && id(options.releaseId) && typeof options.cwd === "string" && options.cwd.length > 0, "identity invalid");
+  const directory = join(options.home, ".qoder", "axom-acp-state", createHash("sha256").update(options.cwd).digest("hex"));
+  await verifiedDirectory(directory, true);
+  const path = join(directory, options.root + ".json"), lock = path + ".lock";
+  const token = randomUUID();
+  let closed = false;
+  const processStat = process.platform === "linux" ? await readFile(`/proc/${process.pid}/stat`, "utf8") : void 0;
+  const processStart = processStat ? processStat.slice(processStat.lastIndexOf(")") + 2).split(" ")[19] : String(Math.round(Date.now() - process.uptime() * 1e3));
+  const withGuard = async (action) => {
+    const guard = lock + ".reclaim", claim = `${process.pid}-${randomUUID()}`;
+    await verifiedDirectory(guard, true);
+    const mine = join(guard, claim);
+    const f = await open(mine, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 384);
+    try {
+      await f.writeFile(JSON.stringify({ pid: process.pid, processStart, token: claim }));
+      await f.sync();
+      await f.close();
+      for (const name of await readdir(guard)) {
+        if (name === claim) continue;
+        const match = name.match(/^([1-9][0-9]*)-[a-f0-9-]{36}$/);
+        insist(match, "owner guard malformed");
+        const pid = Number(match[1]);
+        let dead = false;
+        try {
+          process.kill(pid, 0);
+        } catch (e) {
+          dead = e.code === "ESRCH";
+        }
+        insist(dead, "owner acquisition locked");
+        await unlink(join(guard, name)).catch((e) => {
+          if (!missing(e)) throw e;
+        });
+      }
+      return await action();
+    } finally {
+      await f.close().catch(() => {
+      });
+      await unlink(mine).catch((error) => {
+        if (!missing(error)) throw error;
+      });
+    }
+  };
+  await withGuard(async () => {
+    const candidate = lock + "." + token + ".candidate";
+    const f = await open(candidate, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 384);
+    try {
+      await f.writeFile(JSON.stringify({ pid: process.pid, token, processStart, started: Date.now() }));
+      await f.sync();
+      await f.close();
+      for (let attempt = 0; ; attempt++) {
+        try {
+          await link(candidate, lock);
+          break;
+        } catch (error) {
+          if (error.code !== "EEXIST")
+            throw error;
+          insist(attempt === 0, "owner locked");
+          const before = await lstat(lock);
+          const raw = await readBoundedFile(lock, 4096);
+          let owner;
+          try {
+            owner = JSON.parse(raw.toString());
+          } catch {
+            throw new Error("Qoder recovery owner lock malformed");
+          }
+          insist(Number.isSafeInteger(owner.pid) && owner.pid > 0 && typeof owner.token === "string", "owner lock invalid");
+          const dead = () => {
+            try {
+              process.kill(owner.pid, 0);
+              return false;
+            } catch (e) {
+              return e.code === "ESRCH";
+            }
+          };
+          insist(dead(), "owner locked");
+          const now = await lstat(lock);
+          const content = await readBoundedFile(lock, 4096);
+          insist(now.ino === before.ino && now.dev === before.dev && content.equals(raw) && dead(), "owner changed or live");
+          await unlink(lock);
+        }
+      }
+    } finally {
+      await f.close().catch(() => {
+      });
+      await unlink(candidate).catch((error) => {
+        if (!missing(error)) throw error;
+      });
+    }
+  });
+  const owned = async () => {
+    insist(!closed, "store closed");
+    const owner = JSON.parse((await readBoundedFile(lock, 4096)).toString());
+    insist(owner.token === token && owner.pid === process.pid, "owner changed");
+  };
+  return {
+    async load() {
+      await owned();
+      let bytes;
+      try {
+        bytes = await readBoundedFile(path, MAX_CHECKPOINT);
+      } catch (error) {
+        if (missing(error)) return void 0;
+        throw error;
+      }
+      let value;
+      try {
+        value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+      } catch {
+        throw new Error("Qoder recovery malformed checkpoint");
+      }
+      validateRecoveryData(value, options);
+      return value;
+    },
+    async save(data) {
+      await owned();
+      validateRecoveryData(data, options);
+      const bytes = Buffer.from(JSON.stringify(data));
+      insist(bytes.length <= MAX_CHECKPOINT, "checkpoint exceeds 16 MiB");
+      await verifiedDirectory(directory);
+      await assertRegularOrMissing(path);
+      const temporary = path + "." + randomUUID() + ".pending";
+      const f = await open(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 384);
+      try {
+        await f.writeFile(bytes);
+        await f.sync();
+        await f.close();
+        await owned();
+        await verifiedDirectory(directory);
+        await assertRegularOrMissing(path);
+        await rename(temporary, path);
+      } finally {
+        await f.close().catch(() => {
+        });
+        await unlink(temporary).catch((error) => {
+          if (!missing(error)) throw error;
+        });
+      }
+    },
+    async close() {
+      if (closed) return;
+      await withGuard(async () => {
+        await owned();
+        await unlink(lock);
+        closed = true;
+      });
+    }
+  };
+}
+
+// src/history.ts
+var MAX_HISTORY = 64 * 1024 * 1024;
+var MAX_LINE = 1024 * 1024;
+var MAX_UUIDS = 1e5;
+function refuse(ok, why) {
+  if (!ok) throw new Error(`Qoder history ${why}`);
+}
+async function readHistorySnapshot(path) {
+  const rows = [];
+  let pending = Buffer.alloc(0), completeBytes = 0;
+  const decoder = new TextDecoder2("utf-8", { fatal: true });
+  const snapshot = await scanFileSnapshot(path, MAX_HISTORY, (chunk) => {
+    const bytes = Buffer.concat([pending, chunk]);
+    let start = 0;
+    for (let end = bytes.indexOf(10); end >= 0; end = bytes.indexOf(10, start)) {
+      refuse(end - start <= MAX_LINE, "complete line exceeds 1 MiB");
+      let row;
+      try {
+        row = JSON.parse(decoder.decode(bytes.subarray(start, end)));
+      } catch {
+        throw new Error("Qoder history malformed complete line");
+      }
+      refuse(row && typeof row === "object" && !Array.isArray(row), "malformed row");
+      rows.push(row);
+      completeBytes += end - start + 1;
+      start = end + 1;
+    }
+    pending = Buffer.from(bytes.subarray(start));
+    refuse(pending.length <= MAX_LINE, "partial line exceeds 1 MiB");
+  });
+  return { ...snapshot, rows, completeBytes };
+}
+function metadata(row, root) {
+  const type = row.type;
+  if (!["active-leaf", "workspace-directories", "worktree-state", "last-prompt"].includes(String(type))) return false;
+  refuse(row.sessionId === root, "metadata identity mismatch");
+  if (type === "active-leaf") refuse((row.leafUuid === null || address(row.leafUuid)) && typeof row.explicit === "boolean" && Number.isSafeInteger(row.timestamp), "metadata active-leaf malformed");
+  if (type === "workspace-directories") refuse(Array.isArray(row.directories) && row.directories.length <= 4096 && row.directories.every((x) => typeof x === "string"), "metadata directories malformed");
+  if (type === "worktree-state") refuse(row.worktreeSession === null || !!row.worktreeSession && typeof row.worktreeSession === "object" && !Array.isArray(row.worktreeSession), "metadata worktree malformed");
+  if (type === "last-prompt") refuse(typeof row.lastPrompt === "string", "metadata last-prompt malformed");
+  return true;
+}
+function validateHistoryRow(row, context) {
+  const { root, cwd, historyVersions, child } = context;
+  if (metadata(row, root)) return false;
+  refuse(row.sessionId === root && row.cwd === cwd && row.isSidechain === (child !== void 0) && (!child || row.agentId === child.agentId && row.parent_tool_use_id === child.toolUseId), "identity mismatch");
+  refuse(typeof row.version === "string" && historyVersions.includes(row.version), "version incompatible");
+  refuse(address(row.uuid), "UUID identity invalid");
+  if (row.isMeta === true && object(row.origin).kind === "task-notification") {
+    const content = object(row.message).content;
+    if (Array.isArray(content)) for (const block of content.map(object)) {
+      if (typeof block.text !== "string") continue;
+      const result = block.text.match(/<result>([\s\S]*)<\/result>/);
+      if (result) refuse(Buffer.byteLength(result[1]) <= MAX_RESULT, "background result exceeds 128 KiB");
+    }
+  }
+  return true;
+}
+var own2 = (record2, key) => Object.hasOwn(record2, key);
+function admitRecoveryEvent(data, event) {
+  if (event.acpSessionId && event.acpSessionId !== data.root || !["tool_call", "tool_call_update"].includes(event.eventName)) return;
+  const payload = event.payload, input = object(payload.rawInput), toolId = payload.toolCallId;
+  const qoder = object(object(payload._meta).qoder);
+  if (payload.kind !== "think" || qoder.toolName !== "Agent" || typeof input.prompt !== "string") return;
+  const optionalTypeValid = input.subagent_type == null || typeof input.subagent_type === "string";
+  const marked = qoder.version === 1 && ["native-acp-patch", "sdk", "correction"].includes(String(qoder.source));
+  if (isSubworkId(toolId) && marked && optionalTypeValid && (input.run_in_background === void 0 || typeof input.run_in_background === "boolean") && !own2(data.subwork.calls, toolId)) {
+    refuse(data.subwork.count < 4096, "subwork call bound");
+  }
+  const backgroundId = address(toolId);
+  if (backgroundId && optionalTypeValid && input.run_in_background === true && !own2(data.background.calls, backgroundId)) {
+    refuse(data.background.callCount < MAX_TASKS, "background call bound");
+  }
+  if (event.eventName === "tool_call" && typeof toolId === "string" && (input.run_in_background === void 0 || input.run_in_background === false) && !own2(data.foreground.pending, toolId)) {
+    refuse(Object.keys(data.foreground.pending).length < 4096, "foreground call bound");
+  }
+}
+function admitRecoveryFact(data, fold, fact) {
+  const background = data.background;
+  if (fact.kind === "call" && !own2(background.calls, fact.toolUseId)) refuse(background.callCount < MAX_TASKS, "background call bound");
+  if (fact.kind === "launch" && fact.agentId && !background.launches.some(([id3]) => id3 === fact.toolUseId)) refuse(background.launches.length < MAX_TASKS, "background launch bound");
+  if (fact.kind === "terminal" && !background.terminals.some((t) => t.toolUseId === fact.toolUseId)) {
+    refuse(background.terminals.length < MAX_TASKS && Buffer.byteLength(fact.result) <= MAX_RESULT && background.resultBytes + Buffer.byteLength(fact.result) <= MAX_RESULTS, "background result bound");
+  }
+  if (fact.kind === "child" && fold.wantsProcess(fact.toolUseId)) {
+    const seen = own2(background.childRows, fact.toolUseId) ? background.childRows[fact.toolUseId] : void 0;
+    if (!seen?.includes(fact.uuid)) refuse((seen?.length ?? 0) < CHILD_ROW_LIMIT, "background child UUID bound");
+  }
+}
+async function bootstrapHistory(options) {
+  const { home, cwd, root, historyVersions, data } = options;
+  validateRecoveryData(data, { root, cwd, releaseId: data.releaseId });
+  refuse(historyVersions.length > 0, "version allowlist missing");
+  const path = historyPath(home, cwd, root);
+  refuse(path, "identity path invalid");
+  const rootSnapshot = await readHistorySnapshot(path);
+  const rootRows = rootSnapshot.rows.filter((row) => !metadata(row, root)), rootAssistantUuids = /* @__PURE__ */ new Set();
+  const rootSeen = /* @__PURE__ */ new Set();
+  const check = (row, child) => validateHistoryRow(row, { root, cwd, historyVersions, child });
+  const launches = /* @__PURE__ */ new Map(), agentCalls = /* @__PURE__ */ new Set(), backgroundCalls = /* @__PURE__ */ new Set(), terminalIds = /* @__PURE__ */ new Set();
+  let resultBytes = 0;
+  for (const row of rootRows) {
+    check(row);
+    if (!rootSeen.has(row.uuid)) {
+      refuse(rootSeen.size < MAX_UUIDS, "UUID count exceeds 100000");
+      rootSeen.add(row.uuid);
+    }
+    if (row.type === "assistant")
+      rootAssistantUuids.add(row.uuid);
+    const content = object(row.message).content;
+    if (Array.isArray(content))
+      for (const block of content.map(object)) {
+        if (row.type === "assistant" && block.type === "tool_use" && block.name === "Agent" && address(block.id)) {
+          agentCalls.add(block.id);
+          refuse(agentCalls.size <= 4096, "subwork call bound");
+          if (object(block.input).run_in_background === true) {
+            backgroundCalls.add(block.id);
+            refuse(backgroundCalls.size <= MAX_TASKS, "background call bound");
+          }
+        }
+        if (row.isMeta === true && object(row.origin).kind === "task-notification" && typeof block.text === "string") {
+          const match = block.text.match(/<result>([\s\S]*)<\/result>/);
+          if (match)
+            refuse(Buffer.byteLength(match[1]) <= MAX_RESULT, "background result exceeds 128 KiB");
+        }
+      }
+    const facts = rootRowFacts(row, { nativeSessionId: root, cwd, restoreCalls: true });
+    for (const fact of facts) {
+      if (fact.kind === "terminal" && !terminalIds.has(fact.toolUseId)) {
+        terminalIds.add(fact.toolUseId);
+        resultBytes += Buffer.byteLength(fact.result);
+        refuse(terminalIds.size <= MAX_TASKS && resultBytes <= MAX_RESULTS, "background result bound");
+      }
+    }
+    for (const fact of facts)
+      if (fact.kind === "launch" && fact.agentId) {
+        refuse(launches.has(fact.toolUseId) || launches.size < MAX_TASKS, "background task bound");
+        launches.set(fact.toolUseId, fact.agentId);
+      }
+  }
+  const childSnapshots = [];
+  const children = [];
+  let total = rootSnapshot.capturedBytes;
+  for (const [toolUseId, agentId] of launches) {
+    const childPath = join2(dirname2(path), root, "subagents", `agent-${agentId}.jsonl`);
+    let snapshot;
+    try {
+      snapshot = await readHistorySnapshot(childPath);
+    } catch (error) {
+      if (error.code === "ENOENT")
+        continue;
+      throw error;
+    }
+    childSnapshots.push({ toolUseId, agentId, path: childPath, snapshotBytes: snapshot.completeBytes, fileIdentity: snapshot.fileIdentity });
+    total += snapshot.capturedBytes;
+    refuse(total <= MAX_HISTORY, "indexed history exceeds 64 MiB");
+    const childRows = snapshot.rows.filter((row) => !metadata(row, root)), seen = /* @__PURE__ */ new Set();
+    for (const row of childRows) {
+      check(row, { toolUseId, agentId });
+      seen.add(row.uuid);
+      refuse(seen.size <= CHILD_ROW_LIMIT, "child UUID count exceeds 4096");
+    }
+    children.push({ toolUseId, agentId, rows: childRows });
+  }
+  const restored = structuredClone(data);
+  restored.background = { ...restored.background, restoreCalls: true, includeProcess: true };
+  const fold = new TerminalRepairFold(restored.background), subwork = new SubworkBoundary(root, restored.subwork), foreground = new ForegroundOutputBoundary(root, restored.foreground);
+  const consume = (event) => {
+    admitRecoveryEvent(restored, event);
+    foreground.accept(event);
+    fold.observe(event);
+    subwork.map(event);
+  };
+  const apply = (fact) => {
+    admitRecoveryFact(restored, fold, fact);
+    return fold.apply(fact);
+  };
+  const toolNames = /* @__PURE__ */ new Map();
+  const consumeRow = (row, parentToolUseId) => {
+    const content = object(row.message).content;
+    if (!Array.isArray(content))
+      return;
+    for (const block of content.map(object)) {
+      const name = typeof block.name === "string" ? block.name : void 0;
+      const toolId = address(block.id);
+      const meta = (toolName) => ({ qoder: { version: 1, source: parentToolUseId ? "correction" : "native-acp-patch", ...parentToolUseId ? { parentToolUseId, route: "child" } : {}, ...toolName ? { toolName } : {} } });
+      if (row.type === "assistant" && block.type === "tool_use" && toolId && name) {
+        toolNames.set(toolId, name);
+        consume({ eventName: "tool_call", payload: { toolCallId: toolId, kind: name === "Agent" ? "think" : "other", rawInput: object(block.input), status: "pending", _meta: meta(name) } });
+      } else if (row.type === "user" && block.type === "tool_result" && address(block.tool_use_id)) {
+        const toolUseId = block.tool_use_id;
+        consume({ eventName: "tool_call_update", payload: { toolCallId: toolUseId, status: block.is_error === true ? "failed" : "completed", rawOutput: row.toolUseResult ?? block.content, _meta: meta(toolNames.get(toolUseId)) } });
+      } else if (parentToolUseId && row.type === "assistant" && block.type === "text" && typeof block.text === "string") {
+        consume({ eventName: "agent_message_chunk", payload: { content: { type: "text", text: block.text }, _meta: meta() } });
+      }
+    }
+  };
+  const foldedRoot = /* @__PURE__ */ new Set();
+  for (const row of rootRows) {
+    if (foldedRoot.has(row.uuid))
+      continue;
+    foldedRoot.add(row.uuid);
+    consumeRow(row);
+    for (const fact of rootRowFacts(row, { nativeSessionId: root, cwd, restoreCalls: true }))
+      apply(fact);
+  }
+  for (const child of children) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const row of child.rows) {
+      const uuid = row.uuid;
+      if (seen.has(uuid))
+        continue;
+      seen.add(uuid);
+      if (fold.wantsProcess(child.toolUseId)) {
+        if (!Object.hasOwn(restored.background.childRows, child.toolUseId) || !restored.background.childRows[child.toolUseId].includes(uuid)) consumeRow(row, child.toolUseId);
+        apply({ kind: "child", toolUseId: child.toolUseId, uuid, events: [] });
+      }
+    }
+    apply({ kind: "child_status", toolUseId: child.toolUseId, caughtUp: true });
+  }
+  for (const [toolUseId] of launches)
+    apply({ kind: "child_status", toolUseId, caughtUp: true });
+  for (const event of apply({ kind: "poll_end" }))
+    consume(event);
+  validateRecoveryData(restored, { root, cwd, releaseId: data.releaseId });
+  Object.assign(data, restored);
+  return { rootAssistantUuids, snapshotBytes: rootSnapshot.completeBytes, rootIdentity: rootSnapshot.fileIdentity, childSnapshots };
+}
+
+// src/background/backgroundTerminal.ts
+import { dirname as dirname4, join as join3 } from "node:path";
+
+// src/background/transcript.ts
+import { constants as constants2 } from "node:fs";
+import { lstat as lstat2, open as open2 } from "node:fs/promises";
+import { dirname as dirname3 } from "node:path";
+import { TextDecoder as TextDecoder3 } from "node:util";
+var Transcript = class {
+  constructor(path, snapshot, onSize) {
+    this.path = path;
+    this.snapshot = snapshot;
+    this.onSize = onSize;
+    if (snapshot) this.identity = snapshot.fileIdentity;
+  }
+  path;
+  snapshot;
+  onSize;
+  offset = 0;
+  identity = "";
+  tail = Buffer.alloc(0);
+  decoder = new TextDecoder3("utf-8", { fatal: true });
+  /** Preflight all followed files' sizes before any poll derives new evidence. */
+  async measure() {
+    await verifiedDirectory(dirname3(this.path));
+    await assertRegularOrMissing(this.path);
+    const stat = await lstat2(this.path), identity = `${stat.dev}:${stat.ino}`;
+    if (!stat.isFile() || this.identity && this.identity !== identity || stat.size < this.offset || this.snapshot && stat.size < this.snapshot.snapshotBytes) throw new Error("Qoder history file replaced or truncated");
+    if (stat.size > MAX_HISTORY) throw new Error("Qoder history exceeds 64 MiB");
+    this.onSize?.(stat.size);
+    this.identity = identity;
+  }
+  /** Replay only the fixed captured prefix, silently, before following later appends. */
+  async bootstrap(consume) {
+    if (this.snapshot && this.offset < this.snapshot.snapshotBytes) {
+      await this.read(consume, this.snapshot.snapshotBytes - this.offset, this.snapshot.snapshotBytes);
+      if (this.offset !== this.snapshot.snapshotBytes || this.tail.length) throw new Error("Qoder history snapshot incomplete");
+    }
+  }
+  async read(consume, budget = 4 * 1024 * 1024, boundary) {
+    await verifiedDirectory(dirname3(this.path));
+    await assertRegularOrMissing(this.path);
+    const file = await open2(this.path, constants2.O_RDONLY | constants2.O_NOFOLLOW);
+    try {
+      const before = await file.stat(), identity = `${before.dev}:${before.ino}`;
+      if (!before.isFile() || this.identity && identity !== this.identity || before.size < this.offset || this.snapshot && before.size < this.snapshot.snapshotBytes) throw new Error("Qoder history file replaced or truncated");
+      if (before.size > MAX_HISTORY) throw new Error("Qoder history exceeds 64 MiB");
+      this.onSize?.(before.size);
+      this.identity = identity;
+      const end = Math.min(before.size, this.offset + budget, boundary ?? Infinity);
+      while (this.offset < end) {
+        const chunk = Buffer.alloc(Math.min(64 * 1024, end - this.offset));
+        const { bytesRead } = await file.read(chunk, 0, chunk.length, this.offset);
+        if (!bytesRead) throw new Error("Qoder history changed while reading");
+        this.offset += bytesRead;
+        this.lines(chunk.subarray(0, bytesRead), consume);
+      }
+      const after = await file.stat(), named = await lstat2(this.path);
+      if (after.size < before.size || named.dev !== before.dev || named.ino !== before.ino || named.isSymbolicLink() || after.size === before.size && after.mtimeMs !== before.mtimeMs) throw new Error("Qoder history file replaced while reading");
+      await verifiedDirectory(dirname3(this.path));
+      return this.offset >= before.size && this.tail.length === 0;
+    } finally {
+      await file.close();
+    }
+  }
+  get established() {
+    return this.identity !== "";
+  }
+  lines(chunk, consume) {
+    const bytes = Buffer.concat([this.tail, chunk]);
+    let start = 0;
+    for (let end = bytes.indexOf(10); end >= 0; end = bytes.indexOf(10, start)) {
+      if (end - start > MAX_LINE) throw new Error("Qoder history complete line exceeds 1 MiB");
+      let row;
+      try {
+        row = JSON.parse(this.decoder.decode(bytes.subarray(start, end)));
+      } catch {
+        throw new Error("Qoder history malformed complete line");
+      }
+      if (!row || typeof row !== "object" || Array.isArray(row)) throw new Error("Qoder history malformed row");
+      consume(row);
+      start = end + 1;
+    }
+    this.tail = Buffer.from(bytes.subarray(start));
+    if (this.tail.length > MAX_LINE) throw new Error("Qoder history partial line exceeds 1 MiB");
+  }
+};
+
+// src/background/backgroundProcess.ts
+var object3 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
+var id2 = (value) => typeof value === "string" && /^[a-zA-Z0-9_-]{1,160}$/.test(value);
+var BackgroundProcess = class {
+  constructor(options) {
+    this.options = options;
+    this.transcript = new Transcript(options.path, options.snapshot, options.onSize);
+  }
+  options;
+  seen = /* @__PURE__ */ new Set();
+  tools = /* @__PURE__ */ new Map();
+  transcript;
+  bootstrapped = false;
+  measure() {
+    return this.transcript.measure();
+  }
+  get established() {
+    return this.transcript.established;
+  }
+  async poll(onRow = this.options.onRow) {
+    if (!this.bootstrapped) {
+      await this.transcript.bootstrap((row) => this.consume(row, () => {
+      }));
+      this.bootstrapped = true;
+    }
+    return this.transcript.read((row) => this.consume(row, onRow));
+  }
+  consume(row, onRow = this.options.onRow) {
+    const o = this.options;
+    if (!validateHistoryRow(row, {
+      root: o.sessionId,
+      cwd: o.cwd,
+      historyVersions: o.historyVersions,
+      child: { agentId: o.agentId, toolUseId: o.parentToolUseId }
+    })) return;
+    if (this.seen.has(row.uuid)) return;
+    if (this.seen.size >= 4096) throw new Error("Qoder history child UUID count exceeds 4096");
+    this.seen.add(row.uuid);
+    const content = object3(row.message).content;
+    if (!Array.isArray(content)) return;
+    const events = [];
+    for (const block of content.map(object3)) {
+      if (row.type === "assistant" && block.type === "tool_use" && id2(block.id) && typeof block.name === "string") {
+        if (this.tools.has(block.id)) continue;
+        if (this.tools.size >= 4096) throw new Error("Qoder history child tool count exceeds 4096");
+        const input = object3(block.input);
+        this.tools.set(block.id, { name: block.name, input });
+        this.derive(events, "tool_call", {
+          toolCallId: block.id,
+          name: block.name,
+          title: block.name,
+          kind: block.name === "Read" ? "read" : block.name === "Bash" ? "execute" : block.name === "Agent" ? "think" : "other",
+          rawInput: input,
+          status: "pending"
+        }, block.name);
+      } else if (row.type === "user" && block.type === "tool_result" && id2(block.tool_use_id)) {
+        const tool = this.tools.get(block.tool_use_id);
+        if (!tool) continue;
+        const raw = row.toolUseResult ?? block.content;
+        const text = typeof block.content === "string" ? block.content : JSON.stringify(block.content ?? "");
+        this.derive(events, "tool_call_update", {
+          toolCallId: block.tool_use_id,
+          name: tool.name,
+          status: block.is_error === true ? "failed" : "completed",
+          rawOutput: raw,
+          content: [{ type: "content", content: { type: "text", text } }]
+        }, tool.name);
+      } else if (row.type === "assistant" && (block.type === "text" && typeof block.text === "string" || block.type === "thinking" && typeof block.thinking === "string")) {
+        this.derive(
+          events,
+          block.type === "text" ? "agent_message_chunk" : "agent_thought_chunk",
+          { content: { type: "text", text: block.type === "text" ? block.text : block.thinking } }
+        );
+      }
+    }
+    if (onRow) {
+      if (events.length > 0) onRow(row.uuid, events);
+    } else for (const event of events) this.options.emit(event);
+  }
+  derive(events, eventName, payload, toolName) {
+    events.push({ eventName, payload: { ...payload, _meta: { qoder: {
+      version: 1,
+      source: "correction",
+      parentToolUseId: this.options.parentToolUseId,
+      route: "child",
+      ...toolName ? { toolName } : {}
+    } } } });
+  }
+};
+
+// src/background/backgroundTerminal.ts
+var BackgroundSideReader = class {
+  constructor(options) {
+    this.options = options;
+    this.restoring = options.restoreCalls === true;
+    this.transcript = new Transcript(options.path, options.snapshot ? { snapshotBytes: options.snapshot.snapshotBytes, fileIdentity: options.snapshot.rootIdentity } : void 0, (size) => this.recordSize(options.path, size));
+    for (const child of options.snapshot?.childSnapshots ?? []) {
+      this.launches.set(child.toolUseId, child.agentId);
+      this.sizes.set(child.path, child.snapshotBytes);
+    }
+  }
+  options;
+  launches = /* @__PURE__ */ new Map();
+  sizes = /* @__PURE__ */ new Map();
+  seen = /* @__PURE__ */ new Set();
+  processes = /* @__PURE__ */ new Map();
+  transcript;
+  closed = false;
+  restoring;
+  bootstrapped = false;
+  async read(demand, sink) {
+    if (this.closed || !this.restoring && !demand.active()) return;
+    try {
+      await this.transcript.measure();
+      for (const [id3, agentId] of this.launches) {
+        if (!demand.wantsProcess(id3)) continue;
+        const process2 = this.processFor(id3, agentId);
+        try {
+          await process2.measure();
+        } catch (error) {
+          if (error.code !== "ENOENT" || process2.established) throw error;
+        }
+      }
+      if (!this.bootstrapped) {
+        await this.transcript.bootstrap((row) => this.consume(row, () => {
+        }));
+        this.bootstrapped = true;
+      }
+      const caughtUp = await this.transcript.read((row) => this.consume(row, sink));
+      if (caughtUp) this.restoring = false;
+      if (!this.closed) {
+        await this.pollProcesses(demand, sink);
+        if (!this.closed && caughtUp) sink({ kind: "poll_end" });
+      }
+    } catch (error) {
+      if (error.code === "ENOENT" && !this.transcript.established && this.options.allowMissing) return;
+      this.close();
+      throw error;
+    }
+  }
+  close() {
+    this.closed = true;
+    this.launches.clear();
+    this.processes.clear();
+  }
+  consume(row, sink) {
+    if (this.closed) return;
+    const { nativeSessionId, cwd, historyVersions } = this.options;
+    if (!validateHistoryRow(row, { root: nativeSessionId, cwd, historyVersions })) return;
+    if (this.seen.has(row.uuid)) return;
+    if (this.seen.size >= MAX_UUIDS) throw new Error("Qoder history UUID count exceeds 100000");
+    this.seen.add(row.uuid);
+    for (const fact of rootRowFacts(row, { nativeSessionId, cwd, restoreCalls: this.options.restoreCalls === true })) {
+      if (fact.kind === "launch" && fact.agentId && !this.launches.has(fact.toolUseId)) {
+        if (this.launches.size >= MAX_TASKS) throw new Error("Qoder history background task bound");
+        this.launches.set(fact.toolUseId, fact.agentId);
+      }
+      sink(fact);
+    }
+  }
+  recordSize(path, bytes) {
+    this.sizes.set(path, bytes);
+    if ([...this.sizes.values()].reduce((a, b) => a + b, 0) > MAX_HISTORY) throw new Error("Qoder indexed history exceeds 64 MiB");
+  }
+  processFor(id3, agentId) {
+    let process2 = this.processes.get(id3);
+    if (!process2) {
+      const path = join3(dirname4(this.options.path), this.options.nativeSessionId, "subagents", `agent-${agentId}.jsonl`);
+      process2 = new BackgroundProcess({
+        path,
+        historyVersions: this.options.historyVersions,
+        sessionId: this.options.nativeSessionId,
+        cwd: this.options.cwd,
+        agentId,
+        parentToolUseId: id3,
+        snapshot: this.options.snapshot?.childSnapshots.find((child) => child.toolUseId === id3),
+        onSize: (bytes) => this.recordSize(path, bytes),
+        emit: () => {
+        }
+      });
+      this.processes.set(id3, process2);
+    }
+    return process2;
+  }
+  async pollProcesses(demand, sink) {
+    for (const [id3, agentId] of this.launches) {
+      if (this.closed || !demand.wantsProcess(id3)) continue;
+      const process2 = this.processFor(id3, agentId);
+      let caughtUp;
+      try {
+        caughtUp = await process2.poll((uuid, events) => {
+          if (!this.closed) sink({ kind: "child", toolUseId: id3, uuid, events });
+        });
+      } catch (error) {
+        if (error.code !== "ENOENT" || process2.established) throw error;
+        caughtUp = true;
+      }
+      if (!this.closed) sink({ kind: "child_status", toolUseId: id3, caughtUp });
+    }
+  }
+};
+
+// src/background/poller.ts
+var SIDE_POLL_MS = 1e3;
+var address2 = (v) => v.length > 0 && v.length <= 256 && !/[\x00-\x1f\x7f/\\]/.test(v);
+function historyPath(home, cwd, sessionId) {
+  if (!address2(sessionId) || !isAbsolute(cwd) || !isAbsolute(home)) return void 0;
+  return join4(home, ".qoder", "projects", resolve2(cwd).replace(/[^a-zA-Z0-9]/g, "-"), sessionId + ".jsonl");
+}
+var BackgroundPoller = class {
+  constructor(options) {
+    this.options = options;
+    this.fold = new TerminalRepairFold(options.data?.background ?? newTerminalRepairData({ nativeSessionId: options.root, restoreCalls: options.restoreCalls, includeProcess: true }));
+    const path = historyPath(options.home, options.cwd, options.root);
+    if (!path) throw new Error("Qoder history identity path invalid");
+    this.reader = new BackgroundSideReader({ ...options, path, nativeSessionId: options.root });
+  }
+  options;
+  fold;
+  reader;
+  timer;
+  inFlight;
+  closed = false;
+  observe(event) {
+    if (!this.closed) this.fold.observe(event);
+  }
+  pollOnce() {
+    if (this.closed) return Promise.resolve();
+    if (this.inFlight) return this.inFlight;
+    const read = async () => {
+      if (this.closed) return;
+      const events = [];
+      await this.reader.read(this.fold, (fact) => {
+        if (this.closed) return;
+        if (this.options.data) admitRecoveryFact(this.options.data, this.fold, fact);
+        events.push(...this.fold.apply(fact));
+      });
+      if (!this.closed) await this.options.emit(events);
+    };
+    this.inFlight = (this.options.serialize ? this.options.serialize(read) : read()).catch((error) => {
+      this.halt();
+      this.options.fail(error instanceof Error ? error : new Error(String(error)));
+      throw error;
+    }).finally(() => {
+      this.inFlight = void 0;
+    });
+    return this.inFlight;
+  }
+  start() {
+    if (this.closed || this.timer) return;
+    this.timer = setInterval(() => {
+      const polling = this.pollOnce();
+      void polling.catch(() => {
+      });
+      return polling;
+    }, SIDE_POLL_MS);
+    this.timer.unref();
+  }
+  halt() {
+    this.closed = true;
+    if (this.timer) clearInterval(this.timer);
+    this.timer = void 0;
+    this.reader.close();
+  }
+  async stop() {
+    this.halt();
+    await this.inFlight?.catch(() => {
+    });
+  }
+};
+
+// src/events.ts
+function toSessionUpdate(event, rootSessionId) {
+  return {
+    jsonrpc: "2.0",
+    method: "session/update",
+    params: { sessionId: event.acpSessionId ?? rootSessionId, update: { sessionUpdate: event.eventName, ...event.payload } }
+  };
+}
+
+// src/boundary.ts
+async function createBoundary(options) {
+  const store = await openRecoveryStore(options);
+  try {
+    const saved = await store.load();
+    if (options.mode === "new" && saved) throw new Error("Qoder new session already has recovery state; use load or resume");
+    const data = saved ?? newRecoveryData(options.root, options.cwd, options.releaseId);
+    const index = options.mode === "new" ? void 0 : await bootstrapHistory({ ...options, data });
+    await store.save(data);
+    const foreground = new ForegroundOutputBoundary(options.root, data.foreground);
+    const subwork = new SubworkBoundary(options.root, data.subwork);
+    const terminal2 = new TerminalRepairFold(data.background);
+    const display = options.mode === "load" ? newRecoveryData(options.root, options.cwd, options.releaseId) : void 0;
+    const displayForeground = display ? new ForegroundOutputBoundary(options.root, display.foreground) : void 0;
+    const displaySubwork = display ? new SubworkBoundary(options.root, display.subwork) : void 0;
+    let active = false, closing = false, fatalError;
+    let serial = Promise.resolve(), closingPromise;
+    let poller;
+    let cleanup;
+    const release = () => cleanup ??= store.close();
+    const fatal = (error) => {
+      if (fatalError) return;
+      fatalError = error;
+      poller?.halt();
+      void serial.then(release).catch((releaseError) => {
+        options.fail(releaseError instanceof Error ? releaseError : new Error(String(releaseError)));
+      });
+      options.fail(error);
+    };
+    const serialize = (operation) => {
+      if (closing) return Promise.reject(fatalError ?? new Error("Qoder boundary closed"));
+      const result = serial.then(async () => {
+        if (fatalError) throw fatalError;
+        try {
+          return await operation();
+        } catch (error) {
+          const failure = error instanceof Error ? error : new Error(String(error));
+          fatal(failure);
+          throw failure;
+        }
+      });
+      serial = result.then(() => {
+      }, () => {
+      });
+      return result;
+    };
+    const params = (events) => events.map((event) => toSessionUpdate(event, options.root).params);
+    poller = new BackgroundPoller({
+      ...options,
+      data,
+      snapshot: index,
+      restoreCalls: true,
+      allowMissing: options.mode === "new",
+      serialize,
+      fail: fatal,
+      emit: async (events) => {
+        const output = [];
+        for (const event of events) {
+          admitRecoveryEvent(data, event);
+          output.push(...subwork.map(event));
+        }
+        await store.save(data);
+        for (const p of params(output)) {
+          if (closing || fatalError) break;
+          await options.send(p);
+        }
+      }
+    });
+    return {
+      map(update) {
+        return serialize(async () => {
+          if (typeof update.sessionUpdate !== "string") throw new Error("Qoder boundary session update missing kind");
+          const { sessionUpdate, ...payload } = update;
+          const event = { eventName: sessionUpdate, payload };
+          let events;
+          if (display && !active) {
+            admitRecoveryEvent(display, event);
+            events = displayForeground.accept(event) ? displaySubwork.map(event) : [];
+          } else {
+            admitRecoveryEvent(data, event);
+            terminal2.observe(event);
+            events = foreground.accept(event) ? subwork.map(event) : [];
+          }
+          await store.save(data);
+          return params(events);
+        });
+      },
+      historyMessage(message) {
+        if (fatalError) throw fatalError;
+        if (closing) throw new Error("Qoder boundary closed");
+        return message.type === "assistant" && message.sessionId === options.root && message.cwd === options.cwd && typeof message.uuid === "string" && index?.rootAssistantUuids.has(message.uuid) && message.parent_tool_use_id === void 0 ? { ...message, parent_tool_use_id: null } : message;
+      },
+      activate() {
+        return serialize(async () => {
+          if (active) return;
+          await store.save(data);
+          active = true;
+          poller.start();
+        });
+      },
+      endTurn() {
+        return serialize(async () => {
+          foreground.endTurn();
+          displayForeground?.endTurn();
+          await store.save(data);
+        });
+      },
+      close() {
+        if (closingPromise) return closingPromise;
+        closing = true;
+        poller.halt();
+        closingPromise = (async () => {
+          await serial;
+          await poller.stop();
+          await release();
+        })();
+        return closingPromise;
+      }
+    };
+  } catch (error) {
+    await store.close();
+    throw error;
+  }
+}
+
+// src/steering.ts
+var SteeringValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SteeringValidationError";
+  }
+};
+function validatedPrompt(params) {
+  const priority = params._meta?.steering?.priority;
+  if (priority !== void 0 && priority !== "next")
+    throw new SteeringValidationError("Only next steering priority is supported");
+  if (!Array.isArray(params.prompt) || params.prompt.length === 0)
+    throw new SteeringValidationError("Steering requires nonempty text content");
+  const texts = [];
+  for (const block of params.prompt) {
+    if (block === null || typeof block !== "object" || block.type !== "text" || typeof block.text !== "string")
+      throw new SteeringValidationError("Steering supports text content only");
+    texts.push(block.text);
+  }
+  const prompt = texts.join("\n");
+  if (prompt.trim().length === 0)
+    throw new SteeringValidationError("Steering requires nonempty text content");
+  if (Buffer.byteLength(prompt, "utf8") > 128 * 1024)
+    throw new SteeringValidationError("Steering text exceeds 128 KiB UTF-8");
+  return prompt;
+}
+var NextSteering = class {
+  constructor(root, hooks) {
+    this.root = root;
+    this.hooks = hooks;
+  }
+  root;
+  hooks;
+  running = false;
+  pending = /* @__PURE__ */ new Set();
+  begin() {
+    if (this.running) throw new Error("A native prompt is already running");
+    if (this.pending.size) throw new Error("Prior native prompt still has owned pending inputs");
+    this.running = true;
+  }
+  accept(params) {
+    const prompt = validatedPrompt(params);
+    if (!this.running) return { outcome: "promptRequired" };
+    if (this.pending.size >= 32)
+      throw new SteeringValidationError("Steering has 32 pending inputs");
+    const uuid = this.hooks.uuid();
+    if (this.pending.has(uuid)) throw new Error("Native input UUID collision");
+    this.pending.add(uuid);
+    try {
+      this.hooks.enqueue({
+        uuid,
+        sessionId: this.root,
+        prompt,
+        priority: "next",
+        commandMode: "prompt",
+        origin: { kind: "human" }
+      });
+    } catch (enqueueError) {
+      try {
+        this.hooks.remove(/* @__PURE__ */ new Set([uuid]));
+      } catch (removalError) {
+        throw new AggregateError([enqueueError, removalError], "Native enqueue and owned rollback failed");
+      }
+      this.pending.delete(uuid);
+      throw enqueueError;
+    }
+    return { outcome: "injected" };
+  }
+  consumed(uuids) {
+    for (const uuid of uuids) this.pending.delete(uuid);
+  }
+  /** Native attachment cancellation is not successful consumption. */
+  cancelled(uuids) {
+    if (!uuids.some((uuid) => this.pending.has(uuid))) return false;
+    this.cancel();
+    return true;
+  }
+  tryFinish() {
+    if (this.pending.size) return false;
+    this.running = false;
+    return true;
+  }
+  cancel() {
+    this.running = false;
+    if (!this.pending.size) return;
+    const owned = new Set(this.pending);
+    this.hooks.remove(owned);
+    for (const uuid of owned) this.pending.delete(uuid);
+  }
+};
+
+// src/entry.ts
+var owners = /* @__PURE__ */ new Map();
+function initialize(result, releaseId, version, bindings) {
+  for (const name of ["RequestError", "uuid", "enqueue", "remove", "select", "consume"])
+    if (typeof bindings[name] !== "function")
+      throw new Error(`Native ACP runtime binding unavailable: ${name}`);
+  if (new bindings.RequestError(-32602, "probe").name !== "RequestError")
+    throw new Error("Native ACP RequestError binding mismatch");
+  if (result.agentInfo?.name !== "qoder-cli" || result.agentInfo?.version !== version || !result.agentCapabilities?.sessionCapabilities?.resume)
+    throw new Error("Native ACP initialize identity/capability mismatch");
+  if (result._meta?.axom !== void 0 || result._meta?.steering !== void 0)
+    throw new Error("Conflicting ACP metadata");
+  return { ...result, _meta: { ...result._meta, axom: { cachedReconnect: "resume", releaseId }, steering: { supported: true, timings: ["next"] } } };
+}
+function finish(root, child) {
+  return child || (owners.get(root)?.tryFinish() ?? true);
+}
+function terminal(root, child, verdict) {
+  if (child)
+    return;
+  const owner = owners.get(root);
+  if (!owner)
+    return;
+  const pending = !owner.tryFinish();
+  owner.cancel();
+  if (pending && verdict.reason === "end_turn")
+    throw new Error("Native ACP stopped before accepted next input was consumed");
+}
+function cancelled(root, child, uuids) {
+  if (!child && owners.get(root)?.cancelled(uuids))
+    throw new Error("Native ACP accepted next input was cancelled before consumption");
+}
+function consumed(root, child, uuids) {
+  if (!child)
+    owners.get(root)?.consumed(uuids);
+}
+function createBridge(options) {
+  const { root, bindings } = options;
+  if (owners.has(root))
+    throw new Error("Native ACP root already owned");
+  const steering = new NextSteering(root, { uuid: bindings.uuid, enqueue: bindings.enqueue, remove: (ids) => {
+    bindings.remove((input) => input.sessionId === root && ids.has(input.uuid));
+  } });
+  owners.set(root, steering);
+  let closed = false, fatal, closing;
+  const origins = /* @__PURE__ */ new Map();
+  const fail = (error) => {
+    fatal ??= error;
+    steering.cancel();
+    options.fail(error);
+  };
+  const ready = createBoundary({ ...options, home: homedir(), fail }).catch((error) => {
+    fatal = error;
+    if (owners.get(root) === steering)
+      owners.delete(root);
+    throw error;
+  });
+  ready.catch(() => {
+  });
+  const check = () => {
+    if (fatal)
+      throw fatal;
+    if (closed)
+      throw new Error("Native ACP session closed");
+  };
+  const id3 = (value) => typeof value === "string" && value.length > 0 && value.length <= 256 && !/[\x00-\x1f\x7f]/.test(value);
+  const observe = (message) => {
+    if (message.type !== "assistant" || !Array.isArray(message.message?.content))
+      return;
+    const parent = message.parent_tool_use_id;
+    if (parent !== null && !id3(parent))
+      return;
+    for (const block of message.message.content) {
+      if (block?.type !== "tool_use" || !id3(block.id) || !id3(block.name))
+        continue;
+      const prior = origins.get(block.id);
+      if (origins.has(block.id)) {
+        if (prior && (prior.parent !== parent || prior.name !== block.name))
+          origins.set(block.id, null);
+        continue;
+      }
+      if (origins.size >= 4096)
+        throw new Error("Native ACP tool origin bound exceeded");
+      origins.set(block.id, { parent, name: block.name });
+    }
+  };
+  return {
+    async ready() {
+      await ready;
+      check();
+    },
+    begin() {
+      check();
+      steering.begin();
+    },
+    accept(params) {
+      check();
+      try {
+        return steering.accept(params);
+      } catch (error) {
+        if (error instanceof SteeringValidationError)
+          throw new bindings.RequestError(-32602, error.message);
+        throw error;
+      }
+    },
+    cancel() {
+      steering.cancel();
+    },
+    observe,
+    async history(message) {
+      check();
+      observe((await ready).historyMessage(message));
+    },
+    async send(update, message) {
+      check();
+      if (message && id3(message.parent_tool_use_id))
+        update = { ...update, _meta: { ...update._meta, qoder: { ...update._meta?.qoder, version: 1, source: "native-acp-patch", parentToolUseId: message.parent_tool_use_id, route: "child" } } };
+      if (update.sessionUpdate === "tool_call" || update.sessionUpdate === "tool_call_update") {
+        const origin = origins.get(update.toolCallId);
+        if (origin)
+          update = { ...update, _meta: { ...update._meta, qoder: { ...update._meta?.qoder, version: 1, source: "native-acp-patch", toolName: origin.name, ...origin.parent ? { parentToolUseId: origin.parent, route: "child" } : {} } } };
+      }
+      for (const value of await (await ready).map(update)) {
+        check();
+        await options.send(value);
+      }
+    },
+    async activate() {
+      check();
+      await (await ready).activate();
+    },
+    async endTurn() {
+      steering.cancel();
+      await (await ready).endTurn();
+    },
+    close() {
+      if (closing)
+        return closing;
+      closed = true;
+      steering.cancel();
+      closing = (async () => {
+        try {
+          await (await ready).close();
+        } finally {
+          origins.clear();
+          if (owners.get(root) === steering)
+            owners.delete(root);
+        }
+      })();
+      closing.catch(() => {
+      });
+      return closing;
+    }
+  };
+}
+export {
+  cancelled,
+  consumed,
+  createBridge,
+  finish,
+  initialize,
+  terminal
+};