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

package/dist/chunk-SMA4N4AC.js

@@ -0,0 +1,211 @@
+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 {
+  benchFactsCommand
+} from "./chunk-CP3L3FH7.js";
+import {
+  BenchStory,
+  benchKnownFields,
+  benchStoryFromStories,
+  factFieldNames,
+  parseDraftStory,
+  parseReference,
+  parseReferenceStory,
+  scoreStory
+} from "./chunk-STUPFGXY.js";
+import "./chunk-RYSCLMU3.js";
+import "./chunk-ZUIAOKXI.js";
+import "./chunk-DPC5Y5DL.js";
+import "./chunk-6SCVQZX5.js";
+import "./chunk-65NYPGRC.js";
+import {
+  draftedStories
+} from "./chunk-VPTTCYOC.js";
+import "./chunk-L6SGQIR3.js";
+import "./chunk-7UFQZXZA.js";
+import "./chunk-56YQ6ROQ.js";
+import "./chunk-4AK7IBVP.js";
+import "./chunk-7JUKDRSZ.js";
+import "./chunk-OLWFG75W.js";
+import "./chunk-L24C55VN.js";
+import "./chunk-PAMPPUR6.js";
+import "./chunk-23W7VWKR.js";
+import "./chunk-7EKXJZ2Y.js";
+import "./chunk-MC3H7736.js";
+import "./chunk-T6AIP7H5.js";
+import "./chunk-KJPMEAI4.js";
+import "./chunk-GQ4N4WKF.js";
+import "./chunk-CNUKCS2T.js";
+import {
+  changesDirOf,
+  parseFacts,
+  require_dist
+} from "./chunk-S2A7YC3Q.js";
+import "./chunk-D3PO4DOZ.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/cli/dist/bench-stories-commands.js
+var import_yaml = __toESM(require_dist(), 1);
+import { existsSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
+var str = (v) => typeof v === "string" && v !== "" ? v : void 0;
+async function benchScoreCli(command, arg, values, io, root) {
+  const common = {
+    ...str(values.bench) ? { bench: str(values.bench) } : {},
+    ...str(values.cache) ? { cache: str(values.cache) } : {},
+    ...str(values.facts) ? { facts: str(values.facts) } : {},
+    json: values.json === true
+  };
+  if (command === "facts") {
+    const repo = arg ?? str(values.repo);
+    const batch = Number(str(values.batch));
+    return benchFactsCommand({ ...common, ...repo ? { repo } : {}, ...batch > 0 ? { batch } : {} }, io);
+  }
+  const change = str(values.change);
+  if (change) {
+    const story = str(values.story);
+    if (!story) {
+      io.err("bench stories --change needs the reference story the change answers: atticus bench stories --change <change> --story <id> (an id in bench/stories).");
+      return 2;
+    }
+    const out = str(values.out);
+    return benchChangeStories({ ...common, change, story, root: root ?? process.cwd(), ...out ? { out } : {} }, io);
+  }
+  const draft = str(values.draft) ?? arg;
+  if (!draft) {
+    io.err("bench stories needs a drafted story: atticus bench stories --draft <file>, or a change's stories: --change <change> --story <id>");
+    return 2;
+  }
+  return benchStories({ ...common, draft }, io);
+}
+function changeAt(value, root) {
+  const dir = resolve(value);
+  if (!existsSync(join(dir, "change.yaml")))
+    return { root: resolve(root), id: value };
+  const id = basename(dir);
+  for (let up = dirname(dir); ; up = dirname(up)) {
+    if (resolve(changesDirOf(up), id) === dir)
+      return { root: up, id };
+    if (dirname(up) === up)
+      break;
+  }
+  throw new Error(`${dir} is a change folder, but not in a metarepo's changes folder.`);
+}
+async function benchChangeStories(o, io) {
+  let draft;
+  try {
+    const { root, id } = changeAt(o.change, o.root);
+    const d = await draftedStories(root, id);
+    draft = BenchStory.parse(benchStoryFromStories({
+      story: o.story,
+      change: d.change.id,
+      title: d.change.title,
+      stories: d.stories,
+      answer: d.answer,
+      ...d.extras.done ? { done: d.extras.done } : {},
+      requests: d.requests
+    }));
+    if (o.out) {
+      await mkdir(dirname(resolve(o.out)), { recursive: true });
+      await writeFile(resolve(o.out), `# The stories atticus plan stories drafted for ${d.change.id}, as a bench story (atticus bench stories --change).
+${(0, import_yaml.stringify)(draft, { lineWidth: 0 })}`);
+    }
+  } catch (e) {
+    io.err(e.message);
+    return 2;
+  }
+  return scoreAndReport(draft, o, io, o.out ? resolve(o.out) : void 0);
+}
+var defaultCache = () => process.env.LOCALAPPDATA ? join(process.env.LOCALAPPDATA, "atticus", "bench") : join(homedir(), ".cache", "atticus", "bench");
+async function benchStories(o, io) {
+  let draft;
+  try {
+    const draftText = await readFile(resolve(o.draft), "utf8").catch(() => void 0);
+    if (draftText === void 0)
+      throw new Error(`There is no draft at ${resolve(o.draft)}.`);
+    draft = parseDraftStory(draftText);
+  } catch (e) {
+    io.err(e.message);
+    return 2;
+  }
+  return scoreAndReport(draft, o, io);
+}
+async function scoreAndReport(draft, o, io, written) {
+  const dir = resolve(o.bench ?? "bench");
+  const cache = resolve(o.cache ?? defaultCache());
+  let score;
+  try {
+    const refText = await readFile(join(dir, "stories", `${draft.story}.yaml`), "utf8").catch(() => void 0);
+    if (refText === void 0)
+      throw new Error(`There is no reference story ${draft.story} in ${join(dir, "stories")}: the draft's story names the reference it answers.`);
+    const ref = parseReferenceStory(refText);
+    const known = [];
+    for (const repo of ref.repos) {
+      const text = await readFile(join(dir, "references", `${repo}.yaml`), "utf8").catch(() => void 0);
+      if (text !== void 0)
+        known.push(...benchKnownFields([parseReference(text)]));
+    }
+    const factFiles = o.facts ? [resolve(o.facts)] : ref.repos.flatMap((r) => [
+      join(cache, r, ".atticus", "facts", `${r}.jsonl`),
+      join(cache, "facts", `${r}.jsonl`)
+    ]);
+    for (const f of factFiles) {
+      if (!existsSync(f)) {
+        if (o.facts)
+          throw new Error(`There is no facts file at ${f}.`);
+        continue;
+      }
+      const parsed = parseFacts(await readFile(f, "utf8"));
+      if (!parsed.ok)
+        throw new Error(`${f} does not read as facts.`);
+      known.push(...factFieldNames(parsed.facts));
+    }
+    score = scoreStory(ref, draft, known);
+  } catch (e) {
+    io.err(e.message);
+    return 2;
+  }
+  const code = score.invented.length ? 1 : 0;
+  if (o.json) {
+    io.out(JSON.stringify(score, null, 2));
+    return code;
+  }
+  const pct = (x) => `${Math.round(x * 100)}%`;
+  const row = (what, s) => `${what.padEnd(18)} ${s.found} of ${s.total} (${pct(s.coverage)})`;
+  io.out(`Story ${score.story}`);
+  if (written)
+    io.out(`Draft: ${written}`);
+  io.out(row("Changed steps", score.steps));
+  if (score.steps.missed.length)
+    io.out(`  missed: ${score.steps.missed.join(", ")}`);
+  if (score.steps.extra.length)
+    io.out(`  draft steps no reference step matches: ${score.steps.extra.join(", ")}`);
+  io.out(row("Fields", score.fields));
+  if (score.fields.missed.length)
+    io.out(`  missed: ${score.fields.missed.join(", ")}`);
+  io.out(row("Error cases", score.errors));
+  for (const m of score.errors.missed)
+    io.out(`  missed: ${m}`);
+  io.out(row("  by entry", score.errorsByEntry));
+  for (const m of score.errorsByEntry.missed)
+    io.out(`  missed: ${m}`);
+  io.out(`${"Invented fields".padEnd(18)} ${score.invented.join(", ") || "none"}`);
+  io.out(`${"Rubric sections".padEnd(18)} ${score.sections.present} of ${score.sections.total}`);
+  if (score.sections.missing.length)
+    io.out(`  missing: ${score.sections.missing.join(", ")}`);
+  if (code)
+    io.out("A draft must name only fields the reference, the bench references or the repos' facts know (bench/stories/rubric.md).");
+  return code;
+}
+export {
+  benchChangeStories,
+  benchScoreCli,
+  benchStories
+};

package/dist/chunk-SP2I63OO.js

@@ -0,0 +1,252 @@
+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 {
+  ANSWERED_BY_SPEC,
+  APPLIES_SPEC,
+  ASKS_CHECK_SPEC,
+  AiOffError,
+  BIGGER_MODEL,
+  BREAKING_SPEC,
+  CLASSIFIED_PERSONAL,
+  COVERS_FIELD_SPEC,
+  DATA_RULE,
+  DEFENCES_VERSION,
+  FLAG_OPEN,
+  HandoffRuntime,
+  HashEmbedder,
+  HeadlessClaudeCodeRuntime,
+  INSTRUCTION_RULES,
+  JUDGE_AGENT,
+  MockModelProvider,
+  MockRuntime,
+  ModelRuntime,
+  NAMES_SECRET_SPEC,
+  OneShotRuntime,
+  PERSONAL_DATA_SPEC,
+  PROMPT_FRAME_TOKENS,
+  PROMPT_MARGIN,
+  PromptTooLong,
+  REACHES_SPEC,
+  RUNTIME_MODES,
+  RecordedEmbedder,
+  ReplayRuntime,
+  RuntimeConfigError,
+  RuntimeError,
+  SAME_QUESTION_SPEC,
+  STATES_VALUE_SPEC,
+  STEP_CLASS_BY_AGENT,
+  TOKEN_FORMATS,
+  TOOLS_RULE,
+  TOOL_LIMITS,
+  ToolError,
+  ToolSession,
+  UNDOES_SPEC,
+  answerJudge,
+  answerProblem,
+  assess,
+  buildContextPack,
+  chatWithTools,
+  checkAllowed,
+  claudeCodeCliRunner,
+  clearModelProviders,
+  collectChild,
+  combine,
+  cosine,
+  createRuntime,
+  currentPromptLimit,
+  decodeBlob,
+  defendSource,
+  dotInt8,
+  escapeDelimiters,
+  estimateTokens,
+  fitBudget,
+  formatOf,
+  guardToolText,
+  hiddenDiagramLabels,
+  hiddenOfficeRuns,
+  hiddenSpans,
+  judge,
+  judgeInstructions,
+  judgeItemsOf,
+  judgeStandIn,
+  judgesDirectly,
+  makeModelProvider,
+  makeRunId,
+  modelEnvOf,
+  modelSourceWords,
+  modelsByClass,
+  namesWord,
+  neutralise,
+  personalItem,
+  posixPath,
+  promptBudget,
+  providerFactoryFor,
+  providerModelOf,
+  pruneRuns,
+  quantize,
+  quarantineItems,
+  quarantineReason,
+  questionJudge,
+  readToolCalls,
+  recordRun,
+  recordToolCalls,
+  recordedJudge,
+  registerModelProvider,
+  registerModelProviderPluginLoader,
+  registerToolSource,
+  registeredModelProviders,
+  resumedAttempt,
+  riskAtLeast,
+  runtimeForCli,
+  screenAbsorbed,
+  screenDiagramXml,
+  screenDocuments,
+  screenHiddenRuns,
+  screenOfficeXml,
+  screenText,
+  settle,
+  sha256,
+  skeleton,
+  stepClassOf,
+  stepClassOfCommand,
+  stepClassOfNextStep,
+  stripInvisible,
+  textSha,
+  toRunSummary,
+  tokenFormatIn,
+  toolStops,
+  transition,
+  vectorFromText,
+  vectorToText,
+  verdictOf,
+  withPromptLimit,
+  wrapData
+} from "./chunk-CNUKCS2T.js";
+import "./chunk-S2A7YC3Q.js";
+import "./chunk-D3PO4DOZ.js";
+import "./chunk-TV45EUGM.js";
+export {
+  ANSWERED_BY_SPEC,
+  APPLIES_SPEC,
+  ASKS_CHECK_SPEC,
+  AiOffError,
+  BIGGER_MODEL,
+  BREAKING_SPEC,
+  CLASSIFIED_PERSONAL,
+  COVERS_FIELD_SPEC,
+  DATA_RULE,
+  DEFENCES_VERSION,
+  FLAG_OPEN,
+  HandoffRuntime,
+  HashEmbedder,
+  HeadlessClaudeCodeRuntime,
+  INSTRUCTION_RULES,
+  JUDGE_AGENT,
+  MockModelProvider,
+  MockRuntime,
+  ModelRuntime,
+  NAMES_SECRET_SPEC,
+  OneShotRuntime,
+  PERSONAL_DATA_SPEC,
+  PROMPT_FRAME_TOKENS,
+  PROMPT_MARGIN,
+  PromptTooLong,
+  REACHES_SPEC,
+  RUNTIME_MODES,
+  RecordedEmbedder,
+  ReplayRuntime,
+  RuntimeConfigError,
+  RuntimeError,
+  SAME_QUESTION_SPEC,
+  STATES_VALUE_SPEC,
+  STEP_CLASS_BY_AGENT,
+  TOKEN_FORMATS,
+  TOOLS_RULE,
+  TOOL_LIMITS,
+  ToolError,
+  ToolSession,
+  UNDOES_SPEC,
+  answerJudge,
+  answerProblem,
+  assess,
+  buildContextPack,
+  chatWithTools,
+  checkAllowed,
+  claudeCodeCliRunner,
+  clearModelProviders,
+  collectChild,
+  combine,
+  cosine,
+  createRuntime,
+  currentPromptLimit,
+  decodeBlob,
+  defendSource,
+  dotInt8,
+  escapeDelimiters,
+  estimateTokens,
+  fitBudget,
+  formatOf,
+  guardToolText,
+  hiddenDiagramLabels,
+  hiddenOfficeRuns,
+  hiddenSpans,
+  judge,
+  judgeInstructions,
+  judgeItemsOf,
+  judgeStandIn,
+  judgesDirectly,
+  makeModelProvider,
+  makeRunId,
+  modelEnvOf,
+  modelSourceWords,
+  modelsByClass,
+  namesWord,
+  neutralise,
+  personalItem,
+  posixPath,
+  promptBudget,
+  providerFactoryFor,
+  providerModelOf,
+  pruneRuns,
+  quantize,
+  quarantineItems,
+  quarantineReason,
+  questionJudge,
+  readToolCalls,
+  recordRun,
+  recordToolCalls,
+  recordedJudge,
+  registerModelProvider,
+  registerModelProviderPluginLoader,
+  registerToolSource,
+  registeredModelProviders,
+  resumedAttempt,
+  riskAtLeast,
+  runtimeForCli,
+  screenAbsorbed,
+  screenDiagramXml,
+  screenDocuments,
+  screenHiddenRuns,
+  screenOfficeXml,
+  screenText,
+  settle,
+  sha256,
+  skeleton,
+  stepClassOf,
+  stepClassOfCommand,
+  stepClassOfNextStep,
+  stripInvisible,
+  textSha,
+  toRunSummary,
+  tokenFormatIn,
+  toolStops,
+  transition,
+  vectorFromText,
+  vectorToText,
+  verdictOf,
+  withPromptLimit,
+  wrapData
+};

package/dist/chunk-STHSY74Q.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-RYSCLMU3.js";
+import {
+  judgingRuntime
+} from "./chunk-BWZ77RQT.js";
+import {
+  changeStore
+} from "./chunk-56YQ6ROQ.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
+};