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

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

@@ -28,14 +28,114 @@ import {
   runsRelOf,
   stateDirOf,
   stepModelsOf
-} from "./chunk-YK6CSODO.js";
+} from "./chunk-PAINMSID.js";
 import {
   writeFileAtomic
-} from "./chunk-MMB2OHUY.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";
 
@@ -1134,7 +1234,9 @@ function toRunSummary(run) {
     ...run.request.retrieval ? { retrieval: run.request.retrieval } : {},
     stepClass: run.stepClass ?? stepClassOf(run.request),
     ...run.model ? { model: run.model } : {},
-    ...run.assistant ? { assistant: run.assistant } : {}
+    ...run.assistant ? { assistant: run.assistant } : {},
+    ...run.batch ? { batch: run.batch } : {},
+    ...run.parts?.length ? { parts: run.parts } : {}
   };
 }
 var OneShotRuntime = class {
@@ -1554,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";
@@ -1579,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;
@@ -1596,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,
@@ -1638,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") {
@@ -1661,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);
@@ -1711,6 +2012,7 @@ async function pruneRuns(root, days, now = /* @__PURE__ */ new Date(), only) {
 }
 
 // packages/ai/dist/factory.js
+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";
@@ -1969,18 +2271,7 @@ function commandLineOf(line) {
 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)"
-  },
+  // 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"
@@ -2013,6 +2304,13 @@ function atticusArgvOf(command, args = []) {
   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;
@@ -2059,6 +2357,11 @@ var Paths = class {
     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] ?? "";
@@ -2073,6 +2376,7 @@ var Paths = class {
     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]
@@ -2084,8 +2388,22 @@ function readRootsOf(root) {
     out.push(state);
   return out;
 }
-var needsShell = (command) => process.platform === "win32" && !/\.(exe|com)$/i.test(command);
+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;
@@ -2152,7 +2470,7 @@ var spawnAcpServer = (o) => {
       child.stdin?.end();
       await new Promise((res) => {
         const t = setTimeout(() => {
-          child.kill();
+          killTree(child);
           res();
         }, 2e3);
         closes.push(() => {
@@ -2588,7 +2906,7 @@ async function copilotAcpProbe(o) {
       res({ ok: false, text: e.message });
       return;
     }
-    const t = setTimeout(() => child.kill(), o.timeoutMs ?? 6e4);
+    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) => {
@@ -2764,15 +3082,48 @@ var AiOffError = class extends RuntimeConfigError {
   }
 };
 function claudeCodeCliRunner(o = {}) {
-  return (i) => collectChild(() => spawn2(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 (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 = {};
@@ -2794,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);
@@ -3012,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;
@@ -3692,6 +4045,9 @@ function recordedJudge(byTexts, o = {}) {
 }
 
 export {
+  personOnlyWhy,
+  isPersonsFactsFile,
+  windowsName,
   DEFENCES_VERSION,
   INSTRUCTION_RULES,
   riskAtLeast,
@@ -3757,6 +4113,9 @@ export {
   recordRun,
   MockModelProvider,
   ModelRuntime,
+  BATCH_OUTPUT,
+  DEFAULT_BATCH_MAX_TOKENS,
+  batchSections,
   HandoffRuntime,
   pruneRuns,
   ACP_PROTOCOL_VERSION,
@@ -3770,8 +4129,12 @@ export {
   isAuthRequired,
   commandLineOf,
   atticusArgvOf,
+  acpPathsOf,
   factsOnly,
   readRootsOf,
+  needsShell,
+  quoteForCmd,
+  killTree,
   spawnAcpServer,
   atticusExec,
   AcpSignInError,
@@ -3787,6 +4150,8 @@ export {
   RuntimeConfigError,
   AiOffError,
   claudeCodeCliRunner,
+  resolveWindowsCommand,
+  quoteForCmdAlways,
   collectChild,
   posixPath,
   HeadlessClaudeCodeRuntime,