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

package/dist/chunk-2ANOROX3.js

@@ -0,0 +1,2522 @@
+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 {
+  buildStub,
+  generate,
+  parseSpec
+} from "./chunk-65NYPGRC.js";
+import {
+  loadPlanContext,
+  parseStory
+} from "./chunk-CKSITVS4.js";
+import {
+  docOf,
+  fingerprint,
+  hopRoutes,
+  readRound,
+  roundsOf,
+  sectionLines,
+  writeFinding
+} from "./chunk-3HI6Z55Y.js";
+import {
+  changeFolder
+} from "./chunk-XY3P7JW7.js";
+import {
+  baseClonePath,
+  changeWorktreesDir,
+  readChangeRepos,
+  worktreePath
+} from "./chunk-EFHQ3TWP.js";
+import {
+  buildContextPack,
+  toRunSummary
+} from "./chunk-CNUKCS2T.js";
+import {
+  AgentDefinition,
+  ChecklistPack,
+  Finding,
+  RecordId,
+  changeBranch,
+  external_exports,
+  normalizePath,
+  require_dist,
+  taskBranch,
+  toCanonicalYaml
+} from "./chunk-S2A7YC3Q.js";
+import {
+  writeFileAtomic
+} from "./chunk-D3PO4DOZ.js";
+import {
+  __toESM
+} from "./chunk-TV45EUGM.js";
+
+// packages/testgen/dist/generate.js
+var import_yaml2 = __toESM(require_dist(), 1);
+import { readdir, readFile as readFile3 } from "node:fs/promises";
+import { join as join5, relative, sep } from "node:path";
+
+// packages/testgen/dist/errors.js
+var TestgenError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "TestgenError";
+  }
+};
+
+// packages/testgen/dist/words.js
+var words = (s) => s.replace(/([a-z0-9])([A-Z])/g, "$1 $2").split(/[^A-Za-z0-9]+/).filter(Boolean);
+function camel(s, max = 60) {
+  const w = words(s).map((x) => x.toLowerCase());
+  if (!w.length)
+    return "test";
+  const out = w.map((x, i) => i === 0 ? x : x.charAt(0).toUpperCase() + x.slice(1)).join("");
+  const id = /^[0-9]/.test(out) ? `t${out}` : out;
+  return id.slice(0, max);
+}
+function pascal(s, max = 60) {
+  const c = camel(s, max);
+  return c.charAt(0).toUpperCase() + c.slice(1);
+}
+function slug(s) {
+  return s.toLowerCase().replace(/\{[^}]*\}/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function uniqueNames(names) {
+  const seen = /* @__PURE__ */ new Map();
+  return names.map((n) => {
+    const k = seen.get(n) ?? 0;
+    seen.set(n, k + 1);
+    return k === 0 ? n : `${n}${k + 1}`;
+  });
+}
+var quote = (s) => s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\r?\n/g, " ");
+var oneLine = (s, max = 120) => s.replace(/[\r\n]+/g, " ").replace(/[`*]/g, "").replace(/\s+/g, " ").trim().slice(0, max);
+
+// packages/testgen/dist/generators/types.js
+function layout(repo) {
+  switch (repo.language) {
+    case "java":
+      return { features: "src/test/resources/features", json: "src/test/resources/atticus" };
+    case "node":
+      return { features: "test/features", json: "test/atticus" };
+    default:
+      return { features: "features", json: "atticus" };
+  }
+}
+
+// packages/testgen/dist/generators/generic.js
+var gherkinGenerator = {
+  id: "gherkin",
+  version: "1.0.0",
+  generic: true,
+  appliesTo: () => true,
+  render(model, repo, ctx) {
+    const scenarios = repo.cases.filter((c) => c.type === "acceptance");
+    if (!scenarios.length)
+      return [];
+    const s = model.story;
+    const lines = [
+      `@change-${model.change} @story-${s.id}`,
+      `Feature: ${oneLine(s.title)}`,
+      ...s.asA && s.iWant && s.soThat ? [
+        `  As ${/^an?\s/i.test(s.asA) ? s.asA : `a ${s.asA}`}`,
+        `  I want ${s.iWant}`,
+        `  So that ${s.soThat}`
+      ] : [],
+      ...s.tracesTo ? [`  Traces to ${s.tracesTo}.`] : []
+    ];
+    for (const c of scenarios) {
+      lines.push("");
+      if (c.trace)
+        lines.push(`  # ${c.trace.file}:${c.trace.line}${c.trace.name ? ` (${c.trace.name})` : ""}`);
+      lines.push(`  ${[`@criterion-${c.criterion}`, ...c.tags.map((t) => `@${t}`)].join(" ")}`);
+      lines.push(`  Scenario: ${oneLine(c.name)}`);
+      if (c.given)
+        lines.push(`    Given ${c.given}`);
+      if (c.when)
+        lines.push(`    When ${c.when}`);
+      lines.push(`    Then ${c.then}`);
+    }
+    return [
+      {
+        path: `${layout(repo).features}/${s.id}.feature`,
+        content: `${lines.join("\n")}
+`,
+        style: "hash",
+        source: ctx.source,
+        cases: scenarios.map((c) => c.id)
+      }
+    ];
+  }
+};
+function jsonCase(c) {
+  const { title: _t, ...rest } = c;
+  void _t;
+  return rest;
+}
+var jsonGenerator = {
+  id: "json",
+  version: "1.0.0",
+  generic: true,
+  appliesTo: () => true,
+  render(model, repo, ctx) {
+    const doc = {
+      format: "atticus-tests/1",
+      change: model.change,
+      story: model.story,
+      ...repo.repo ? { repo: repo.repo } : {},
+      ...repo.component ? { component: repo.component } : {},
+      strategy: model.strategy.required,
+      cases: repo.cases.map(jsonCase)
+    };
+    return [
+      {
+        path: `${layout(repo).json}/${model.story.id}.tests.json`,
+        content: `${JSON.stringify(doc, null, 2)}
+`,
+        style: "json",
+        source: ctx.source,
+        cases: repo.cases.map((c) => c.id)
+      }
+    ];
+  }
+};
+
+// packages/testgen/dist/generators/junit.js
+var CODE = /^[A-Z][A-Z0-9]*_[A-Z0-9_]+$/;
+var textBlock = (v) => {
+  const json2 = JSON.stringify(v, null, 2).replace(/\\/g, "\\\\").replace(/"""/g, '\\"""');
+  return `"""
+${json2.split("\n").map((l) => `        ${l}`).join("\n")}
+        """`;
+};
+function statusMatcher(status) {
+  if (/^\d{3}$/.test(status))
+    return `.statusCode(${status})`;
+  const d = /^([1-5])XX$/i.exec(status)?.[1];
+  return d ? `.statusCode(allOf(greaterThanOrEqualTo(${d}00), lessThan(${Number(d) + 1}00)))` : ".statusCode(greaterThanOrEqualTo(400))";
+}
+function bodyChecks(fields, body) {
+  const out = [];
+  if (body && typeof body === "object" && !Array.isArray(body)) {
+    for (const [k, v] of Object.entries(body))
+      if (typeof v === "string" && CODE.test(v))
+        out.push(`.body("${quote(k)}", equalTo("${quote(v)}"))`);
+  }
+  for (const f of fields)
+    if (!out.some((o) => o.startsWith(`.body("${f}"`)))
+      out.push(`.body("$", hasKey("${quote(f)}"))`);
+  return out;
+}
+function authLine(c) {
+  if (c.request.auth === "none")
+    return [];
+  if (c.request.auth === "no-scope")
+    return [
+      `.auth().oauth2(env("ATTICUS_TOKEN_WITHOUT_${c.request.scope.toUpperCase().replace(/[^A-Z0-9]+/g, "_")}"))`
+    ];
+  switch (c.request.authType) {
+    case "basic":
+      return [`.auth().preemptive().basic(env("ATTICUS_USER"), env("ATTICUS_PASSWORD"))`];
+    case "apiKey":
+    case "api-key":
+      return [`.header(env("ATTICUS_API_KEY_HEADER", "X-API-Key"), env("ATTICUS_API_KEY"))`];
+    case "mtls":
+    case "mutualTLS":
+      return [
+        `// mTLS: the client certificate comes from the test environment (RestAssured keyStore).`
+      ];
+    default:
+      return [`.auth().oauth2(env("ATTICUS_TOKEN"))`];
+  }
+}
+var header = (pkg) => [
+  `package ${pkg};`,
+  "",
+  "import static io.restassured.RestAssured.given;",
+  "import static org.hamcrest.Matchers.*;",
+  "",
+  "import io.restassured.http.ContentType;",
+  "import org.junit.jupiter.api.Assumptions;",
+  "import org.junit.jupiter.api.DisplayName;",
+  "import org.junit.jupiter.api.Test;",
+  ""
+];
+var ENV = [
+  "  private static String env(String name) {",
+  '    return env(name, "");',
+  "  }",
+  "",
+  "  private static String env(String name, String fallback) {",
+  "    String v = System.getenv(name);",
+  "    return v == null || v.isEmpty() ? fallback : v;",
+  "  }"
+];
+function apiMethod(c, name, baseVar) {
+  const lines = [`  @Test`, `  @DisplayName("${quote(c.name)}")`, `  void ${name}() {`];
+  if (c.request.auth === "no-scope") {
+    const v = `ATTICUS_TOKEN_WITHOUT_${c.request.scope.toUpperCase().replace(/[^A-Z0-9]+/g, "_")}`;
+    lines.push(`    Assumptions.assumeFalse(env("${v}").isEmpty(), "Set ${v} to a token without ${quote(c.request.scope)}.");`);
+  }
+  if (c.kind === "error" || c.why.includes("needs data"))
+    lines.push(`    // ${c.why}`);
+  const hasBody = c.request.body !== void 0;
+  const dataVar = c.data && (c.kind === "happy" || c.kind === "error") ? c.data.name : "body";
+  if (hasBody)
+    lines.push(`    String ${dataVar} = ${textBlock(c.request.body)};`);
+  lines.push(`    given()`, `        .baseUri(${baseVar})`);
+  for (const a of authLine(c))
+    lines.push(`        ${a}`);
+  for (const [k, v] of Object.entries(c.request.pathParams))
+    lines.push(`        .pathParam("${quote(k)}", ${JSON.stringify(v)})`);
+  for (const [k, v] of Object.entries(c.request.query))
+    lines.push(`        .queryParam("${quote(k)}", ${JSON.stringify(v)})`);
+  if (hasBody)
+    lines.push(`        .contentType(ContentType.JSON)`, `        .body(${dataVar})`);
+  lines.push(`        .when()`, `        .${c.method.toLowerCase()}("${quote(c.path)}")`, `        .then()`);
+  const checks = [
+    statusMatcher(c.expect.status),
+    ...c.kind === "happy" || c.kind === "error" ? bodyChecks(c.expect.fields, c.expect.body) : []
+  ];
+  checks.forEach((ch, i) => lines.push(`        ${ch}${i === checks.length - 1 ? ";" : ""}`));
+  lines.push("  }");
+  return lines;
+}
+function apiClass(m, repo, pkg, cls, cases) {
+  const names = uniqueNames(cases.map((c) => camel(c.name)));
+  const body = cases.flatMap((c, i) => ["", ...apiMethod(c, names[i], "BASE_URL")]);
+  return [
+    ...header(pkg),
+    `/** API tests for story ${m.story.id} (change ${m.change}) on ${repo.component ?? repo.repo}. Base URL: ATTICUS_BASE_URL. */`,
+    `class ${cls} {`,
+    `  private static final String BASE_URL = env("ATTICUS_BASE_URL", "http://localhost:8080");`,
+    ...body,
+    "",
+    ...ENV,
+    "}",
+    ""
+  ].join("\n");
+}
+function contractMethod(c, name) {
+  const lines = [`  @Test`, `  @DisplayName("${quote(c.name)}")`, `  void ${name}() {`];
+  for (const ch of c.checks)
+    lines.push(`    // ${ch}`);
+  for (const g of c.gaps)
+    lines.push(`    // Gap: ${g}`);
+  if (c.topic) {
+    lines.push(`    Assumptions.abort("Connect the event test harness: ${quote(c.role === "consumer" ? `deliver a ${c.topic} message to ${c.consumer}` : `capture what ${c.provider} publishes to ${c.topic}`)}.");`, "  }");
+    return lines;
+  }
+  const base = c.role === "consumer" ? "STUB_URL" : "BASE_URL";
+  const hasBody = c.request.example !== void 0;
+  if (hasBody)
+    lines.push(`    String body = ${textBlock(c.request.example)};`);
+  lines.push(`    given()`, `        .baseUri(${base})`);
+  if (c.role === "provider")
+    lines.push(`        .auth().oauth2(env("ATTICUS_TOKEN"))`);
+  for (const m of (c.path ?? "").matchAll(/\{([^}]+)\}/g))
+    lines.push(`        .pathParam("${quote(m[1])}", 1)`);
+  if (hasBody)
+    lines.push(`        .contentType(ContentType.JSON)`, `        .body(body)`);
+  lines.push(`        .when()`, `        .${(c.method ?? "get").toLowerCase()}("${quote(c.path ?? "/")}")`, `        .then()`);
+  const checks = [
+    c.response.status ? statusMatcher(c.response.status) : ".statusCode(lessThan(400))",
+    ...c.response.fields.map((f) => `.body("$", hasKey("${quote(f.split(/[.[]/)[0])}"))`)
+  ];
+  checks.forEach((ch, i) => lines.push(`        ${ch}${i === checks.length - 1 ? ";" : ""}`));
+  lines.push("  }");
+  return lines;
+}
+function contractClass(m, pkg, cls, cases) {
+  const names = uniqueNames(cases.map((c) => camel(c.name)));
+  return [
+    ...header(pkg),
+    `/**`,
+    ` * Contract tests for story ${m.story.id} (change ${m.change}). Consumer tests run against a stub`,
+    ` * of the provider (atticus stub <provider>, at ATTICUS_STUB_URL); provider tests against the`,
+    ` * service at ATTICUS_BASE_URL.`,
+    ` */`,
+    `class ${cls} {`,
+    `  private static final String BASE_URL = env("ATTICUS_BASE_URL", "http://localhost:8080");`,
+    `  private static final String STUB_URL = env("ATTICUS_STUB_URL", "http://127.0.0.1:4010");`,
+    ...cases.flatMap((c, i) => ["", ...contractMethod(c, names[i])]),
+    "",
+    ...ENV,
+    "}",
+    ""
+  ].join("\n");
+}
+function dataClass(m, pkg, cls, cases) {
+  const names = uniqueNames(cases.map((c) => camel(c.name)));
+  const body = cases.flatMap((c, i) => {
+    const lines = [
+      "",
+      `  @Test`,
+      `  @DisplayName("${quote(c.name)}")`,
+      `  void ${names[i]}() throws Exception {`
+    ];
+    for (const ch of c.checks)
+      lines.push(`    // ${ch}`);
+    if (c.kind === "migration") {
+      lines.push(`    Assumptions.abort("Run ${quote(c.migration ?? "the migration")} on a copy of ${quote(c.store)} in the pipeline, then run this class.");`, "  }");
+      return lines;
+    }
+    lines.push(`    try (Connection db = connect()) {`);
+    if (c.kind === "table") {
+      lines.push(`      assertTrue(exists(db, "${quote(c.table)}", null), "table ${quote(c.table)} exists");`);
+      for (const col of c.columns ?? [])
+        lines.push(`      assertTrue(exists(db, "${quote(c.table)}", "${quote(col.name)}"), "column ${quote(col.name)} (${quote(col.type)}) exists");`);
+    } else {
+      lines.push(`      assertTrue(exists(db, "${quote(c.table)}", "${quote(c.column)}"), "column ${quote(c.table)}.${quote(c.column)} exists");`);
+      if (c.notNull)
+        lines.push(`      assertEquals("NO", nullable(db, "${quote(c.table)}", "${quote(c.column)}"), "${quote(c.column)} is not null");`);
+    }
+    lines.push("    }", "  }");
+    return lines;
+  });
+  return [
+    `package ${pkg};`,
+    "",
+    "import static org.junit.jupiter.api.Assertions.*;",
+    "",
+    "import java.sql.Connection;",
+    "import java.sql.DriverManager;",
+    "import java.sql.PreparedStatement;",
+    "import java.sql.ResultSet;",
+    "import org.junit.jupiter.api.Assumptions;",
+    "import org.junit.jupiter.api.DisplayName;",
+    "import org.junit.jupiter.api.Test;",
+    "",
+    `/** Data tests for story ${m.story.id} (change ${m.change}): run against a migrated copy of the database at ATTICUS_DB_URL. */`,
+    `class ${cls} {`,
+    ...body,
+    "",
+    "  private static Connection connect() throws Exception {",
+    '    String url = System.getenv("ATTICUS_DB_URL");',
+    '    Assumptions.assumeTrue(url != null && !url.isEmpty(), "Set ATTICUS_DB_URL to a migrated copy of the database.");',
+    '    return DriverManager.getConnection(url, System.getenv("ATTICUS_DB_USER"), System.getenv("ATTICUS_DB_PASSWORD"));',
+    "  }",
+    "",
+    "  private static boolean exists(Connection db, String table, String column) throws Exception {",
+    "    String sql = column == null",
+    '        ? "select 1 from information_schema.tables where lower(table_name) = lower(?)"',
+    '        : "select 1 from information_schema.columns where lower(table_name) = lower(?) and lower(column_name) = lower(?)";',
+    "    try (PreparedStatement q = db.prepareStatement(sql)) {",
+    "      q.setString(1, table);",
+    "      if (column != null) q.setString(2, column);",
+    "      try (ResultSet r = q.executeQuery()) {",
+    "        return r.next();",
+    "      }",
+    "    }",
+    "  }",
+    "",
+    "  private static String nullable(Connection db, String table, String column) throws Exception {",
+    '    String sql = "select is_nullable from information_schema.columns where lower(table_name) = lower(?) and lower(column_name) = lower(?)";',
+    "    try (PreparedStatement q = db.prepareStatement(sql)) {",
+    "      q.setString(1, table);",
+    "      q.setString(2, column);",
+    "      try (ResultSet r = q.executeQuery()) {",
+    "        return r.next() ? r.getString(1) : null;",
+    "      }",
+    "    }",
+    "  }",
+    "}",
+    ""
+  ].join("\n");
+}
+function eventClass(m, pkg, cls, cases) {
+  const names = uniqueNames(cases.map((c) => camel(c.name)));
+  return [
+    `package ${pkg};`,
+    "",
+    "import org.junit.jupiter.api.Assumptions;",
+    "import org.junit.jupiter.api.DisplayName;",
+    "import org.junit.jupiter.api.Test;",
+    "",
+    `/** Event tests for story ${m.story.id} (change ${m.change}). Connect them to the team's event test harness. */`,
+    `class ${cls} {`,
+    ...cases.flatMap((c, i) => [
+      "",
+      `  @Test`,
+      `  @DisplayName("${quote(c.name)}")`,
+      `  void ${names[i]}() {`,
+      ...c.checks.map((ch) => `    // ${ch}`),
+      `    Assumptions.abort("Connect the event test harness for ${quote(c.topic)}.");`,
+      "  }"
+    ]),
+    "}",
+    ""
+  ].join("\n");
+}
+var junitGenerator = {
+  id: "junit5-restassured",
+  version: "1.0.0",
+  generic: false,
+  appliesTo: (repo) => repo.language === "java",
+  render(model, repo, ctx) {
+    const pkgName = `atticus.${model.change.replace(/[^a-z0-9]+/g, "_")}`;
+    const dir = `src/test/java/atticus/${model.change.replace(/[^a-z0-9]+/g, "_")}`;
+    const story = pascal(model.story.id);
+    const out = [];
+    const file2 = (suffix, content2, cases) => out.push({
+      path: `${dir}/${story}${suffix}.java`,
+      content: content2,
+      style: "slash",
+      source: ctx.source,
+      cases: cases.map((c) => c.id)
+    });
+    const api = repo.cases.filter((c) => c.type === "api");
+    const contracts = repo.cases.filter((c) => c.type === "contract");
+    const data = repo.cases.filter((c) => c.type === "data");
+    const events = repo.cases.filter((c) => c.type === "event");
+    if (api.length)
+      file2("ApiTest", apiClass(model, repo, pkgName, `${story}ApiTest`, api), api);
+    if (contracts.length)
+      file2("ContractTest", contractClass(model, pkgName, `${story}ContractTest`, contracts), contracts);
+    if (data.length)
+      file2("DataTest", dataClass(model, pkgName, `${story}DataTest`, data), data);
+    if (events.length)
+      file2("EventTest", eventClass(model, pkgName, `${story}EventTest`, events), events);
+    return out;
+  }
+};
+
+// packages/testgen/dist/generators/node.js
+var CODE2 = /^[A-Z][A-Z0-9]*_[A-Z0-9_]+$/;
+var json = (v, indent) => JSON.stringify(v, null, 2).split("\n").map((l, i) => i === 0 ? l : `${indent}${l}`).join("\n");
+function statusCheck(status) {
+  if (/^\d{3}$/.test(status))
+    return `expect(res.status).toBe(${status});`;
+  const d = /^([1-5])XX$/i.exec(status)?.[1] ?? "4";
+  return `expect(Math.floor(res.status / 100)).toBe(${d});`;
+}
+var url = (base, path, params, query) => {
+  const p = path.replace(/\{([^}]+)\}/g, (_, k) => `\${encodeURIComponent(String(${JSON.stringify(params[k] ?? 1)}))}`);
+  const q = Object.entries(query).map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`).join("&");
+  return `\`\${${base}}${p}${q ? `?${q}` : ""}\``;
+};
+function headers(c) {
+  const h = [];
+  if (c.request.body !== void 0)
+    h.push(`"content-type": "application/json"`);
+  if (c.request.auth === "valid") {
+    if (c.request.authType === "basic")
+      h.push('authorization: `Basic ${Buffer.from(`${env("ATTICUS_USER")}:${env("ATTICUS_PASSWORD")}`).toString("base64")}`');
+    else if (c.request.authType === "apiKey" || c.request.authType === "api-key")
+      h.push(`[env("ATTICUS_API_KEY_HEADER", "x-api-key")]: env("ATTICUS_API_KEY")`);
+    else
+      h.push('authorization: `Bearer ${env("ATTICUS_TOKEN")}`');
+  } else if (c.request.auth === "no-scope") {
+    const v = `ATTICUS_TOKEN_WITHOUT_${c.request.scope.toUpperCase().replace(/[^A-Z0-9]+/g, "_")}`;
+    h.push(`authorization: \`Bearer \${env("${v}")}\``);
+  }
+  return h;
+}
+function apiTest(c) {
+  const lines = [];
+  const skip = c.request.auth === "no-scope";
+  const v = skip ? `ATTICUS_TOKEN_WITHOUT_${c.request.scope.toUpperCase().replace(/[^A-Z0-9]+/g, "_")}` : "";
+  lines.push(`  it${skip ? `.skipIf(!process.env.${v})` : ""}("${quote(c.name)}", async () => {`);
+  if (c.kind === "error")
+    lines.push(`    // ${c.why}`);
+  const dataVar = c.data && (c.kind === "happy" || c.kind === "error") ? c.data.name : "body";
+  if (c.request.body !== void 0)
+    lines.push(`    const ${dataVar} = ${json(c.request.body, "    ")};`);
+  const h = headers(c);
+  lines.push(`    const res = await fetch(${url("BASE_URL", c.path, c.request.pathParams, c.request.query)}, {`, `      method: "${c.method}",`, ...h.length ? [`      headers: { ${h.join(", ")} },`] : [], ...c.request.body !== void 0 ? [`      body: JSON.stringify(${dataVar}),`] : [], `    });`, `    ${statusCheck(c.expect.status)}`);
+  if (c.kind === "happy" || c.kind === "error") {
+    const checks = [];
+    const b = c.expect.body;
+    if (b && typeof b === "object" && !Array.isArray(b)) {
+      for (const [k, val] of Object.entries(b))
+        if (typeof val === "string" && CODE2.test(val))
+          checks.push(`    expect(json).toHaveProperty("${quote(k)}", "${quote(val)}");`);
+    }
+    for (const f of c.expect.fields)
+      if (!checks.some((x) => x.includes(`"${f}"`)))
+        checks.push(`    expect(json).toHaveProperty("${quote(f)}");`);
+    if (checks.length)
+      lines.push(`    const json = (await res.json()) as Record<string, unknown>;`, ...checks);
+  }
+  lines.push("  });");
+  return lines;
+}
+function contractTest(c) {
+  const lines = [`  // ${c.checks.join("; ")}`, ...c.gaps.map((g) => `  // Gap: ${g}`)];
+  if (c.topic)
+    return [...lines, `  it.todo("${quote(c.name)}");`];
+  const base = c.role === "consumer" ? "STUB_URL" : "BASE_URL";
+  const params = Object.fromEntries([...(c.path ?? "").matchAll(/\{([^}]+)\}/g)].map((m) => [m[1], 1]));
+  lines.push(`  it("${quote(c.name)}", async () => {`);
+  if (c.request.example !== void 0)
+    lines.push(`    const body = ${json(c.request.example, "    ")};`);
+  const h = [
+    ...c.request.example !== void 0 ? [`"content-type": "application/json"`] : [],
+    ...c.role === "provider" ? ['authorization: `Bearer ${env("ATTICUS_TOKEN")}`'] : []
+  ];
+  lines.push(`    const res = await fetch(${url(base, c.path ?? "/", params, {})}, {`, `      method: "${c.method ?? "GET"}",`, ...h.length ? [`      headers: { ${h.join(", ")} },`] : [], ...c.request.example !== void 0 ? [`      body: JSON.stringify(body),`] : [], `    });`, c.response.status ? `    ${statusCheck(c.response.status)}` : `    expect(res.status).toBeLessThan(400);`);
+  if (c.response.fields.length)
+    lines.push(`    const json = (await res.json()) as Record<string, unknown>;`, ...c.response.fields.map((f) => `    expect(json).toHaveProperty("${quote(f.split(/[.[]/)[0])}");`));
+  lines.push("  });");
+  return lines;
+}
+var todo = (c) => [
+  `  // ${c.checks.join("; ")}`,
+  `  it.todo("${quote(c.name)}");`
+];
+function file(m, runner, what, body, bases) {
+  return [
+    runner === "vitest" ? `import { describe, expect, it } from "vitest";` : `import { describe, expect, it } from "@jest/globals";`,
+    "",
+    `const env = (name: string, fallback = "") => process.env[name] || fallback;`,
+    ...bases,
+    "",
+    `describe("${quote(`${what} for story ${m.story.id} (change ${m.change})`)}", () => {`,
+    ...body,
+    "});",
+    ""
+  ].join("\n");
+}
+function generator(runner) {
+  return {
+    id: `${runner}-fetch`,
+    version: "1.0.0",
+    generic: false,
+    appliesTo: (repo) => repo.language === "node" && (repo.runner ?? "vitest") === runner,
+    render(model, repo, ctx) {
+      const dir = "test/atticus";
+      const out = [];
+      const add = (kind, content2, cases) => out.push({
+        path: `${dir}/${model.story.id}.${kind}.test.ts`,
+        content: content2,
+        style: "slash",
+        source: ctx.source,
+        cases: cases.map((c) => c.id)
+      });
+      const BASE = `const BASE_URL = env("ATTICUS_BASE_URL", "http://localhost:3000");`;
+      const STUB = `const STUB_URL = env("ATTICUS_STUB_URL", "http://127.0.0.1:4010");`;
+      const api = repo.cases.filter((c) => c.type === "api");
+      const contracts = repo.cases.filter((c) => c.type === "contract");
+      const rest = repo.cases.filter((c) => c.type === "data" || c.type === "event");
+      const fixSkip = (lines) => runner === "jest" ? lines.map((l) => l.replace(/it\.skipIf\((![^)]+)\)\(/, (_, cond) => `(${cond} ? it.skip : it)(`)) : lines;
+      if (api.length)
+        add("api", file(model, runner, "API tests", fixSkip(api.flatMap((c, i) => [...i ? [""] : [], ...apiTest(c)])), [BASE]), api);
+      if (contracts.length)
+        add("contract", file(model, runner, "Contract tests", contracts.flatMap((c, i) => [...i ? [""] : [], ...contractTest(c)]), [BASE, STUB]), contracts);
+      if (rest.length)
+        add("data-and-events", file(model, runner, "Data and event tests", rest.flatMap((c, i) => [...i ? [""] : [], ...todo(c)]), []), rest);
+      return out;
+    }
+  };
+}
+var vitestGenerator = generator("vitest");
+var jestGenerator = generator("jest");
+
+// packages/testgen/dist/generators/index.js
+var BUILT_IN_GENERATORS = [
+  gherkinGenerator,
+  jsonGenerator,
+  junitGenerator,
+  vitestGenerator,
+  jestGenerator
+];
+function generatorsFor(repo, o = {}) {
+  const all = [...o.plugins ?? [], ...BUILT_IN_GENERATORS];
+  const generic = all.filter((g2) => g2.generic);
+  const concrete = all.filter((g2) => !g2.generic);
+  if (o.framework && ["gherkin", "json"].includes(o.framework))
+    return { generators: generic };
+  if (o.framework) {
+    const g2 = concrete.find((x) => x.id === o.framework);
+    return { generators: g2 ? [...generic, g2] : generic };
+  }
+  const g = concrete.find((x) => x.appliesTo(repo));
+  return g ? { generators: [...generic, g] } : {
+    generators: generic,
+    ...repo.repo ? {
+      note: `No test framework suits ${repo.repo} (its language isn't known): only Gherkin and JSON were written.`
+    } : {}
+  };
+}
+
+// packages/testgen/dist/header.js
+import { createHash } from "node:crypto";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+var sha256 = (s) => createHash("sha256").update(s, "utf8").digest("hex");
+var TAG = "atticus-sha256";
+var TEXT = (source, hash) => `Generated by Atticus from ${source}. Edit the source instead: Atticus regenerates this file and keeps hand edits only until --force. ${TAG}: ${hash}`;
+var LINE_RE = new RegExp(`^(?:#|//) Generated by Atticus from (.+?)\\. .*${TAG}: ([0-9a-f]{64})$`);
+var JSON_RE = new RegExp(`^\\{\\n  "\\$generated": "Generated by Atticus from (.+?)\\. .*${TAG}: ([0-9a-f]{64})",\\n`);
+function withHeader(f) {
+  const hash = sha256(f.content);
+  if (f.style === "json") {
+    if (!f.content.startsWith("{\n"))
+      throw new Error(`${f.path}: JSON content must be an object`);
+    return `{
+  "$generated": "${TEXT(f.source, hash)}",
+${f.content.slice(2)}`;
+  }
+  return `${f.style === "hash" ? "#" : "//"} ${TEXT(f.source, hash)}
+${f.content}`;
+}
+function readHeader(text) {
+  const t = text.replace(/\r\n/g, "\n");
+  const j = JSON_RE.exec(t);
+  if (j)
+    return { source: j[1], hash: j[2], body: `{
+${t.slice(j[0].length)}` };
+  const nl = t.indexOf("\n");
+  const first = nl < 0 ? t : t.slice(0, nl);
+  const m = LINE_RE.exec(first);
+  if (m)
+    return { source: m[1], hash: m[2], body: t.slice(nl + 1) };
+  return void 0;
+}
+async function writeGenerated(dir, files, o = {}) {
+  const out = [];
+  for (const f of files) {
+    if (f.path.startsWith("/") || f.path.split("/").includes("..") || /^[A-Za-z]:/.test(f.path))
+      throw new Error(`refusing to write outside the target folder: ${f.path}`);
+    const full = join(dir, ...f.path.split("/"));
+    const text = withHeader(f);
+    const current = await readFile(full, "utf8").then((t) => t.replace(/\r\n/g, "\n")).catch(() => void 0);
+    let action;
+    if (current === void 0)
+      action = "created";
+    else if (current === text)
+      action = "unchanged";
+    else {
+      const h = readHeader(current);
+      if (!h)
+        action = o.force ? "updated" : "kept-not-generated";
+      else if (sha256(h.body) !== h.hash)
+        action = o.force ? "updated" : "kept-edited";
+      else
+        action = "updated";
+    }
+    const write = !o.check && (action === "created" || action === "updated");
+    if (write) {
+      await mkdir(dirname(full), { recursive: true });
+      const tmp = `${full}.atticus-tmp`;
+      await writeFile(tmp, text, "utf8");
+      await rename(tmp, full);
+    }
+    out.push({ path: f.path, action, written: write });
+  }
+  return out;
+}
+
+// packages/testgen/dist/spec.js
+import { existsSync, readFileSync } from "node:fs";
+import { join as join2 } from "node:path";
+var isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+function candidates(ctx, hop, places) {
+  const out = [];
+  const calleeRepo = ctx.repoOf(hop.callee);
+  const place = calleeRepo ? places.get(calleeRepo) : void 0;
+  const contract = hop.contract.replace(/[`*]/g, "").trim();
+  if (contract && !/^(none|n\/a|-|tbd)$/i.test(contract)) {
+    if (place?.dir)
+      out.push({ file: join2(place.dir, contract), label: `${calleeRepo}:${contract}` });
+    out.push({ file: join2(ctx.root, contract), label: contract });
+  }
+  const ep = endpointFor(ctx, hop);
+  for (const e of ep?.evidence ?? []) {
+    if (e.source !== "spec" || !e.path)
+      continue;
+    const p = e.repo ? places.get(e.repo) : void 0;
+    if (e.repo && p?.dir)
+      out.push({ file: join2(p.dir, e.path), label: `${e.repo}:${e.path}` });
+    else if (!e.repo)
+      out.push({ file: join2(ctx.root, e.path), label: e.path });
+  }
+  return out;
+}
+function endpointFor(ctx, hop) {
+  if (!hop.method || !hop.path)
+    return void 0;
+  const p = normalizePath(hop.path);
+  return ctx.records.find((r) => r.kind === "Endpoint" && r.component === hop.callee && (r.method ?? "").toUpperCase() === hop.method && normalizePath(r.normalizedPath ?? r.pathOrTopic) === p);
+}
+var stripReadOnly = (schema) => {
+  if (!schema?.properties)
+    return schema;
+  return {
+    ...schema,
+    properties: Object.fromEntries(Object.entries(schema.properties).filter(([, s]) => !s.readOnly))
+  };
+};
+function securityOf(doc, op) {
+  const reqs = Array.isArray(op.security) ? op.security : Array.isArray(doc.security) ? doc.security : [];
+  const schemes = isObj(doc.components) && isObj(doc.components.securitySchemes) ? doc.components.securitySchemes : isObj(doc.securityDefinitions) ? doc.securityDefinitions : {};
+  const out = [];
+  for (const r of reqs) {
+    if (!isObj(r))
+      continue;
+    for (const [name, scopes] of Object.entries(r)) {
+      const s = isObj(schemes[name]) ? schemes[name] : {};
+      const type = s.type === "http" ? String(s.scheme ?? "http").toLowerCase() : String(s.type ?? "unknown");
+      out.push({ scheme: name, type, scopes: Array.isArray(scopes) ? scopes.map(String) : [] });
+    }
+  }
+  return out;
+}
+var pick = (content2) => {
+  if (!isObj(content2))
+    return void 0;
+  const k = Object.keys(content2).find((x) => x.toLowerCase() === "application/json") ?? Object.keys(content2).find((x) => /json/.test(x));
+  return k && isObj(content2[k]) ? content2[k] : void 0;
+};
+function findOperation(ctx, hop, places) {
+  const tried = [];
+  if (!hop.method || !hop.path)
+    return { tried };
+  const want = normalizePath(hop.path);
+  for (const c of candidates(ctx, hop, places)) {
+    if (!existsSync(c.file) || tried.includes(c.label))
+      continue;
+    tried.push(c.label);
+    let doc;
+    let stub;
+    try {
+      const text = readFileSync(c.file, "utf8");
+      doc = parseSpec(text);
+      stub = buildStub(text);
+    } catch {
+      continue;
+    }
+    const route = stub.routes.find((r) => {
+      if (r.method !== hop.method)
+        return false;
+      const p = normalizePath(r.path);
+      return p === want || stub.basePaths.some((b) => normalizePath(`${b}${r.path}`) === want);
+    });
+    if (!route)
+      continue;
+    const item = isObj(doc.paths) && isObj(doc.paths[route.path]) ? doc.paths[route.path] : {};
+    const op = isObj(item[route.method.toLowerCase()]) ? item[route.method.toLowerCase()] : {};
+    const media = pick(isObj(op.requestBody) ? op.requestBody.content : void 0);
+    const bodySchema = stripReadOnly(route.body?.schema);
+    const requestExample = media?.example !== void 0 ? media.example : route.body?.json && bodySchema ? generate(bodySchema) : void 0;
+    const ok = route.responses.find((r) => /^2/.test(r.status));
+    const okMedia = (() => {
+      const responses = isObj(op.responses) ? op.responses : {};
+      const r = ok ? responses[ok.status] : void 0;
+      return pick(isObj(r) ? r.content : void 0);
+    })();
+    const okSchema = okMedia && isObj(okMedia.schema) ? okMedia.schema : void 0;
+    return {
+      op: {
+        source: c.label,
+        route,
+        ...requestExample !== void 0 ? { requestExample } : {},
+        security: securityOf(doc, op),
+        requestFields: Object.keys(bodySchema?.properties ?? {}),
+        responseFields: Object.keys(okSchema?.properties ?? (isObj(ok?.body) ? ok.body : {}))
+      },
+      tried
+    };
+  }
+  return { tried };
+}
+
+// packages/testgen/dist/targets.js
+import { existsSync as existsSync2, readFileSync as readFileSync2, statSync } from "node:fs";
+import { join as join3 } from "node:path";
+var isDir = (p) => {
+  try {
+    return statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+};
+function repoPlace(ctx, story, repo, changeRepos) {
+  for (const t of story.tasks.filter((x) => x.repo === repo)) {
+    const d = join3(changeWorktreesDir(ctx.root, ctx.change.id), ".tasks", t.id, repo);
+    if (isDir(d))
+      return { repo, dir: d, kind: "task-worktree", task: t.id };
+  }
+  const listed = changeRepos?.repos.find((r) => r.id === repo);
+  for (const d of [
+    ...listed ? [join3(ctx.root, ...listed.worktree.split("/"))] : [],
+    worktreePath(ctx.root, ctx.change.id, repo)
+  ])
+    if (isDir(d))
+      return { repo, dir: d, kind: "worktree" };
+  const base = baseClonePath(ctx.root, repo);
+  if (isDir(base))
+    return { repo, dir: base, kind: "base-clone" };
+  return { repo, kind: "none" };
+}
+var JAVA_TYPES = /\b(java|jvm|kotlin|spring|quarkus|micronaut|jakarta|scala)\b/i;
+var NODE_TYPES = /node|spa|frontend|react|angular|vue|svelte|next|nest|express|typescript|javascript/i;
+function languageOf(place, type) {
+  if (place.dir) {
+    const has = (p) => existsSync2(join3(place.dir, p));
+    if (has("pom.xml") || has("build.gradle") || has("build.gradle.kts") || has("src/main/java"))
+      return "java";
+    if (has("package.json"))
+      return "node";
+  }
+  if (type && JAVA_TYPES.test(type))
+    return "java";
+  if (type && NODE_TYPES.test(type))
+    return "node";
+  return void 0;
+}
+function nodeRunner(place) {
+  if (!place.dir)
+    return "vitest";
+  try {
+    const pkg = JSON.parse(readFileSync2(join3(place.dir, "package.json"), "utf8"));
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    if (deps.vitest)
+      return "vitest";
+    if (deps.jest)
+      return "jest";
+  } catch {
+  }
+  return "vitest";
+}
+
+// packages/testgen/dist/model.js
+var NEEDS = {
+  api: ["integration", "e2e", "regression", "security"],
+  contract: ["contract"],
+  data: ["data-migration", "integration"],
+  event: ["contract", "integration"]
+};
+var below = (min, integer) => integer ? min - 1 : min >= 1 ? min - 1 : min > 0 ? 0 : min - 1;
+var typeOf = (s) => (Array.isArray(s.type) ? s.type.find((t) => t !== "null") : s.type) ?? (s.properties ? "object" : void 0);
+function mutations(name, s) {
+  const out = [];
+  const t = typeOf(s);
+  if (s.enum?.length) {
+    let v = "INVALID";
+    while (s.enum.includes(v))
+      v += "-1";
+    out.push({ key: "enum", value: v, title: `refuses ${name} outside ${s.enum.join(", ")}` });
+  } else if (t === "integer" || t === "number")
+    out.push({ key: "type", value: "abc", title: `refuses ${name} that is not a number` });
+  else if (t === "string")
+    out.push({ key: "type", value: 12345, title: `refuses ${name} that is not text` });
+  else if (t === "boolean")
+    out.push({ key: "type", value: "yes", title: `refuses ${name} that is not true or false` });
+  if (typeof s.minimum === "number")
+    out.push({
+      key: "minimum",
+      value: below(s.minimum, t === "integer"),
+      title: `refuses ${name} below ${s.minimum}`
+    });
+  if (typeof s.exclusiveMinimum === "number")
+    out.push({
+      key: "exclusive-minimum",
+      value: s.exclusiveMinimum,
+      title: `refuses ${name} of ${s.exclusiveMinimum}`
+    });
+  if (typeof s.maximum === "number")
+    out.push({ key: "maximum", value: s.maximum + 1, title: `refuses ${name} above ${s.maximum}` });
+  if (typeof s.exclusiveMaximum === "number")
+    out.push({
+      key: "exclusive-maximum",
+      value: s.exclusiveMaximum,
+      title: `refuses ${name} of ${s.exclusiveMaximum}`
+    });
+  if (typeof s.minLength === "number" && s.minLength > 0)
+    out.push({
+      key: "min-length",
+      value: "x".repeat(s.minLength - 1),
+      title: `refuses ${name} shorter than ${s.minLength} characters`
+    });
+  if (typeof s.maxLength === "number")
+    out.push({
+      key: "max-length",
+      value: "x".repeat(s.maxLength + 1),
+      title: `refuses ${name} longer than ${s.maxLength} characters`
+    });
+  if (s.format && ["date", "date-time", "email", "uuid", "uri"].includes(s.format))
+    out.push({
+      key: "format",
+      value: `not-a-${s.format}`,
+      title: `refuses ${name} that is not a ${s.format}`
+    });
+  return out;
+}
+var CODE3 = /\b[A-Z][A-Z0-9]*_[A-Z0-9_]+\b/g;
+function apiCases(hop, op, endpoint, acceptance) {
+  const notes = [];
+  const method = hop.method;
+  const path = op?.route.path ?? hop.path;
+  const base = `api.${slug(`${method} ${path}`)}`;
+  const common = {
+    component: hop.callee,
+    method,
+    path,
+    ...op?.route.operationId ? { operationId: op.route.operationId } : {},
+    .../^if-/.test(hop.id) ? { interfaceId: hop.id } : {},
+    ...endpoint ? { endpoint: endpoint.id } : {}
+  };
+  const pathParams = {};
+  const query = {};
+  for (const p of op?.route.params ?? []) {
+    const v = p.schema ? generate(p.schema) : "1";
+    if (p.in === "path")
+      pathParams[p.name] = v;
+    else if (p.in === "query" && p.required)
+      query[p.name] = v;
+  }
+  for (const m of path.matchAll(/\{([^}]+)\}/g))
+    if (!(m[1] in pathParams))
+      pathParams[m[1]] = "1";
+  const authType = op?.security[0]?.type ?? (endpoint?.auth && endpoint.auth !== "none" ? endpoint.auth : void 0);
+  const req = (o = {}) => ({
+    pathParams,
+    query,
+    ...op?.requestExample !== void 0 ? { body: op.requestExample } : {},
+    auth: authType ? "valid" : "none",
+    ...authType ? { authType } : {},
+    ...o
+  });
+  const cases = [];
+  const data = op?.requestExample !== void 0 ? { id: `data.${slug(`${method} ${path}`)}`, name: "" } : void 0;
+  const statuses = new Set((op?.route.responses ?? []).map((r) => r.status));
+  const bad = statuses.has("400") ? "400" : statuses.has("422") && !op?.route.responses.find((r) => r.status === "422")?.body ? "422" : "4XX";
+  const ok = op?.route.responses.find((r) => /^2/.test(r.status));
+  const okStatus = op ? String(op.route.status) : method === "POST" ? "201" : "200";
+  cases.push({
+    type: "api",
+    id: `${base}.happy`,
+    kind: "happy",
+    title: `${method} ${path} accepts a valid request`,
+    name: "",
+    ...common,
+    request: req(),
+    expect: {
+      status: okStatus,
+      ...ok?.body !== void 0 && ok.example !== "none" ? { body: ok.body } : {},
+      fields: op?.responseFields ?? []
+    },
+    why: op ? `The spec (${op.source}) answers ${okStatus} for a valid request.` : "The design calls this operation; no spec was found.",
+    ...data ? { data } : {}
+  });
+  if (!op)
+    notes.push(`No spec has ${method} ${hop.path} for ${hop.callee}: only the happy path was generated.`);
+  const schema = op?.route.body?.schema;
+  const example = op?.requestExample;
+  if (schema?.properties && example && typeof example === "object" && !Array.isArray(example)) {
+    for (const f of schema.required ?? []) {
+      const body = { ...example };
+      delete body[f];
+      cases.push({
+        type: "api",
+        id: `${base}.missing-${slug(f)}`,
+        kind: "negative",
+        title: `${method} ${path} refuses a request without ${f}`,
+        name: "",
+        ...common,
+        request: req({ body }),
+        expect: { status: bad, fields: [] },
+        why: `${f} is required by the spec.`
+      });
+    }
+    for (const [f, s] of Object.entries(schema.properties)) {
+      if (s.readOnly)
+        continue;
+      for (const m of mutations(f, s))
+        cases.push({
+          type: "api",
+          id: `${base}.${slug(f)}-${m.key}`,
+          kind: "negative",
+          title: `${method} ${path} ${m.title}`,
+          name: "",
+          ...common,
+          request: req({ body: { ...example, [f]: m.value } }),
+          expect: { status: bad, fields: [] },
+          why: `The spec constrains ${f} (${m.key.replace(/-/g, " ")}).`
+        });
+    }
+  }
+  for (const p of op?.route.params ?? []) {
+    if (p.in !== "path" || !p.schema)
+      continue;
+    for (const m of mutations(p.name, p.schema))
+      cases.push({
+        type: "api",
+        id: `${base}.${slug(p.name)}-${m.key}`,
+        kind: "negative",
+        title: `${method} ${path} ${m.title.replace("refuses ", "refuses a path ")}`,
+        name: "",
+        ...common,
+        request: req({ pathParams: { ...pathParams, [p.name]: m.value } }),
+        expect: { status: bad, fields: [] },
+        why: `The spec constrains the path parameter ${p.name} (${m.key.replace(/-/g, " ")}).`
+      });
+  }
+  for (const r of op?.route.responses ?? []) {
+    if (!/^[45]\d\d$/.test(r.status) || ["400", "401", "403"].includes(r.status))
+      continue;
+    const said = `${r.description ?? ""} ${JSON.stringify(r.body ?? "")}`;
+    const codes = [...new Set(said.match(CODE3) ?? [])];
+    const scenario = acceptance.find((a) => codes.some((c) => a.then.includes(c)) || new RegExp(`\\b${r.status}\\b`).test(a.then));
+    cases.push({
+      type: "api",
+      id: `${base}.status-${r.status}`,
+      kind: "error",
+      title: `${method} ${path} answers ${r.status}${r.description ? `: ${r.description}` : ""}`,
+      name: "",
+      ...common,
+      request: req(),
+      expect: { status: r.status, ...r.body !== void 0 ? { body: r.body } : {}, fields: [] },
+      why: `The spec documents ${r.status}${r.description ? `: ${r.description}` : ""}. The request needs data in that state${scenario ? ` (${scenario.trace?.name || `criterion ${scenario.criterion}`})` : ""}.`,
+      ...scenario ? { scenario: scenario.id } : {},
+      ...data ? { data } : {}
+    });
+  }
+  if (authType) {
+    cases.push({
+      type: "api",
+      id: `${base}.no-credentials`,
+      kind: "auth",
+      title: `${method} ${path} refuses a request without credentials`,
+      name: "",
+      ...common,
+      request: req({ auth: "none" }),
+      expect: { status: "401", fields: [] },
+      why: `The operation needs ${authType} credentials.`
+    });
+    for (const s of op?.security ?? [])
+      for (const scope of s.scopes)
+        cases.push({
+          type: "api",
+          id: `${base}.no-scope-${slug(scope)}`,
+          kind: "auth",
+          title: `${method} ${path} refuses a token without scope ${scope}`,
+          name: "",
+          ...common,
+          request: req({ auth: "no-scope", scope }),
+          expect: { status: "403", fields: [] },
+          why: `The spec asks for scope ${scope}.`
+        });
+  }
+  return { cases, notes };
+}
+function mappedFields(text) {
+  const rows = text.split("\n").filter((l) => l.trim().startsWith("|"));
+  if (rows.length < 2)
+    return [];
+  const cells2 = (l) => l.trim().replace(/^\||\|$/g, "").split("|").map((c) => c.replace(/[`*]/g, "").trim());
+  const head = cells2(rows[0]).map((h) => h.toLowerCase());
+  const ti = head.findIndex((h) => /^target( field)?$/.test(h));
+  if (ti < 0)
+    return [];
+  return [
+    ...new Set(rows.slice(1).map(cells2).filter((c) => !c.every((x) => /^:?-+:?$/.test(x) || x === "")).map((c) => c[ti] ?? "").filter((f) => /^[A-Za-z_][\w.[\]-]*$/.test(f)))
+  ];
+}
+var topicOf = (op) => /^(publish|subscribe|send|receive)\s+(\S+)/i.exec(op.trim());
+function contractCases(ctx, hop, op, tried) {
+  if (!/^planned-(new|modify)$/.test(hop.status))
+    return [];
+  const mapping = ctx.mapping(hop);
+  const notes = ctx.notes(hop).map((n) => n.text).join("\n");
+  const fields = mappedFields(mapping);
+  const errors = [];
+  for (const m of `${notes}
+${mapping}`.matchAll(/HTTP\s+(\d{3})/g)) {
+    const around = `${notes}
+${mapping}`;
+    const code = (around.match(CODE3) ?? [])[0];
+    if (!errors.some((e) => e.status === m[1]))
+      errors.push({ status: m[1], ...code ? { code } : {} });
+  }
+  const t = topicOf(hop.operation);
+  const base = `contract.${slug(t ? `${t[1]} ${t[2]}` : `${hop.method} ${hop.path}`)}`;
+  const common = {
+    status: hop.status,
+    .../^if-/.test(hop.id) ? { interfaceId: hop.id } : {}
+  };
+  if (t) {
+    const publish = /^(publish|send)$/i.test(t[1]);
+    const publisher = publish ? hop.caller : hop.callee;
+    const subscriber = publish ? hop.callee : hop.caller;
+    const shared2 = {
+      ...common,
+      consumer: subscriber,
+      provider: publisher,
+      topic: t[2],
+      request: { fields },
+      response: { fields: [] },
+      errors: [],
+      gaps: []
+    };
+    return [
+      {
+        type: "contract",
+        id: `${base}.subscriber`,
+        title: `${subscriber} handles a ${t[2]} message from ${publisher}`,
+        name: "",
+        role: "consumer",
+        ...shared2,
+        checks: [
+          `${subscriber} accepts a message on ${t[2]}`,
+          ...fields.length ? [`it reads ${fields.join(", ")}`] : []
+        ]
+      },
+      {
+        type: "contract",
+        id: `${base}.publisher`,
+        title: `${publisher} publishes ${t[2]} as ${subscriber} expects`,
+        name: "",
+        role: "provider",
+        ...shared2,
+        checks: [
+          `${publisher} publishes to ${t[2]}`,
+          ...fields.length ? [`the message carries ${fields.join(", ")}`] : []
+        ]
+      }
+    ];
+  }
+  if (!hop.method || !hop.path)
+    return [];
+  const route = hopRoutes(ctx.files, hop).map((id) => ctx.get("GatewayRoute", id)).find((r) => r !== void 0);
+  const consumerPath = route ? `${route.basepath.replace(/\/+$/, "")}${hop.path}` : hop.path;
+  const gaps = [];
+  const req = [];
+  const res = [];
+  const read = hop.method === "GET" || hop.method === "DELETE" || hop.method === "HEAD";
+  for (const f of fields) {
+    const top = f.split(/[.[]/)[0];
+    if (op?.requestFields.includes(top))
+      req.push(f);
+    else if (op?.responseFields.includes(top))
+      res.push(f);
+    else {
+      (read ? res : req).push(f);
+      if (op)
+        gaps.push(`The consumer maps ${f}, which ${hop.callee}'s spec (${op.source}) doesn't define.`);
+    }
+  }
+  if (!op)
+    gaps.push(tried.length ? `${tried.join(", ")} ${tried.length === 1 ? "has" : "have"} no ${hop.method} ${hop.path}: the provider's side can't be checked until the spec has it.` : `No spec for ${hop.callee} was found (interfaces.md contract: ${hop.contract.trim() || "none"}): the provider's side can't be checked.`);
+  const statuses = new Set((op?.route.responses ?? []).map((r) => r.status));
+  for (const e of errors)
+    if (op && !statuses.has(e.status))
+      gaps.push(`The design says ${hop.method} ${hop.path} answers ${e.status}, which the spec doesn't document.`);
+  const okStatus = op ? String(op.route.status) : void 0;
+  const required = op?.route.body?.schema?.required ?? [];
+  const shared = {
+    ...common,
+    consumer: hop.caller,
+    provider: hop.callee,
+    method: hop.method,
+    path: hop.path,
+    consumerPath,
+    request: {
+      fields: req,
+      ...op?.requestExample !== void 0 ? { example: op.requestExample } : {}
+    },
+    response: {
+      ...okStatus ? { status: okStatus } : {},
+      fields: res,
+      ...op?.route.responses.find((r) => /^2/.test(r.status))?.body !== void 0 ? { example: op.route.responses.find((r) => /^2/.test(r.status)).body } : {}
+    },
+    errors,
+    gaps,
+    ...op ? { spec: op.source } : {}
+  };
+  return [
+    {
+      type: "contract",
+      id: `${base}.consumer`,
+      title: `${hop.caller} calls ${hop.method} ${consumerPath} as ${hop.callee}'s contract says`,
+      name: "",
+      role: "consumer",
+      ...shared,
+      checks: [
+        `${hop.caller} sends ${hop.method} ${consumerPath}${req.length ? ` with ${req.join(", ")}` : ""}`,
+        ...res.length ? [`it reads ${res.join(", ")} from the answer`] : [],
+        ...errors.map((e) => `it handles ${e.status}${e.code ? ` ${e.code}` : ""}`)
+      ]
+    },
+    {
+      type: "contract",
+      id: `${base}.provider`,
+      title: `${hop.callee} serves ${hop.method} ${hop.path} as ${hop.caller} expects`,
+      name: "",
+      role: "provider",
+      ...shared,
+      checks: [
+        `${hop.callee} serves ${hop.method} ${hop.path}`,
+        ...required.length ? [`it requires ${required.join(", ")}`] : [],
+        ...okStatus ? [`it answers ${okStatus}${res.length ? ` with ${res.join(", ")}` : ""}`] : [],
+        ...errors.map((e) => `it answers ${e.status}${e.code ? ` with ${e.code}` : ""}`)
+      ]
+    }
+  ];
+}
+function dataCases(d) {
+  const common = { store: d.store, table: d.table, tableId: d.tableId };
+  const cases = [];
+  const gaps = [];
+  const base = `data.${slug(d.table)}`;
+  if (d.newTable) {
+    cases.push({
+      type: "data",
+      id: `${base}.table`,
+      title: `table ${d.table} exists with its columns`,
+      name: "",
+      kind: "table",
+      ...common,
+      columns: d.newColumns,
+      checks: [
+        `${d.store} has table ${d.table}`,
+        ...d.newColumns.map((c) => `column ${c.name} is ${c.type}`)
+      ]
+    });
+  } else {
+    for (const c of d.newColumns) {
+      const m = new RegExp(`add column\\s+${c.name}\\s+[\\w(),]+([^,;]*)`, "i").exec(d.change);
+      const rest = m?.[1] ?? "";
+      const notNull = /\bnot null\b/i.test(rest);
+      const def = /\bdefault\s+('[^']*'|\S+)/i.exec(rest)?.[1];
+      cases.push({
+        type: "data",
+        id: `${base}.${slug(c.name)}`,
+        title: `column ${d.table}.${c.name} exists as ${c.type}`,
+        name: "",
+        kind: "column",
+        ...common,
+        column: c.name,
+        columnType: c.type,
+        ...notNull ? { notNull } : {},
+        ...def ? { default: def } : {},
+        checks: [
+          `${d.table}.${c.name} is ${c.type}`,
+          ...notNull ? [`${d.table}.${c.name} is not null`] : [],
+          ...def ? [`existing rows get ${def}`] : []
+        ]
+      });
+    }
+  }
+  if (d.migration)
+    cases.push({
+      type: "data",
+      id: `${base}.migration`,
+      title: `migration ${d.migration} applies on a copy of ${d.store}`,
+      name: "",
+      kind: "migration",
+      ...common,
+      migration: d.migration,
+      checks: [
+        `${d.migration} applies cleanly on a copy of ${d.store}`,
+        `afterwards ${d.newTable ? `table ${d.table} exists` : `${d.newColumns.map((c) => `${d.table}.${c.name}`).join(", ")} exist`}`
+      ]
+    });
+  else if (d.newTable || d.newColumns.length)
+    gaps.push(`data.md names no migration for ${d.table}: the migration test can't be generated.`);
+  return { cases, gaps };
+}
+function eventCases(hop, fields, firstWhen) {
+  const t = topicOf(hop.operation);
+  if (!t)
+    return [];
+  const publish = /^(publish|send)$/i.test(t[1]);
+  const publisher = publish ? hop.caller : hop.callee;
+  const subscriber = publish ? hop.callee : hop.caller;
+  const base = `event.${slug(t[2])}`;
+  const common = {
+    topic: t[2],
+    publisher,
+    subscriber,
+    fields,
+    .../^if-/.test(hop.id) ? { interfaceId: hop.id } : {}
+  };
+  return [
+    {
+      type: "event",
+      id: `${base}.publish`,
+      title: `${publisher} publishes ${t[2]}${firstWhen ? ` when ${firstWhen}` : ""}`,
+      name: "",
+      role: "publisher",
+      ...common,
+      checks: [
+        `a message is published to ${t[2]}${firstWhen ? ` when ${firstWhen}` : ""}`,
+        ...fields.length ? [`it carries ${fields.join(", ")}`] : []
+      ]
+    },
+    {
+      type: "event",
+      id: `${base}.consume`,
+      title: `${subscriber} handles ${t[2]}`,
+      name: "",
+      role: "subscriber",
+      ...common,
+      checks: [
+        `${subscriber} processes a message from ${t[2]} once, even if it is delivered twice`
+      ]
+    }
+  ];
+}
+function buildTestModel(ctx, story, changeRepos) {
+  const required = ctx.tests.required;
+  const rowKinds = ctx.tests.matrix ?? ctx.tests.required;
+  const row = ctx.tests.row ? `${ctx.tests.row.changeType}/${ctx.tests.row.risk}` : void 0;
+  const askedBy = /* @__PURE__ */ new Map();
+  for (const a of ctx.tests.added ?? [])
+    for (const k of a.kinds)
+      if (!rowKinds.includes(k) && !askedBy.has(k))
+        askedBy.set(k, { factor: a.factor, why: a.why });
+  const kinds = [
+    { type: "acceptance", generated: true, why: "Every acceptance criterion gets a scenario." }
+  ];
+  for (const [type, needs] of Object.entries(NEEDS)) {
+    const hit = needs.filter((n) => rowKinds.includes(n));
+    const added = needs.filter((n) => askedBy.has(n));
+    const fromRow = hit.length ? `test-strategy.yaml${row ? ` (${row})` : ""} asks for ${hit.join(", ")}.` : "";
+    const fromRisk = added.map((n) => {
+      const a = askedBy.get(n);
+      return `The change's ${a.factor} risk asks for ${n} tests ${a.why}.`;
+    }).join(" ");
+    kinds.push({
+      type,
+      generated: hit.length + added.length > 0,
+      why: [fromRow, fromRisk].filter(Boolean).join(" ") || `test-strategy.yaml${row ? ` (${row})` : ""} asks for ${required.join(", ") || "nothing"}, not ${needs.join(" or ")}.`
+    });
+  }
+  const on = (t) => kinds.find((k) => k.type === t).generated;
+  const notes = [];
+  const gaps = [];
+  if (ctx.tests.note)
+    notes.push(ctx.tests.note);
+  if (story.linkedBy === "inferred")
+    notes.push(`${story.id} has no links section: its interfaces and data changes were found by what it mentions.`);
+  const accTags = ["e2e", "regression", "accessibility"].filter((k) => required.includes(k));
+  const acceptance = story.criteria.map((c) => ({
+    type: "acceptance",
+    id: `acceptance.c${c.n}`,
+    title: c.trace?.name || `Criterion ${c.n}`,
+    name: "",
+    criterion: c.n,
+    given: c.given,
+    when: c.when,
+    then: c.then,
+    text: c.text,
+    ...c.trace ? { trace: c.trace } : {},
+    tags: accTags
+  }));
+  if (!story.criteria.length)
+    gaps.push(`${story.id} has no acceptance criteria: no scenario was generated.`);
+  const places = /* @__PURE__ */ new Map();
+  const allRepos = new Set(story.repos);
+  for (const h of story.hops)
+    for (const c of [h.caller, h.callee]) {
+      const r = ctx.repoOf(c);
+      if (r)
+        allRepos.add(r);
+    }
+  const ownerRepo = (d) => {
+    const s = ctx.get("DataStore", d.store);
+    return s?.ownerComponent ? ctx.repoOf(s.ownerComponent) : void 0;
+  };
+  for (const d of story.data) {
+    const r = ownerRepo(d);
+    if (r)
+      allRepos.add(r);
+  }
+  for (const r of allRepos)
+    places.set(r, repoPlace(ctx, story, r, changeRepos));
+  const repoCases = new Map([...allRepos].map((r) => [r, []]));
+  const add = (repo, cs) => {
+    if (!repo || !cs.length)
+      return false;
+    repoCases.set(repo, [...repoCases.get(repo) ?? [], ...cs]);
+    return true;
+  };
+  const elsewhere = [];
+  for (const h of story.hops) {
+    const calleeRepo = ctx.repoOf(h.callee);
+    const isRest = !!h.method && !!h.path && !topicOf(h.operation);
+    const found = isRest ? findOperation(ctx, h, places) : { tried: [] };
+    const op = found.op;
+    if (isRest && on("api")) {
+      if (calleeRepo) {
+        const a = apiCases(h, op, endpointFor(ctx, h), acceptance);
+        add(calleeRepo, a.cases);
+        notes.push(...a.notes);
+      } else
+        notes.push(`${h.callee} has no repo here, so its ${h.method} ${h.path} gets no API tests; ${h.caller}'s contract tests cover the call.`);
+    }
+    if (on("contract")) {
+      for (const c of contractCases(ctx, h, op, found.tried)) {
+        const repo = ctx.repoOf(c.role === "consumer" ? c.consumer : c.provider);
+        if (!add(repo, [c]))
+          elsewhere.push(c);
+        if (c.role === "provider")
+          gaps.push(...c.gaps);
+      }
+    }
+    if (on("event") && topicOf(h.operation)) {
+      const evs = eventCases(h, mappedFields(ctx.mapping(h)), story.criteria[0]?.when);
+      for (const e of evs)
+        add(ctx.repoOf(e.role === "publisher" ? e.publisher : e.subscriber), [e]);
+    }
+  }
+  if (on("data"))
+    for (const d of story.data) {
+      const dc = dataCases(d);
+      const repo = ownerRepo(d);
+      if (!add(repo, dc.cases) && dc.cases.length)
+        notes.push(`No repo owns ${d.store}, so the data tests for ${d.table} were not written.`);
+      gaps.push(...dc.gaps);
+    }
+  const primary = story.repos.find((r) => places.has(r)) ?? [...repoCases.keys()].find((r) => repoCases.get(r).length);
+  if (primary)
+    repoCases.set(primary, [...acceptance, ...repoCases.get(primary) ?? []]);
+  const repos = [];
+  for (const [repo, cases] of repoCases) {
+    if (!cases.length)
+      continue;
+    const place = places.get(repo) ?? { repo, kind: "none" };
+    const manifest = ctx.lifecycle.orgPack.profiles.flatMap((p) => p.repos?.repos ?? []).find((r) => r.id === repo);
+    const language = languageOf(place, manifest?.type);
+    const component = ctx.componentOfRepo(repo);
+    repos.push({
+      repo,
+      ...component ? { component } : {},
+      ...language ? { language } : {},
+      ...language === "node" ? { runner: nodeRunner(place) } : {},
+      place,
+      primary: repo === primary,
+      cases
+    });
+  }
+  if (!primary && acceptance.length)
+    repos.push({ repo: "", place: { repo: "", kind: "none" }, primary: true, cases: acceptance });
+  return {
+    change: ctx.change.id,
+    story: {
+      id: story.id,
+      path: story.path,
+      title: story.title,
+      ...story.parsed.who ? {
+        asA: story.parsed.who.asA,
+        iWant: story.parsed.who.iWant,
+        soThat: story.parsed.who.soThat
+      } : {},
+      ...story.tracesTo ? { tracesTo: story.tracesTo } : {}
+    },
+    strategy: {
+      required,
+      ...row ? { row } : {},
+      ...ctx.tests.note ? { note: ctx.tests.note } : {}
+    },
+    kinds,
+    repos: repos.sort((a, b) => Number(b.primary) - Number(a.primary) || a.repo.localeCompare(b.repo)),
+    elsewhere,
+    linkedBy: story.linkedBy,
+    notes: [...new Set(notes)],
+    gaps: [...new Set(gaps)]
+  };
+}
+var allCases = (m) => [
+  ...m.repos.flatMap((r) => r.cases),
+  ...m.elsewhere
+];
+
+// packages/testgen/dist/names.js
+var import_yaml = __toESM(require_dist(), 1);
+var TEST_WRITER = "test-writer";
+function testWriter(orgPack) {
+  const own = orgPack?.agents.find((a) => a.id === TEST_WRITER);
+  if (own)
+    return own;
+  return AgentDefinition.parse({
+    schemaVersion: 1,
+    id: TEST_WRITER,
+    role: "qa",
+    description: "Names the scenarios, test cases and test data of tests Atticus generates from a story, in plain words.",
+    inputs: ["stories", "specs", "catalog-slice"],
+    outputArtifact: "code",
+    tokenBudget: orgPack?.runtime.budgets.defaultTokens ?? 15e4,
+    allowedRuntimes: ["hand-off", "model", "headless-claude-code", "mock", "replay"]
+  });
+}
+var INSTRUCTIONS = `# Test writer
+
+Atticus has generated the tests for one story; their structure, steps, requests and checks are decided. You only name things, in plain, short English:
+
+- scenarios: a title for each Gherkin scenario, at most 80 characters, saying what is checked;
+- cases: a test name for each test case, at most 80 characters, starting with a verb;
+- data: a name for each piece of test data, two to five words, saying what it is (it becomes a variable name).
+
+Use only what the material says. Don't add cases or change what they check. Write YAML and nothing else:
+
+scenarios:
+  - id: <scenario id, exactly as given>
+    name: <title>
+cases:
+  - id: <case id, exactly as given>
+    name: <test name>
+data:
+  - id: <data id, exactly as given>
+    name: <data name>`;
+function namingMaterial(m) {
+  const cases = allCases(m);
+  const data = /* @__PURE__ */ new Map();
+  for (const c of cases)
+    if (c.type === "api" && c.data && !data.has(c.data.id))
+      data.set(c.data.id, `request body for ${c.method} ${c.path}: ${JSON.stringify(c.request.body)}`);
+  return toCanonicalYaml({
+    story: { id: m.story.id, title: m.story.title },
+    scenarios: cases.filter((c) => c.type === "acceptance").map((c) => ({
+      id: c.id,
+      given: c.given,
+      when: c.when,
+      then: c.then,
+      ...c.trace?.name ? { specScenario: c.trace.name } : {}
+    })),
+    cases: cases.filter((c) => c.type !== "acceptance").map((c) => ({ id: c.id, what: c.title })),
+    data: [...data].map(([id, what]) => ({ id, what }))
+  }, ["story", "scenarios", "cases", "data", "id", "title", "given", "when", "then", "what"]).trimEnd();
+}
+var Named = external_exports.object({ id: external_exports.string().min(1), name: external_exports.string().min(1) });
+var Answer = external_exports.object({
+  scenarios: external_exports.array(external_exports.unknown()).default([]),
+  cases: external_exports.array(external_exports.unknown()).default([]),
+  data: external_exports.array(external_exports.unknown()).default([])
+});
+function applyNames(m, output) {
+  const discarded = [];
+  let data;
+  try {
+    data = (0, import_yaml.parse)(output.replace(/^```(?:ya?ml)?\s*\n|\n```\s*$/g, ""));
+  } catch (e) {
+    return [{ reason: `the answer isn't YAML: ${e.message.split("\n")[0]}` }];
+  }
+  const a = Answer.safeParse(data);
+  if (!a.success)
+    return [{ reason: "the answer has no scenarios, cases or data lists" }];
+  const cases = allCases(m);
+  const byId = new Map(cases.map((c) => [c.id, c]));
+  const apply = (list, ok, set) => {
+    for (const raw of list) {
+      const n = Named.safeParse(raw);
+      if (!n.success) {
+        discarded.push({ reason: "an entry without an id and a name" });
+        continue;
+      }
+      const name = oneLine(n.data.name, 100);
+      if (!ok(n.data.id)) {
+        discarded.push({ id: n.data.id, reason: "no such id in the generated tests" });
+        continue;
+      }
+      if (!name) {
+        discarded.push({ id: n.data.id, reason: "an empty name" });
+        continue;
+      }
+      set(n.data.id, name);
+    }
+  };
+  apply(a.data.scenarios, (id) => byId.get(id)?.type === "acceptance", (id, name) => {
+    for (const c of cases)
+      if (c.id === id)
+        c.name = name;
+  });
+  apply(a.data.cases, (id) => !!byId.get(id) && byId.get(id).type !== "acceptance", (id, name) => {
+    for (const c of cases)
+      if (c.id === id)
+        c.name = name;
+  });
+  const dataIds = new Set(cases.flatMap((c) => c.type === "api" && c.data ? [c.data.id] : []));
+  apply(a.data.data, (id) => dataIds.has(id), (id, name) => {
+    for (const c of cases)
+      if (c.type === "api" && c.data?.id === id)
+        c.data = { id, name: camel(name, 40) };
+  });
+  return discarded;
+}
+function fallbackNames(m) {
+  for (const c of allCases(m)) {
+    if (!c.name)
+      c.name = c.title;
+    if (c.type === "api" && c.data && !c.data.name)
+      c.data = { id: c.data.id, name: camel(`${c.method} ${c.path} request`, 40) };
+  }
+}
+async function nameTests(m, o) {
+  if (!o.runtime) {
+    fallbackNames(m);
+    return { by: "fallback", discarded: [] };
+  }
+  const agent = testWriter(o.orgPack);
+  const levels = o.orgPack?.pack?.classification ?? [
+    "public",
+    "internal",
+    "confidential",
+    "restricted"
+  ];
+  const sources = [
+    {
+      id: "instructions",
+      kind: "instruction",
+      origin: "atticus/testgen",
+      text: INSTRUCTIONS,
+      classification: "public",
+      trusted: true
+    },
+    {
+      id: "tests",
+      kind: "artifact",
+      origin: `atticus tests generate ${m.story.id} (deterministic)`,
+      text: namingMaterial(m),
+      classification: "internal",
+      priority: 100
+    }
+  ];
+  const pack = buildContextPack({
+    change: m.change,
+    agent: agent.id,
+    budget: o.orgPack?.runtime.budgets.perAgent[agent.id] ?? agent.tokenBudget,
+    sources,
+    levels,
+    maxClassification: levels.includes("internal") ? "internal" : levels[0],
+    now: o.now
+  });
+  let run;
+  if (o.resume)
+    run = await o.runtime.result(o.resume);
+  else {
+    const prepared = await o.runtime.prepare({
+      change: m.change,
+      agent,
+      pack,
+      outputPath: `tests/${m.story.id}/names.yaml`
+    });
+    run = await o.runtime.run(prepared.runId);
+  }
+  if (run.state === "waiting" || run.state === "prepared") {
+    fallbackNames(m);
+    return {
+      by: "fallback",
+      discarded: [],
+      waiting: run.runId,
+      promptSha256: pack.manifest.promptSha256
+    };
+  }
+  if (run.output === void 0 || run.state === "failed" || run.state === "cancelled") {
+    fallbackNames(m);
+    return {
+      by: "fallback",
+      discarded: [
+        { reason: `the test writer ${run.state}: ${run.errors.join("; ") || "no output"}` }
+      ],
+      run: toRunSummary(run),
+      promptSha256: pack.manifest.promptSha256
+    };
+  }
+  const discarded = applyNames(m, run.output);
+  fallbackNames(m);
+  return { by: "ai", discarded, run: toRunSummary(run), promptSha256: pack.manifest.promptSha256 };
+}
+
+// packages/testgen/dist/story.js
+import { readFile as readFile2 } from "node:fs/promises";
+import { join as join4 } from "node:path";
+var GWT = /^given\s+(.+?),?\s+when\s+(.+?),?\s+then\s+(.+?)\.?(?:\s*\(([^()]+?):(\d+)\))?\.?\s*$/i;
+var content = (s) => new Set(s.toLowerCase().replace(/[^a-z0-9_ ]+/g, " ").split(/\s+/).filter((w) => w.length > 2 && !STOP.has(w)));
+var STOP = /* @__PURE__ */ new Set([
+  "the",
+  "and",
+  "with",
+  "that",
+  "has",
+  "its",
+  "for",
+  "asks",
+  "when",
+  "then",
+  "given",
+  "error"
+]);
+function overlap(a, b) {
+  const x = content(a);
+  const y = content(b);
+  if (!x.size || !y.size)
+    return 0;
+  let n = 0;
+  for (const w of x)
+    if (y.has(w))
+      n++;
+  return n / (x.size + y.size - n);
+}
+function traceCriterion(text, ref, scenarios) {
+  if (ref) {
+    const hit = scenarios.find((x) => x.file === ref.file && x.s.line === ref.line);
+    return { file: ref.file, line: ref.line, name: hit?.s.name ?? "" };
+  }
+  let best;
+  for (const x of scenarios) {
+    const score = overlap(text, `${x.s.when.join(" ")} ${x.s.then.join(" ")}`);
+    if (score >= 0.5 && (!best || score > best.score))
+      best = { ...x, score };
+  }
+  return best ? { file: best.file, line: best.s.line, name: best.s.name } : void 0;
+}
+function splitCriterion(text) {
+  text = text.replace(/\s*\(also accepts tasks? [^()]*\)\s*$/i, "");
+  const m = GWT.exec(text.trim());
+  if (!m)
+    return { given: "", when: "", then: text.trim().replace(/\.$/, "") };
+  return {
+    given: m[1].trim(),
+    when: m[2].trim(),
+    then: m[3].trim(),
+    ...m[4] ? { ref: { file: m[4].trim(), line: Number(m[5]) } } : {}
+  };
+}
+var LINK_IF = /^Interface\s+(\S+?):\s*(\S+)\s*→\s*(\S+)\s+(.+?)\s*(?:\(([^)]*)\))?\s*$/;
+var LINK_REC = /^Record\s+([a-z0-9][a-z0-9._-]*?)[:.]?(?:\s|$)/;
+function links(doc) {
+  const s = doc.sections.find((x) => x.level === 2 && /^links$/i.test(x.heading));
+  const interfaces = [];
+  const records = [];
+  if (!s)
+    return { interfaces, records };
+  for (const l of sectionLines(doc, s)) {
+    const b = /^\s*[-*]\s+(.*)$/.exec(l.text)?.[1]?.trim();
+    if (!b)
+      continue;
+    const i = LINK_IF.exec(b);
+    if (i) {
+      const line = /interfaces\.md:(\d+)/.exec(i[5] ?? "")?.[1];
+      interfaces.push({
+        id: i[1].replace(/[()]/g, ""),
+        caller: i[2],
+        callee: i[3],
+        operation: i[4].trim(),
+        ...line ? { line: Number(line) } : {}
+      });
+      continue;
+    }
+    const r = LINK_REC.exec(b);
+    if (r)
+      records.push(r[1]);
+  }
+  return { interfaces, records };
+}
+var opKey = (op) => {
+  const m = /^([A-Za-z]+)\s+(\S+)/.exec(op.trim());
+  return m ? `${m[1].toUpperCase()} ${/^\//.test(m[2]) ? normalizePath(m[2]) : m[2]}` : op.trim();
+};
+var TASK = /^\s*[-*]\s+\[[ xX]?\]\s+(\S+)\s+(.*)$/;
+function storyTasks(ctx, story) {
+  const doc = docOf(ctx.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.exec(l);
+    if (!m || !repo || !RecordId.safeParse(m[1].toLowerCase()).success)
+      return;
+    const stories = [...m[2].matchAll(/\bstor(?:y|ies)\s+([a-z0-9][a-z0-9._-]*)/gi)].map((s) => s[1].toLowerCase().replace(/[.,)]+$/, ""));
+    if (stories.includes(story))
+      out.push({ id: m[1].toLowerCase(), repo, text: m[2], line: i + 1 });
+  });
+  return out;
+}
+async function loadStory(ctx, storyId) {
+  if (!RecordId.safeParse(storyId).success)
+    throw new TestgenError("invalid", `"${storyId}" is not a story id.`);
+  const path = `stories/${storyId}.md`;
+  let text;
+  try {
+    text = await readFile2(join4(ctx.dir, "stories", `${storyId}.md`), "utf8");
+  } catch {
+    throw new TestgenError("not-found", `${ctx.change.id} has no story ${storyId} (no ${path}). Plan the stories first: atticus plan stories ${ctx.change.id}`);
+  }
+  const parsed = parseStory(path, text);
+  const scenarios = ctx.requirements.flatMap((r) => r.scenarios.map((s) => ({ file: r.file, s })));
+  const criteriaLines = (() => {
+    const s = parsed.doc.sections.find((x) => x.level === 2 && /acceptance criteria/i.test(x.heading));
+    return s ? sectionLines(parsed.doc, s).filter((l2) => /^\s*[-*]\s+/.test(l2.text)) : [];
+  })();
+  const criteria = parsed.criteria.map((c, i) => {
+    const p = splitCriterion(c);
+    const trace = traceCriterion(c, p.ref, scenarios);
+    return {
+      n: i + 1,
+      text: c,
+      given: p.given,
+      when: p.when,
+      then: p.then,
+      ...trace ? { trace } : {},
+      line: criteriaLines[i]?.n ?? 1
+    };
+  });
+  const l = links(parsed.doc);
+  let hops = [];
+  let linkedBy = "links";
+  if (l.interfaces.length) {
+    for (const li of l.interfaces) {
+      const h = (li.line ? ctx.hops.find((x) => x.line === li.line) : void 0) ?? (li.id !== "new" ? ctx.hops.find((x) => x.id === li.id) : void 0) ?? ctx.hops.find((x) => x.caller === li.caller && x.callee === li.callee && opKey(x.operation) === opKey(li.operation));
+      if (h && !hops.includes(h))
+        hops.push(h);
+    }
+  } else {
+    linkedBy = "inferred";
+    const said = [
+      text,
+      ...ctx.requirements.find((r) => parsed.traces?.includes(`${r.file}:${r.line}`))?.text ?? []
+    ].join("\n");
+    hops = ctx.hops.filter((h) => {
+      const op = h.path ?? h.operation.replace(/^\S+\s+/, "");
+      return op && said.includes(op);
+    });
+  }
+  const tasks = storyTasks(ctx, storyId);
+  let data = ctx.data.filter((d) => l.records.includes(d.tableId));
+  if (!data.length && !l.records.length) {
+    const taskText = tasks.map((t) => t.text).join("\n");
+    data = ctx.data.filter((d) => d.migration && taskText.includes(d.migration) || taskText.includes(`table ${d.table}`));
+    if (data.length)
+      linkedBy = "inferred";
+  }
+  const repos = [
+    .../* @__PURE__ */ new Set([...parsed.repos.map((r) => r.toLowerCase()), ...tasks.map((t) => t.repo)])
+  ].filter((r) => RecordId.safeParse(r).success);
+  return {
+    id: storyId,
+    path,
+    parsed,
+    title: parsed.title ?? storyId,
+    criteria,
+    hops,
+    data,
+    repos,
+    tasks,
+    linkedBy,
+    ...parsed.traces ? { tracesTo: /^(\S+:\d+)/.exec(parsed.traces)?.[1] ?? parsed.traces } : {}
+  };
+}
+
+// packages/testgen/dist/generate.js
+var ManifestFile = external_exports.strictObject({
+  schemaVersion: external_exports.literal(1),
+  change: RecordId,
+  story: RecordId,
+  strategy: external_exports.array(external_exports.string()),
+  names: external_exports.enum(["ai", "fallback"]),
+  files: external_exports.array(external_exports.strictObject({
+    path: external_exports.string().min(1),
+    repo: external_exports.string(),
+    generator: external_exports.string().min(1),
+    cases: external_exports.array(external_exports.string())
+  })),
+  cases: external_exports.array(external_exports.strictObject({
+    id: external_exports.string().min(1),
+    type: external_exports.enum(["acceptance", "api", "contract", "data", "event"]),
+    repo: external_exports.string(),
+    name: external_exports.string(),
+    criterion: external_exports.number().int().positive().optional(),
+    scenario: external_exports.string().optional(),
+    endpoint: external_exports.string().optional(),
+    interface: external_exports.string().optional(),
+    method: external_exports.string().optional(),
+    path: external_exports.string().optional(),
+    table: external_exports.string().optional(),
+    topic: external_exports.string().optional(),
+    role: external_exports.string().optional()
+  }))
+});
+var posix = (p) => p.split(sep).join("/");
+function manifestCase(c, repo) {
+  const base = { id: c.id, type: c.type, repo, name: c.name };
+  switch (c.type) {
+    case "acceptance":
+      return {
+        ...base,
+        criterion: c.criterion,
+        ...c.trace ? { scenario: `${c.trace.file}:${c.trace.line}` } : {}
+      };
+    case "api":
+      return {
+        ...base,
+        ...c.scenario ? { criterion: Number(c.scenario.replace(/^acceptance\.c/, "")) } : {},
+        method: c.method,
+        path: c.path,
+        ...c.endpoint ? { endpoint: c.endpoint } : {},
+        ...c.interfaceId ? { interface: c.interfaceId } : {}
+      };
+    case "contract":
+      return {
+        ...base,
+        role: c.role,
+        ...c.method ? { method: c.method } : {},
+        ...c.path ? { path: c.path } : {},
+        ...c.topic ? { topic: c.topic } : {},
+        ...c.interfaceId ? { interface: c.interfaceId } : {}
+      };
+    case "data":
+      return { ...base, table: c.tableId };
+    case "event":
+      return {
+        ...base,
+        topic: c.topic,
+        role: c.role,
+        ...c.interfaceId ? { interface: c.interfaceId } : {}
+      };
+  }
+}
+async function generateTests(root, changeId, storyId, o = {}) {
+  const known = [...o.generators ?? [], ...BUILT_IN_GENERATORS].map((g) => g.id);
+  if (o.framework && !known.includes(o.framework))
+    throw new TestgenError("invalid", `There is no test framework ${o.framework}. Frameworks: ${known.join(", ")}.`);
+  const ctx = await loadPlanContext(root, changeId, { requireApprovedDesign: false }).catch((e) => {
+    throw new TestgenError("not-found", e.message);
+  });
+  if (ctx.change.state === "archived")
+    throw new TestgenError("refused", `${ctx.change.id} is archived; its tests can't be generated again.`);
+  const story = await loadStory(ctx, storyId);
+  const changeRepos = await readChangeRepos(root, changeId);
+  const model = buildTestModel(ctx, story, changeRepos);
+  const names = await nameTests(model, {
+    ...o.runtime ? { runtime: o.runtime } : {},
+    orgPack: ctx.lifecycle.orgPack,
+    now: o.now ?? /* @__PURE__ */ new Date(),
+    ...o.resume ? { resume: o.resume } : {}
+  });
+  const changeRel = posix(relative(root, ctx.dir));
+  const source = `${changeRel}/${story.path}`;
+  const files = [];
+  const notes = [...model.notes];
+  for (const repo of model.repos) {
+    const inWorktree = repo.place.kind === "task-worktree" || repo.place.kind === "worktree";
+    const dir = inWorktree ? repo.place.dir : join5(ctx.dir, "tests", story.id, ...repo.repo ? [repo.repo] : []);
+    const where = inWorktree ? repo.place.kind : "change-folder";
+    const chosen = generatorsFor(repo, {
+      ...o.framework ? { framework: o.framework } : {},
+      ...o.generators ? { plugins: o.generators } : {}
+    });
+    if (chosen.note)
+      notes.push(chosen.note);
+    for (const g of chosen.generators) {
+      const rendered = g.render(model, repo, { source });
+      const results = await writeGenerated(dir, rendered, {
+        ...o.force ? { force: true } : {},
+        ...o.check ? { check: true } : {}
+      });
+      results.forEach((r, i) => files.push({
+        repo: repo.repo,
+        where,
+        generator: g.id,
+        path: posix(relative(root, join5(dir, ...r.path.split("/")))),
+        action: r.action,
+        written: r.written,
+        cases: rendered[i].cases ?? []
+      }));
+    }
+  }
+  for (const f of files.filter((x) => x.action === "kept-edited"))
+    notes.push(`${f.path} was edited by a person, so it was kept; use --force to replace it.`);
+  for (const f of files.filter((x) => x.action === "kept-not-generated"))
+    notes.push(`${f.path} wasn't written by Atticus, so it was kept; use --force to replace it.`);
+  const manifestRel = `${changeRel}/tests/${story.id}/manifest.yaml`;
+  if (!o.check) {
+    const m = ManifestFile.parse({
+      schemaVersion: 1,
+      change: model.change,
+      story: story.id,
+      strategy: model.strategy.required,
+      names: names.by,
+      files: files.map((f) => ({
+        path: f.path,
+        repo: f.repo,
+        generator: f.generator,
+        cases: f.cases
+      })),
+      cases: model.repos.flatMap((r) => r.cases.map((c) => manifestCase(c, r.repo)))
+    });
+    await writeFileAtomic(join5(root, ...manifestRel.split("/")), toCanonicalYaml(m, ["schemaVersion", "change", "story"]));
+  }
+  return {
+    change: model.change,
+    story: story.id,
+    model,
+    names,
+    files,
+    manifest: manifestRel,
+    notes: [...new Set(notes)],
+    gaps: model.gaps
+  };
+}
+async function readManifests(changeDir) {
+  const manifests = [];
+  const problems = [];
+  let dirs;
+  try {
+    dirs = (await readdir(join5(changeDir, "tests"), { withFileTypes: true })).filter((d) => d.isDirectory()).map((d) => d.name).sort();
+  } catch {
+    return { manifests, problems };
+  }
+  for (const d of dirs) {
+    const text = await readFile3(join5(changeDir, "tests", d, "manifest.yaml"), "utf8").catch(() => void 0);
+    if (text === void 0)
+      continue;
+    const r = ManifestFile.safeParse((0, import_yaml2.parse)(text));
+    if (r.success)
+      manifests.push(r.data);
+    else
+      problems.push(`tests/${d}/manifest.yaml: ${r.error.issues[0]?.message ?? "invalid"}`);
+  }
+  return { manifests, problems };
+}
+
+// packages/testgen/dist/trace.js
+var import_yaml3 = __toESM(require_dist(), 1);
+import { existsSync as existsSync3 } from "node:fs";
+import { readdir as readdir2, readFile as readFile4 } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { join as join7, relative as relative2, sep as sep2 } from "node:path";
+
+// packages/testgen/dist/rounds.js
+import { join as join6 } from "node:path";
+var sig = (fs) => fs.map((f) => `${fingerprint(f)}|${f.state}|${f.severity}`).sort().join("\n");
+async function writeGateRound(root, change, gate, fresh, now) {
+  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 byPrint = new Map(prev.map((f) => [fingerprint(f), f]));
+  const taken = /* @__PURE__ */ new Set();
+  const next = [];
+  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(join6(changeFolder(root, change), "review", gate, String(round), "meta", "round.yaml"), toCanonicalYaml({
+    schemaVersion: 1,
+    change,
+    gate,
+    round,
+    createdAt: now,
+    findings: findings.map((f) => ({
+      id: f.finding.id,
+      rule: f.finding.rule,
+      severity: f.finding.severity
+    }))
+  }, ["schemaVersion", "change", "gate", "round", "createdAt"]));
+  return { gate, round, unchanged: false, findings };
+}
+
+// packages/testgen/dist/trace.js
+var __atticus_import_meta_url = __atticusUrl("packages/testgen/dist/trace.js");
+var TRACE_GATE = "trace";
+var TEST_FILE = /(^|\/)(src\/test|tests?|__tests__|spec|specs|e2e)\/|\.(test|spec)\.[a-z]+$|Tests?\.(java|kt|cs|py|go|scala)$|_test\.(go|py)$|(^|\/)test_[^/]+\.py$|\.feature$/;
+var SKIP = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "target",
+  "build",
+  "dist",
+  ".gradle",
+  ".idea",
+  ".atticus"
+]);
+var posix2 = (p) => p.split(sep2).join("/");
+var escape = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+async function walk(dir, rel = "", out = []) {
+  let entries;
+  try {
+    entries = await readdir2(join7(dir, rel), { withFileTypes: true });
+  } catch {
+    return out;
+  }
+  for (const e of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+    const p = rel ? `${rel}/${e.name}` : e.name;
+    if (e.isDirectory()) {
+      if (!SKIP.has(e.name))
+        await walk(dir, p, out);
+    } else if (e.isFile() && TEST_FILE.test(p))
+      out.push(p);
+  }
+  return out;
+}
+function pathPattern(path) {
+  const segs = normalizePath(path).split("/").filter(Boolean);
+  const body = segs.map((s) => s === "{}" ? "[^/\"'`\\s?]+" : escape(s)).join("/");
+  return new RegExp(`/${body}(?=["'\`?\\s)]|$)`, "m");
+}
+function requirementsOf(ctx) {
+  const out = [];
+  for (const r of ctx.requirements) {
+    if (!r.scenarios.length)
+      out.push({ file: r.file, line: r.line, requirement: r.name, key: `${r.file}:${r.line}` });
+    for (const s of r.scenarios)
+      out.push({
+        file: r.file,
+        line: s.line,
+        requirement: r.name,
+        scenario: s.name,
+        key: `${r.file}:${s.line}`
+      });
+  }
+  return out;
+}
+async function storyIds(dir) {
+  return (await readdir2(join7(dir, "stories")).catch(() => [])).filter((f) => f.endsWith(".md")).map((f) => f.replace(/\.md$/, "")).sort();
+}
+async function codeOf(ctx, story, dirOf, git, problems, notStarted) {
+  const out = /* @__PURE__ */ new Set();
+  for (const t of story.tasks) {
+    const text = await readFile4(join7(ctx.dir, "tasks", t.id, "task-run.yaml"), "utf8").catch(() => void 0);
+    if (text) {
+      const run = (0, import_yaml3.parse)(text);
+      for (const f of Array.isArray(run.changed) ? run.changed : [])
+        out.add(`${t.repo}:${String(f)}`);
+    }
+    const dir = dirOf(t.repo);
+    if (!git || !dir || !existsSync3(join7(dir, ".git")))
+      continue;
+    try {
+      const r = await git([
+        "diff",
+        "--name-only",
+        `${changeBranch(ctx.change.id)}...${taskBranch(ctx.change.id, t.id)}`
+      ], dir);
+      for (const f of r.stdout.split("\n").map((x) => x.trim()).filter(Boolean))
+        out.add(`${t.repo}:${f}`);
+    } catch (e) {
+      const branch = `refs/heads/${taskBranch(ctx.change.id, t.id)}`;
+      const exists = await git(["rev-parse", "--verify", "--quiet", branch], dir).then(() => true, () => false);
+      if (exists)
+        problems.push(`${t.repo}: no diff for task ${t.id} (${e.message.split("\n")[0]})`);
+      else if (!text)
+        notStarted.add(`${t.repo} ${t.id}`);
+    }
+  }
+  return [...out].sort();
+}
+var isTaskPlace = (dir) => /[\\/]\.tasks[\\/]/.test(dir);
+async function traceMatrix(root, changeId, o = {}) {
+  const ctx = await loadPlanContext(root, changeId, { requireApprovedDesign: false }).catch((e) => {
+    throw new TestgenError("not-found", e.message);
+  });
+  const problems = [];
+  const notStarted = /* @__PURE__ */ new Set();
+  const requirements = requirementsOf(ctx);
+  const stories = [];
+  for (const id of await storyIds(ctx.dir))
+    stories.push(await loadStory(ctx, id));
+  const { manifests, problems: mp } = await readManifests(ctx.dir);
+  problems.push(...mp);
+  const manifestOf = new Map(manifests.map((m) => [m.story, m]));
+  const changeRepos = await readChangeRepos(root, changeId);
+  const repos = /* @__PURE__ */ new Set([
+    ...changeRepos?.repos.map((r) => r.id) ?? [],
+    ...stories.flatMap((s) => s.repos)
+  ]);
+  const generatedPaths = new Set(manifests.flatMap((m) => m.files.map((f) => f.path)));
+  const restHops = ctx.hops.filter((h) => h.method && h.path?.startsWith("/"));
+  const scenarioNames = requirements.filter((r) => r.scenario && r.scenario.split(/\s+/).length >= 2);
+  const found = [];
+  const dirs = /* @__PURE__ */ new Map();
+  for (const repo of [...repos].sort()) {
+    const storiesAt = /* @__PURE__ */ new Map();
+    for (const s of stories.filter((x) => x.repos.includes(repo) || x.tasks.some((t) => t.repo === repo))) {
+      const d = repoPlace(ctx, s, repo, changeRepos).dir;
+      if (!d)
+        continue;
+      if (!storiesAt.has(d))
+        storiesAt.set(d, /* @__PURE__ */ new Set());
+      storiesAt.get(d).add(s.id);
+    }
+    const places = [...storiesAt.keys()];
+    const fallback = repoPlace(ctx, { tasks: [] }, repo, changeRepos).dir;
+    if (fallback && !places.includes(fallback))
+      places.push(fallback);
+    if (places[0])
+      dirs.set(repo, fallback && !isTaskPlace(fallback) ? fallback : places[0]);
+    const copies = /* @__PURE__ */ new Map();
+    for (const dir of places) {
+      for (const rel of await walk(dir)) {
+        const text = (await readFile4(join7(dir, rel), "utf8").catch(() => "")).replace(/\r\n/g, "\n");
+        if (text.length > 512 * 1024)
+          continue;
+        const key = `${rel}\0${text}`;
+        const c = copies.get(key);
+        if (c)
+          c.dirs.push(dir);
+        else
+          copies.set(key, { rel, text, dirs: [dir] });
+      }
+    }
+    for (const { rel, text, dirs: at } of copies.values()) {
+      const refs = {
+        stories: stories.filter((s) => new RegExp(`\\b${escape(s.id)}\\b`).test(text)).map((s) => s.id),
+        scenarios: scenarioNames.filter((r) => text.toLowerCase().includes(r.scenario.toLowerCase())).map((r) => r.key),
+        endpoints: [
+          ...new Set(restHops.filter((h) => pathPattern(h.path).test(text)).map((h) => `${h.method} ${h.path}`))
+        ]
+      };
+      if (!refs.stories.length && !refs.scenarios.length && !refs.endpoints.length)
+        continue;
+      const own = at.find((d) => refs.stories.some((id) => storiesAt.get(d)?.has(id)));
+      const shared = at.find((d) => !isTaskPlace(d));
+      const dir = own ?? shared ?? at[0];
+      const path = posix2(relative2(root, join7(dir, rel)));
+      if (generatedPaths.has(path))
+        continue;
+      found.push({ kind: "found", path, repo, refs });
+    }
+  }
+  found.sort((a, b) => a.path.localeCompare(b.path));
+  const capabilities = ctx.records.filter((r) => r.kind === "Capability");
+  const rows = [];
+  const gaps = [];
+  const coveredReqs = /* @__PURE__ */ new Set();
+  for (const s of stories) {
+    const m = manifestOf.get(s.id);
+    const gen = (m?.files ?? []).map((f) => ({
+      kind: "generated",
+      path: f.path,
+      repo: f.repo,
+      cases: f.cases
+    }));
+    const records = [
+      .../* @__PURE__ */ new Set([
+        ...s.hops.flatMap((h) => {
+          const ep = endpointFor(ctx, h);
+          const i = /^if-/.test(h.id) && ctx.get("Interface", h.id) ? [h.id] : [];
+          return [
+            ...i,
+            ...ep ? [ep.id] : [],
+            ...!i.length && !ep ? [`new: ${h.caller} \u2192 ${h.callee} ${h.operation.trim()}`] : []
+          ];
+        }),
+        ...s.data.map((d) => ctx.get("Table", d.tableId) ? d.tableId : `new: table ${d.tableId}`)
+      ])
+    ];
+    const ids = new Set(records);
+    const features = capabilities.filter((c) => [...c.entryPoints, ...c.records].some((r) => ids.has(r))).map((c) => c.id).sort();
+    const code = await codeOf(ctx, s, (r) => dirs.get(r), o.git, problems, notStarted);
+    const storyFound = found.filter((f) => f.refs.stories.includes(s.id));
+    for (const c of s.criteria) {
+      const req = c.trace ? requirements.find((r) => r.key === `${c.trace.file}:${c.trace.line}`) : void 0;
+      if (req)
+        coveredReqs.add(req.key);
+      const caseId = `acceptance.c${c.n}`;
+      const linked = new Set((m?.cases ?? []).filter((x) => x.id === caseId || x.type !== "acceptance" && x.criterion === c.n).map((x) => x.id));
+      const tests = [
+        ...gen.filter((g) => g.cases.some((x) => linked.has(x))),
+        ...found.filter((f) => req && f.refs.scenarios.includes(req.key) || f.refs.stories.includes(s.id))
+      ];
+      rows.push({
+        ...req ? { requirement: req } : {},
+        story: s.id,
+        criterion: { n: c.n, text: c.text },
+        tests,
+        code,
+        records,
+        features
+      });
+    }
+    if (s.tracesTo)
+      for (const r of requirements.filter((x) => x.key === s.tracesTo || `${x.file}:${x.line}` === s.tracesTo))
+        coveredReqs.add(r.key);
+    const other = gen.filter((g) => !g.cases.every((x) => x.startsWith("acceptance.")) || !s.criteria.length);
+    if (other.length || !s.criteria.length)
+      rows.push({ story: s.id, tests: other, code, records, features });
+    const hasTest = gen.length > 0 || storyFound.length > 0 || found.some((f) => f.refs.scenarios.some((k) => s.criteria.some((c) => c.trace && `${c.trace.file}:${c.trace.line}` === k)));
+    if (!hasTest)
+      gaps.push({
+        kind: "story-without-test",
+        subject: s.id,
+        summary: `Story ${s.id} has no test: none generated and none in its repos names it.`,
+        artifact: s.path,
+        locator: { heading: s.title },
+        evidence: [{ source: "artifact", path: s.path, line: 1 }]
+      });
+    const traced = s.criteria.some((c) => c.trace) || !!s.tracesTo;
+    if (gen.length && !traced)
+      gaps.push({
+        kind: "test-without-requirement",
+        subject: s.id,
+        summary: `The tests of ${s.id} trace to no requirement: its criteria match no spec scenario.`,
+        artifact: s.path,
+        locator: { heading: s.title },
+        evidence: [{ source: "artifact", path: s.path, line: 1 }]
+      });
+  }
+  for (const r of requirements)
+    if (!coveredReqs.has(r.key)) {
+      rows.push({ requirement: r, tests: [], code: [], records: [], features: [] });
+      gaps.push({
+        kind: "requirement-without-story",
+        subject: r.key,
+        summary: `${r.scenario ? `Scenario "${r.scenario}" of requirement "${r.requirement}"` : `Requirement "${r.requirement}"`} has no story.`,
+        artifact: r.file,
+        locator: { line: r.line },
+        evidence: [{ source: "artifact", path: r.file, line: r.line }]
+      });
+    }
+  for (const f of found)
+    if (!f.refs.stories.length && !f.refs.scenarios.length)
+      gaps.push({
+        kind: "test-without-requirement",
+        subject: f.path,
+        summary: `${f.path.split("/").pop()} in ${f.repo} tests ${f.refs.endpoints.join(", ")} but names no story or spec scenario.`,
+        artifact: "tests",
+        locator: { heading: f.path },
+        evidence: [{ source: "code", repo: f.repo, path: f.path }]
+      });
+  for (const h of restHops.filter((x) => /^planned-(new|modify)$/.test(x.status))) {
+    const p = normalizePath(h.path);
+    const generated = manifests.some((m) => m.cases.some((c) => (c.type === "api" || c.type === "contract") && c.method === h.method && c.path && normalizePath(c.path) === p));
+    const inRepo = found.some((f) => f.refs.endpoints.includes(`${h.method} ${h.path}`));
+    if (generated || inRepo)
+      continue;
+    gaps.push({
+      kind: "endpoint-without-test",
+      subject: `${h.caller}-${h.callee}-${h.method}-${h.path}`,
+      summary: `${h.method} ${h.path} (${h.caller} to ${h.callee}, ${h.status}) has no API or contract test.`,
+      artifact: "interfaces.md",
+      locator: { line: h.line },
+      evidence: [{ source: "artifact", path: "interfaces.md", line: h.line }]
+    });
+  }
+  if (notStarted.size)
+    problems.push(`Not started yet (no task branch): ${[...notStarted].sort().join(", ")}.`);
+  return {
+    change: ctx.change.id,
+    requirements,
+    stories: stories.map((s) => s.id),
+    rows,
+    gaps: gaps.sort((a, b) => a.kind.localeCompare(b.kind) || a.subject.localeCompare(b.subject)),
+    found,
+    problems
+  };
+}
+var RULES_FILE = fileURLToPath(new URL("../rules/trace.yaml", __atticus_import_meta_url));
+async function loadTraceRules() {
+  const pack = ChecklistPack.parse((0, import_yaml3.parse)(await readFile4(RULES_FILE, "utf8")));
+  return new Map(pack.rules.map((r) => [r.id, r]));
+}
+var FIX = {
+  "requirement-without-story": "Plan a story for the scenario (atticus plan stories), or take the scenario out of the spec.",
+  "story-without-test": "Generate its tests (atticus tests generate) or write one that names the story or its scenarios.",
+  "endpoint-without-test": "Link the interface to a story and generate its API and contract tests, or write a test that calls it.",
+  "test-without-requirement": "Trace the story to a spec scenario, add the requirement to the spec, or remove the test."
+};
+async function traceFindings(m, now) {
+  const rules = await loadTraceRules();
+  return m.gaps.map((g) => {
+    const rule = rules.get(`trace.${g.kind}`);
+    return Finding.parse({
+      schemaVersion: 1,
+      id: `${g.kind}-${slug(g.subject)}`.slice(0, 120).replace(/-+$/, ""),
+      kind: "issue",
+      change: m.change,
+      gate: TRACE_GATE,
+      round: 1,
+      rule: rule.id,
+      layer: rule.layer,
+      lens: rule.lens,
+      severity: rule.severity,
+      artifact: g.artifact,
+      locator: g.locator,
+      summary: g.summary.length <= 200 ? g.summary : `${g.summary.slice(0, 197)}...`,
+      why: rule.description ?? rule.title,
+      fix: { text: FIX[g.kind] },
+      evidence: g.evidence,
+      waivable: false,
+      state: "open",
+      createdAt: now
+    });
+  });
+}
+async function writeTraceFindings(root, m, now) {
+  return writeGateRound(root, m.change, TRACE_GATE, await traceFindings(m, now), now);
+}
+function cells(r) {
+  return [
+    r.requirement ? `${r.requirement.requirement} (${r.requirement.file}:${r.requirement.line})` : "",
+    r.requirement?.scenario ?? "",
+    r.story ?? "",
+    r.criterion ? `${r.criterion.n}. ${r.criterion.text}` : r.story ? "(story)" : "",
+    r.tests.map((t) => `${t.path}${t.kind === "found" ? " (found)" : ""}`).join("; "),
+    r.code.join("; "),
+    r.records.join("; "),
+    r.features.join("; ")
+  ];
+}
+var HEAD = [
+  "Requirement",
+  "Scenario",
+  "Story",
+  "Criterion",
+  "Tests",
+  "Code",
+  "Records",
+  "Features"
+];
+function matrixMarkdown(m) {
+  const md = (s) => s.replace(/\|/g, "\\|") || " ";
+  const lines = [
+    `# Traceability: ${m.change}`,
+    "",
+    `| ${HEAD.join(" | ")} |`,
+    `| ${HEAD.map(() => "---").join(" | ")} |`,
+    ...m.rows.map((r) => `| ${cells(r).map(md).join(" | ")} |`),
+    "",
+    m.gaps.length ? "## Gaps" : "No gaps.",
+    ...m.gaps.length ? ["", ...m.gaps.map((g) => `- ${g.kind}: ${g.summary}`)] : []
+  ];
+  return `${lines.join("\n")}
+`;
+}
+function matrixCsv(m) {
+  const q = (s) => /[",\n]/.test(s) ? `"${s.replace(/"/g, '""')}"` : s;
+  return `${[HEAD.map((h) => h.toLowerCase()), ...m.rows.map(cells)].map((r) => r.map(q).join(",")).join("\n")}
+`;
+}
+
+export {
+  slug,
+  generateTests,
+  writeGateRound,
+  traceMatrix,
+  writeTraceFindings,
+  matrixMarkdown,
+  matrixCsv
+};