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

package/dist/chunk-RCU3MPY2.js

@@ -0,0 +1,1496 @@
+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 {
+  BEGIN_RE,
+  END,
+  buildEngineFor,
+  findSection,
+  generateAssistantFiles,
+  parseHeader,
+  writeAssistantFiles
+} from "./chunk-V5PKHHQQ.js";
+import {
+  CONSTITUTION_FILE_LABEL,
+  buildContext,
+  docOf,
+  findingIdFor,
+  fingerprint,
+  layerRules,
+  lensAgent,
+  loadConstitution,
+  parseDoc,
+  parseLensOutput,
+  questionOfRule,
+  readChangeFiles,
+  readDataChanges,
+  readHops,
+  readPackFiles,
+  readRound,
+  roundsOf,
+  sectionMatching,
+  toFinding,
+  writeFinding
+} from "./chunk-7UFQZXZA.js";
+import {
+  changeFolder,
+  changeFootprint,
+  changeStore,
+  changeTypeOf,
+  loadChangeContext,
+  referenceMetarepoIn
+} from "./chunk-56YQ6ROQ.js";
+import {
+  readSpecKitFeatures
+} from "./chunk-MC3H7736.js";
+import {
+  baseClonePath,
+  changeWorktreesDir,
+  createGit,
+  loadRepos,
+  readChangeRepos,
+  toRepoRelative
+} from "./chunk-KJPMEAI4.js";
+import {
+  fsRepo
+} from "./chunk-GQ4N4WKF.js";
+import {
+  buildContextPack,
+  toRunSummary
+} from "./chunk-CNUKCS2T.js";
+import {
+  ChecklistPack,
+  Finding,
+  RecordId,
+  changeBranch,
+  changesRelOf,
+  normalizePath,
+  orgPackDirOf,
+  require_dist,
+  taskBranch,
+  toCanonicalYaml
+} from "./chunk-S2A7YC3Q.js";
+import {
+  writeFileAtomic
+} from "./chunk-D3PO4DOZ.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/speckit/dist/change.js
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+var SpecKitError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "SpecKitError";
+  }
+};
+var TASK_LINE = /^(\s*[-*]\s+\[)([ xX]?)(\]\s+)(\S+)\s+(.*)$/;
+function readChangeTasks(files) {
+  const doc = docOf(files, "tasks.md");
+  if (!doc)
+    return [];
+  const out = [];
+  let repo = "";
+  doc.lines.forEach((l, i) => {
+    const h = /^##\s+(.+?)\s*$/.exec(l);
+    if (h) {
+      repo = h[1].replace(/[`*]/g, "").trim().split(/\s+/)[0].toLowerCase();
+      return;
+    }
+    const m = TASK_LINE.exec(l);
+    if (!m || !repo || !RecordId.safeParse(m[4].toLowerCase()).success)
+      return;
+    const rest = m[5];
+    const stories = [...rest.matchAll(/\bstor(?:y|ies)\s+([a-z0-9][a-z0-9._-]*)/gi)].map((s) => s[1].toLowerCase().replace(/[.,)]+$/, ""));
+    out.push({
+      id: m[4].toLowerCase(),
+      repo,
+      title: rest.replace(/\s*\((?:story|stories)\b[^)]*\)\s*$/i, "").trim(),
+      stories,
+      line: i + 1,
+      done: m[2].toLowerCase() === "x"
+    });
+  });
+  return out;
+}
+async function markTaskDone(root, changeId, task) {
+  const path = join(changeFolder(root, changeId), "tasks.md");
+  const lines = (await readFile(path, "utf8")).split("\n");
+  const l = lines[task.line - 1];
+  const m = l === void 0 ? null : TASK_LINE.exec(l.replace(/\r$/, ""));
+  if (!m || m[4].toLowerCase() !== task.id)
+    return false;
+  if (m[2].toLowerCase() === "x")
+    return false;
+  lines[task.line - 1] = l.replace(TASK_LINE, (_a, a, _b, c, d, e) => `${a}x${c}${d} ${e}`);
+  await writeFileAtomic(path, lines.join("\n"));
+  return true;
+}
+function readStory(files, id) {
+  const doc = files.docs.get(`stories/${id}.md`);
+  if (!doc)
+    return void 0;
+  const title = doc.sections.find((s) => s.level === 1)?.heading ?? id;
+  const first = doc.sections.find((s) => s.level === 2);
+  const start = (doc.sections.find((s) => s.level === 1)?.line ?? 0) + 1;
+  const end = first ? first.line - 1 : doc.lines.length;
+  const text = doc.lines.slice(start - 1, end).join("\n").trim().split("\n");
+  const ac = doc.sections.find((s) => /acceptance criteria/i.test(s.heading));
+  const criteria = ac ? doc.lines.slice(ac.line, ac.end).map((l) => /^\s*[-*]\s+(.*)$/.exec(l)?.[1]?.trim()).filter((x) => !!x) : [];
+  return { id, title, text: text[0] === "" ? [] : text, criteria, path: doc.path };
+}
+function readTaskKnowledge(files, storyIds, task) {
+  const out = [];
+  for (const id of storyIds) {
+    const doc = files.docs.get(`stories/${id}.md`);
+    if (!doc)
+      continue;
+    const head = new RegExp(`^###\\s+Task\\s+${task.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}:`, "i");
+    const lines = doc.rawLines;
+    const at = lines.findIndex((l) => head.test(l));
+    if (at < 0)
+      continue;
+    let k = lines.findIndex((l, j) => j > at && /^- Knowledge that applies:\s*$/.test(l));
+    const next = lines.findIndex((l, j) => j > at && /^#{1,3}\s/.test(l));
+    if (k < 0 || next >= 0 && k > next)
+      continue;
+    for (k += 1; k < lines.length && /^\s{2,}\S/.test(lines[k]); k++)
+      out.push(lines[k].slice(2));
+  }
+  return out;
+}
+var STATES_WITH_APPROVED_DESIGN = /* @__PURE__ */ new Set([
+  "plan",
+  "build",
+  "qa",
+  "release-ready",
+  "released",
+  "post-release-review"
+]);
+async function loadTask(root, changeId, taskId, o = {}) {
+  const ctx = await loadChangeContext(root);
+  const change = await changeStore(root).read(changeId).catch((e) => {
+    throw new SpecKitError("not-found", e.message);
+  });
+  if (o.needApprovedDesign !== false && !STATES_WITH_APPROVED_DESIGN.has(change.state))
+    throw new SpecKitError("refused", `${change.id} is ${change.state}: a task is handed down only after the design is approved (plan phase or later).`);
+  const files = await readChangeFiles(changeFolder(root, change.id));
+  const tasks = readChangeTasks(files);
+  const task = tasks.find((t) => t.id === taskId.toLowerCase());
+  if (!task)
+    throw new SpecKitError("not-found", tasks.length ? `There is no task ${taskId} in ${change.id}'s tasks.md. Tasks: ${tasks.map((t) => t.id).join(", ")}.` : `${change.id} has no tasks yet: tasks.md needs \`- [ ] <id> <what>\` lines under a \`## <repo>\` heading.`);
+  const repo = (await loadRepos(root)).find((r) => r.id === task.repo);
+  if (!repo)
+    throw new SpecKitError("not-found", `Task ${task.id} is under ${task.repo}, which no repos.manifest.yaml lists.`);
+  return {
+    root,
+    ctx,
+    change,
+    files,
+    task,
+    repo,
+    component: repo.component ?? repo.id,
+    hops: readHops(files),
+    data: readDataChanges(files),
+    patterns: new Map(ctx.orgPack.patterns.map((p) => [p.code, p]))
+  };
+}
+async function changeWorktree(root, changeId, repo) {
+  const r = (await readChangeRepos(root, changeId))?.repos.find((x) => x.id === repo);
+  if (!r)
+    throw new SpecKitError("refused", `${repo} has no worktree for ${changeId} yet. Open it first: atticus workspace open ${changeId} --repos ${repo}`);
+  return join(root, r.worktree);
+}
+function viaOf(patterns, code) {
+  const route = patterns.get(code)?.route;
+  if (!route)
+    return void 0;
+  return ["gateway", "direct", "event-bus", "pubsub", "sftp", "mq"].includes(route) ? route : "other";
+}
+function mappingSections(doc) {
+  if (!doc)
+    return [];
+  return doc.sections.filter((s) => s.level === 2).map((s) => {
+    const m = /^([A-Za-z]+)\s+(\S+)$/.exec(s.heading.trim());
+    if (!m)
+      return void 0;
+    const body = doc.rawLines.slice(s.line, s.end).join("\n").trim();
+    return { method: m[1].toUpperCase(), path: m[2], lines: body ? body.split("\n") : [] };
+  }).filter((x) => !!x);
+}
+
+// packages/speckit/dist/handdown.js
+import { mkdir, readFile as readFile2, rename, writeFile } from "node:fs/promises";
+import { dirname, join as join3 } from "node:path";
+
+// packages/speckit/dist/constitution.js
+import { join as join2 } from "node:path";
+var ROMAN = [
+  [1e3, "M"],
+  [900, "CM"],
+  [500, "D"],
+  [400, "CD"],
+  [100, "C"],
+  [90, "XC"],
+  [50, "L"],
+  [40, "XL"],
+  [10, "X"],
+  [9, "IX"],
+  [5, "V"],
+  [4, "IV"],
+  [1, "I"]
+];
+function roman(n) {
+  let out = "";
+  for (const [v, s] of ROMAN)
+    while (n >= v) {
+      out += s;
+      n -= v;
+    }
+  return out;
+}
+async function rulesForRepo(root, team) {
+  const constitution = await loadConstitution();
+  const sources = [
+    { pack: constitution, file: CONSTITUTION_FILE_LABEL, origin: "constitution" }
+  ];
+  const org = await readPackFiles(root, join2(orgPackDirOf(root), "checklists"));
+  for (const p of org.packs)
+    sources.push({ ...p, origin: "org" });
+  const problems = [...org.problems];
+  if (team) {
+    const t = await readPackFiles(root, join2(orgPackDirOf(root), "teams", team, "checklists"));
+    problems.push(...t.problems);
+    for (const p of t.packs)
+      sources.push({ ...p, origin: "team" });
+  }
+  const layered = layerRules(sources);
+  problems.push(...layered.problems, ...layered.refused.map((r) => `${r.file}: ${r.reason}`));
+  return {
+    rules: layered.rules.filter((r) => r.status === "active"),
+    problems,
+    constitutionVersion: constitution.version
+  };
+}
+var describe = (r) => (r.description ?? (r.check.type === "ai" ? r.check.prompt : r.title)).trim();
+var line = (r) => `Rule \`${r.id}\` (${r.lens} lens, ${r.severity}${r.effectiveLayer === "constitution" || !r.waivable ? ", never waived" : ", waivable by the stage owner"}).`;
+function ruleSections(o, depth) {
+  const byLayer = (l) => o.rules.filter((r) => r.effectiveLayer === l);
+  const core = byLayer("constitution");
+  const org = byLayer("org");
+  const team = byLayer("team");
+  const h2 = "#".repeat(depth + 1);
+  const h3 = "#".repeat(depth + 2);
+  const block = (r, heading) => [heading, "", describe(r), "", line(r), ""];
+  return [
+    `${h2} Core Principles`,
+    "",
+    ...core.flatMap((r, i) => block(r, `${h3} ${roman(i + 1)}. ${r.title}`)),
+    ...org.length ? [`${h2} Organisation Rules`, "", ...org.flatMap((r) => block(r, `${h3} ${r.title}`))] : [],
+    ...team.length ? [
+      `${h2} Team Rules (${o.team ?? "owning team"})`,
+      "",
+      ...team.flatMap((r) => block(r, `${h3} ${r.title}`))
+    ] : []
+  ];
+}
+var packName = (o) => o.orgPack.pack ? `${o.orgPack.pack.name} ${o.orgPack.pack.version}` : "built-in defaults";
+function renderConstitutionSection(o) {
+  return [
+    "## Atticus Rules",
+    "",
+    `Merged by Atticus from the Atticus constitution ${o.constitutionVersion} and the org pack (${packName(o)}): the rules the critic applies at every gate, which apply here alongside the team's own principles. Everything outside this section is the team's own and Atticus never changes it. Change these rules in the org pack, never here; hand-down regenerates this section.`,
+    "",
+    ...ruleSections(o, 2)
+  ].join("\n").replace(/\n+$/, "\n");
+}
+function constitutionPlan(current) {
+  if (current === void 0 || parseHeader(current))
+    return { mode: "file" };
+  const lines = current.replace(/\r\n/g, "\n").split("\n");
+  const begins = lines.filter((l) => /^<!-- atticus:begin\b/.test(l)).length;
+  const ends = lines.filter((l) => l === END).length;
+  if (begins === 0 && ends === 0)
+    return { mode: "section" };
+  if (begins === 1 && ends === 1 && findSection(current))
+    return { mode: "section" };
+  const why = begins > ends ? "a begin marker without an end marker" : begins < ends ? "an end marker without a begin marker" : begins > 1 ? "more than one Atticus section" : !lines.some((l) => BEGIN_RE.test(l)) ? "a begin marker Atticus can't read" : "an end marker before the begin marker";
+  return {
+    mode: "refuse",
+    reason: `.specify/memory/constitution.md is the team's own constitution and its Atticus section markers are broken (${why}), so Atticus can't merge its rules into it. Fix or remove the markers, then hand down again.`
+  };
+}
+function renderConstitution(o) {
+  const pack = packName(o);
+  return [
+    `# ${o.repo} Constitution`,
+    "",
+    `Generated from the Atticus constitution ${o.constitutionVersion} and the org pack (${pack}): the rules the critic applies at every gate. Change them in the org pack, never here.`,
+    "",
+    ...ruleSections(o, 1),
+    "## Governance",
+    "",
+    "This constitution is generated by Atticus from the org pack, the same source as the critic's constitution layer. Core principles are never waived, and a team can only tighten a rule, never drop or loosen it. Amend it with a pull request to the org pack; hand-down regenerates this file.",
+    "",
+    `**Version**: ${o.constitutionVersion}+${(o.orgPack.pack?.name ?? "defaults").replace(/[^a-z0-9.-]/g, "-")}.${o.orgPack.pack?.version ?? "0.0.0"} | **Source**: org-pack and the Atticus constitution`,
+    ""
+  ].join("\n");
+}
+
+// packages/speckit/dist/render.js
+var import_yaml = __toESM(require_dist(), 1);
+var NC = "NEEDS CLARIFICATION";
+var date = (t) => t.change.createdAt.slice(0, 10);
+var GWT = /^given\s+(.+?),\s*when\s+(.+?),\s*then\s+(.+)$/i;
+function renderSpec(t) {
+  const stories = t.task.stories.map((s) => readStory(t.files, s)).filter((s) => !!s);
+  const out = [
+    `# Feature Specification: ${t.task.title}`,
+    "",
+    `**Feature Branch**: \`${taskBranch(t.change.id, t.task.id)}\``,
+    `**Created**: ${date(t)}`,
+    "**Status**: Draft",
+    `**Input**: Task ${t.task.id} of change ${t.change.id} (${t.change.title})`,
+    "",
+    `<!-- Handed down by Atticus from ${changesRelOf(t.root)}/${t.change.id}: ${stories.length ? stories.map((s) => s.path).join(", ") : "tasks.md"}. Refine it with /speckit.specify and /speckit.clarify. A question that needs the change's design goes back up, never into this repo alone. -->`,
+    "",
+    "## User Scenarios & Testing *(mandatory)*",
+    ""
+  ];
+  const frs = [];
+  stories.forEach((s, i) => {
+    out.push(`### User Story ${i + 1} - ${s.title} (Priority: P${i + 1})`, "");
+    if (s.text.length)
+      out.push(...s.text, "");
+    out.push("**Acceptance Scenarios**:", "");
+    if (s.criteria.length === 0)
+      out.push(`1. [${NC}: the story has no acceptance criteria]`);
+    s.criteria.forEach((c, j) => {
+      const m = GWT.exec(c);
+      out.push(`${j + 1}. ${m ? `**Given** ${m[1]}, **When** ${m[2]}, **Then** ${m[3]}` : c}`);
+      frs.push(`System MUST meet acceptance scenario ${j + 1} of User Story ${i + 1}.`);
+    });
+    out.push("");
+  });
+  if (stories.length === 0)
+    out.push(`### User Story 1 - ${t.task.title} (Priority: P1)`, "", `[${NC}: the task names no story]`, "");
+  out.push("### Edge Cases", "", `- [${NC}: cases the story's acceptance criteria don't cover]`, "", "## Requirements *(mandatory)*", "", "### Functional Requirements", "", ...frs.length ? frs.map((f, i) => `- **FR-${String(i + 1).padStart(3, "0")}**: ${f}`) : [`- **FR-001**: [${NC}: no acceptance criteria to trace]`], "", "## Success Criteria *(mandatory)*", "", "### Measurable Outcomes", "", "- **SC-001**: Every acceptance scenario above passes as an automated test.", "");
+  return out.join("\n");
+}
+var isHttp = (h) => !!h.method && ["GET", "PUT", "POST", "DELETE", "PATCH", "HEAD", "OPTIONS"].includes(h.method);
+var topicOf = (operation) => /^(publish|subscribe|send|receive)\s+(\S+)/i.exec(operation.trim());
+function repoHops(t) {
+  return {
+    calls: t.hops.filter((h) => h.caller === t.component),
+    serves: t.hops.filter((h) => h.callee === t.component && isHttp(h))
+  };
+}
+function repoData(t) {
+  const owned = new Set(t.ctx.records.filter((r) => r.kind === "DataStore" && r.ownerComponent === t.component).map((r) => r.id));
+  const tableOwner = (id) => t.ctx.records.find((r) => r.kind === "Table" && r.id === id)?.ownerComponent;
+  return t.data.filter((d) => owned.has(d.store) || tableOwner(d.tableId) === t.component);
+}
+function contractFile(t) {
+  return `contracts/${t.component}.yaml`;
+}
+function renderPlan(t) {
+  const { calls, serves } = repoHops(t);
+  const data = repoData(t);
+  const stores = [...new Set(data.map((d) => d.store))];
+  const owned = t.ctx.records.filter((r) => r.kind === "DataStore" && r.ownerComponent === t.component);
+  const storage = [.../* @__PURE__ */ new Set([...owned.map((s) => s.id), ...stores])].sort().map((id) => {
+    const s = owned.find((x) => x.id === id);
+    return s?.storeType ? `${id} (${s.storeType})` : id;
+  });
+  const platforms = [
+    ...new Set(t.ctx.records.filter((r) => r.kind === "Deployment" && r.component === t.component).map((r) => r.platform))
+  ].sort();
+  const design = docOf(t.files, "design.md");
+  const approach = sectionMatching(design, /^approach$/i);
+  const summary = design && approach ? design.rawLines.slice(approach.line, approach.end).join("\n").trim() : `[${NC}: the change's design.md has no Approach section]`;
+  const status = (s) => /^planned-(new|modify|retire)$/.test(s) ? s : "planned-new";
+  const mapping = mappingSections(docOf(t.files, "mappings.md")).filter((m) => [...calls, ...serves].some((h) => h.method === m.method && h.path === m.path));
+  const feature = `specs/${t.task.id}`;
+  const out = [
+    `# Implementation Plan: ${t.task.title}`,
+    "",
+    `**Branch**: \`${taskBranch(t.change.id, t.task.id)}\` | **Date**: ${date(t)} | **Spec**: [spec.md](./spec.md)`,
+    `**Input**: Feature specification from \`${feature}/spec.md\``,
+    "",
+    `<!-- Seeded by Atticus from the approved design of change ${t.change.id} for ${t.repo.id} (component ${t.component}). The services table, data-model.md and contracts/ are the design: Atticus reads them on every scan and reports drift, so amend the design through the change instead of here. -->`,
+    "",
+    "## Summary",
+    "",
+    summary,
+    "",
+    "## Technical Context",
+    "",
+    `**Language/Version**: ${NC}`,
+    `**Primary Dependencies**: ${NC}`,
+    `**Storage**: ${storage.length ? storage.join(", ") : "N/A"}`,
+    `**Testing**: ${NC}`,
+    `**Target Platform**: ${platforms.length ? platforms.join(", ") : NC}`,
+    "**Project Type**: single",
+    `**Performance Goals**: ${NC}`,
+    `**Constraints**: ${NC}`,
+    "",
+    "### Services this feature calls",
+    "",
+    "| Service | Operation | Via | Pattern | Status |",
+    "| --- | --- | --- | --- | --- |",
+    ...calls.map((h) => {
+      const via = viaOf(t.patterns, h.pattern) ?? (topicOf(h.operation) ? "event-bus" : "other");
+      return `| ${h.callee} | ${h.operation.trim()} | ${via} | ${h.pattern} | ${status(h.status)} |`;
+    }),
+    ""
+  ];
+  if (serves.length)
+    out.push("### Operations this feature serves", "", "| Operation | Caller | Pattern | Status | Contract |", "| --- | --- | --- | --- | --- |", ...serves.map((h) => `| ${h.method} ${h.path} | ${h.caller} | ${h.pattern} | ${status(h.status)} | ${contractFile(t)} |`), "");
+  if (mapping.length)
+    out.push("### Field mappings", "", ...mapping.flatMap((m) => [`#### ${m.method} ${m.path}`, "", ...m.lines, ""]));
+  const knowledge = readTaskKnowledge(t.files, t.task.stories, t.task.id);
+  if (knowledge.length)
+    out.push("### Knowledge that applies", "", `<!-- From the task's story in change ${t.change.id}: the organisation's pages (wikis and documents) that apply to this task, quoted as data. Where pages disagree, a person or the code decides; ask rather than pick. -->`, "", ...knowledge, "");
+  out.push("## Constitution Check", "", `[${NC}: check each principle of \`.specify/memory/constitution.md\`, generated from the org pack]`, "", "## Project Structure", "", "### Documentation (this feature)", "", "```text", `${feature}/`, "\u251C\u2500\u2500 plan.md", ...data.length ? ["\u251C\u2500\u2500 data-model.md"] : [], ...serves.length || calls.some((h) => topicOf(h.operation)) ? ["\u251C\u2500\u2500 contracts/"] : [], "\u2514\u2500\u2500 tasks.md", "```", "", "### Source Code (repository root)", "", "```text", `[${NC}: the files this feature adds or changes]`, "```", "", "## Open questions", "", "- None yet. Anything that needs the change's design goes here; it goes back up as an owner question.", "");
+  return out.join("\n");
+}
+function renderDataModel(t) {
+  const data = repoData(t);
+  if (data.length === 0)
+    return void 0;
+  const stores = [...new Set(data.map((d) => d.store))].sort();
+  const tables = /* @__PURE__ */ new Map();
+  for (const d of data) {
+    const name = d.table.includes(".") ? d.table.split(".").pop() : d.table;
+    const e = tables.get(d.tableId) ?? { name, store: d.store, isNew: false, rows: [] };
+    e.isNew ||= d.newTable;
+    for (const c of d.newColumns) {
+      let type = c.type;
+      const notNull = /\bnot null\b/i.test(type) || !d.newTable && /\bnot null\b/i.test(d.change);
+      type = type.replace(/\s*\bnot null\b.*$/i, "").replace(/\s*\bdefault\b.*$/i, "").trim();
+      const notes = d.newTable ? "" : `${d.change.trim()}${d.migration ? ` (${d.migration})` : ""}`;
+      e.rows.push(`| ${c.name} | ${type} | ${notNull ? "no" : ""} | ${notes} |`);
+    }
+    tables.set(d.tableId, e);
+  }
+  const out = [
+    `# Data Model: ${t.task.title}`,
+    "",
+    ...stores.length === 1 ? [`**Data store**: ${stores[0]}`, ""] : [],
+    `<!-- Seeded by Atticus from data.md of change ${t.change.id}. Keep the headings and tables in this shape: Atticus reads them on every scan. -->`,
+    "",
+    "## Entities",
+    ""
+  ];
+  for (const e of tables.values()) {
+    out.push(`### ${e.name} (${e.isNew ? "new" : "existing"} table)`, "");
+    if (stores.length > 1)
+      out.push(`**Store**: ${e.store}`, "");
+    out.push("| Column | Type | Nullable | Notes |", "| --- | --- | --- | --- |", ...e.rows, "");
+  }
+  return out.join("\n").replace(/\n+$/, "\n");
+}
+function renderOpenApi(t) {
+  const { serves } = repoHops(t);
+  if (serves.length === 0)
+    return void 0;
+  const paths = {};
+  for (const h of serves) {
+    const params = [...h.path.matchAll(/\{([^}]+)\}/g)].map((m) => ({
+      name: m[1],
+      in: "path",
+      required: true,
+      schema: { type: "string" }
+    }));
+    const op = {
+      operationId: `${h.method.toLowerCase()}-${h.path.replace(/[{}]/g, "").replace(/[^A-Za-z0-9]+/g, "-").replace(/^-+|-+$/g, "").toLowerCase()}`,
+      summary: `Called by ${h.caller}${h.pattern ? ` (${h.pattern})` : ""}`,
+      "x-atticus-status": /^planned-(new|modify|retire)$/.test(h.status) ? h.status : "planned-new",
+      ...h.pattern ? { "x-atticus-pattern": h.pattern } : {},
+      ...params.length ? { parameters: params } : {},
+      responses: { default: { description: "See the change's mappings.md" } }
+    };
+    (paths[h.path] ??= {})[h.method.toLowerCase()] = op;
+  }
+  return (0, import_yaml.stringify)({
+    openapi: "3.0.3",
+    info: {
+      title: `${t.component}, as planned by change ${t.change.id}`,
+      version: "0.0.0",
+      description: "Seeded by Atticus from interfaces.md. Fill in schemas while planning; keep the paths and methods, or amend the design."
+    },
+    paths
+  }, { lineWidth: 0 });
+}
+function renderAsyncApi(t) {
+  const topics = repoHops(t).calls.map((h) => ({ h, m: topicOf(h.operation) })).filter((x) => !!x.m);
+  if (topics.length === 0)
+    return void 0;
+  const channels = {};
+  const operations = {};
+  for (const { h, m } of topics) {
+    const key = m[2].replace(/[^A-Za-z0-9]+/g, "-");
+    channels[key] = { address: m[2] };
+    const send = /^(publish|send)$/i.test(m[1]);
+    operations[`${send ? "send" : "receive"}-${key}`] = {
+      action: send ? "send" : "receive",
+      channel: { $ref: `#/channels/${key}` },
+      summary: `${send ? "Published for" : "Read from"} ${h.callee}${h.pattern ? ` (${h.pattern})` : ""}`
+    };
+  }
+  return (0, import_yaml.stringify)({
+    asyncapi: "3.0.0",
+    info: {
+      title: `${t.component} events, as planned by change ${t.change.id}`,
+      version: "0.0.0"
+    },
+    channels,
+    operations
+  }, { lineWidth: 0 });
+}
+function renderChecklist(t) {
+  const dor = t.ctx.orgPack.testStrategy.definitionOfReady;
+  return [
+    `# Specification Quality Checklist: ${t.task.title}`,
+    "",
+    "**Purpose**: Check spec.md is ready before planning, against the org pack's definition of ready",
+    "**Feature**: [spec.md](../spec.md)",
+    "",
+    "## Definition of ready",
+    "",
+    ...dor.length ? dor.map((d, i) => `- [ ] CHK${String(i + 1).padStart(3, "0")} ${d}`) : ["- [ ] CHK001 Every acceptance criterion is testable"],
+    ""
+  ].join("\n");
+}
+function renderTasks(t) {
+  const stories = t.task.stories.map((s) => readStory(t.files, s)).filter((s) => !!s);
+  const lines = [
+    `# Tasks: ${t.task.title}`,
+    "",
+    `**Input**: spec.md and plan.md in this folder (task ${t.task.id} of change ${t.change.id})`,
+    "",
+    "<!-- Seeded by Atticus at hand-down. Refine it with /speckit.tasks; tick each box as you finish it. -->",
+    "",
+    "## Implementation",
+    "",
+    `- [ ] T001 ${t.task.title}`,
+    "",
+    "## Tests",
+    ""
+  ];
+  let n = 2;
+  for (const s of stories)
+    for (const c of s.criteria)
+      lines.push(`- [ ] T${String(n++).padStart(3, "0")} [${s.id}] Test: ${c.replace(/\s+/g, " ").trim()}`);
+  if (n === 2)
+    lines.push(`- [ ] T002 Test the behaviour spec.md describes [${NC}: no acceptance criteria]`);
+  lines.push("");
+  return lines.join("\n");
+}
+function renderAtticusTask(t) {
+  const spec = renderSpec(t).split("\n");
+  const plan = renderPlan(t).split("\n");
+  const from = (lines, heading) => {
+    const i = lines.indexOf(heading);
+    if (i < 0)
+      return [];
+    const end = lines.findIndex((l, j) => j > i && /^## /.test(l));
+    return lines.slice(i + 1, end < 0 ? void 0 : end);
+  };
+  return [
+    `# Task ${t.task.id}: ${t.task.title}`,
+    "",
+    `Change ${t.change.id} (${t.change.title}), branch \`${taskBranch(t.change.id, t.task.id)}\`. Handed down by Atticus; amend the design through the change, not here.`,
+    "",
+    "## Stories and acceptance criteria",
+    ...from(spec, "## User Scenarios & Testing *(mandatory)*"),
+    "## Design for this repo",
+    ...from(plan, "## Summary"),
+    ...from(plan, "## Technical Context")
+  ].join("\n").replace(/\n{3,}/g, "\n\n").replace(/\n*$/, "\n");
+}
+
+// packages/speckit/dist/handdown.js
+async function putIfFree(dir, rel, text, force, r) {
+  const full = join3(dir, rel);
+  const current = await readFile2(full, "utf8").catch(() => void 0);
+  if (current === text) {
+    r.unchanged.push(rel);
+    return;
+  }
+  if (current !== void 0 && !force) {
+    r.kept.push(rel);
+    return;
+  }
+  await mkdir(dirname(full), { recursive: true });
+  await writeFile(`${full}.atticus-tmp`, text, "utf8");
+  await rename(`${full}.atticus-tmp`, full);
+  r.written.push(rel);
+}
+function handDownFiles(t, engine) {
+  const files = /* @__PURE__ */ new Map();
+  if (engine === "atticus") {
+    files.set(`.atticus/tasks/${t.task.id}.md`, renderAtticusTask(t));
+    return files;
+  }
+  const dir = `specs/${t.task.id}`;
+  files.set(`${dir}/spec.md`, renderSpec(t));
+  files.set(`${dir}/plan.md`, renderPlan(t));
+  files.set(`${dir}/tasks.md`, renderTasks(t));
+  const dm = renderDataModel(t);
+  if (dm)
+    files.set(`${dir}/data-model.md`, dm);
+  const oa = renderOpenApi(t);
+  if (oa)
+    files.set(`${dir}/${contractFile(t)}`, oa);
+  const aa = renderAsyncApi(t);
+  if (aa)
+    files.set(`${dir}/contracts/${t.component}-events.yaml`, aa);
+  files.set(`${dir}/checklists/requirements.md`, renderChecklist(t));
+  return files;
+}
+function featureJson(t) {
+  return JSON.stringify({
+    feature_directory: `specs/${t.task.id}`,
+    change: t.change.id,
+    task: t.task.id,
+    branch: taskBranch(t.change.id, t.task.id)
+  }, null, 2) + "\n";
+}
+async function handDown(root, changeId, taskId, o = {}) {
+  const t = await loadTask(root, changeId, taskId);
+  const dir = await changeWorktree(root, t.change.id, t.repo.id);
+  const engine = buildEngineFor(t.ctx.orgPack, t.repo.id);
+  const r = {
+    change: t.change.id,
+    task: t.task.id,
+    repo: t.repo.id,
+    engine,
+    worktree: toRepoRelative(root, dir),
+    feature: engine === "speckit" ? `specs/${t.task.id}` : ".atticus/tasks",
+    written: [],
+    unchanged: [],
+    kept: [],
+    assistantFiles: { results: [], upToDate: true },
+    problems: []
+  };
+  for (const [rel, text] of handDownFiles(t, engine))
+    await putIfFree(dir, rel, text, !!o.force, r);
+  const ref = await referenceMetarepoIn(root, dir, o.git ? { git: o.git } : {});
+  if (ref.action === "added")
+    r.written.push(ref.file);
+  else if (ref.action === "present")
+    r.unchanged.push(ref.file);
+  else if (ref.action === "skipped")
+    r.problems.push(`OpenSpec reference not added to ${ref.file}: ${ref.why}`);
+  if (engine === "speckit") {
+    await putIfFree(dir, ".specify/feature.json", featureJson(t), true, r);
+    const rules = await rulesForRepo(root, t.repo.owner);
+    r.problems.push(...rules.problems);
+    const input = {
+      repo: t.repo.id,
+      rules: rules.rules,
+      orgPack: t.ctx.orgPack,
+      constitutionVersion: rules.constitutionVersion,
+      team: t.repo.owner
+    };
+    const path = ".specify/memory/constitution.md";
+    const plan = constitutionPlan(await readFile2(join3(dir, path), "utf8").catch(() => void 0));
+    if (plan.mode === "refuse") {
+      r.kept.push(path);
+      r.problems.push(plan.reason);
+    } else {
+      const c = await writeAssistantFiles(dir, [
+        {
+          path,
+          content: plan.mode === "file" ? renderConstitution(input) : renderConstitutionSection(input),
+          source: "org-pack checklists and the Atticus constitution",
+          mode: plan.mode,
+          style: "html"
+        }
+      ], { ...o.force ? { force: true } : {} });
+      for (const x of c.results)
+        (x.action === "created" || x.action === "updated" ? r.written : x.action === "unchanged" ? r.unchanged : r.kept).push(x.path);
+    }
+  }
+  const af = await generateAssistantFiles(root, {
+    repo: t.repo.id,
+    dir,
+    ...o.force ? { force: true } : {}
+  });
+  r.assistantFiles = { results: af.results, upToDate: af.upToDate };
+  r.problems.push(...af.problems);
+  if (o.commit !== false && (r.written.length || af.results.some((x) => x.written))) {
+    const git = o.git ?? createGit();
+    await git(["add", "-A", "--", "."], dir);
+    const staged = (await git(["diff", "--cached", "--name-only"], dir)).stdout.trim();
+    if (staged) {
+      await git([
+        "commit",
+        "-q",
+        "-m",
+        `Hand down task ${t.task.id} of ${t.change.id}: ${t.task.title}`,
+        "-m",
+        `Atticus-Change: ${t.change.id}
+Atticus-Task: ${t.task.id}`
+      ], dir);
+      r.commit = (await git(["rev-parse", "HEAD"], dir)).stdout.trim();
+    }
+  }
+  return r;
+}
+
+// packages/speckit/dist/drift.js
+import { existsSync as existsSync2 } from "node:fs";
+import { readFile as readFile4 } from "node:fs/promises";
+import { join as join6 } from "node:path";
+
+// packages/speckit/dist/rounds.js
+var import_yaml2 = __toESM(require_dist(), 1);
+import { readFile as readFile3 } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { join as join4 } from "node:path";
+var __atticus_import_meta_url = __atticusUrl("packages/speckit/dist/rounds.js");
+var sig = (fs) => fs.map((f) => `${fingerprint(f)}|${f.state}|${f.severity}`).sort().join("\n");
+async function writeFullRound(root, change, gate, fresh, o) {
+  const rounds = await roundsOf(root, change, gate);
+  const last = rounds.at(-1);
+  const prev = last ? (await readRound(root, change, gate, last)).findings.map((s) => s.finding) : [];
+  const carried = prev.filter((f) => o.carry?.(f));
+  const byPrint = new Map(prev.map((f) => [fingerprint(f), f]));
+  const taken = new Set(carried.map((f) => f.id));
+  const next = [...carried];
+  for (const f of fresh) {
+    const before = byPrint.get(fingerprint(f));
+    let id = f.id;
+    for (let i = 2; taken.has(id); i++)
+      id = `${f.id}-${i}`;
+    taken.add(id);
+    const merged = Finding.safeParse({
+      ...f,
+      id,
+      createdAt: before?.createdAt ?? f.createdAt,
+      ...before?.resolution ? { state: before.state, resolution: before.resolution } : {}
+    });
+    next.push(merged.success ? merged.data : { ...f, id });
+  }
+  if (sig(next) === sig(prev) && (last !== void 0 || next.length === 0)) {
+    const findings2 = last ? (await readRound(root, change, gate, last)).findings : [];
+    return { gate, ...last ? { round: last } : {}, unchanged: true, findings: findings2 };
+  }
+  const round = (last ?? 0) + 1;
+  const findings = [];
+  for (const f of next.sort((a, b) => a.id.localeCompare(b.id))) {
+    const g = Finding.parse({ ...f, round, gate, change });
+    await writeFinding(root, g);
+    findings.push({ finding: g, path: `review/${gate}/${round}/${g.id}.yaml` });
+  }
+  await writeFileAtomic(join4(changeFolder(root, change), "review", gate, String(round), "meta", "round.yaml"), toCanonicalYaml({
+    schemaVersion: 1,
+    change,
+    gate,
+    round,
+    createdAt: o.now,
+    findings: findings.map((f) => ({
+      id: f.finding.id,
+      rule: f.finding.rule,
+      severity: f.finding.severity
+    })),
+    ...o.meta
+  }, ["schemaVersion", "change", "gate", "round", "createdAt"]));
+  return { gate, round, unchanged: false, findings };
+}
+var DRIFT_RULES_FILE = fileURLToPath(new URL("../rules/drift.yaml", __atticus_import_meta_url));
+async function loadDriftRules() {
+  const pack = ChecklistPack.parse((0, import_yaml2.parse)(await readFile3(DRIFT_RULES_FILE, "utf8")));
+  return new Map(pack.rules.map((r) => [r.id, r]));
+}
+
+// packages/speckit/dist/worktree.js
+import { existsSync } from "node:fs";
+import { mkdir as mkdir2 } from "node:fs/promises";
+import { dirname as dirname2, join as join5 } from "node:path";
+function taskWorktreePath(root, change, task, repo) {
+  for (const [what, v] of [
+    ["task id", task],
+    ["repo id", repo]
+  ])
+    if (!RecordId.safeParse(v).success)
+      throw new SpecKitError("invalid", `${what} "${v}" must be a lowercase slug`);
+  return join5(changeWorktreesDir(root, change), ".tasks", task, repo);
+}
+async function openTaskWorktree(root, change, task, repo, git = createGit()) {
+  const path = taskWorktreePath(root, change, task, repo);
+  const branch = taskBranch(change, task);
+  if (existsSync(path))
+    return { path, branch, created: false };
+  const base = baseClonePath(root, repo);
+  if (!existsSync(base))
+    throw new SpecKitError("refused", `There is no base clone of ${repo}; run atticus workspace sync first.`);
+  const ok = async (ref) => git(["rev-parse", "--verify", "--quiet", ref], base).then(() => true, () => false);
+  await mkdir2(dirname2(path), { recursive: true });
+  if (await ok(`refs/heads/${branch}`))
+    await git(["worktree", "add", "--", path, branch], base);
+  else {
+    const from = changeBranch(change);
+    if (!await ok(`refs/heads/${from}`))
+      throw new SpecKitError("refused", `${repo} has no ${from} branch yet. Open the change first: atticus workspace open ${change} --repos ${repo}`);
+    await git(["worktree", "add", "--no-track", "-b", branch, "--", path, from], base);
+  }
+  return { path, branch, created: true };
+}
+
+// packages/speckit/dist/drift.js
+var DRIFT_GATE = "drift";
+var PAST_BUILD = /* @__PURE__ */ new Set(["qa", "release-ready", "released", "post-release-review"]);
+var isPlanOnly = (r) => r.evidence.length > 0 && r.evidence.every((e) => (e.extractor ?? "").startsWith("speckit@"));
+var norm = (p) => normalizePath(p ?? "");
+var typeKey = (t) => t.toLowerCase().replace(/\s+/g, "");
+var topicOf2 = (op) => /^(publish|subscribe|send|receive)\s+(\S+)/i.exec(op.trim())?.[2];
+var slug = (s) => s.toLowerCase().replace(/[^a-z0-9.]+/g, "-").replace(/^-+|-+$/g, "");
+async function readChangePlans(root, changeId) {
+  const repos = (await readChangeRepos(root, changeId))?.repos ?? [];
+  if (repos.length === 0)
+    return [];
+  const manifest = new Map((await loadRepos(root)).map((r) => [r.id, r]));
+  const files = await readChangeFiles(changeFolder(root, changeId));
+  const tasks = readChangeTasks(files);
+  const out = /* @__PURE__ */ new Map();
+  for (const r of repos) {
+    const m = manifest.get(r.id);
+    const component = m?.component ?? r.id;
+    const mine = tasks.filter((t) => t.repo === r.id).map((t) => t.id);
+    const dirs = [
+      join6(root, r.worktree),
+      ...mine.map((t) => taskWorktreePath(root, changeId, t, r.id))
+    ].filter((d) => existsSync2(d));
+    for (const dir of dirs) {
+      const features = await readSpecKitFeatures(fsRepo(r.id, dir, "0".repeat(40)), {
+        component,
+        ...m?.system ? { system: m.system } : {},
+        dialects: [],
+        scannedAt: "1970-01-01T00:00:00Z",
+        warn: () => void 0
+      });
+      for (const f of features)
+        if (mine.includes(f.feature))
+          out.set(`${r.id}/${f.feature}`, {
+            repo: r.id,
+            component,
+            from: dir.slice(root.length + 1).split("\\").join("/"),
+            feature: f
+          });
+    }
+  }
+  return [...out.values()].sort((a, b) => `${a.repo}/${a.feature.feature}`.localeCompare(`${b.repo}/${b.feature.feature}`));
+}
+async function driftCheck(root, changeId, o = {}) {
+  const now = o.now ?? (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
+  const ctx = await loadChangeContext(root);
+  const change = await changeStore(root).read(changeId).catch((e) => {
+    throw new SpecKitError("not-found", e.message);
+  });
+  const rules = await loadDriftRules();
+  const files = await readChangeFiles(changeFolder(root, change.id));
+  const hops = readHops(files);
+  const data = readDataChanges(files);
+  const patterns = new Map(ctx.orgPack.patterns.map((p) => [p.code, p]));
+  const plans = await readChangePlans(root, change.id);
+  const code = ctx.records.filter((r) => !isPlanOnly(r) && !r.status.startsWith("planned-"));
+  const codeOf = (k) => code.filter((r) => r.kind === k);
+  const codeInterfaces = codeOf("Interface");
+  const codeEndpoints = codeOf("Endpoint");
+  const codeIds = new Set(code.map((r) => `${r.kind}/${r.id}`));
+  const systemOf = (id) => {
+    const c = code.find((r) => r.kind === "Component" && r.id === id);
+    return c?.system;
+  };
+  const designParties = /* @__PURE__ */ new Set([
+    ...change.systems,
+    ...hops.flatMap((h) => [h.caller, h.callee])
+  ]);
+  const knownToDesign = (id) => designParties.has(id) || systemOf(id) !== void 0 && designParties.has(systemOf(id));
+  const found = [];
+  const doc = (name) => docOf(files, name);
+  const quote = (lines, n) => {
+    const t = lines?.[n - 1]?.trim();
+    return t ? t.length <= 190 ? t : `${t.slice(0, 187)}...` : void 0;
+  };
+  const planText = /* @__PURE__ */ new Map();
+  for (const p of plans)
+    for (const f of p.feature.files)
+      planText.set(`${p.repo}/${f}`, (await readFile4(join6(root, p.from, f), "utf8")).replace(/\r\n/g, "\n").split("\n"));
+  const specEv = (p, r) => {
+    const e = r.evidence[0];
+    const q = e.path && e.line ? quote(planText.get(`${p.repo}/${e.path}`), e.line) : void 0;
+    return {
+      source: "spec",
+      repo: p.repo,
+      ...e.path ? { path: e.path } : {},
+      ...e.line ? { line: e.line } : {},
+      ...q ? { quote: q } : {}
+    };
+  };
+  const artEv = (name, line2) => {
+    const q = quote(doc(name)?.rawLines, line2);
+    return { source: "artifact", path: name, line: line2, ...q ? { quote: q } : {} };
+  };
+  const add = (ruleId, subject, f) => {
+    const rule = rules.get(ruleId);
+    found.push(Finding.parse({
+      schemaVersion: 1,
+      id: `${ruleId.replace(/^drift\./, "")}-${slug(subject)}`.slice(0, 120),
+      kind: "issue",
+      change: change.id,
+      gate: DRIFT_GATE,
+      round: 1,
+      rule: rule.id,
+      layer: rule.layer,
+      lens: rule.lens,
+      severity: rule.severity,
+      artifact: f.artifact,
+      locator: f.locator,
+      summary: f.summary,
+      why: rule.description ?? rule.title,
+      fix: {
+        text: rule.lens === "architecture" ? "Amend the change's design through its hand-off, or change the repo plan back to the design." : "Check which is right, the plan or the code, and fix the other."
+      },
+      evidence: f.evidence,
+      waivable: false,
+      state: "open",
+      createdAt: now
+    }));
+  };
+  const designHopFor = (from, to, method, path) => hops.find((h) => h.caller === from && h.callee === to && (method ? h.method === method && norm(h.path) === norm(path) : topicOf2(h.operation) === path));
+  const designColumn = (table, column) => {
+    for (const d of data)
+      if (d.tableId === table) {
+        for (const c of d.newColumns)
+          if (c.name.toLowerCase() === column.toLowerCase())
+            return {
+              d,
+              type: c.type.replace(/\s*\bnot null\b.*$/i, "").replace(/\s*\bdefault\b.*$/i, "").trim()
+            };
+      }
+    return void 0;
+  };
+  for (const p of plans) {
+    const where = (r) => `${r.evidence[0]?.path ?? p.feature.dir} in ${p.repo}`;
+    for (const raw of p.feature.records) {
+      const r = raw;
+      if (r.kind === "Interface") {
+        const i = r;
+        const pathOrTopic = i.normalizedPath;
+        const h = designHopFor(i.from, i.to, i.method, pathOrTopic);
+        const shown = i.method ? `${i.method} ${h?.path ?? pathOrTopic}` : `publish ${pathOrTopic}`;
+        if (h) {
+          const dv = viaOf(patterns, h.pattern);
+          const reasons = [];
+          if (dv && i.via !== "other" && i.via !== dv)
+            reasons.push(`${i.via}; the approved design says ${dv} (${h.pattern})`);
+          else if (i.pattern?.code && h.pattern && i.pattern.code !== h.pattern)
+            reasons.push(`with pattern ${i.pattern.code}; the approved design says ${h.pattern}`);
+          if (reasons.length)
+            add("drift.plan-contradicts-design", i.id, {
+              artifact: "interfaces.md",
+              locator: { line: h.line },
+              summary: `${where(i)} calls ${i.to} ${shown} ${reasons[0]}.`,
+              evidence: [artEv("interfaces.md", h.line), specEv(p, i)]
+            });
+        } else {
+          const c = codeInterfaces.find((x) => x.from === i.from && x.to === i.to && (x.method ?? "") === (i.method ?? "") && norm(x.normalizedPath) === norm(pathOrTopic));
+          if (c) {
+            if (i.via !== "other" && c.via !== i.via)
+              add("drift.plan-vs-code", i.id, {
+                artifact: "catalog",
+                locator: { record: c.id },
+                summary: `${where(i)} calls ${i.to} ${shown} ${i.via}; the code calls it ${c.via}.`,
+                evidence: [specEv(p, i), { source: "catalog", record: c.id }]
+              });
+          } else if (!knownToDesign(i.to))
+            add("drift.plan-adds-system", i.id, {
+              artifact: "interfaces.md",
+              locator: { record: i.id },
+              summary: `${where(i)} calls ${i.to} (${shown}), a system the design doesn't include.`,
+              evidence: [specEv(p, i)]
+            });
+          else
+            add("drift.plan-adds-interface", i.id, {
+              artifact: "interfaces.md",
+              locator: { record: i.id },
+              summary: `${where(i)} adds ${i.from} to ${i.to} (${shown}), which the design doesn't have.`,
+              evidence: [specEv(p, i)]
+            });
+        }
+        if (PAST_BUILD.has(change.state) && i.status === "planned-new" && !codeInterfaces.some((x) => x.id === i.id))
+          add("drift.plan-not-built", i.id, {
+            artifact: "catalog",
+            locator: { record: i.id },
+            summary: `${where(i)} plans ${i.from} to ${i.to} (${shown}); the code doesn't have it.`,
+            evidence: [specEv(p, i)]
+          });
+      } else if (r.kind === "Endpoint") {
+        const e = r;
+        if (e.component !== p.component)
+          continue;
+        const rest = e.endpointType === "rest";
+        const inDesign = rest ? hops.some((h) => h.callee === p.component && h.method === e.method && norm(h.path) === norm(e.pathOrTopic)) : hops.some((h) => h.caller === p.component && topicOf2(h.operation) === e.pathOrTopic);
+        const inCode = codeEndpoints.some((x) => rest ? x.component === e.component && x.method === e.method && norm(x.normalizedPath ?? x.pathOrTopic) === norm(e.pathOrTopic) : x.endpointType === "event-topic" && x.pathOrTopic === e.pathOrTopic);
+        const shown = rest ? `${e.method} ${e.pathOrTopic}` : `topic ${e.pathOrTopic}`;
+        if (!inDesign && (!inCode || e.status !== "planned-new"))
+          add("drift.plan-adds-interface", e.id, {
+            artifact: "interfaces.md",
+            locator: { record: e.id },
+            summary: inCode ? `${where(e)} changes ${shown}, which the design doesn't plan to change.` : `${where(e)} serves ${shown}, which the design doesn't have.`,
+            evidence: [specEv(p, e)]
+          });
+        if (PAST_BUILD.has(change.state) && e.status === "planned-new" && !inCode)
+          add("drift.plan-not-built", e.id, {
+            artifact: "catalog",
+            locator: { record: e.id },
+            summary: `${where(e)} plans ${shown}; the code doesn't have it.`,
+            evidence: [specEv(p, e)]
+          });
+      } else if (r.kind === "Table") {
+        const t = r;
+        const inDesign = data.some((d) => d.tableId === t.id);
+        const inCode = codeIds.has(`Table/${t.id}`);
+        if (!inDesign && (!inCode || t.status !== "planned-new"))
+          add("drift.plan-adds-data", t.id, {
+            artifact: "data.md",
+            locator: { record: t.id },
+            summary: inCode ? `${where(t)} changes table ${t.id}, which data.md doesn't.` : `${where(t)} adds table ${t.id}, which data.md doesn't have.`,
+            evidence: [specEv(p, t)]
+          });
+      } else if (r.kind === "Column") {
+        const c = r;
+        const tableName = c.table.split(".").slice(1).join(".");
+        const dc = designColumn(c.table, c.name);
+        const codeCol = code.find((x) => x.kind === "Column" && x.id === c.id);
+        if (dc) {
+          if (typeKey(dc.type) !== typeKey(c.type))
+            add("drift.plan-contradicts-design", c.id, {
+              artifact: "data.md",
+              locator: { line: dc.d.line },
+              summary: `${where(c)} makes ${dc.d.table || tableName}.${c.name} ${c.type}; data.md says ${dc.type}.`,
+              evidence: [artEv("data.md", dc.d.line), specEv(p, c)]
+            });
+        } else if (codeCol) {
+          if (typeKey(codeCol.type) !== typeKey(c.type))
+            add("drift.plan-vs-code", c.id, {
+              artifact: "catalog",
+              locator: { record: codeCol.id },
+              summary: `${where(c)} makes ${tableName}.${c.name} ${c.type}; the code has ${codeCol.type}.`,
+              evidence: [specEv(p, c), { source: "catalog", record: codeCol.id }]
+            });
+        } else if (data.some((d) => d.tableId === c.table) || codeIds.has(`Table/${c.table}`)) {
+          add("drift.plan-adds-data", c.id, {
+            artifact: "data.md",
+            locator: { record: c.id },
+            summary: `${where(c)} adds column ${tableName}.${c.name}, which data.md doesn't have.`,
+            evidence: [specEv(p, c)]
+          });
+        }
+      }
+    }
+  }
+  const codeIfIds = new Set(codeInterfaces.map((i) => i.id));
+  for (const h of hops) {
+    const shown = `${h.caller} to ${h.callee} (${h.operation.trim()})`;
+    if (/^if-/.test(h.id) && /planned-(modify|retire)/.test(h.status) && !codeIfIds.has(h.id))
+      add("drift.design-vs-code", h.id, {
+        artifact: "interfaces.md",
+        locator: { line: h.line },
+        summary: `interfaces.md changes ${h.id}, ${shown}, which the code doesn't have.`,
+        evidence: [artEv("interfaces.md", h.line)]
+      });
+    if (!PAST_BUILD.has(change.state))
+      continue;
+    const there = codeInterfaces.some((x) => x.from === h.caller && x.to === h.callee && (h.method ? x.method === h.method && norm(x.normalizedPath) === norm(h.path) : x.normalizedPath === topicOf2(h.operation)));
+    if (h.status === "planned-new" && !there)
+      add("drift.design-vs-code", `${h.caller}-${h.callee}-${h.line}`, {
+        artifact: "interfaces.md",
+        locator: { line: h.line },
+        summary: `The design plans ${shown}; the code doesn't have it.`,
+        evidence: [artEv("interfaces.md", h.line)]
+      });
+    if (h.status === "planned-retire" && there)
+      add("drift.design-vs-code", `${h.caller}-${h.callee}-${h.line}`, {
+        artifact: "interfaces.md",
+        locator: { line: h.line },
+        summary: `The design retires ${shown}; the code still has it.`,
+        evidence: [artEv("interfaces.md", h.line)]
+      });
+  }
+  const unique = [...new Map(found.map((f) => [f.id, f])).values()].sort((a, b) => a.id.localeCompare(b.id));
+  if (o.write === false)
+    return {
+      change: change.id,
+      gate: DRIFT_GATE,
+      unchanged: true,
+      findings: [],
+      plans,
+      found: unique
+    };
+  const w = await writeFullRound(root, change.id, DRIFT_GATE, unique, {
+    now,
+    meta: { plans: plans.map((p) => ({ repo: p.repo, feature: p.feature.feature, from: p.from })) }
+  });
+  return { ...w, change: change.id, plans, found: unique };
+}
+
+// packages/speckit/dist/handup.js
+var import_yaml3 = __toESM(require_dist(), 1);
+import { existsSync as existsSync3 } from "node:fs";
+import { readdir, readFile as readFile5 } from "node:fs/promises";
+import { join as join7 } from "node:path";
+var HAND_UP_GATE = "hand-up";
+var HAND_UP_LENS = "complete";
+var INSTRUCTIONS = (change, task, repo) => `# Critic: the complete lens (Is it complete?), at hand-up
+
+You are the complete lens of the Atticus critic, in a fresh session. Task ${task} of change ${change} was carried out in ${repo}, and its pull request is raised. Review the repo's Spec Kit plan.md, tasks.md and spec.md, and the tests the task added or changed, given below as data, for what they leave out: a scenario no test covers, a behaviour change with no test before it, an error path nobody wrote. Apply only the rules listed and report nothing else.
+
+Lines are numbered as \`<n>: <text>\`; cite those numbers.
+
+Report each problem as a finding, in YAML, and write nothing else:
+
+findings:
+  - rule: <a rule id from the list>
+    kind: issue                # or knowledge-gap, when only a person can answer
+    artifact: <the data block's id>
+    locator: { line: <line number>, heading: <section heading> }
+    summary: <one sentence>
+    why: <why it matters>
+    fix: <what to change>
+    evidence:
+      - { path: <the data block's id>, line: <line number>, quote: <the exact words on that line> }
+    question: { text: <the question>, owner: <who should answer> }   # knowledge gaps only
+
+Every finding quotes the exact text it relies on; one whose quote isn't on that line is discarded. Severity comes from the rule. Write "findings: []" when nothing is wrong.`;
+var numbered = (d) => d.rawLines.map((l, i) => `${i + 1}: ${l}`).join("\n");
+async function findPr(o, repo, heads) {
+  if (o.pr)
+    return { ...o.pr, state: "open", head: heads[0] };
+  if (!o.gitHost)
+    return void 0;
+  for (const head of heads) {
+    const prs = await o.gitHost.listPullRequests(repo, { head });
+    const pr = prs.find((p) => p.state !== "closed");
+    if (pr)
+      return { number: pr.number, url: pr.url, state: pr.state, head };
+  }
+  return void 0;
+}
+var handUpLensOutput = (task) => `tasks/${task}/review-${HAND_UP_LENS}.yaml`;
+var TEST_FILE = /(^|\/)(src\/test|tests?|__tests__|spec)\/|(\.|_)(test|spec)\.[cm]?[jt]sx?$|(Test|Tests|IT)\.(java|kt|cs)$|_test\.(go|py|rb)$|^test_.*\.py$|\/test_[^/]*\.py$|\.feature$/;
+function handUpLensTask(outputPath) {
+  return /^tasks\/([^/]+)\/review-(?:complete|code-and-test)\.yaml$/.exec(outputPath)?.[1];
+}
+function reviewsTask(r) {
+  if (r.check.type !== "ai" || questionOfRule(r) !== HAND_UP_LENS)
+    return false;
+  return r.lens === "code-and-test" || r.appliesTo.artifacts.some((a) => a === "code" || a === "tests");
+}
+async function lensSetup(root, t, now) {
+  const gate = {
+    id: HAND_UP_GATE,
+    phase: "build",
+    approvers: ["developer"],
+    minApprovals: 1,
+    checklists: [],
+    checks: [],
+    maxAuthorRounds: 2
+  };
+  const criticCtx = buildContext({
+    root,
+    change: t.change,
+    type: changeTypeOf(t.ctx, t.change.type),
+    lifecycle: t.ctx,
+    footprint: await changeFootprint(t.ctx, t.change),
+    files: t.files,
+    gate,
+    now
+  });
+  const { rules: all } = await rulesForRepo(root, t.repo.owner);
+  const rules = all.filter(reviewsTask);
+  return { criticCtx, rules };
+}
+async function applyLensRun(root, a) {
+  const { t, now } = a;
+  const left = new Set(a.run.request.pack.manifest.dropped.map((d) => d.id));
+  const parsed = parseLensOutput(a.criticCtx, HAND_UP_LENS, a.run.output ?? "", a.rules, a.docs.filter((d) => !left.has(d.path)));
+  const taken = /* @__PURE__ */ new Set();
+  const prefix = `t${t.task.id.replace(/[^a-z0-9]+/g, "-")}-`;
+  const fresh = parsed.hits.map((h) => toFinding(h, {
+    id: `${prefix}${findingIdFor(h, taken)}`.slice(0, 120),
+    change: t.change.id,
+    gate: HAND_UP_GATE,
+    round: 1,
+    now
+  }));
+  const review = await writeFullRound(root, t.change.id, HAND_UP_GATE, fresh, {
+    now,
+    carry: (f) => !f.artifact.startsWith(`tasks/${t.task.id}/`),
+    meta: {
+      task: t.task.id,
+      repo: t.repo.id,
+      ...a.pr !== void 0 ? { pr: a.pr } : {},
+      runId: a.run.runId
+    }
+  });
+  return { discarded: parsed.discarded, review };
+}
+async function completeHandUpLens(root, run, o = {}) {
+  const task = handUpLensTask(run.request.outputPath);
+  if (!task)
+    throw new SpecKitError("refused", `Run ${run.runId} isn't a hand-up review of a task.`);
+  const now = o.now ?? (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
+  const t = await loadTask(root, run.request.change, task);
+  const folder = changeFolder(root, t.change.id);
+  const evidenceDir = join7(folder, `tasks/${task}/evidence`);
+  const docs = [];
+  for (const name of (await readdir(evidenceDir).catch(() => [])).sort())
+    if (name.endsWith(".md"))
+      docs.push(parseDoc(`tasks/${task}/evidence/${name}`, await readFile5(join7(evidenceDir, name), "utf8")));
+  const source = (0, import_yaml3.parse)(await readFile5(join7(evidenceDir, "source.yaml"), "utf8").catch(() => "{}"));
+  const { criticCtx, rules } = await lensSetup(root, t, now);
+  const summary = toRunSummary(run);
+  await writeFileAtomic(join7(folder, `tasks/${task}/runs/${run.runId}.yaml`), toCanonicalYaml(summary, ["schemaVersion", "runId"]));
+  const lens = {
+    state: "ran",
+    runId: run.runId,
+    agent: run.request.agent.id,
+    rules: rules.map((r) => r.id),
+    discarded: [],
+    summary
+  };
+  if (run.state !== "validated" || run.output === void 0) {
+    lens.state = "failed";
+    lens.reason = run.errors.join("; ") || `the run ended ${run.state}`;
+    return { change: t.change.id, task, lens };
+  }
+  const applied = await applyLensRun(root, {
+    t,
+    criticCtx,
+    rules,
+    docs,
+    run,
+    ...source?.pr?.number !== void 0 ? { pr: source.pr.number } : {},
+    now
+  });
+  lens.discarded = applied.discarded;
+  return { change: t.change.id, task, lens, review: applied.review };
+}
+async function handUp(root, changeId, taskId, o) {
+  const now = o.now ?? (/* @__PURE__ */ new Date()).toISOString().replace(/\.\d{3}Z$/, "Z");
+  const t = await loadTask(root, changeId, taskId);
+  const heads = [taskBranch(t.change.id, t.task.id), changeBranch(t.change.id)];
+  const pr = await findPr(o, t.repo.id, heads);
+  if (!pr)
+    throw new SpecKitError("refused", `The pull request for task ${t.task.id} isn't raised yet (looked for ${heads.join(" and ")} in ${t.repo.id}). Hand-up runs once it is; with no Git host connected, record it with --pr <number> --pr-url <url>.`);
+  const taskDir = taskWorktreePath(root, t.change.id, t.task.id, t.repo.id);
+  const dir = existsSync3(taskDir) ? taskDir : await changeWorktree(root, t.change.id, t.repo.id);
+  const engine = buildEngineFor(t.ctx.orgPack, t.repo.id);
+  const wanted = engine === "speckit" ? ["plan.md", "tasks.md", "spec.md"].map((f) => `specs/${t.task.id}/${f}`) : [`.atticus/tasks/${t.task.id}.md`];
+  const git = o.git ?? createGit();
+  const sha = await git(["rev-parse", "HEAD"], dir).then((r) => r.stdout.trim(), () => void 0);
+  const folder = changeFolder(root, t.change.id);
+  const evidence = [];
+  const docs = [];
+  for (const rel of wanted) {
+    const text = await readFile5(join7(dir, rel), "utf8").catch(() => void 0);
+    if (text === void 0)
+      continue;
+    const to = `tasks/${t.task.id}/evidence/${rel.split("/").pop()}`;
+    await writeFileAtomic(join7(folder, to), text);
+    evidence.push(to);
+    docs.push(parseDoc(to, text));
+  }
+  const base = await git(["merge-base", "HEAD", t.repo.defaultBranch ?? "main"], dir).then((r) => r.stdout.trim(), () => void 0);
+  if (base) {
+    const changed = await git(["diff", "--name-only", `${base}..HEAD`], dir).then((r) => r.stdout.split("\n").map((l) => l.trim()).filter(Boolean), () => []);
+    const tests = changed.filter((f) => TEST_FILE.test(f)).sort().slice(0, 8);
+    for (const rel of tests) {
+      const text = await readFile5(join7(dir, rel), "utf8").catch(() => void 0);
+      if (text === void 0 || text.length > 6e4)
+        continue;
+      const to = `tasks/${t.task.id}/evidence/tests/${rel.replace(/[\\/]/g, "__")}`;
+      await writeFileAtomic(join7(folder, to), text);
+      evidence.push(to);
+      docs.push(parseDoc(to, text));
+    }
+  }
+  if (engine === "speckit" && !evidence.some((e) => e.endsWith("/plan.md")))
+    throw new SpecKitError("refused", `specs/${t.task.id}/plan.md isn't in ${t.repo.id}; hand the task down first: atticus spec hand-down ${t.change.id} ${t.task.id}`);
+  await writeFileAtomic(join7(folder, `tasks/${t.task.id}/evidence/source.yaml`), toCanonicalYaml({
+    schemaVersion: 1,
+    change: t.change.id,
+    task: t.task.id,
+    repo: t.repo.id,
+    branch: pr.head,
+    ...sha ? { commit: sha } : {},
+    pr: { number: pr.number, url: pr.url },
+    files: wanted.filter((w) => evidence.some((e) => e.endsWith(`/${w.split("/").pop()}`))),
+    ...evidence.some((e) => e.includes("/evidence/tests/")) ? { tests: evidence.filter((e) => e.includes("/evidence/tests/")) } : {},
+    by: o.by,
+    at: now
+  }, ["schemaVersion", "change", "task", "repo", "branch", "commit"]));
+  const markedDone = await markTaskDone(root, t.change.id, t.task);
+  const lens = { state: "skipped", rules: [], discarded: [] };
+  let review;
+  const { criticCtx, rules } = await lensSetup(root, t, now);
+  lens.rules = rules.map((r) => r.id);
+  const agent = lensAgent(criticCtx, HAND_UP_LENS);
+  lens.agent = agent.id;
+  if (rules.length === 0)
+    lens.reason = "no AI rule of the complete lens reviews a task's code or tests";
+  else if (!o.runtime)
+    lens.reason = "no AI runtime was given; review plan.md and tasks.md by hand";
+  else if (!agent.inputs.some((i) => i === "tasks" || i === "repo-code"))
+    lens.reason = `agent ${agent.id} reads neither tasks nor repo code`;
+  else {
+    const levels = criticCtx.classifications;
+    const sources = [
+      {
+        id: "0-instructions",
+        kind: "instruction",
+        origin: "atticus/speckit",
+        text: INSTRUCTIONS(t.change.id, t.task.id, t.repo.id),
+        classification: "public",
+        trusted: true
+      },
+      {
+        id: "1-rules",
+        kind: "checklist",
+        origin: "checklists",
+        text: `## Rules
+
+${toCanonicalYaml(rules.map((r) => ({
+          id: r.id,
+          title: r.title,
+          severity: r.severity,
+          look_for: r.check.type === "ai" ? r.check.prompt : ""
+        })), ["id", "title", "severity", "look_for"]).trimEnd()}`,
+        classification: "public",
+        trusted: true
+      },
+      ...docs.map((d) => ({
+        id: d.path,
+        kind: "artifact",
+        origin: `${t.repo.id}:${wanted.find((w) => w.endsWith(`/${d.path.split("/").pop()}`)) ?? d.path}`,
+        text: numbered(d),
+        classification: "internal",
+        priority: 10
+      }))
+    ];
+    try {
+      const pack = buildContextPack({
+        change: t.change.id,
+        agent: agent.id,
+        budget: t.ctx.orgPack.runtime.budgets.perAgent[agent.id] ?? agent.tokenBudget,
+        sources,
+        levels,
+        maxClassification: o.maxClassification ?? (levels.includes("confidential") ? "confidential" : levels.at(-1)),
+        now: new Date(now)
+      });
+      const prepared = await o.runtime.prepare({
+        change: t.change.id,
+        agent,
+        pack,
+        outputPath: handUpLensOutput(t.task.id),
+        stepClass: "critic"
+      });
+      const run = await o.runtime.run(prepared.runId);
+      lens.runId = run.runId;
+      lens.summary = toRunSummary(run);
+      await writeFileAtomic(join7(folder, `tasks/${t.task.id}/runs/${run.runId}.yaml`), toCanonicalYaml(lens.summary, ["schemaVersion", "runId"]));
+      if (run.state === "waiting") {
+        lens.state = "waiting";
+        lens.reason = `handed to your assistant; finish with atticus handoff done ${run.runId}`;
+      } else if (run.state !== "validated" || run.output === void 0) {
+        lens.state = "failed";
+        lens.reason = run.errors.join("; ") || `the run ended ${run.state}`;
+      } else {
+        const applied = await applyLensRun(root, {
+          t,
+          criticCtx,
+          rules,
+          docs,
+          run,
+          pr: pr.number,
+          now
+        });
+        lens.state = "ran";
+        lens.discarded = applied.discarded;
+        review = applied.review;
+      }
+    } catch (e) {
+      lens.state = "failed";
+      lens.reason = e.message;
+    }
+  }
+  const drift = await driftCheck(root, t.change.id, { now });
+  return {
+    change: t.change.id,
+    task: t.task.id,
+    repo: t.repo.id,
+    pr,
+    markedDone,
+    evidence,
+    lens,
+    ...review ? { review } : {},
+    drift
+  };
+}
+
+// packages/speckit/dist/after-scan.js
+var DRIFT_AFTER_SCAN_STATES = ["build", "qa"];
+async function driftAfterScan(root, o = {}) {
+  const states = new Set(DRIFT_AFTER_SCAN_STATES);
+  const open = (await changeStore(root).list()).filter((c) => states.has(c.state));
+  const out = [];
+  for (const c of open) {
+    try {
+      const r = await driftCheck(root, c.id, o.now ? { now: o.now } : {});
+      const live = r.findings.filter((f) => f.finding.state === "open");
+      out.push({
+        change: c.id,
+        state: c.state,
+        ...r.round !== void 0 ? { round: r.round } : {},
+        unchanged: r.unchanged,
+        open: live.length,
+        blocking: live.filter((f) => f.finding.severity === "blocking").length
+      });
+    } catch (e) {
+      out.push({
+        change: c.id,
+        state: c.state,
+        unchanged: true,
+        open: 0,
+        blocking: 0,
+        error: e.message
+      });
+    }
+  }
+  return out;
+}
+
+export {
+  readChangeTasks,
+  readStory,
+  loadTask,
+  changeWorktree,
+  handDown,
+  openTaskWorktree,
+  driftCheck,
+  handUpLensTask,
+  completeHandUpLens,
+  handUp,
+  driftAfterScan
+};