@maycombhq/atticus 2.0.0-beta.12.2 → 2.0.0-beta.14

package/dist/{chunk-E52MNV5B.js → chunk-BYR5KVSS.js}

@@ -13,6 +13,7 @@ import {
   STEP_CLASSES,
   changesDirOf,
   changesRelOf,
+  copilotAcpOf,
   currentSignal,
   differentThings,
   identifierWords,
@@ -27,7 +28,7 @@ import {
   runsRelOf,
   stateDirOf,
   stepModelsOf
-} from "./chunk-LZABEKI6.js";
+} from "./chunk-FVI44U5N.js";
 import {
   writeFileAtomic
 } from "./chunk-MMB2OHUY.js";
@@ -1111,8 +1112,8 @@ function checkAllowed(kind, agent) {
 }
 function makeRunId(now, seq) {
   const stamp = now.toISOString().replace(/[-:TZ.]/g, "").slice(0, 14);
-  const tail = seq !== void 0 ? String(seq).padStart(4, "0") : Math.random().toString(36).slice(2, 8);
-  return `run-${stamp}-${tail}`;
+  const tail2 = seq !== void 0 ? String(seq).padStart(4, "0") : Math.random().toString(36).slice(2, 8);
+  return `run-${stamp}-${tail2}`;
 }
 function toRunSummary(run) {
   return {
@@ -1132,7 +1133,8 @@ function toRunSummary(run) {
     ...run.tools ? { tools: run.tools } : {},
     ...run.request.retrieval ? { retrieval: run.request.retrieval } : {},
     stepClass: run.stepClass ?? stepClassOf(run.request),
-    ...run.model ? { model: run.model } : {}
+    ...run.model ? { model: run.model } : {},
+    ...run.assistant ? { assistant: run.assistant } : {}
   };
 }
 var OneShotRuntime = class {
@@ -1149,11 +1151,15 @@ var OneShotRuntime = class {
   modelFor(_request) {
     return void 0;
   }
+  /** The kind an agent's allowedRuntimes must name for this runtime (copilot-acp: hand-off too). */
+  allowedAs(_agent) {
+    return this.kind;
+  }
   /** Keep a finished run where Model runs reads it (the model runtime, given a root). */
   async keep(_run) {
   }
   async prepare(request) {
-    checkAllowed(this.kind, request.agent);
+    checkAllowed(this.allowedAs(request.agent), request.agent);
     if (request.pack.manifest.totalTokens > request.agent.tokenBudget) {
       throw new RuntimeError(`context pack (${request.pack.manifest.totalTokens} tokens) is over agent ${request.agent.id}'s budget of ${request.agent.tokenBudget}`);
     }
@@ -1181,8 +1187,14 @@ var OneShotRuntime = class {
       return run;
     }
     try {
-      const { output, usage, tools } = await this.produce(run, signal);
-      run = transition(run, "produced", this.now(), { output, usage, ...tools ? { tools } : {} });
+      const { output, usage, tools, model, assistant } = await this.produce(run, signal);
+      run = transition(run, "produced", this.now(), {
+        output,
+        usage,
+        ...tools ? { tools } : {},
+        ...model ? { model } : {},
+        ...assistant ? { assistant } : {}
+      });
       const problems = await this.opts.validate?.(output, run.request) ?? [];
       run = problems.length === 0 ? transition(run, "validated", this.now()) : transition(run, "failed", this.now(), { errors: problems });
     } catch (e) {
@@ -1699,12 +1711,1005 @@ async function pruneRuns(root, days, now = /* @__PURE__ */ new Date(), only) {
 }
 
 // packages/ai/dist/factory.js
-import { spawn } from "node:child_process";
-import { mkdir as mkdir4, mkdtemp, readFile as readFile4, rm as rm2, stat as stat2, writeFile as writeFile4 } from "node:fs/promises";
+import { spawn as spawn2 } from "node:child_process";
+import { mkdir as mkdir5, mkdtemp, readFile as readFile5, rm as rm2, stat as stat3, writeFile as writeFile5 } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { dirname, join as join4 } from "node:path";
+import { dirname as dirname2, join as join5 } from "node:path";
+
+// packages/ai/dist/copilot-acp.js
+import { spawn } from "node:child_process";
+import { existsSync, realpathSync } from "node:fs";
+import { mkdir as mkdir4, readFile as readFile4, stat as stat2, writeFile as writeFile4 } from "node:fs/promises";
+import { basename, dirname, isAbsolute, join as join4, relative, resolve, sep } from "node:path";
+import { createInterface } from "node:readline";
+
+// packages/ai/dist/acp.js
+var ACP_PROTOCOL_VERSION = 1;
+var ACP_METHODS = {
+  initialize: "initialize",
+  authenticate: "authenticate",
+  sessionNew: "session/new",
+  sessionSetModel: "session/set_model",
+  sessionPrompt: "session/prompt",
+  sessionCancel: "session/cancel",
+  sessionUpdate: "session/update",
+  requestPermission: "session/request_permission",
+  readTextFile: "fs/read_text_file",
+  writeTextFile: "fs/write_text_file",
+  terminalCreate: "terminal/create",
+  terminalOutput: "terminal/output",
+  terminalWaitForExit: "terminal/wait_for_exit",
+  terminalKill: "terminal/kill",
+  terminalRelease: "terminal/release"
+};
+var ACP_ERRORS = {
+  invalidParams: -32602,
+  methodNotFound: -32601,
+  internal: -32603,
+  authRequired: -32e3
+};
+var AcpRpcError = class extends Error {
+  code;
+  data;
+  constructor(code, message, data) {
+    super(message);
+    this.code = code;
+    this.data = data;
+    this.name = "AcpRpcError";
+  }
+};
+var AcpClient = class {
+  t;
+  h;
+  tap;
+  next = 1;
+  pending = /* @__PURE__ */ new Map();
+  closed;
+  constructor(t, h, tap = () => {
+  }) {
+    this.t = t;
+    this.h = h;
+    this.tap = tap;
+    t.onLine((line) => this.receive(line));
+    t.onClose((why) => {
+      this.closed = why;
+      for (const p of this.pending.values())
+        p.reject(new AcpRpcError(ACP_ERRORS.internal, why));
+      this.pending.clear();
+    });
+  }
+  out(message) {
+    const m = { jsonrpc: "2.0", ...message };
+    this.tap("out", m);
+    this.t.send(JSON.stringify(m));
+  }
+  request(method, params) {
+    if (this.closed)
+      return Promise.reject(new AcpRpcError(ACP_ERRORS.internal, this.closed));
+    const id = this.next++;
+    return new Promise((resolve2, reject) => {
+      this.pending.set(id, { resolve: resolve2, reject });
+      this.out({ id, method, params });
+    });
+  }
+  notify(method, params) {
+    if (!this.closed)
+      this.out({ method, params });
+  }
+  receive(line) {
+    if (!line.trim())
+      return;
+    let m;
+    try {
+      m = JSON.parse(line);
+    } catch {
+      this.tap("in", { notJson: line.slice(0, 500) });
+      return;
+    }
+    this.tap("in", m);
+    if (m.method === void 0 && m.id !== void 0) {
+      const p = this.pending.get(Number(m.id));
+      if (!p)
+        return;
+      this.pending.delete(Number(m.id));
+      if (m.error)
+        p.reject(new AcpRpcError(m.error.code, m.error.message, m.error.data));
+      else
+        p.resolve(m.result ?? null);
+      return;
+    }
+    if (m.method === ACP_METHODS.sessionUpdate) {
+      const u = m.params?.update;
+      if (u && typeof u === "object")
+        this.h.update(u);
+      return;
+    }
+    if (m.id === void 0)
+      return;
+    const id = m.id;
+    void this.answer(m.method ?? "", m.params ?? {}).then((result) => this.out({ id, result }), (e) => this.out({
+      id,
+      error: {
+        code: e instanceof AcpRpcError ? e.code : ACP_ERRORS.invalidParams,
+        message: e.message
+      }
+    }));
+  }
+  answer(method, p) {
+    const s = (k) => typeof p[k] === "string" ? p[k] : "";
+    switch (method) {
+      case ACP_METHODS.readTextFile:
+        return this.h.readTextFile({
+          path: s("path"),
+          ...typeof p.line === "number" ? { line: p.line } : {},
+          ...typeof p.limit === "number" ? { limit: p.limit } : {}
+        });
+      case ACP_METHODS.writeTextFile:
+        return this.h.writeTextFile({ path: s("path"), content: s("content") });
+      case ACP_METHODS.requestPermission:
+        return this.h.requestPermission({
+          toolCall: p.toolCall ?? {},
+          options: Array.isArray(p.options) ? p.options : []
+        });
+      case ACP_METHODS.terminalCreate:
+        return this.h.terminalCreate({
+          command: s("command"),
+          ...Array.isArray(p.args) ? { args: p.args.map(String) } : {},
+          ...typeof p.cwd === "string" ? { cwd: p.cwd } : {},
+          ...Array.isArray(p.env) ? { env: p.env } : {},
+          ...typeof p.outputByteLimit === "number" ? { outputByteLimit: p.outputByteLimit } : {}
+        });
+      case ACP_METHODS.terminalOutput:
+        return this.h.terminalOutput({ terminalId: s("terminalId") });
+      case ACP_METHODS.terminalWaitForExit:
+        return this.h.terminalWaitForExit({ terminalId: s("terminalId") });
+      case ACP_METHODS.terminalKill:
+        return this.h.terminalKill({ terminalId: s("terminalId") });
+      case ACP_METHODS.terminalRelease:
+        return this.h.terminalRelease({ terminalId: s("terminalId") });
+      default:
+        return Promise.reject(new AcpRpcError(ACP_ERRORS.methodNotFound, `Atticus doesn't offer ${method}`));
+    }
+  }
+  // ------------------------------------------------------------ the agent's methods
+  initialize(clientInfo) {
+    return this.request(ACP_METHODS.initialize, {
+      protocolVersion: ACP_PROTOCOL_VERSION,
+      clientCapabilities: { fs: { readTextFile: true, writeTextFile: true }, terminal: true },
+      clientInfo
+    });
+  }
+  newSession(cwd) {
+    return this.request(ACP_METHODS.sessionNew, { cwd, mcpServers: [] });
+  }
+  setModel(sessionId, modelId) {
+    return this.request(ACP_METHODS.sessionSetModel, { sessionId, modelId });
+  }
+  prompt(sessionId, text) {
+    return this.request(ACP_METHODS.sessionPrompt, {
+      sessionId,
+      prompt: [{ type: "text", text }]
+    });
+  }
+  cancel(sessionId) {
+    this.notify(ACP_METHODS.sessionCancel, { sessionId });
+  }
+};
+function chunkText(u) {
+  const c = u.content;
+  return c?.type === "text" && typeof c.text === "string" ? c.text : void 0;
+}
+var UPDATE = {
+  message: "agent_message_chunk",
+  thought: "agent_thought_chunk",
+  toolCall: "tool_call",
+  toolCallUpdate: "tool_call_update",
+  plan: "plan"
+};
+function usageOf(u) {
+  if (!u)
+    return void 0;
+  const n = (...ks) => {
+    for (const k of ks)
+      if (typeof u[k] === "number")
+        return u[k];
+    return void 0;
+  };
+  const i = n("inputTokens", "input_tokens", "promptTokens");
+  const o = n("outputTokens", "output_tokens", "completionTokens");
+  return i === void 0 && o === void 0 ? void 0 : {
+    inputTokens: Math.max(0, Math.round(i ?? 0)),
+    outputTokens: Math.max(0, Math.round(o ?? 0))
+  };
+}
+var isAuthRequired = (e) => e instanceof AcpRpcError && (e.code === ACP_ERRORS.authRequired || /auth|sign.?in|log.?in/i.test(e.message));
+
+// packages/ai/dist/copilot-acp.js
+function words(line) {
+  const out = [];
+  let cur = "";
+  let quote;
+  let any = false;
+  let meta = false;
+  for (const ch of line) {
+    if (quote) {
+      if (ch === quote)
+        quote = void 0;
+      else
+        cur += ch;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      any = true;
+      continue;
+    }
+    if (/\s/.test(ch)) {
+      if (cur || any)
+        out.push(cur);
+      cur = "";
+      any = false;
+      continue;
+    }
+    if ("|&;<>`$(){}\n".includes(ch))
+      meta = true;
+    cur += ch;
+  }
+  if (cur || any)
+    out.push(cur);
+  return { words: out, meta: meta || quote !== void 0 };
+}
+function commandLineOf(line) {
+  const w = words(line.trim()).words;
+  if (!w.length)
+    throw new RuntimeConfigLikeError("copilotAcp.command is empty");
+  const args = w.slice(1);
+  return { command: w[0], args: args.includes("--acp") ? args : [...args, "--acp"] };
+}
+var RuntimeConfigLikeError = class extends RuntimeError {
+};
+var PERSONS = [
+  {
+    test: (a) => a[0] === "questions" && a[1] === "answer",
+    why: "a person answers questions (atticus questions answer is theirs to run)"
+  },
+  {
+    test: (a) => a.includes("--approve"),
+    why: "--approve is a person's: a human approves every write to shared systems"
+  },
+  {
+    test: (a) => a.includes("--accept") || a.includes("--accept-proposal"),
+    why: "a person accepts what is proposed (--accept is theirs)"
+  },
+  {
+    test: (a) => a[0] === "map" && a.includes("--all"),
+    why: "this session is one step of atticus map --all; Atticus runs the loop, not the session"
+  },
+  {
+    test: (a) => ["ui", "serve", "mcp"].includes(a[0] ?? ""),
+    why: "a server that keeps running isn't a step's command"
+  },
+  {
+    test: (a) => a.some((x) => x === "--root" || x.startsWith("--root=")),
+    why: "the session works in this metarepo; --root points elsewhere"
+  }
+];
+var ATTICUS_NAMES = /* @__PURE__ */ new Set(["atticus", "atticus.cmd", "atticus.exe"]);
+function atticusArgvOf(command, args = []) {
+  const head = words(command.trim());
+  if (head.meta)
+    return {
+      refused: `Atticus runs no shell here, so a command line with | & ; < > $ or backquotes is refused: ${short(command)}. Run one atticus command at a time.`
+    };
+  const all = [...head.words, ...args];
+  const program = all[0] ?? "";
+  if (!ATTICUS_NAMES.has(program.toLowerCase()))
+    return {
+      refused: `Atticus runs only atticus commands in this session (atticus <command> <arguments>); ${short([program, ...all.slice(1)].join(" "))} is refused. Read files with your file tools; write only under facts/ or the step's result file.`
+    };
+  const argv = all.slice(1);
+  if (!argv.length)
+    return { refused: "atticus needs a command (atticus next, atticus verify <repo>, ...)" };
+  for (const p of PERSONS)
+    if (p.test(argv))
+      return { refused: `Refused: ${p.why}.` };
+  return { argv };
+}
+var short = (s, n = 120) => s.length > n ? `${s.slice(0, n - 1)}\u2026` : s;
+function real(p) {
+  let cur = resolve(p);
+  const rest = [];
+  for (; ; ) {
+    try {
+      return join4(realpathSync.native(cur), ...rest.reverse());
+    } catch {
+      const up = dirname(cur);
+      if (up === cur)
+        return resolve(p);
+      rest.push(basename(cur));
+      cur = up;
+    }
+  }
+}
+var sameOrUnder = (root, p) => {
+  const r = relative(root, p);
+  return r === "" || !r.startsWith("..") && !isAbsolute(r);
+};
+var caseOf = (p) => process.platform === "win32" ? p.toLowerCase() : p;
+var Paths = class {
+  p;
+  reads;
+  writeDirs;
+  files;
+  constructor(p) {
+    this.p = p;
+    this.reads = p.readRoots.map((r) => caseOf(real(r)));
+    this.writeDirs = p.writeRoots.map((r) => caseOf(real(r)));
+    this.files = (p.writeFiles ?? []).map((f) => caseOf(real(f)));
+  }
+  readable(path) {
+    if (!path || !isAbsolute(path))
+      return `the path must be absolute (got ${short(path)})`;
+    const r = caseOf(real(path));
+    return this.reads.some((x) => sameOrUnder(x, r)) ? void 0 : `Atticus lets this session read only under the metarepo and its clones; ${short(path)} is outside`;
+  }
+  writable(path) {
+    if (!path || !isAbsolute(path))
+      return `the path must be absolute (got ${short(path)})`;
+    const r = caseOf(real(path));
+    if (r.split(sep).includes(".git"))
+      return `Atticus never lets a session write in .git (${short(path)})`;
+    if (this.files.includes(r) || this.writeDirs.some((x) => sameOrUnder(x, r)))
+      return void 0;
+    const base = this.p.readRoots[0] ?? "";
+    const rel = (x) => {
+      const r2 = relative(base, x);
+      return r2 && !r2.startsWith("..") && !isAbsolute(r2) ? r2.split(sep).join("/") : x;
+    };
+    const where = [
+      ...this.p.writeRoots.map((d) => `${rel(d)}/`),
+      ...(this.p.writeFiles ?? []).map(rel)
+    ].join(", ");
+    return `Atticus lets this session write only its step's result: it writes only under ${where || "nothing"}; ${short(path)} is refused`;
+  }
+};
+var factsOnly = (root, factsDir) => ({
+  readRoots: readRootsOf(root),
+  writeRoots: [factsDir]
+});
+function readRootsOf(root) {
+  const out = [root];
+  const state = join4(stateDirOf(root), "workspace");
+  if (!sameOrUnder(resolve(root), resolve(state)))
+    out.push(state);
+  return out;
+}
+var needsShell = (command) => process.platform === "win32" && !/\.(exe|com)$/i.test(command);
+var quoteForCmd = (a) => /[\s"]/.test(a) ? `"${a.replace(/"/g, '""')}"` : a;
+var spawnAcpServer = (o) => {
+  const shell = needsShell(o.command);
+  let child;
+  let err = "";
+  let failed = () => {
+  };
+  let ok = () => {
+  };
+  const started = new Promise((res, rej) => {
+    ok = res;
+    failed = rej;
+  });
+  started.catch(() => void 0);
+  try {
+    child = spawn(shell ? quoteForCmd(o.command) : o.command, shell ? o.args.map(quoteForCmd) : o.args, { cwd: o.cwd, env: o.env, stdio: ["pipe", "pipe", "pipe"], windowsHide: true, shell });
+  } catch (e) {
+    failed(e);
+    const dead = { send: () => {
+    }, onLine: () => {
+    }, onClose: (fn) => fn(String(e)) };
+    return { transport: dead, stderr: () => "", close: async () => {
+    }, started };
+  }
+  const lines = [];
+  const closes = [];
+  let closed;
+  const close = (why) => {
+    if (closed)
+      return;
+    closed = why;
+    for (const f of closes)
+      f(why);
+  };
+  child.on("spawn", () => ok());
+  child.on("error", (e) => {
+    failed(e);
+    close(`the Copilot language server couldn't be run: ${e.message}`);
+  });
+  child.on("exit", (code, signal) => close(`the Copilot language server ended (${code ?? signal ?? "no code"})`));
+  for (const s of [child.stdin, child.stdout, child.stderr])
+    s?.on("error", () => void 0);
+  child.stderr?.setEncoding("utf8").on("data", (d) => {
+    err = (err + d).slice(-64e3);
+  });
+  createInterface({ input: child.stdout }).on("line", (l) => {
+    for (const f of lines)
+      f(l);
+  });
+  return {
+    started,
+    stderr: () => err,
+    transport: {
+      send: (t) => {
+        if (!closed)
+          child.stdin?.write(`${t}
+`);
+      },
+      onLine: (f) => lines.push(f),
+      onClose: (f) => closed ? f(closed) : closes.push(f)
+    },
+    close: async () => {
+      if (closed)
+        return;
+      child.stdin?.end();
+      await new Promise((res) => {
+        const t = setTimeout(() => {
+          child.kill();
+          res();
+        }, 2e3);
+        closes.push(() => {
+          clearTimeout(t);
+          res();
+        });
+      });
+    }
+  };
+};
+function atticusExec(entry, node = process.execPath) {
+  return (argv, o) => new Promise((res) => {
+    let output = "";
+    const child = spawn(node, [entry, ...argv], {
+      cwd: o.cwd,
+      env: { ...process.env, ATTICUS_ACP_SESSION: "1" },
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true,
+      signal: o.signal
+    });
+    const take = (d) => {
+      const t = d.toString("utf8");
+      output = (output + t).slice(-1e6);
+      o.onOutput?.(t);
+    };
+    child.stdout.on("data", take);
+    child.stderr.on("data", take);
+    child.on("error", (e) => res({ exitCode: 1, output: `${output}${e.message}
+` }));
+    child.on("close", (code, signal) => res({ exitCode: code, output, signal }));
+  });
+}
+var AcpSignInError = class extends RuntimeError {
+  constructor(message) {
+    super(message);
+    this.name = "AcpSignInError";
+  }
+};
+var ACP_OFFERED = [
+  "fs/read_text_file",
+  "fs/write_text_file",
+  "terminal/create (atticus only)",
+  "session/request_permission"
+];
+var withTimeout = (p, ms, what) => new Promise((res, rej) => {
+  const t = setTimeout(() => rej(new RuntimeError(`${what} took over ${Math.round(ms / 1e3)}s`)), ms);
+  p.then((v) => {
+    clearTimeout(t);
+    res(v);
+  }, (e) => {
+    clearTimeout(t);
+    rej(e);
+  });
+});
+var oneLine = (s, n = 150) => short(s.replace(/\s+/g, " ").trim(), n);
+var signInLines = (stderr) => stderr.split(/\r?\n/).map((l) => l.trim()).filter((l) => /https?:\/\/|code|sign|log.?in|auth/i.test(l)).slice(-5);
+async function runAcpSession(o) {
+  const { command, args } = commandLineOf(o.command);
+  const server = (o.spawn ?? spawnAcpServer)({
+    command,
+    args,
+    cwd: o.cwd,
+    env: { ...process.env, ...o.env ?? {} }
+  });
+  const transcript = [];
+  const paths = new Paths(o.policy);
+  const calls = [];
+  const refused = [];
+  const say = (l) => o.onProgress?.(short(l, 160));
+  let text = "";
+  let pendingText = "";
+  let agentCalls = 0;
+  let cancelWhy;
+  let sessionId;
+  const abort = new AbortController();
+  const flush = () => {
+    if (pendingText.trim())
+      say(`  Copilot: ${oneLine(pendingText)}`);
+    pendingText = "";
+  };
+  const record = (name, input, output, error) => {
+    calls.push({
+      round: 1,
+      name,
+      input,
+      output: short(output, 2e3),
+      tokens: estimateTokens(output),
+      ...error ? { error: true } : {}
+    });
+    if (error) {
+      refused.push(output);
+      flush();
+      say(`  Refused: ${oneLine(output, 140)}`);
+    }
+  };
+  const refuse = (name, input, why) => {
+    record(name, input, why, true);
+    throw new AcpRpcError(ACP_ERRORS.invalidParams, why);
+  };
+  const terminals = /* @__PURE__ */ new Map();
+  let tn = 0;
+  const box = {};
+  const cancel = (why) => {
+    if (cancelWhy)
+      return;
+    cancelWhy = why;
+    flush();
+    say(`  Stopping the session: ${why}.`);
+    if (sessionId)
+      box.client?.cancel(sessionId);
+    for (const t of terminals.values())
+      t.kill.abort();
+  };
+  const handlers = {
+    async readTextFile(p) {
+      const why = paths.readable(p.path);
+      if (why)
+        return refuse("fs/read_text_file", { path: p.path }, why);
+      const all = await readFile4(p.path, "utf8").catch((e) => {
+        throw new AcpRpcError(ACP_ERRORS.invalidParams, `${p.path} can't be read: ${e.code ?? e.message}`);
+      });
+      let content = all;
+      if (p.line !== void 0 || p.limit !== void 0) {
+        const lines = all.split("\n");
+        const from = Math.max(0, (p.line ?? 1) - 1);
+        content = lines.slice(from, p.limit !== void 0 ? from + p.limit : void 0).join("\n");
+      }
+      record("fs/read_text_file", { path: p.path }, `${content.length} characters`);
+      return { content };
+    },
+    async writeTextFile(p) {
+      const why = paths.writable(p.path);
+      if (why)
+        return refuse("fs/write_text_file", { path: p.path }, why);
+      await mkdir4(dirname(p.path), { recursive: true });
+      await writeFile4(p.path, p.content, "utf8");
+      record("fs/write_text_file", { path: p.path }, `${p.content.length} characters written`);
+      return null;
+    },
+    async requestPermission(p) {
+      const tc = p.toolCall;
+      const why = permissionRefused(tc, paths);
+      const pick = (kinds) => kinds.map((k) => p.options.find((x) => x.kind === k)).find(Boolean);
+      const allow = why ? void 0 : pick(["allow_once"]);
+      const input = {
+        kind: tc.kind ?? "",
+        title: tc.title ?? "",
+        ...tc.locations?.length ? { locations: tc.locations.map((l) => l.path) } : {}
+      };
+      if (allow) {
+        record(`permission:${tc.kind ?? "other"}`, input, `allowed once: ${tc.title ?? ""}`);
+        return { outcome: { outcome: "selected", optionId: allow.optionId } };
+      }
+      record(`permission:${tc.kind ?? "other"}`, input, why ?? "Refused: the server offered only to allow it always; Atticus allows once at a time", true);
+      const reject = pick(["reject_once", "reject_always"]);
+      return reject ? { outcome: { outcome: "selected", optionId: reject.optionId } } : { outcome: { outcome: "cancelled" } };
+    },
+    async terminalCreate(p) {
+      const a = atticusArgvOf(p.command, p.args ?? []);
+      const input = { command: p.command, args: p.args ?? [] };
+      if (a.refused !== void 0)
+        return refuse("terminal/create", input, a.refused);
+      const cwd = p.cwd ?? o.cwd;
+      const out = paths.readable(cwd);
+      if (out)
+        return refuse("terminal/create", input, `the command runs in the metarepo: ${out}`);
+      const id = `atticus-${++tn}`;
+      const kill = new AbortController();
+      flush();
+      say(`  atticus ${oneLine(a.argv.join(" "), 140)}`);
+      const t = {
+        output: "",
+        kill,
+        ...p.outputByteLimit ? { limit: p.outputByteLimit } : {}
+      };
+      t.done = o.exec(a.argv, {
+        cwd,
+        signal: kill.signal,
+        onOutput: (s) => {
+          t.output += s;
+          if (t.limit && Buffer.byteLength(t.output) > t.limit)
+            t.output = t.output.slice(-t.limit);
+        }
+      }).then((r) => {
+        if (!t.output && r.output)
+          t.output = r.output;
+        t.exit = { exitCode: r.exitCode, signal: r.signal ?? null };
+        record("terminal/create", input, `exit ${r.exitCode ?? "none"}: ${short(t.output, 1500)}`);
+        return t.exit;
+      });
+      terminals.set(id, t);
+      return { terminalId: id };
+    },
+    async terminalOutput(p) {
+      const t = terminals.get(p.terminalId);
+      if (!t)
+        throw new AcpRpcError(ACP_ERRORS.invalidParams, `no terminal ${p.terminalId}`);
+      return { output: t.output, truncated: false, ...t.exit ? { exitStatus: t.exit } : {} };
+    },
+    async terminalWaitForExit(p) {
+      const t = terminals.get(p.terminalId);
+      if (!t)
+        throw new AcpRpcError(ACP_ERRORS.invalidParams, `no terminal ${p.terminalId}`);
+      return t.done;
+    },
+    async terminalKill(p) {
+      terminals.get(p.terminalId)?.kill.abort();
+      return null;
+    },
+    async terminalRelease(p) {
+      const t = terminals.get(p.terminalId);
+      t?.kill.abort();
+      terminals.delete(p.terminalId);
+      return null;
+    },
+    update(u) {
+      const kind = u.sessionUpdate;
+      if (kind === UPDATE.message) {
+        const t = chunkText(u);
+        if (t) {
+          text += t;
+          pendingText += t;
+        }
+      } else if (kind === UPDATE.toolCall) {
+        agentCalls++;
+        flush();
+        say(`  \xB7 ${oneLine(String(u.title ?? u.kind ?? "a tool"), 140)}`);
+        if (o.maxTurns !== void 0 && agentCalls > o.maxTurns)
+          cancel(`maxTurns ${o.maxTurns}`);
+      } else if (kind === UPDATE.plan) {
+        const n = Array.isArray(u.entries) ? u.entries.length : 0;
+        if (n)
+          say(`  Plan: ${n} steps`);
+      }
+    }
+  };
+  const client = new AcpClient(server.transport, handlers, (dir, m) => transcript.push(JSON.stringify({ dir, m })));
+  box.client = client;
+  const onAbort = () => cancel("stopped (Ctrl+C)");
+  o.signal?.addEventListener("abort", onAbort, { once: true });
+  let timer;
+  try {
+    let init;
+    try {
+      await server.started;
+      init = await withTimeout(client.initialize({ name: "atticus", version: o.clientVersion ?? "2" }), 6e4, "The Copilot language server's initialize");
+    } catch (e) {
+      throw new RuntimeError(`Atticus couldn't start the Copilot language server (${o.command}): ${firstLine(e)}${tail(server.stderr())}. Check copilotAcp.command in runtime.yaml, and that ${command} --help lists --acp.`);
+    }
+    const assistant = {
+      name: init.agentInfo?.name ?? basename(command).replace(/\.(cmd|exe)$/i, ""),
+      ...init.agentInfo?.version ? { version: init.agentInfo.version } : {},
+      ...typeof init.protocolVersion === "number" ? { protocolVersion: init.protocolVersion } : {}
+    };
+    let ns;
+    try {
+      ns = await withTimeout(client.newSession(o.cwd), 12e4, "Opening a Copilot session");
+    } catch (e) {
+      if (isAuthRequired(e)) {
+        await new Promise((r) => setTimeout(r, 150));
+        throw signInError(e, init, server.stderr());
+      }
+      throw new RuntimeError(`The Copilot language server didn't open a session: ${firstLine(e)}`);
+    }
+    sessionId = ns.sessionId;
+    let model = ns.models?.currentModelId;
+    if (o.model && o.model !== model) {
+      const offered = (ns.models?.availableModels ?? []).map((m) => m.modelId);
+      if (!offered.includes(o.model))
+        throw new RuntimeError(`The Copilot language server doesn't offer the model ${o.model} (it offers ${offered.join(", ") || "no list"}): change copilotAcp.model in runtime.yaml, or leave it out for Copilot's own.`);
+      await client.setModel(sessionId, o.model);
+      model = o.model;
+    }
+    say(`  Copilot session open (${assistant.name}${assistant.version ? ` ${assistant.version}` : ""}${model ? `, ${model}` : ""}).`);
+    if (o.signal?.aborted)
+      cancel("stopped (Ctrl+C)");
+    const asked = client.prompt(sessionId, o.prompt);
+    timer = setTimeout(() => cancel("timeout"), o.timeoutMs ?? 30 * 6e4);
+    let answer;
+    try {
+      answer = await new Promise((res, rej) => {
+        asked.then(res, rej);
+        const watch = setInterval(() => {
+          if (!cancelWhy)
+            return;
+          clearInterval(watch);
+          setTimeout(() => res({ stopReason: "cancelled" }), 1e4);
+        }, 50);
+        asked.finally(() => clearInterval(watch)).catch(() => void 0);
+      });
+    } catch (e) {
+      if (isAuthRequired(e))
+        throw signInError(e, init, server.stderr());
+      throw new RuntimeError(`The Copilot session failed: ${firstLine(e)}${tail(server.stderr())}`);
+    }
+    flush();
+    const usage = usageOf(answer.usage);
+    return {
+      stopReason: cancelWhy ? "cancelled" : answer.stopReason,
+      ...cancelWhy ? { stopped: cancelWhy } : {},
+      ...model ? { model } : {},
+      assistant,
+      ...usage ? { usage } : {},
+      text,
+      toolCalls: calls,
+      refused,
+      agentToolCalls: agentCalls
+    };
+  } finally {
+    clearTimeout(timer);
+    o.signal?.removeEventListener("abort", onAbort);
+    abort.abort();
+    for (const t of terminals.values())
+      t.kill.abort();
+    await server.close().catch(() => void 0);
+    if (o.transcript) {
+      await mkdir4(dirname(o.transcript), { recursive: true });
+      await writeFile4(o.transcript, transcript.join("\n") + (transcript.length ? "\n" : ""), "utf8");
+    }
+  }
+}
+var firstLine = (e) => String(e?.message ?? e).split("\n")[0];
+var tail = (stderr) => {
+  const l = stderr.trim().split(/\r?\n/).slice(-2).join(" ").trim();
+  return l ? ` (it said: ${short(l, 300)})` : "";
+};
+function signInError(e, init, stderr) {
+  const how = (init.authMethods ?? []).map((m) => m.description || m.name).filter(Boolean).join("; ");
+  const lines = signInLines(stderr);
+  return new AcpSignInError([
+    `GitHub Copilot isn't signed in here, so the run stopped. The Copilot language server said: ${firstLine(e)}`,
+    ...lines.length ? [`It also said: ${lines.join(" ")}`] : [],
+    ...how ? [`Its ways to sign in: ${how}.`] : [],
+    "Sign in yourself (Copilot's sign-in in your editor, or the link and code above), then run the command again. Atticus never enters or keeps your credentials."
+  ].join("\n"));
+}
+function permissionRefused(tc, paths) {
+  const locs = (tc.locations ?? []).map((l) => l.path);
+  switch (tc.kind) {
+    case "think":
+      return void 0;
+    case "read":
+    case "search": {
+      if (!locs.length)
+        return tc.kind === "search" ? void 0 : "Refused: a read must say which file (use fs/read_text_file)";
+      for (const l of locs) {
+        const why = paths.readable(l);
+        if (why)
+          return why;
+      }
+      return void 0;
+    }
+    case "edit": {
+      if (!locs.length)
+        return "Refused: an edit must say which file it changes";
+      for (const l of locs) {
+        const why = paths.writable(l);
+        if (why)
+          return why;
+      }
+      return void 0;
+    }
+    case "execute": {
+      const raw = tc.rawInput ?? {};
+      const cmd = typeof raw.command === "string" ? raw.command : typeof raw.commandLine === "string" ? raw.commandLine : tc.title ?? "";
+      const args = Array.isArray(raw.args) ? raw.args.map(String) : [];
+      const a = atticusArgvOf(cmd, args);
+      return a.refused;
+    }
+    default:
+      return `Refused: Atticus doesn't let this session ${tc.kind ?? "do"} ${short(tc.title ?? "that")} (it may read the metarepo, write its step's result and run atticus commands)`;
+  }
+}
+async function copilotAcpProbe(o) {
+  const { command, args } = commandLineOf(o.command);
+  const plain = args.filter((a) => a !== "--acp");
+  const env = { ...process.env, ...o.env ?? {} };
+  const version = await new Promise((res) => {
+    const shell = needsShell(command);
+    let out = "";
+    let child;
+    try {
+      child = spawn(shell ? quoteForCmd(command) : command, [...shell ? plain.map(quoteForCmd) : plain, "--version"], {
+        cwd: o.cwd,
+        env,
+        stdio: ["ignore", "pipe", "pipe"],
+        windowsHide: true,
+        shell
+      });
+    } catch (e) {
+      res({ ok: false, text: e.message });
+      return;
+    }
+    const t = setTimeout(() => child.kill(), o.timeoutMs ?? 6e4);
+    child.stdout?.on("data", (d) => out += d.toString("utf8"));
+    child.stderr?.on("data", (d) => out += d.toString("utf8"));
+    child.on("error", (e) => {
+      clearTimeout(t);
+      res({ ok: false, text: e.message });
+    });
+    child.on("close", (code) => {
+      clearTimeout(t);
+      res({ ok: code === 0, text: out.trim() });
+    });
+  });
+  if (!version.ok)
+    return { found: false, said: oneLine(version.text, 200) };
+  const v = version.text.split(/\r?\n/).find((l) => l.trim())?.trim();
+  const server = (o.spawn ?? spawnAcpServer)({ command, args, cwd: o.cwd, env });
+  const client = new AcpClient(server.transport, {
+    readTextFile: () => Promise.reject(new AcpRpcError(ACP_ERRORS.invalidParams, "doctor reads nothing")),
+    writeTextFile: () => Promise.reject(new AcpRpcError(ACP_ERRORS.invalidParams, "doctor writes nothing")),
+    requestPermission: async () => ({ outcome: { outcome: "cancelled" } }),
+    terminalCreate: () => Promise.reject(new AcpRpcError(ACP_ERRORS.invalidParams, "doctor runs nothing")),
+    terminalOutput: () => Promise.reject(new AcpRpcError(ACP_ERRORS.invalidParams, "no terminal")),
+    terminalWaitForExit: () => Promise.reject(new AcpRpcError(ACP_ERRORS.invalidParams, "no terminal")),
+    terminalKill: async () => null,
+    terminalRelease: async () => null,
+    update: () => {
+    }
+  });
+  const base = { found: true, ...v ? { version: v } : {} };
+  try {
+    await server.started;
+    await withTimeout(client.initialize({ name: "atticus-doctor", version: "2" }), o.timeoutMs ?? 6e4, "initialize");
+    try {
+      await withTimeout(client.newSession(o.cwd), o.timeoutMs ?? 6e4, "a new session");
+      return { ...base, signedIn: true };
+    } catch (e) {
+      if (isAuthRequired(e)) {
+        await new Promise((r) => setTimeout(r, 150));
+        const lines = signInLines(server.stderr());
+        return { ...base, signedIn: false, said: [firstLine(e), ...lines].join(" ") };
+      }
+      return { ...base, said: firstLine(e) };
+    }
+  } catch (e) {
+    return { ...base, said: `the --acp handshake failed: ${firstLine(e)}` };
+  } finally {
+    await server.close().catch(() => void 0);
+  }
+}
+var CopilotAcpRuntime = class extends OneShotRuntime {
+  c;
+  kind = "copilot-acp";
+  constructor(c) {
+    super({ ...c.now ? { now: c.now } : {}, ...c.validate ? { validate: c.validate } : {} });
+    this.c = c;
+  }
+  allowedAs(agent) {
+    return agent.allowedRuntimes.includes("copilot-acp") ? "copilot-acp" : "hand-off";
+  }
+  modelFor() {
+    return this.c.model;
+  }
+  async produce(run, signal) {
+    const { request } = run;
+    const root = this.c.root;
+    const dir = join4(runsDirOf(root), request.change, run.runId);
+    await mkdir4(dir, { recursive: true });
+    const outRel = HandoffRuntime.outputRel(run, changesRelOf(root), runsRelOf(root));
+    const prompt = HandoffRuntime.promptFor(run, changesRelOf(root), runsRelOf(root)).replace(/\nWhen the file is complete.*\n$/s, "\n") + (request.selfCheck ? `
+Before you finish, check the file: run ${request.selfCheck.command} ${outRel}. Fix each problem it lists and run it again, until it says the file is clean (at most ${request.selfCheck.limit} times).
+` : "") + `
+${DATA_RULE}
+`;
+    await writeFile4(join4(dir, "prompt.md"), prompt, "utf8");
+    await writeFile4(join4(dir, "context-manifest.json"), JSON.stringify(request.pack.manifest, null, 2) + "\n", "utf8");
+    const outputFile = request.outputIn === "run" ? join4(dir, request.outputPath) : join4(changesDirOf(root), request.change, request.outputPath);
+    const before = (await stat2(outputFile).catch(() => void 0))?.mtimeMs;
+    const r = await runAcpSession({
+      command: this.c.command,
+      cwd: root,
+      prompt,
+      policy: { readRoots: readRootsOf(root), writeRoots: [], writeFiles: [outputFile] },
+      exec: this.c.exec ?? noExec,
+      ...this.c.model ? { model: this.c.model } : {},
+      ...this.c.maxTurns ? { maxTurns: this.c.maxTurns } : {},
+      ...this.c.timeoutMs ? { timeoutMs: this.c.timeoutMs } : {},
+      ...signal ? { signal } : {},
+      ...this.c.onProgress ? { onProgress: this.c.onProgress } : {},
+      ...this.c.env ? { env: this.c.env } : {},
+      ...this.c.spawn ? { spawn: this.c.spawn } : {},
+      ...this.c.clientVersion ? { clientVersion: this.c.clientVersion } : {},
+      transcript: join4(dir, "transcript.jsonl")
+    });
+    const after = (await stat2(outputFile).catch(() => void 0))?.mtimeMs;
+    const written = after !== void 0 && after !== before ? await readFile4(outputFile, "utf8") : void 0;
+    const tools = {
+      offered: ACP_OFFERED,
+      calls: r.toolCalls,
+      ...r.stopped ? { stopped: r.stopped } : {}
+    };
+    if (written === void 0 && r.stopReason !== "end_turn")
+      throw Object.assign(new RuntimeError(`The Copilot session ended (${r.stopped ?? r.stopReason}) without writing ${outRel}.`), { tools });
+    return {
+      output: written ?? r.text,
+      usage: r.usage ?? {
+        inputTokens: request.pack.manifest.totalTokens,
+        outputTokens: estimateTokens(r.text)
+      },
+      tools,
+      ...r.model ? { model: r.model } : {},
+      assistant: r.assistant
+    };
+  }
+  /** Kept as a hand-off run is: run.json beside the prompt, so Model runs shows it. */
+  async keep(run) {
+    const dir = join4(runsDirOf(this.c.root), run.request.change, run.runId);
+    await mkdir4(dir, { recursive: true });
+    await writeFile4(join4(dir, "run.json"), JSON.stringify(run, null, 2) + "\n", "utf8");
+  }
+};
+var noExec = async (argv) => ({
+  exitCode: 127,
+  output: `atticus ${argv.join(" ")}: this program can't run atticus commands for the session; run the step with the atticus command line.
+`
+});
+async function keepAcpRun(o) {
+  const dir = join4(runsDirOf(o.root), o.change, o.runId);
+  await mkdir4(dir, { recursive: true });
+  if (!existsSync(join4(dir, "prompt.md")))
+    await writeFile4(join4(dir, "prompt.md"), o.prompt, "utf8");
+  const r = o.result;
+  const run = {
+    runId: o.runId,
+    request: { change: o.change, agent: o.agent, outputPath: o.outputPath },
+    runtime: "copilot-acp",
+    state: o.state,
+    attempt: 1,
+    startedAt: o.startedAt,
+    finishedAt: o.finishedAt,
+    errors: o.errors,
+    ...r?.usage ? { usage: r.usage } : {},
+    ...r ? {
+      tools: {
+        offered: ACP_OFFERED,
+        calls: r.toolCalls,
+        ...r.stopped ? { stopped: r.stopped } : {}
+      }
+    } : {},
+    stepClass: o.stepClass ?? stepClassOf({ agent: o.agent }),
+    ...r?.model ? { model: r.model } : {},
+    ...r ? { assistant: r.assistant } : {}
+  };
+  await writeFile4(join4(dir, "run.json"), JSON.stringify(run, null, 2) + "\n", "utf8");
+  return dir;
+}
+
+// packages/ai/dist/factory.js
 var RUNTIME_MODES = RuntimeKind.options;
-var CONFIGURED = ["hand-off", "model", "headless-claude-code"];
+var CONFIGURED = [
+  "hand-off",
+  "model",
+  "headless-claude-code",
+  "copilot-acp"
+];
 var RuntimeConfigError = class extends RuntimeError {
   constructor(message) {
     super(message);
@@ -1717,7 +2722,7 @@ var AiOffError = class extends RuntimeConfigError {
   }
 };
 function claudeCodeCliRunner(o = {}) {
-  return (i) => collectChild(() => spawn(o.command ?? "claude", i.args, {
+  return (i) => collectChild(() => spawn2(o.command ?? "claude", i.args, {
     cwd: i.cwd,
     env: { ...process.env, ...i.env },
     stdio: ["pipe", "pipe", "pipe"],
@@ -1726,7 +2731,7 @@ function claudeCodeCliRunner(o = {}) {
   }), i.prompt, i.timeoutMs, i.cwd);
 }
 function collectChild(start, prompt, timeoutMs, cwd, platform = process.platform) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     let done = false;
     const timer = {};
     const fail = (e) => {
@@ -1758,16 +2763,16 @@ function collectChild(start, prompt, timeoutMs, cwd, platform = process.platform
         return;
       done = true;
       clearTimeout(timer.id);
-      resolve({ exitCode: code, stdout, stderr });
+      resolve2({ exitCode: code, stdout, stderr });
     });
     child.stdin.end(prompt, "utf8");
   });
 }
-var cloneDirs = (root) => [join4(root, "workspace"), join4(stateDirOf(root), "workspace")];
+var cloneDirs = (root) => [join5(root, "workspace"), join5(stateDirOf(root), "workspace")];
 async function existingDirs(dirs) {
   const out = [];
   for (const d of [...new Set(dirs)])
-    if ((await stat2(d).catch(() => void 0))?.isDirectory())
+    if ((await stat3(d).catch(() => void 0))?.isDirectory())
       out.push(d);
   return out;
 }
@@ -1804,9 +2809,9 @@ var HeadlessClaudeCodeRuntime = class _HeadlessClaudeCodeRuntime extends OneShot
   }
   async produce(run, signal) {
     const { request } = run;
-    const dir = join4(runsDirOf(this.h.root), request.change, run.runId);
+    const dir = join5(runsDirOf(this.h.root), request.change, run.runId);
     const reviewer = request.agent.outputArtifact === "findings" && request.outputIn === "run";
-    const work = reviewer ? await mkdtemp(join4(tmpdir(), "atticus-review-")) : void 0;
+    const work = reviewer ? await mkdtemp(join5(tmpdir(), "atticus-review-")) : void 0;
     const clones = work ? await existingDirs(cloneDirs(this.h.root)) : [];
     const base = work ? {
       cwd: work,
@@ -1820,27 +2825,27 @@ var HeadlessClaudeCodeRuntime = class _HeadlessClaudeCodeRuntime extends OneShot
         `Bash(${request.selfCheck.command}:*)`
       ]
     } : base;
-    await mkdir4(dir, { recursive: true });
-    const promptFile = join4(dir, "prompt.md");
+    await mkdir5(dir, { recursive: true });
+    const promptFile = join5(dir, "prompt.md");
     const self = reviewer ? void 0 : request.selfCheck;
     const handoff = HandoffRuntime.promptFor(run, changesRelOf(this.h.root), runsRelOf(this.h.root)).replace(/\nWhen the file is complete.*\n$/s, "\n") + // W3a: the drafter checks its own file with the stage's checks before it finishes.
     (self ? `
 Before you finish, check the file: run ${self.command} ${HandoffRuntime.outputRel(run, changesRelOf(this.h.root), runsRelOf(this.h.root))}. Fix each problem it lists and run it again, until it says the file is clean (at most ${self.limit} times).
 ` : "");
     const prompt = reviewer ? handoff.replace(`Write the result to ${HandoffRuntime.outputRel(run, changesRelOf(this.h.root), runsRelOf(this.h.root))}.`, `Write the result to ${request.outputPath}.${clones.length ? ` The metarepo is at ${this.h.root}: a folder named relative to the metarepo (the repos' clones under workspace/) is there, to read, never to edit.` : ""}`) : handoff;
-    await writeFile4(promptFile, prompt, "utf8");
-    await writeFile4(join4(dir, "context-manifest.json"), JSON.stringify(request.pack.manifest, null, 2) + "\n", "utf8");
-    if (!await stat2(inv.cwd).catch(() => void 0))
+    await writeFile5(promptFile, prompt, "utf8");
+    await writeFile5(join5(dir, "context-manifest.json"), JSON.stringify(request.pack.manifest, null, 2) + "\n", "utf8");
+    if (!await stat3(inv.cwd).catch(() => void 0))
       throw new RuntimeError(`the worktree ${inv.cwd} doesn't exist`);
-    const outputFile = work ? join4(work, request.outputPath) : request.outputIn === "run" ? join4(dir, request.outputPath) : join4(changesDirOf(this.h.root), request.change, request.outputPath);
+    const outputFile = work ? join5(work, request.outputPath) : request.outputIn === "run" ? join5(dir, request.outputPath) : join5(changesDirOf(this.h.root), request.change, request.outputPath);
     try {
       return await this.runIn(run, dir, inv, prompt, promptFile, outputFile, signal);
     } finally {
       if (work) {
-        const kept = await readFile4(outputFile, "utf8").catch(() => void 0);
+        const kept = await readFile5(outputFile, "utf8").catch(() => void 0);
         if (kept !== void 0) {
-          await mkdir4(dirname(join4(dir, request.outputPath)), { recursive: true });
-          await writeFile4(join4(dir, request.outputPath), kept, "utf8");
+          await mkdir5(dirname2(join5(dir, request.outputPath)), { recursive: true });
+          await writeFile5(join5(dir, request.outputPath), kept, "utf8");
         }
         await rm2(work, { recursive: true, force: true, maxRetries: 5 }).catch(() => void 0);
       }
@@ -1848,7 +2853,7 @@ Before you finish, check the file: run ${self.command} ${HandoffRuntime.outputRe
   }
   async runIn(run, dir, inv, prompt, promptFile, outputFile, signal) {
     const { request } = run;
-    const before = (await stat2(outputFile).catch(() => void 0))?.mtimeMs;
+    const before = (await stat3(outputFile).catch(() => void 0))?.mtimeMs;
     const res = await this.runner({
       cwd: inv.cwd,
       prompt,
@@ -1864,7 +2869,7 @@ Before you finish, check the file: run ${self.command} ${HandoffRuntime.outputRe
       timeoutMs: this.h.timeoutMs ?? 30 * 6e4,
       ...signal ? { signal } : {}
     });
-    await writeFile4(join4(dir, "claude-output.json"), res.stdout, "utf8");
+    await writeFile5(join5(dir, "claude-output.json"), res.stdout, "utf8");
     let parsed;
     try {
       parsed = JSON.parse(res.stdout);
@@ -1874,8 +2879,8 @@ Before you finish, check the file: run ${self.command} ${HandoffRuntime.outputRe
     const text = typeof parsed.result === "string" ? parsed.result : "";
     if (res.exitCode !== 0 || parsed.is_error === true)
       throw new RuntimeError(`Claude Code reported a failure: ${text || res.stderr.trim()}`);
-    const after = (await stat2(outputFile).catch(() => void 0))?.mtimeMs;
-    const written = after !== void 0 && after !== before ? await readFile4(outputFile, "utf8") : void 0;
+    const after = (await stat3(outputFile).catch(() => void 0))?.mtimeMs;
+    const written = after !== void 0 && after !== before ? await readFile5(outputFile, "utf8") : void 0;
     return {
       output: written ?? text,
       usage: {
@@ -1920,6 +2925,10 @@ var toolSource;
 function registerToolSource(source) {
   toolSource = source;
 }
+var acpRunner;
+function registerCopilotAcp(o) {
+  acpRunner = o;
+}
 function classModels(rt, o) {
   const by = modelsByClass(rt, o.env ?? {});
   const out = {};
@@ -1941,17 +2950,19 @@ function classModels(rt, o) {
 }
 var told = /* @__PURE__ */ new WeakMap();
 var nonEmpty = async (file, request) => {
-  const text = await readFile4(file, "utf8").catch(() => "");
+  const text = await readFile5(file, "utf8").catch(() => "");
   return text.trim() ? [] : [`${request.outputPath} is empty`];
 };
 async function createRuntime(orgPack, o) {
   const rt = orgPack.runtime;
-  const mode = o.mode ?? rt.modes.default;
+  const asked = o.mode ?? rt.modes.default;
+  const inSession = !!(o.env ?? process.env).ATTICUS_ACP_SESSION;
+  const mode = asked === "copilot-acp" && inSession ? "hand-off" : asked;
   if (!RUNTIME_MODES.includes(mode))
     throw new RuntimeConfigError(`There is no AI mode called ${String(mode)}. Use one of: ${RUNTIME_MODES.join(", ")}.`);
   if (rt.ai === "off" && CONFIGURED.includes(mode))
     throw new AiOffError();
-  if (CONFIGURED.includes(mode) && !rt.modes.allowed.includes(mode))
+  if (CONFIGURED.includes(mode) && !rt.modes.allowed.includes(mode) && !(inSession && asked === "copilot-acp"))
     throw new RuntimeConfigError(`runtime.yaml doesn't allow ${mode} mode (allowed: ${rt.modes.allowed.join(", ")}). Change modes.allowed in a pull request, or pick an allowed mode.`);
   const one = { ...o.now ? { now: o.now } : {}, ...o.validate ? { validate: o.validate } : {} };
   switch (mode) {
@@ -1999,6 +3010,22 @@ async function createRuntime(orgPack, o) {
         ...o.validate ? { validate: o.validate } : {}
       });
     }
+    case "copilot-acp": {
+      if (!rt.assistants.allowed.includes("copilot"))
+        throw new RuntimeConfigError("copilot-acp drives GitHub Copilot, which runtime.yaml doesn't list under assistants.allowed.");
+      const c = copilotAcpOf(rt);
+      return new CopilotAcpRuntime({
+        root: o.root,
+        command: c.command,
+        ...c.model ? { model: c.model } : {},
+        maxTurns: c.maxTurns,
+        timeoutMs: c.timeoutMs,
+        ...acpRunner,
+        ...o.copilotAcp,
+        ...o.now ? { now: o.now } : {},
+        ...o.validate ? { validate: o.validate } : {}
+      });
+    }
     case "replay":
       if (o.recordings)
         return new ReplayRuntime(o.recordings, one);
@@ -2015,13 +3042,13 @@ var sayOnce = (line) => process.stderr.write(`${line}
 `);
 async function runtimeForCli(root, o = {}) {
   const env = o.env ?? process.env;
-  const op = await loadOrgPack(join4(orgPackDirOf(root)));
+  const op = await loadOrgPack(join5(orgPackDirOf(root)));
   const bad = op.problems.filter((p) => p.file === "runtime.yaml");
   if (bad.length)
     throw new RuntimeConfigError(`org-pack/runtime.yaml has problems: ${bad.map((p) => `${p.path ? `${p.path}: ` : ""}${p.message}`).join("; ")}`);
   const asked = o.mode ?? env.ATTICUS_RUNTIME ?? op.runtime.modes.default;
   if (asked === "mock")
-    throw new RuntimeConfigError("Mock mode is for tests; use hand-off, model, headless-claude-code or replay.");
+    throw new RuntimeConfigError("Mock mode is for tests; use hand-off, model, headless-claude-code, copilot-acp or replay.");
   const mode = asked;
   const runtime = await createRuntime(op, {
     root,
@@ -2029,13 +3056,14 @@ async function runtimeForCli(root, o = {}) {
     ...env.ATTICUS_REPLAY_DIR ? { replayDir: env.ATTICUS_REPLAY_DIR } : {},
     ...o.providers ? { providers: o.providers } : {},
     ...o.headless ? { headless: o.headless } : {},
+    ...o.copilotAcp ? { copilotAcp: o.copilotAcp } : {},
     ...o.handoffValidate ? { handoffValidate: o.handoffValidate } : {},
     // ADR 0121 addendum: the person's model per kind of step, and a model passed over said once.
     env,
     onNote: o.onNote ?? sayOnce
   });
-  const describe = mode === "hand-off" ? "AI steps are handed to your assistant: Atticus writes the prompt and waits for atticus handoff done." : mode === "model" ? `AI steps call the ${op.runtime.adapters.model?.type ?? "configured"} model directly.` : mode === "headless-claude-code" ? "AI steps run in headless Claude Code." : "AI steps replay recorded answers.";
-  return { runtime, mode, describe };
+  const describe = runtime.kind === "hand-off" ? "AI steps are handed to your assistant: Atticus writes the prompt and waits for atticus handoff done." : mode === "model" ? `AI steps call the ${op.runtime.adapters.model?.type ?? "configured"} model directly.` : mode === "headless-claude-code" ? "AI steps run in headless Claude Code." : mode === "copilot-acp" ? "AI steps run in GitHub Copilot, unattended, one new session each (copilot-acp)." : "AI steps replay recorded answers.";
+  return { runtime, mode: runtime.kind === "hand-off" ? "hand-off" : mode, describe };
 }
 
 // packages/ai/dist/attempts.js
@@ -2131,8 +3159,8 @@ var HashEmbedder = class {
       return { i: h.readUInt32BE(0) % this.dim, sign: h[4] & 1 ? 1 : -1 };
     };
     for (const m of text.matchAll(/[A-Za-z0-9]+/g)) {
-      const words = [m[0].toLowerCase(), ...identifierWords(m[0])];
-      for (const w of new Set(words)) {
+      const words2 = [m[0].toLowerCase(), ...identifierWords(m[0])];
+      for (const w of new Set(words2)) {
         if (w.length < 3)
           continue;
         const b = bucket(`w:${w}`);
@@ -2689,6 +3717,27 @@ export {
   ModelRuntime,
   HandoffRuntime,
   pruneRuns,
+  ACP_PROTOCOL_VERSION,
+  ACP_METHODS,
+  ACP_ERRORS,
+  AcpRpcError,
+  AcpClient,
+  chunkText,
+  UPDATE,
+  usageOf,
+  isAuthRequired,
+  commandLineOf,
+  atticusArgvOf,
+  factsOnly,
+  readRootsOf,
+  spawnAcpServer,
+  atticusExec,
+  AcpSignInError,
+  ACP_OFFERED,
+  runAcpSession,
+  copilotAcpProbe,
+  CopilotAcpRuntime,
+  keepAcpRun,
   RUNTIME_MODES,
   RuntimeConfigError,
   AiOffError,
@@ -2703,6 +3752,7 @@ export {
   registeredModelProviders,
   clearModelProviders,
   registerToolSource,
+  registerCopilotAcp,
   createRuntime,
   runtimeForCli,
   resumedAttempt,