@maycombhq/atticus 0.0.0-stage → 2.0.0-beta.11

package/dist/chunk-5P5BGG5L.js

@@ -0,0 +1,307 @@
+import { createRequire as __atticusCreateRequire } from "node:module";
+import { fileURLToPath as __atticusFileURLToPath } from "node:url";
+var require = __atticusCreateRequire(import.meta.url);
+var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
+var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
+import {
+  RunLevel,
+  completeTaskHandoff,
+  runTask
+} from "./chunk-7HWXYP4H.js";
+import {
+  driftCheck,
+  handDown,
+  handUp
+} from "./chunk-EI4KQYJ3.js";
+import {
+  generateAssistantFiles,
+  smokeCheck
+} from "./chunk-6RGIM2ZH.js";
+import {
+  createAdapters,
+  fileStepStore
+} from "./chunk-CAN3EBE5.js";
+import {
+  RUNTIME_MODES,
+  runtimeForCli
+} from "./chunk-BKFGGJKA.js";
+import {
+  changesRelOf,
+  loadOrgPack,
+  orgPackDirOf,
+  runsRelOf
+} from "./chunk-JMOLB347.js";
+
+// packages/cli/dist/run-commands.js
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+var KNOWN = /* @__PURE__ */ new Set([
+  "SpecKitError",
+  "TaskRunError",
+  "RuntimeConfigError",
+  "AssistantFilesError",
+  "ChangeError",
+  "ChangeFileError",
+  "AdapterError",
+  "WorkspaceFileError"
+]);
+function fail(io, e) {
+  if (e instanceof Error && KNOWN.has(e.name)) {
+    io.err(e.message);
+    return e.code === "invalid" ? 2 : 1;
+  }
+  throw e;
+}
+var plural = (n, w) => `${n} ${w}${n === 1 ? "" : "s"}`;
+function describeRun(root, r, io) {
+  const what = {
+    planned: `Wrote the plan for task ${r.task}: ${changesRelOf(root)}/${r.change}/tasks/${r.task}/plan.md.`,
+    waiting: `Handed task ${r.task} to your assistant. The prompt is in ${runsRelOf(root)}/${r.change}/${r.waiting}/prompt.md; it ends with: atticus handoff done ${r.waiting}`,
+    built: `Task ${r.task} is drafted on ${r.branch} and the build passes (${plural(r.attempts.length, "attempt")}); committed ${r.commit?.slice(0, 12) ?? ""}.`,
+    unverified: `Task ${r.task} is drafted on ${r.branch} but wasn't built: ${r.repo} has no build command.`,
+    "pr-open": `Opened PR ${r.pr?.url ?? ""} from ${r.branch} for review.`,
+    "needs-person": `Task ${r.task} needs a person in ${r.worktree}.`,
+    failed: `The run for task ${r.task} failed.`
+  };
+  const reason = r.state === "failed" ? r.notes.at(-1) : void 0;
+  io.out(reason ? `The run for task ${r.task} failed: ${reason}` : what[r.state]);
+  for (const n of reason ? r.notes.slice(0, -1) : r.notes)
+    io.out(`  ${n}`);
+  return r.state === "failed" || r.state === "needs-person" ? 1 : 0;
+}
+async function taskRun(root, changeId, taskId, o, io, deps = {}) {
+  if (!changeId || !taskId) {
+    io.err("Usage: atticus task run <change> <task> [--by <you>] [--level plan|draft|pr] [--mode hand-off|model|headless-claude-code] [--approve]");
+    return 2;
+  }
+  if (!o.by) {
+    io.err("Say who is running the task: set your Git user (git config user.name), or pass --by <you>.");
+    return 2;
+  }
+  if (o.level !== void 0 && !RunLevel.safeParse(o.level).success) {
+    io.err(`Unknown level ${o.level}. Use one of: plan, draft, pr.`);
+    return 2;
+  }
+  const env = deps.env ?? process.env;
+  const mode = o.mode ?? env.ATTICUS_RUNTIME;
+  if (mode !== void 0 && (!RUNTIME_MODES.includes(mode) || mode === "mock")) {
+    io.err(`Unknown mode ${mode}. Use one of: hand-off, model, headless-claude-code, replay.`);
+    return 2;
+  }
+  const now = deps.now ?? (() => /* @__PURE__ */ new Date());
+  try {
+    const r = await runTask(root, changeId, taskId, {
+      by: o.by,
+      ...o.level ? { level: o.level } : {},
+      ...mode ? { mode } : {},
+      ...env.ATTICUS_REPLAY_DIR ? { replayDir: env.ATTICUS_REPLAY_DIR } : {},
+      ...o.approve ? {
+        approval: {
+          by: o.by,
+          at: now().toISOString(),
+          ref: `task ${taskId} of ${changeId}: push and PR`
+        }
+      } : {},
+      ...deps.runtime ? { runtime: deps.runtime } : {},
+      ...deps.runtimeOptions ? { runtimeOptions: deps.runtimeOptions } : {},
+      ...deps.commands ? { commands: deps.commands } : {},
+      ...deps.git ? { git: deps.git } : {},
+      ...deps.gitHost ? { gitHost: deps.gitHost } : {},
+      now
+    });
+    if (o.json) {
+      io.out(JSON.stringify(r, null, 2));
+      return r.state === "failed" || r.state === "needs-person" ? 1 : 0;
+    }
+    return describeRun(root, r, io);
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function taskHandoff(root, runId, o, io, deps = {}) {
+  if (!runId) {
+    io.err("Usage: atticus handoff done <run-id>");
+    return 2;
+  }
+  const now = deps.now ?? (() => /* @__PURE__ */ new Date());
+  try {
+    const r = await completeTaskHandoff(root, runId, {
+      ...o.approve && o.by ? { approval: { by: o.by, at: now().toISOString(), ref: `${runId}: push and PR` } } : {},
+      ...deps.commands ? { commands: deps.commands } : {},
+      ...deps.git ? { git: deps.git } : {},
+      ...deps.gitHost ? { gitHost: deps.gitHost } : {},
+      now
+    });
+    if (o.json)
+      io.out(JSON.stringify(r, null, 2));
+    else if (r.state === "waiting")
+      io.out(`The build still fails; fix it in ${r.worktree} and run atticus handoff done ${runId} again.`);
+    else
+      return describeRun(root, r, io);
+    return r.state === "waiting" ? 1 : 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function specHandDown(root, changeId, taskId, o, io, deps = {}) {
+  if (!changeId || !taskId) {
+    io.err("Usage: atticus spec hand-down <change> <task> [--force]");
+    return 2;
+  }
+  try {
+    const r = await handDown(root, changeId, taskId, {
+      ...o.force ? { force: true } : {},
+      ...deps.git ? { git: deps.git } : {}
+    });
+    if (o.json) {
+      io.out(JSON.stringify(r, null, 2));
+      return 0;
+    }
+    io.out(r.engine === "speckit" ? `Handed task ${r.task} down to ${r.repo} as the Spec Kit feature ${r.feature}, in ${r.worktree}.` : `Handed task ${r.task} down to ${r.repo} as ${r.feature}/${r.task}.md, in ${r.worktree}.`);
+    for (const f of r.written)
+      io.out(`  wrote ${f}`);
+    for (const f of r.kept)
+      io.out(`  kept ${f} (changed since the last hand-down; --force replaces it)`);
+    const af = r.assistantFiles.results.filter((x) => x.written).length;
+    if (af)
+      io.out(`  ${plural(af, "assistant file")} written or updated`);
+    for (const p of r.problems)
+      io.err(p);
+    io.out(r.commit ? `Committed ${r.commit.slice(0, 12)} on change/${r.change}; nothing was pushed.` : "Nothing new to commit.");
+    return 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function specHandUp(root, changeId, taskId, o, io, deps = {}) {
+  if (!changeId || !taskId) {
+    io.err("Usage: atticus spec hand-up <change> <task> [--by <you>] [--pr <number> --pr-url <url>]");
+    return 2;
+  }
+  if (!o.by) {
+    io.err("Say who is handing the task up: set your Git user (git config user.name), or pass --by <you>.");
+    return 2;
+  }
+  if (o.pr === void 0 !== (o.prUrl === void 0)) {
+    io.err("Give both --pr <number> and --pr-url <url>, or neither.");
+    return 2;
+  }
+  try {
+    const runtime = deps.runtime ?? (await runtimeForCli(root, { ...deps.env ? { env: deps.env } : {} })).runtime;
+    let gitHost = deps.gitHost;
+    if (!gitHost && o.pr === void 0) {
+      const op = await loadOrgPack(join(orgPackDirOf(root)));
+      gitHost = createAdapters(op.runtime, {}, { store: fileStepStore(root), root, procedures: op.procedures }).gitHost;
+    }
+    const r = await handUp(root, changeId, taskId, {
+      by: o.by,
+      runtime,
+      ...gitHost ? { gitHost } : {},
+      ...o.pr !== void 0 ? { pr: { number: o.pr, url: o.prUrl } } : {},
+      ...deps.git ? { git: deps.git } : {},
+      ...deps.now ? {
+        now: deps.now().toISOString().replace(/\.\d{3}Z$/, "Z")
+      } : {}
+    });
+    if (o.json) {
+      io.out(JSON.stringify(r, null, 2));
+      return 0;
+    }
+    io.out(`Task ${r.task} is handed up from PR ${r.pr.url}${r.markedDone ? " and marked done in tasks.md" : ""}.`);
+    for (const e of r.evidence)
+      io.out(`  evidence: ${changesRelOf(root)}/${r.change}/${e}`);
+    const lens = r.lens.state === "ran" ? `the complete lens raised ${plural(r.review?.findings.filter((f) => f.finding.artifact.startsWith(`tasks/${r.task}/`)).length ?? 0, "finding")}` : `the complete lens ${r.lens.state === "waiting" ? "is waiting" : `was ${r.lens.state}`}${r.lens.reason ? `: ${r.lens.reason}` : ""}`;
+    io.out(`  ${lens[0].toUpperCase()}${lens.slice(1)}.`);
+    io.out(`  Drift: ${r.drift.found.length ? plural(r.drift.found.length, "finding") : "none"}.`);
+    return r.drift.found.some((f) => f.severity === "blocking") ? 1 : 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function driftCommand(root, changeId, o, io, deps = {}) {
+  if (!changeId) {
+    io.err("Usage: atticus drift <change> [--json]");
+    return 2;
+  }
+  try {
+    const r = await driftCheck(root, changeId, deps.now ? {
+      now: deps.now().toISOString().replace(/\.\d{3}Z$/, "Z")
+    } : {});
+    const open = r.findings.filter((f) => f.finding.state === "open");
+    if (o.json) {
+      io.out(JSON.stringify({
+        change: r.change,
+        round: r.round,
+        unchanged: r.unchanged,
+        plans: r.plans.map((p) => ({ repo: p.repo, feature: p.feature.feature, from: p.from })),
+        findings: r.findings.map((f) => ({ ...f.finding, path: f.path }))
+      }, null, 2));
+      return open.length ? 1 : 0;
+    }
+    if (r.plans.length === 0)
+      io.out(`No repo plans for ${r.change} yet; the design was compared with the code only.`);
+    else
+      io.out(`Compared the design of ${r.change} with ${plural(r.plans.length, "repo plan")} and the code.`);
+    if (!r.findings.length) {
+      io.out("No drift.");
+      return 0;
+    }
+    for (const f of r.findings)
+      io.out(`  [${f.finding.severity}${f.finding.state === "open" ? "" : `, ${f.finding.state}`}] ${f.finding.summary} (${f.path})`);
+    io.out(`${plural(open.length, "open finding")} on the drift gate, round ${r.round}${r.unchanged ? " (unchanged)" : ""}. A blocking one stops the PR until the design is amended or the plan is fixed.`);
+    return open.length ? 1 : 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function assistantFiles(root, o, io) {
+  if (o.change && !o.repo) {
+    io.err("--change goes with --repo: atticus assistant-files --repo <id> --change <id>");
+    return 2;
+  }
+  const { isMetarepo, notMetarepo } = await import("./chunk-76WKMA4J.js");
+  if (!isMetarepo(root)) {
+    io.err(notMetarepo(root));
+    return 2;
+  }
+  try {
+    const r = await generateAssistantFiles(root, {
+      ...o.repo ? { repo: o.repo } : {},
+      ...o.change ? { change: o.change } : {},
+      ...o.force ? { force: true } : {},
+      ...o.check ? { check: true } : {}
+    });
+    const files = o.check ? [] : await Promise.all(r.results.filter((x) => x.action !== "kept-not-generated").map(async (x) => ({
+      path: x.path,
+      content: await readFile(join(r.dir, x.path), "utf8")
+    })));
+    const smoke = smokeCheck(files);
+    if (o.json) {
+      io.out(JSON.stringify({ dir: r.dir, profile: r.profile, results: r.results, problems: r.problems, smoke }, null, 2));
+    } else {
+      for (const x of r.results.filter((y) => y.action !== "unchanged"))
+        io.out(`  ${o.check ? `would be ${x.action}` : x.action === "kept-edited" ? "kept (edited by hand; --force replaces it)" : x.action === "kept-not-generated" ? "kept (not written by Atticus)" : x.action}: ${x.path}`);
+      for (const p of r.problems)
+        io.err(p);
+      for (const p of smoke)
+        io.err(`${p.path}: ${p.message}`);
+      const where = r.profile.kind === "metarepo" ? "the metarepo" : `${r.profile.repo} (${r.profile.engine})`;
+      io.out(r.upToDate ? `Assistant files for ${where} are up to date.` : o.check ? `Assistant files for ${where} are out of date; run atticus assistant-files${o.repo ? ` --repo ${o.repo}` : ""}.` : `Wrote assistant files for ${where} from the org pack.`);
+    }
+    if (smoke.length || r.problems.length)
+      return 1;
+    return o.check && !r.upToDate ? 1 : 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+
+export {
+  describeRun,
+  taskRun,
+  taskHandoff,
+  specHandDown,
+  specHandUp,
+  driftCommand,
+  assistantFiles
+};

package/dist/chunk-5RUMHLIS.js

@@ -0,0 +1,104 @@
+import { createRequire as __atticusCreateRequire } from "node:module";
+import { fileURLToPath as __atticusFileURLToPath } from "node:url";
+var require = __atticusCreateRequire(import.meta.url);
+var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
+var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
+import {
+  loadRepos
+} from "./chunk-XZJE6WIT.js";
+import {
+  changesDirOf,
+  checkedProposals,
+  isPersonsQuestion,
+  orderQuestions,
+  peopleOfChange,
+  questionWeights,
+  readTeams,
+  require_dist,
+  routeOfQuestion,
+  teamsOfPerson
+} from "./chunk-JMOLB347.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/question-routing.js
+var import_yaml = __toESM(require_dist(), 1);
+import { readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+async function changePeopleOf(root, id) {
+  const text = await readFile(join(changesDirOf(root), id, "change.yaml"), "utf8").catch(() => void 0);
+  if (text === void 0)
+    return [];
+  let data;
+  try {
+    data = (0, import_yaml.parse)(text);
+  } catch {
+    return [];
+  }
+  const owners = data?.owners;
+  if (!owners || typeof owners !== "object" || Array.isArray(owners))
+    return [];
+  const lists = {};
+  for (const [role, v] of Object.entries(owners))
+    if (Array.isArray(v))
+      lists[role] = v.filter((h) => typeof h === "string" && !!h.trim());
+  return peopleOfChange(lists);
+}
+async function routeQuestions(root, questions, o = {}) {
+  const problems = [];
+  const owners = /* @__PURE__ */ new Map();
+  try {
+    for (const r of await loadRepos(root))
+      owners.set(r.id, r.owner);
+  } catch (e) {
+    problems.push({
+      file: "org-pack/profiles",
+      message: e.message.split("\n")[0]
+    });
+  }
+  const { teams, problem } = await readTeams(root);
+  if (problem)
+    problems.push({ file: "org-pack/roles.yaml", message: problem });
+  const changes = new Set(await readdir(changesDirOf(root), { withFileTypes: true }).then((d) => d.filter((x) => x.isDirectory()).map((x) => x.name), () => []));
+  const changePeople = /* @__PURE__ */ new Map();
+  for (const id of new Set(questions.map((q) => q.repo)))
+    if (changes.has(id))
+      changePeople.set(id, await changePeopleOf(root, id));
+  const weights = await questionWeights(root, questions);
+  const proposals = new Map((await checkedProposals(root).catch(() => [])).filter((p) => p.ok && p.proposal).map((p) => [p.id, { ...p.proposal, file: p.file }]));
+  const about = {};
+  for (const q of questions) {
+    const p = q.state === "open" ? proposals.get(q.id) : void 0;
+    about[q.id] = {
+      ...weights.get(q.id) ?? { restsOn: [], joins: 0 },
+      owner: routeOfQuestion(q, { owners, teams, changes, changePeople }),
+      ...p ? {
+        proposal: {
+          answer: p.answer,
+          why: p.why,
+          cites: p.cites,
+          by: p.by,
+          at: p.at,
+          file: p.file
+        }
+      } : {}
+    };
+  }
+  let list = orderQuestions(questions, weights);
+  let me;
+  if (o.mine !== void 0) {
+    const mine = teamsOfPerson(o.mine, teams);
+    me = {
+      handle: o.mine,
+      teams: mine.map((t) => ({ id: t.id, ...t.name ? { name: t.name } : {} }))
+    };
+    const handle = o.mine;
+    list = list.filter((q) => isPersonsQuestion(handle, about[q.id].owner, teams));
+  }
+  return { questions: list, about, ...me ? { me } : {}, problems };
+}
+
+export {
+  routeQuestions
+};

package/dist/chunk-5TY4DTHQ.js

@@ -0,0 +1,242 @@
+import { createRequire as __atticusCreateRequire } from "node:module";
+import { fileURLToPath as __atticusFileURLToPath } from "node:url";
+var require = __atticusCreateRequire(import.meta.url);
+var __atticusUrl = (p) => new URL("./" + p, import.meta.url).href;
+var __atticusPath = (p) => __atticusFileURLToPath(__atticusUrl(p));
+import {
+  AUDIENCES,
+  ReleaseError,
+  deploymentPlan,
+  evidencePack,
+  loadRelease,
+  outcomesView,
+  recordOutcome,
+  releaseForecast,
+  releaseNotes,
+  securityReview,
+  writeEvidencePack
+} from "./chunk-7A7IG7OA.js";
+import {
+  judgingRuntime
+} from "./chunk-NBGBMRIS.js";
+import {
+  changeStore
+} from "./chunk-3LU6YCSQ.js";
+
+// packages/cli/dist/release-commands.js
+import { resolve } from "node:path";
+function fail(io, e) {
+  if (e instanceof ReleaseError) {
+    io.err(e.message);
+    return e.code === "usage" ? 2 : 1;
+  }
+  throw e;
+}
+var load = async (root, id, deps) => {
+  const runtime = await judgingRuntime(root, deps.runtime);
+  return loadRelease(root, id, {
+    ...deps.now ? { now: deps.now() } : {},
+    ...runtime ? { runtime } : {}
+  });
+};
+function lines(io, text) {
+  for (const l of text.replace(/\n$/, "").split("\n"))
+    io.out(l);
+}
+function planText(p, f) {
+  const out = [`Deployment plan for ${p.change} (${p.state}), ${p.today}`, ""];
+  for (const w of p.before)
+    out.push(`0. Before anything: ${w.requestType}${w.record ? ` for ${w.record}` : ""} (${w.state}${w.readyBy ? `, ready by ${w.readyBy}` : ""}). ${w.source}`);
+  for (const s of p.steps) {
+    out.push(`${s.n}. ${s.repo} (${s.kind})${s.waitDays ? `, from ${s.earliest}` : ""}`);
+    for (const w of s.what)
+      out.push(`   - ${w}`);
+    for (const y of s.why)
+      out.push(`   why: ${y}`);
+    for (const w of s.waitsOn)
+      out.push(`   waits on: ${w.requestType}${w.record ? ` for ${w.record}` : ""}, ${w.state === "filed" ? `filed${w.number ? ` as ${w.number}` : ""}` : w.state === "waiting" ? "waiting for a person to file it" : "not filed"}${w.readyBy ? `, ready by ${w.readyBy} (${w.waitDays} working days)` : ""}${w.missing.length ? `; missing ${w.missing.join(", ")}` : ""}`);
+    out.push(`   rollback: ${s.rollback.text ? `${s.rollback.text} (${s.rollback.source})` : `GAP: ${s.rollback.gap}`}`);
+  }
+  if (!p.steps.length)
+    out.push("No repo to deploy: the change names no interface, data change, task or repo.");
+  for (const x of p.external)
+    out.push(`External: ${x.what}${x.beforeStep ? `, before step ${x.beforeStep}` : ""}.`);
+  out.push("", "Release sections (design.md):");
+  for (const s of p.sections)
+    out.push(`  ${s.name}: ${s.text ? `${s.heading} (${s.source})` : `GAP: ${s.gap}`}`);
+  if (p.findings.length) {
+    out.push("", "Release lens findings still open:");
+    for (const x of p.findings)
+      out.push(`  ${x.severity}: ${x.summary} (${x.path})`);
+  }
+  out.push("", `Forecast: ${f.ready ? `ready by ${f.ready}` : "no date"}${f.target ? `, target ${f.target.date} (${f.status})` : ""}.`);
+  for (const d of f.drivers)
+    out.push(`  ${d.until}: ${d.what}. ${d.source}`);
+  const gaps = p.gaps.filter((g) => !/^No rollback step (written|judged)|^design\.md (has no|says nothing)/.test(g));
+  if (gaps.length) {
+    out.push("", "Gaps:");
+    for (const g of gaps)
+      out.push(`  - ${g}`);
+  }
+  for (const n of [...p.notes, ...f.notes])
+    out.push(`Note: ${n}`);
+  return out;
+}
+async function releasePlanCommand(root, id, o, io, deps = {}) {
+  if (!id) {
+    io.err("Usage: atticus release plan <change> [--json]");
+    return 2;
+  }
+  try {
+    const ctx = await load(root, id, deps);
+    const plan = await deploymentPlan(ctx);
+    const forecast = await releaseForecast(ctx, plan);
+    if (o.json)
+      io.out(JSON.stringify({ ...plan, forecast }, null, 2));
+    else
+      for (const l of planText(plan, forecast))
+        io.out(l);
+    return 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function releaseForecastCommand(root, id, o, io, deps = {}) {
+  if (!id) {
+    io.err("Usage: atticus release forecast <change> [--json]");
+    return 2;
+  }
+  try {
+    const f = await releaseForecast(await load(root, id, deps));
+    if (o.json) {
+      io.out(JSON.stringify(f, null, 2));
+      return 0;
+    }
+    io.out(f.status === "released" ? `${f.change} is released${f.ready ? ` (${f.ready})` : ""}.` : `${f.change}: ready by ${f.ready} (${f.waitDays} working days)${f.target ? `; target ${f.target.date}, ${f.status} (${f.target.source})` : "; no target date"}.`);
+    for (const d of f.drivers)
+      io.out(`  ${d.until}: ${d.what}. ${d.source}`);
+    for (const n of f.notes)
+      io.out(`Note: ${n}`);
+    return 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function releaseEvidenceCommand(root, id, o, io, deps = {}) {
+  if (!id) {
+    io.err("Usage: atticus release evidence <change> [--out <dir>] [--json]");
+    return 2;
+  }
+  try {
+    const ctx = await load(root, id, deps);
+    if (o.out) {
+      const dir = resolve(o.out);
+      const written = await writeEvidencePack(ctx, dir);
+      if (o.json)
+        io.out(JSON.stringify({ out: dir, written }, null, 2));
+      else
+        io.out(`Wrote the evidence pack for ${id} to ${dir}: evidence.md, manifest.json and ${written.length - 2} files.`);
+      return 0;
+    }
+    const pack = await evidencePack(ctx);
+    if (o.json)
+      io.out(JSON.stringify(pack, null, 2));
+    else
+      lines(io, pack.markdown);
+    return 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function releaseNotesCommand(root, id, o, io, deps = {}) {
+  const audience = o.audience ?? "business";
+  if (!id || !AUDIENCES.includes(audience)) {
+    io.err("Usage: atticus release notes <change> [--audience business|technical] [--json]");
+    return 2;
+  }
+  try {
+    const n = await releaseNotes(await load(root, id, deps), audience);
+    if (o.json)
+      io.out(JSON.stringify(n, null, 2));
+    else
+      lines(io, n.markdown);
+    return 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function releaseSecurityCommand(root, id, o, io, deps = {}) {
+  if (!id) {
+    io.err("Usage: atticus release security <change> [--json]");
+    return 2;
+  }
+  try {
+    const s = await securityReview(await load(root, id, deps));
+    if (o.json)
+      io.out(JSON.stringify(s, null, 2));
+    else
+      lines(io, s.markdown);
+    return 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function outcomeList(root, o, io, deps = {}) {
+  try {
+    const ids = o.change ? [o.change] : (await changeStore(root).list()).map((c) => c.id).sort();
+    const views = [];
+    for (const id of ids)
+      views.push(await outcomesView(await load(root, id, deps)));
+    if (o.json) {
+      io.out(JSON.stringify(o.change ? views[0] : views, null, 2));
+      return 0;
+    }
+    if (!views.length)
+      io.out("No changes yet.");
+    for (const v of views) {
+      io.out(`${v.change} (${v.state}): ${v.title}`);
+      if (!v.measures.length)
+        io.out(`  ${v.gaps[0] ?? "No success measures."}`);
+      for (const m of v.measures)
+        io.out(`  ${m.n}. ${m.measure} [${m.id}]: ${m.latest ? `${m.latest.value} (${m.latest.by}, ${m.latest.at.slice(0, 10)})` : "not measured yet"}`);
+      for (const x of v.orphans)
+        io.out(`  ! ${x.id}: recorded, but brief.md no longer has this measure`);
+      if (v.why && v.measures.length)
+        io.out(`  ${v.why}`);
+    }
+    return 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+async function outcomeRecord(root, id, measure, o, io, deps = {}) {
+  if (!id || !measure || !o.value?.trim() || !o.by) {
+    io.err('Usage: atticus outcome record <change> <measure id or number> --value "<what you measured>" [--by <you>] [--note "<how>"]');
+    return 2;
+  }
+  try {
+    const r = await recordOutcome(await load(root, id, deps), {
+      measure,
+      value: o.value,
+      by: o.by,
+      ...o.note ? { note: o.note } : {}
+    });
+    if (o.json)
+      io.out(JSON.stringify(r, null, 2));
+    else
+      io.out(`Recorded "${r.value.value}" for ${r.measure.id} as ${r.value.by}. Wrote ${r.written}.`);
+    return 0;
+  } catch (e) {
+    return fail(io, e);
+  }
+}
+
+export {
+  releasePlanCommand,
+  releaseForecastCommand,
+  releaseEvidenceCommand,
+  releaseNotesCommand,
+  releaseSecurityCommand,
+  outcomeList,
+  outcomeRecord
+};