@maycombhq/atticus 2.0.0-beta.2 → 2.0.0-beta.21

package/dist/{chunk-CNUKCS2T.js → chunk-QHJJMZLX.js}

@@ -13,6 +13,7 @@ import {
   STEP_CLASSES,
   changesDirOf,
   changesRelOf,
+  copilotAcpOf,
   currentSignal,
   differentThings,
   identifierWords,
@@ -27,14 +28,114 @@ import {
   runsRelOf,
   stateDirOf,
   stepModelsOf
-} from "./chunk-S2A7YC3Q.js";
+} from "./chunk-PAINMSID.js";
 import {
   writeFileAtomic
-} from "./chunk-D3PO4DOZ.js";
+} from "./chunk-ODMBPDDV.js";
 import {
   __toESM
 } from "./chunk-TV45EUGM.js";
 
+// packages/ai/dist/person-only.js
+var flag = (a, ...names) => a.some((x) => names.some((n) => x === n || x.startsWith(`${n}=`)));
+var RULES = [
+  {
+    test: (w, a) => w[0] === "change" && w[1] === "release-prs" && flag(a, "--approve"),
+    why: "a person raises the release PRs into each repo's default branch (ADR 0184); a session never approves a push or a PR"
+  },
+  {
+    test: (w, a) => w[0] === "task" && w[1] === "run-ready" && flag(a, "--approve"),
+    why: "a person approves each ready task's push and PR into the change branch (ADR 0181); a session never approves a push or a PR"
+  },
+  { test: (w) => w[0] === "questions" && w[1] === "answer", why: "a person answers questions" },
+  {
+    // ADR 0181: the AI decides as itself, through Atticus; correcting it, spreading the
+    // correction and undoing a batch are a person's word.
+    test: (w) => w[0] === "questions" && (w[1] === "correct" || w[1] === "undo"),
+    why: "a person corrects an AI decision and undoes a batch of decisions (ADR 0181); the AI decides only as itself, through Atticus"
+  },
+  {
+    test: (w, a) => w[0] === "questions" && w[1] === "sheet" && flag(a, "--apply"),
+    why: "a person answers questions (questions sheet --apply answers as them)"
+  },
+  {
+    test: (w, a) => w[0] === "verify" && w[1] === "audit" && flag(a, "--right", "--wrong", "--unsure", "--answers"),
+    why: "a person answers an audit: its record says who confirmed each fact"
+  },
+  {
+    test: (w) => w[0] === "knowledge" && ["verify", "correct", "reject"].includes(w[1] ?? ""),
+    why: "a person verifies, corrects or rejects a knowledge item"
+  },
+  { test: (w) => w[1] === "accept", why: "a person accepts what is proposed" },
+  { test: (w) => w[0] === "baseline", why: "a person accepts the catalog as the baseline" },
+  { test: (w) => w[0] === "triage" && w[1] === "decide", why: "a person decides a triage item" },
+  { test: (w) => w[0] === "finding", why: "a person acts on a finding (it is recorded with them)" },
+  {
+    test: (w) => w[0] === "feature" && ["name", "link"].includes(w[1] ?? ""),
+    why: "a person names a feature or links it to work"
+  },
+  { test: (w) => w[0] === "todo" && w[1] === "done", why: "a person records a manual step done" },
+  {
+    test: (w) => {
+      const n = w[0] === "change" && w[1] === "needs" ? w.slice(1) : w;
+      return n[0] === "needs" && ["done", "skip"].includes(n[1] ?? "");
+    },
+    why: "a person records a need done or not needed"
+  },
+  { test: (_w, a) => flag(a, "--by"), why: "--by names a person; a session acts as no one" },
+  {
+    test: (_w, a) => flag(a, "--approve", "--send"),
+    why: "--approve and --send are a person's: a human approves every write to shared systems"
+  },
+  { test: (_w, a) => flag(a, "--as"), why: "--as names a person; a session acts as no one" },
+  {
+    test: (w, a) => w[0] === "rules" && (w[1] === "activate" || w[1] === "off" || w[1] === "add" && !flag(a, "--draft")),
+    why: "a person sets a reading rule active or off (a session drafts)"
+  },
+  {
+    test: (w) => w[0] === "initiative" && ["commit", "new", "plan", "request"].includes(w[1] ?? ""),
+    why: "a person starts, plans and records an initiative"
+  },
+  {
+    test: (w) => w[0] === "questions" && w[1] === "owner",
+    why: "an owner answers a knowledge gap's question"
+  },
+  { test: (w) => w[0] === "outcome" && w[1] === "record", why: "a person records an outcome" },
+  {
+    test: (_w, a) => flag(a, "--accept", "--accept-proposal"),
+    why: "a person accepts what is proposed (--accept is theirs)"
+  },
+  {
+    test: (w, a) => w[0] === "repo" && (w[1] === "add" || w[1] === "describe" && flag(a, "--description", "--reject")),
+    why: "a person adds a repo and writes or drops its description (a session drafts with --drafted)"
+  },
+  {
+    test: (w) => w[0] === "knowledge" && w[1] === "keep",
+    why: "a person keeps a knowledge item (it is recorded as verified by them)"
+  },
+  { test: (w) => w[0] === "alias", why: "a person decides what a name means" },
+  {
+    test: (w) => w[0] === "glossary" && ["define", "link", "alias"].includes(w[1] ?? ""),
+    why: "a person defines, links or aliases a glossary term"
+  },
+  {
+    // Seventh UX walk: shown by anyone; set (a handle given) only by a person, as in the app.
+    test: (w) => w[0] === "orgpack" && w[1] === "owner" && !!w[2],
+    why: "a person says who looks after the org pack"
+  }
+];
+function personOnlyWhy(argv) {
+  const words2 = [];
+  for (const x of argv) {
+    if (x.startsWith("-"))
+      break;
+    words2.push(x);
+  }
+  return RULES.find((r) => r.test(words2, argv))?.why;
+}
+var isPersonsFactsFile = (name) => /\.audit\.yaml$|\.corrections\.jsonl$/i.test(windowsName(name));
+var windowsName = (name) => name.replace(/:.*$/, "").replace(/[. ]+$/, "");
+
 // packages/ai/dist/context.js
 import { createHash as createHash2 } from "node:crypto";
 
@@ -1018,6 +1119,10 @@ var NEXT_CLASS = {
   survey: "draft",
   verify: "read",
   map: "read",
+  // ADR 0141: a mapped repo read again where its clone moved on.
+  reread: "read",
+  // ADR 0167: a read repo topped up for reading rules added since.
+  rules: "read",
   spec: "draft",
   knowledge: "knowledge",
   feature: "draft",
@@ -1107,8 +1212,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 {
@@ -1128,7 +1233,10 @@ 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 } : {},
+    ...run.batch ? { batch: run.batch } : {},
+    ...run.parts?.length ? { parts: run.parts } : {}
   };
 }
 var OneShotRuntime = class {
@@ -1145,11 +1253,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}`);
     }
@@ -1177,8 +1289,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) {
@@ -1538,6 +1656,36 @@ ${DATA_RULE}`;
 // packages/ai/dist/handoff.js
 import { mkdir as mkdir3, readdir as readdir3, readFile as readFile3, rm, stat, writeFile as writeFile3 } from "node:fs/promises";
 import { join as join3 } from "node:path";
+var BATCH_OUTPUT = "answers.md";
+var DEFAULT_BATCH_MAX_TOKENS = 6e4;
+var SECTION = /^===[ \t]*([a-z][a-z0-9-]*)[ \t]*$/;
+function batchSections(text) {
+  const out = /* @__PURE__ */ new Map();
+  let name;
+  let lines = [];
+  const end = () => {
+    if (name === void 0)
+      return;
+    while (lines.length && !lines[0].trim())
+      lines.shift();
+    while (lines.length && !lines.at(-1).trim())
+      lines.pop();
+    const body = lines.length ? `${lines.join("\n")}
+` : "";
+    out.set(name, out.has(name) ? { text: body, twice: true } : { text: body });
+  };
+  for (const line of text.replace(/\r\n/g, "\n").split("\n")) {
+    const m = SECTION.exec(line);
+    if (m) {
+      end();
+      name = m[1];
+      lines = [];
+    } else
+      lines.push(line);
+  }
+  end();
+  return out;
+}
 var HandoffRuntime = class _HandoffRuntime {
   o;
   kind = "hand-off";
@@ -1563,6 +1711,39 @@ var HandoffRuntime = class _HandoffRuntime {
     const { outputPath, change } = run.request;
     return run.request.outputIn === "run" ? `${runsRel}/${change}/${run.runId}/${outputPath}` : `${changesRel}/${change}/${outputPath}`;
   }
+  /**
+   * A batched hand-off's prompt (ADR 0185): one section to write per part, then each part's own
+   * prompt, whole and in order, under its name. It ends with the completion command.
+   */
+  static promptForBatch(run, parts, changesRel = "openspec/changes", runsRel = ".runs") {
+    const { agent, change } = run.request;
+    const where = _HandoffRuntime.outputRel(run, changesRel, runsRel);
+    const n = parts.length;
+    return [
+      `# ${agent.id}: ${n} parts for change ${change}, in one answer`,
+      "",
+      agent.description,
+      "",
+      `Write the result to ${where}. Change no other files.`,
+      "",
+      `The file holds one section per part below. Start each section with a line that holds only "=== " and the part's name, then write that part's answer exactly as the part asks for it, and nothing else. Answer each part from its own instructions and its own data only: the parts are separate. Leave no part out. Atticus checks each section on its own, as if that part were answered alone: a section that is missing or fails its check is asked for again, and the others are kept.`,
+      "",
+      ...parts.flatMap((p) => [`=== ${p.name}`, `<the ${p.name} part's answer>`]),
+      "",
+      ...parts.flatMap((p, i) => [
+        "---",
+        "",
+        `Part ${i + 1} of ${n}: ${p.name}. Its answer is the section "=== ${p.name}".`,
+        "",
+        p.prompt.trimEnd(),
+        ""
+      ]),
+      "---",
+      "",
+      `When the file is complete, run: atticus handoff done ${run.runId}`,
+      ""
+    ].join("\n");
+  }
   /** The prompt the person's assistant gets. It ends with the completion command. */
   static promptFor(run, changesRel = "openspec/changes", runsRel = ".runs") {
     const { agent, pack, outputPath, change } = run.request;
@@ -1580,15 +1761,96 @@ var HandoffRuntime = class _HandoffRuntime {
       ""
     ].join("\n");
   }
+  /** A run id no run folder of the change has yet. */
+  async freshId(change, now) {
+    let runId = makeRunId(now, ++this.seq);
+    while (await stat(this.runDir(change, runId)).catch(() => void 0))
+      runId = makeRunId(now, ++this.seq);
+    return runId;
+  }
+  /**
+   * Whether `parts` runs that wait together, `tokens` in all, are asked in one prompt (ADR 0185):
+   * only when this runtime batches, for two parts or more, within the size a batch may hold.
+   */
+  canBatch(parts, tokens) {
+    return !!this.o.batch && parts >= 2 && tokens <= (this.o.batchMaxTokens ?? DEFAULT_BATCH_MAX_TOKENS);
+  }
+  /**
+   * Ask several waiting runs of one change in one prompt (ADR 0185). Each part keeps its own run,
+   * prompt, pack and answer file, and can still be answered alone; the batch links them, and each
+   * part names the batch. The batch's pack is its parts' packs together: their sources, each id
+   * under its part's name, and their sizes added up. Run it (`run`) to hand it over.
+   */
+  async prepareBatch(o) {
+    checkAllowed(this.kind, o.agent);
+    if (o.parts.length < 2)
+      throw new RuntimeError("a batched hand-off needs two parts or more");
+    const twice = o.parts.find((p, i) => o.parts.findIndex((x) => x.name === p.name) !== i);
+    if (twice)
+      throw new RuntimeError(`a batched hand-off can't have two parts named ${twice.name}`);
+    const parts = [];
+    for (const p of o.parts) {
+      const run2 = await this.load(p.runId);
+      if (run2.request.change !== o.change)
+        throw new RuntimeError(`run ${p.runId} isn't a run of ${o.change}`);
+      if (run2.state !== "waiting" && run2.state !== "prepared")
+        throw new RuntimeError(`run ${p.runId} is ${run2.state}: only a run still waiting for its answer can be batched`);
+      if (run2.batch)
+        throw new RuntimeError(`run ${p.runId} is already asked in ${run2.batch}`);
+      parts.push({ name: p.name, run: run2 });
+    }
+    const now = this.now();
+    const runId = await this.freshId(o.change, now);
+    const manifests = parts.map((p) => ({ name: p.name, m: p.run.request.pack.manifest }));
+    const totalTokens = manifests.reduce((n, x) => n + x.m.totalTokens, 0);
+    const agent = { ...o.agent, tokenBudget: Math.max(o.agent.tokenBudget, totalTokens) };
+    const run = {
+      runId,
+      request: {
+        change: o.change,
+        agent,
+        pack: { prompt: "", manifest: manifests[0].m },
+        outputPath: BATCH_OUTPUT,
+        outputIn: "run",
+        ...o.stepClass ? { stepClass: o.stepClass } : {}
+      },
+      runtime: this.kind,
+      state: "prepared",
+      attempt: 1,
+      startedAt: now.toISOString(),
+      errors: [],
+      stepClass: o.stepClass ?? stepClassOf({ agent }),
+      parts: parts.map((p) => ({ name: p.name, runId: p.run.runId }))
+    };
+    const prompt = _HandoffRuntime.promptForBatch(run, parts.map((p) => ({ name: p.name, prompt: p.run.request.pack.prompt })), changesRelOf(this.o.root), runsRelOf(this.o.root));
+    const manifest = {
+      schemaVersion: 1,
+      change: o.change,
+      agent: o.agent.id,
+      createdAt: now.toISOString(),
+      budget: manifests.reduce((n, x) => n + x.m.budget, 0),
+      totalTokens,
+      sources: manifests.flatMap((x) => x.m.sources.map((s) => ({ ...s, id: `${x.name}/${s.id}` }))),
+      dropped: manifests.flatMap((x) => x.m.dropped.map((d) => ({ ...d, id: `${x.name}/${d.id}` }))),
+      promptSha256: sha2562(prompt)
+    };
+    run.request.pack = { prompt, manifest };
+    const dir = this.runDir(o.change, runId);
+    await mkdir3(dir, { recursive: true });
+    await writeFile3(join3(dir, "prompt.md"), prompt, "utf8");
+    await writeFile3(join3(dir, "context-manifest.json"), JSON.stringify(manifest, null, 2) + "\n", "utf8");
+    await this.save(run);
+    for (const p of parts)
+      await this.save({ ...p.run, batch: runId });
+    return run;
+  }
   async prepare(request) {
     checkAllowed(this.kind, 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}`);
     }
     const now = this.now();
-    let runId = makeRunId(now, ++this.seq);
-    while (await stat(this.runDir(request.change, runId)).catch(() => void 0))
-      runId = makeRunId(now, ++this.seq);
+    const runId = await this.freshId(request.change, now);
     const run = {
       runId,
       request,
@@ -1622,6 +1884,8 @@ var HandoffRuntime = class _HandoffRuntime {
   async done(runId, o = {}) {
     let run = await this.load(runId);
     const model = o.model?.trim();
+    if (run.parts?.length)
+      return this.doneBatch(run, model);
     if (model)
       run = { ...run, model };
     if (run.state === "failed") {
@@ -1645,8 +1909,61 @@ var HandoffRuntime = class _HandoffRuntime {
       return run;
     if (this.now().getTime() - info.mtimeMs < (this.o.stableMs ?? 3e4))
       return run;
+    if (run.parts?.length)
+      return this.doneBatch(run);
     return this.validate(transition(run, "produced", this.now()));
   }
+  /**
+   * A batched hand-off's Done (ADR 0185): its answer is split into its parts' sections, each
+   * written to its part's own answer file and checked there as that part's Done would check it.
+   * A part that passes is in; a missing, doubled or failing section fails only its part, which can
+   * be fixed in the batch (Done again checks only the parts still out) or answered alone. The
+   * batch passes once every part is in; until then it fails, naming each part that is out and why.
+   */
+  async doneBatch(start, model) {
+    let run = start;
+    if (run.state === "validated" || run.state === "cancelled")
+      return run;
+    if (run.state === "failed")
+      run = transition(transition(run, "prepared", this.now(), { attempt: run.attempt + 1, errors: [] }), "waiting", this.now());
+    if (model)
+      run = { ...run, model };
+    const output = await readFile3(this.outputFile(run), "utf8").catch(() => void 0);
+    if (output === void 0)
+      return this.save(transition(run, "failed", this.now(), {
+        errors: [`${run.request.outputPath} was not written`]
+      }));
+    const names = run.parts.map((p) => p.name);
+    const sections = batchSections(output);
+    if (!names.some((n) => sections.has(n)))
+      return this.save(transition(run, "failed", this.now(), {
+        output,
+        errors: [
+          `${run.request.outputPath} has no section of any part. Start each part's answer with its own line "=== <part>": ${names.map((n) => `=== ${n}`).join(", ")}.`
+        ]
+      }));
+    run = transition(run, "produced", this.now(), { output });
+    const errors = [];
+    const runsRel = runsRelOf(this.o.root);
+    for (const p of run.parts) {
+      const part = await this.load(p.runId);
+      if (part.state === "validated" || part.state === "cancelled")
+        continue;
+      const s = sections.get(p.name);
+      const alone = `answer that part alone: its prompt is ${_HandoffRuntime.promptRel(part, runsRel)}.`;
+      if (!s || s.twice) {
+        errors.push(s ? `${p.name}: the answer has two "=== ${p.name}" sections. Keep one, or ${alone}` : `${p.name}: the answer has no "=== ${p.name}" section. Add it, or ${alone}`);
+        const why = `The batched answer (run ${run.runId}) has ${s ? 'two "=== ' + p.name + '" sections' : 'no "=== ' + p.name + '" section'}. Answer this part here.`;
+        await this.save(part.state === "failed" ? { ...part, errors: [why] } : transition(part, "failed", this.now(), { errors: [why] }));
+        continue;
+      }
+      await writeFile3(this.outputFile(part), s.text, "utf8");
+      const r = await this.done(p.runId, model ? { model } : {});
+      if (r.state !== "validated")
+        errors.push(...r.errors.map((e) => `${p.name}: ${e}`));
+    }
+    return this.save(errors.length ? transition(run, "failed", this.now(), { errors }) : transition(run, "validated", this.now()));
+  }
   /** Retry after a failure: a fresh attempt with the same request. */
   async retry(runId) {
     const run = await this.load(runId);
@@ -1695,12 +2012,1064 @@ 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 { existsSync as existsSync2 } from "node:fs";
+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 = [
+  // What only a person does is personOnlyWhy's list (person-only.ts), shared with the CLI.
+  {
+    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}.` };
+  if (argv[0].startsWith("-") && !["--help", "--version", "-h"].includes(argv[0]))
+    return {
+      refused: `Put the command first: atticus <command> [arguments] (got ${short(argv.join(" "))})`
+    };
+  const person = personOnlyWhy(argv);
+  if (person)
+    return { refused: `Refused: ${person}; Atticus lets a session act as no one.` };
+  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)})`;
+    const parts = r.split(sep).slice(/^[A-Za-z]:$/.test(r.split(sep)[0] ?? "") ? 1 : 0);
+    if (parts.some((x) => x !== "." && x !== ".." && (/[. ]$/.test(x) || x.includes(":"))))
+      return `Atticus never lets a session write a name that ends in a dot or space or names a stream (${short(path)})`;
+    if (isPersonsFactsFile(basename(r)))
+      return `Atticus never lets a session write a person's record (${short(path)}: an audit's answers or a person's corrections)`;
+    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 acpPathsOf = (p) => new Paths(p);
+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, platform = process.platform) => platform === "win32" && !/\.(exe|com)$/i.test(command);
+var quoteForCmd = (a) => /[\s"]/.test(a) ? `"${a.replace(/"/g, '""')}"` : a;
+function killTree(child, platform = process.platform, run = spawn) {
+  if (platform === "win32" && child.pid) {
+    try {
+      const k = run("taskkill", ["/pid", String(child.pid), "/T", "/F"], {
+        windowsHide: true,
+        stdio: "ignore"
+      });
+      k.on("error", () => child.kill());
+      return;
+    } catch {
+    }
+  }
+  child.kill();
+}
+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(() => {
+          killTree(child);
+          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 AcpSetupError = class extends RuntimeError {
+  constructor(message) {
+    super(message);
+    this.name = "AcpSetupError";
+  }
+};
+var MAX_NUDGES = 3;
+function carryOnPrompt(refusals) {
+  return [
+    "Atticus refused this, and you are not finished yet:",
+    ...refusals.slice(-3).map((r) => `- ${oneLine(r, 300)}`),
+    "",
+    "Carry on with the step. Use your own file tools to find, view and search files: they are allowed and need no shell. Don't run shell commands (cd, dir, Get-ChildItem, Select-String, Get-Content, grep, find); the only command Atticus runs is one `atticus ...` command at a time, with nothing piped or chained. The step says where its files are. Finish what the step asks for (the facts, or the result file it names), then stop."
+  ].join("\n");
+}
+function sumUsage(us) {
+  if (!us.length)
+    return void 0;
+  const out = {};
+  for (const u of us)
+    for (const [k, v] of Object.entries(u))
+      out[k] = typeof v === "number" ? (out[k] ?? 0) + v : out[k] ?? v;
+  return out;
+}
+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,
+    // beta.17: set on the server too, so an atticus command Copilot runs in its own shell (not
+    // through Atticus's terminal) knows it is inside a session and hands off instead of starting
+    // a Copilot session of its own (a session within a session, waiting on itself).
+    env: { ...process.env, ...o.env ?? {}, ATTICUS_ACP_SESSION: "1", ATTICUS_ROOT: o.cwd }
+  });
+  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 textAtRefusal = 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) {
+      textAtRefusal = text.length;
+      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 = o.cwd;
+      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 AcpSetupError(`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 AcpSetupError(`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 AcpSetupError(`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)");
+    timer = setTimeout(() => cancel("timeout"), o.timeoutMs ?? 30 * 6e4);
+    let prompt = o.prompt;
+    let answer = {
+      stopReason: "end_turn"
+    };
+    const usages = [];
+    for (let nudge = 0; ; nudge++) {
+      const before = refused.length;
+      const asked = client.prompt(sessionId, prompt);
+      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();
+      if (answer.usage)
+        usages.push(answer.usage);
+      const fresh = refused.slice(before);
+      const after = text.slice(textAtRefusal);
+      const overIt = fresh.length > 0 && !!calls.at(-1)?.error && (!after.trim() || /cancel|refused|not allowed|can'?t|cannot|couldn'?t|unable/i.test(after));
+      if (cancelWhy || !overIt || nudge >= MAX_NUDGES || !["end_turn", "cancelled"].includes(answer.stopReason))
+        break;
+      say(`  Atticus: told Copilot why that was refused and to carry on (${nudge + 1} of ${MAX_NUDGES}).`);
+      prompt = carryOnPrompt(fresh);
+    }
+    const usage = usageOf(sumUsage(usages));
+    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(() => killTree(child), 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);
@@ -1713,16 +3082,49 @@ var AiOffError = class extends RuntimeConfigError {
   }
 };
 function claudeCodeCliRunner(o = {}) {
-  return (i) => collectChild(() => spawn(o.command ?? "claude", i.args, {
-    cwd: i.cwd,
-    env: { ...process.env, ...i.env },
-    stdio: ["pipe", "pipe", "pipe"],
-    windowsHide: true,
-    ...i.signal ? { signal: i.signal } : {}
-  }), i.prompt, i.timeoutMs, i.cwd);
-}
-function collectChild(start, prompt, timeoutMs, cwd, platform = process.platform) {
-  return new Promise((resolve, reject) => {
+  return (i) => {
+    const command = resolveWindowsCommand(o.command ?? "claude");
+    const shell = isShim(command);
+    let started;
+    const end = () => {
+      if (started)
+        killTree(started);
+    };
+    if (shell && i.signal) {
+      if (i.signal.aborted)
+        queueMicrotask(end);
+      else
+        i.signal.addEventListener("abort", end, { once: true });
+    }
+    return collectChild(() => {
+      started = spawn2(shell ? quoteForCmdAlways(command) : command, shell ? i.args.map(quoteForCmdAlways) : i.args, {
+        cwd: i.cwd,
+        env: { ...process.env, ...i.env },
+        stdio: ["pipe", "pipe", "pipe"],
+        windowsHide: true,
+        shell,
+        ...i.signal && !shell ? { signal: i.signal } : {}
+      });
+      return started;
+    }, i.prompt, i.timeoutMs, i.cwd, process.platform, shell ? (c) => killTree(c) : void 0);
+  };
+}
+var isShim = (command, platform = process.platform) => platform === "win32" && /\.(cmd|bat)$/i.test(command);
+function resolveWindowsCommand(command, env = process.env, platform = process.platform, exists = existsSync2) {
+  if (platform !== "win32" || /[\\/]/.test(command) || /\.[a-z0-9]+$/i.test(command))
+    return command;
+  const exts = (env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean);
+  for (const dir of (env.Path ?? env.PATH ?? "").split(";").map((d) => d.trim().replace(/^"(.*)"$/, "$1")).filter(Boolean))
+    for (const ext of exts) {
+      const full = `${dir.replace(/[\\/]+$/, "")}\\${command}${ext.toLowerCase()}`;
+      if (exists(full))
+        return full;
+    }
+  return command;
+}
+var quoteForCmdAlways = (a) => `"${a.replace(/"/g, '""')}"`;
+function collectChild(start, prompt, timeoutMs, cwd, platform = process.platform, stop) {
+  return new Promise((resolve2, reject) => {
     let done = false;
     const timer = {};
     const fail = (e) => {
@@ -1743,7 +3145,7 @@ function collectChild(start, prompt, timeoutMs, cwd, platform = process.platform
     }
     let stdout = "";
     let stderr = "";
-    timer.id = setTimeout(() => child.kill("SIGINT"), timeoutMs);
+    timer.id = setTimeout(() => stop ? stop(child) : child.kill("SIGINT"), timeoutMs);
     for (const s of [child.stdin, child.stdout, child.stderr])
       s.on("error", fail);
     child.stdout.setEncoding("utf8").on("data", (d) => stdout += d);
@@ -1754,16 +3156,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;
 }
@@ -1800,9 +3202,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,
@@ -1816,27 +3218,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);
       }
@@ -1844,7 +3246,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,
@@ -1860,7 +3262,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);
@@ -1870,8 +3272,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: {
@@ -1916,6 +3318,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 = {};
@@ -1937,17 +3343,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) {
@@ -1955,7 +3363,9 @@ async function createRuntime(orgPack, o) {
       return new HandoffRuntime({
         root: o.root,
         validate: o.handoffValidate ?? nonEmpty,
-        ...o.now ? { now: o.now } : {}
+        ...o.now ? { now: o.now } : {},
+        // ADR 0185: a stage's critic lenses go to the person's assistant in one prompt.
+        batch: true
       });
     case "model": {
       const cfg = rt.adapters.model;
@@ -1995,6 +3405,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);
@@ -2011,13 +3437,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,
@@ -2025,13 +3451,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
@@ -2127,8 +3554,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}`);
@@ -2618,6 +4045,9 @@ function recordedJudge(byTexts, o = {}) {
 }
 
 export {
+  personOnlyWhy,
+  isPersonsFactsFile,
+  windowsName,
   DEFENCES_VERSION,
   INSTRUCTION_RULES,
   riskAtLeast,
@@ -2683,12 +4113,45 @@ export {
   recordRun,
   MockModelProvider,
   ModelRuntime,
+  BATCH_OUTPUT,
+  DEFAULT_BATCH_MAX_TOKENS,
+  batchSections,
   HandoffRuntime,
   pruneRuns,
+  ACP_PROTOCOL_VERSION,
+  ACP_METHODS,
+  ACP_ERRORS,
+  AcpRpcError,
+  AcpClient,
+  chunkText,
+  UPDATE,
+  usageOf,
+  isAuthRequired,
+  commandLineOf,
+  atticusArgvOf,
+  acpPathsOf,
+  factsOnly,
+  readRootsOf,
+  needsShell,
+  quoteForCmd,
+  killTree,
+  spawnAcpServer,
+  atticusExec,
+  AcpSignInError,
+  AcpSetupError,
+  MAX_NUDGES,
+  carryOnPrompt,
+  ACP_OFFERED,
+  runAcpSession,
+  copilotAcpProbe,
+  CopilotAcpRuntime,
+  keepAcpRun,
   RUNTIME_MODES,
   RuntimeConfigError,
   AiOffError,
   claudeCodeCliRunner,
+  resolveWindowsCommand,
+  quoteForCmdAlways,
   collectChild,
   posixPath,
   HeadlessClaudeCodeRuntime,
@@ -2699,6 +4162,7 @@ export {
   registeredModelProviders,
   clearModelProviders,
   registerToolSource,
+  registerCopilotAcp,
   createRuntime,
   runtimeForCli,
   resumedAttempt,