@antelopejs/dms 0.16.2 → 0.17.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## v0.17.0
+
+[compare changes](https://github.com/AntelopeJS/dms/compare/v0.16.2...v0.17.0)
+
+### 🏡 Chore
+
+- **dms-control:** Remove seeded runs and containment journeys from verification ([#774](https://github.com/AntelopeJS/dms/pull/774))
+
+### ❤️ Contributors
+
+- Antony Rizzitelli ([@Upd4ting](http://github.com/Upd4ting))
+
 ## v0.16.2
 
 [compare changes](https://github.com/AntelopeJS/dms/compare/v0.16.1...v0.16.2)

package/bin/control/base.mjs

@@ -43,9 +43,9 @@ function baseCheckout(state, skill) {
 
 /**
  * Runs `action` while the backend is the base version's, on the run's
- * current database, then starts the run's own backend again. A Format
- * containment journey writes data with the base version inside `action`
- * and reads it back with the head version after it.
+ * current database, then starts the run's own backend again. An upgrade
+ * journey writes data with the base version inside `action` and reads it
+ * back with the head version after it.
  *
  * @param {import("./run-state.mjs").RunState} state The run
  * @param {import("./verify/skill.mjs").Skill} skill The skill, whose `prepare` builds the base

package/bin/control/commands-verify.mjs

@@ -16,7 +16,6 @@ import {
   readStatus,
   setStatus,
 } from "./verify/publish.mjs";
-import { runSeededBreaks } from "./verify/seeded.mjs";
 import { journeysFile, loadSkill } from "./verify/skill.mjs";
 import { renderVerdict } from "./verify/verdict.mjs";
 
@@ -86,31 +85,6 @@ async function commandJourney(dir, feature, ids, values) {
   return results.every((result) => result.status === "PASS") ? 0 : 1;
 }
 
-/**
- * @param {string[]} features The features whose seeded breaks run
- * @param {Values} values The options of the command line
- * @returns {Promise<number>} The exit code
- */
-async function commandSeeded(features, values) {
-  const skill = await skillOf(values);
-  const outcomes = runSeededBreaks(skill, features);
-  for (const outcome of outcomes) {
-    print(
-      `${outcome.caught ? "CAUGHT" : "MISSED"} ${outcome.feature} by ${outcome.caughtBy.join(", ") || "no journey"} (evidence ${outcome.run}/evidence/${outcome.feature}, control ${outcome.controlRun}/evidence/${outcome.feature})`,
-    );
-    if (outcome.failingInControl.length > 0)
-      print(
-        `    already failing without the patch, not counted: ${outcome.failingInControl.join(", ")}`,
-      );
-    if (outcome.harnessErrors.length > 0)
-      print(
-        `    failed without a failing check (harness error), not counted: ${outcome.harnessErrors.join(", ")}`,
-      );
-    if (!outcome.caught) print(outcome.output.replace(/^/gm, "    "));
-  }
-  return outcomes.every((outcome) => outcome.caught) ? 0 : 1;
-}
-
 /**
  * @param {string | undefined} patch A patch file, or none for the diff
  * @param {Values} values The options of the command line
@@ -201,7 +175,7 @@ async function commandJudge(command, dir, values) {
 
 /**
  * Runs a command of the verification harness: `map`, `plan`, `journey`,
- * `seeded`, `doors`, `formal`, `verdict` and `publish`.
+ * `doors`, `formal`, `verdict` and `publish`.
  *
  * @param {string} command The command
  * @param {string[]} rest Its positional arguments
@@ -216,8 +190,6 @@ export function runVerifyCommand(command, rest, values) {
       return commandPlan(values);
     case "journey":
       return commandJourney(rest[0], rest[1], rest.slice(2), values);
-    case "seeded":
-      return commandSeeded(rest, values);
     case "doors":
       return commandDoors(rest[0], values);
     case "formal":

package/bin/control/renderer.test.mjs

@@ -15,7 +15,6 @@ import { targetOf } from "./commands-stack.mjs";
 import { git } from "./git.mjs";
 import { resolveRenderer } from "./renderer.mjs";
 import { decodeSkillConfig } from "./verify/decode.mjs";
-import { upArguments } from "./verify/seeded.mjs";
 import { cliPaths, layOutCopy } from "./stack.mjs";
 
 /**
@@ -266,59 +265,3 @@ await test("a run with a renderer has no base backend", async () => {
     /no base backend/,
   );
 });
-
-/**
- * @param {Partial<import("./verify/skill.mjs").SkillConfig>} config What differs from a skill with a playground in its repository
- * @returns {import("./verify/skill.mjs").Skill} The skill
- */
-function skillWith(config) {
-  return {
-    dir: "/repo/.agents/skills/verify-x",
-    name: "verify-x",
-    repo: "/repo",
-    config: { ...decodeSkillConfig(CONFIG, "verify.config.ts"), ...config },
-    featuresDir: "",
-    journeysDir: "",
-    seededBreaksDir: "",
-    seededDoorsDir: "",
-  };
-}
-
-await test("seeded starts each run on the worktree's renderer and an external playground as it is", () => {
-  const prepared = {
-    worktree: "/work/seeded-auth-1",
-    skill: "/work/seeded-auth-1/skill",
-  };
-  assert.deepEqual(
-    upArguments(
-      skillWith({ playground: "/dms/playground", renderer: "." }),
-      prepared,
-    ),
-    [
-      "up",
-      "--playground",
-      "/dms/playground",
-      "--renderer",
-      "/work/seeded-auth-1",
-      "--skill",
-      "/work/seeded-auth-1/skill",
-    ],
-  );
-});
-
-await test("seeded without a renderer starts the worktree's own playground", () => {
-  const prepared = {
-    worktree: "/work/seeded-auth-1",
-    skill: "/work/seeded-auth-1/skill",
-  };
-  assert.deepEqual(
-    upArguments(skillWith({ playground: "packages/dms/playground" }), prepared),
-    [
-      "up",
-      "--playground",
-      "/work/seeded-auth-1/packages/dms/playground",
-      "--skill",
-      "/work/seeded-auth-1/skill",
-    ],
-  );
-});

package/bin/control/verify/decode.mjs

@@ -98,7 +98,6 @@ export const isRawJudgement = objectOf(
               location: isString,
               irreversible: isString,
               containment: isString,
-              containmentJourney: isString,
             },
           ),
         ),
@@ -141,7 +140,6 @@ const isFormalCheck = objectOf(
 const isDoorRule = objectOf({
   globs: strings,
   funnels: strings,
-  containments: strings,
   why: isString,
 });
 

package/bin/control/verify/decode.test.mjs

@@ -124,7 +124,7 @@ const CONFIG = `export default {
   userFacing: ["src/**"],
   smoke: "smoke",
   smokeJourney: "onboard",
-  doors: { data: { globs: ["src/**"], funnels: [], containments: [], why: "rows" }, format: null },
+  doors: { data: { globs: ["src/**"], funnels: [], why: "rows" }, format: null },
   formal: [],
 };
 `;

package/bin/control/verify/doors.test.mjs

@@ -1,40 +1,85 @@
 import assert from "node:assert/strict";
-import { execFileSync } from "node:child_process";
-import { existsSync } from "node:fs";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
 import { join } from "node:path";
 import test from "node:test";
-import { flaggedDoors, patchFiles } from "./doors.mjs";
-import { loadSkill } from "./skill.mjs";
+import { doorLine, flaggedDoors, patchFiles } from "./doors.mjs";
 
-const skill = await loadSkill(undefined, import.meta.dirname);
-const kinds = Object.entries(skill.config.doors)
-  .filter(
-    ([kind, rule]) =>
-      rule && existsSync(join(skill.seededDoorsDir, `${kind}.patch`)),
-  )
-  .map(([kind]) => kind);
+/** @type {import("./skill.mjs").Skill} */
+const skill = {
+  dir: "/repo/.agents/skills/verify-x",
+  name: "verify-x",
+  repo: "/repo",
+  featuresDir: "",
+  journeysDir: "",
+  config: {
+    playground: "playground",
+    prepare: [],
+    userFacing: [],
+    notUserFacing: [],
+    smoke: "smoke",
+    smokeJourney: "",
+    formal: [],
+    doors: {
+      data: { globs: ["src/crons/**"], funnels: [], why: "deletes rows" },
+      outbound: {
+        globs: ["src/utils/*-mail.ts"],
+        funnels: ["src/emails.ts"],
+        why: "sends mail",
+      },
+      publish: null,
+    },
+  },
+};
 
-for (const kind of kinds) {
-  const patch = join(skill.seededDoorsDir, `${kind}.patch`);
+await test("flaggedDoors names each kind a file hits, with its files, through globs and funnels", () => {
+  assert.deepEqual(
+    flaggedDoors(skill, [
+      "src/crons/purge.ts",
+      "src/emails.ts",
+      "src/utils/invite-mail.ts",
+      "src/pages/home.ts",
+    ]),
+    [
+      { kind: "data", files: ["src/crons/purge.ts"] },
+      {
+        kind: "outbound",
+        files: ["src/emails.ts", "src/utils/invite-mail.ts"],
+      },
+    ],
+  );
+});
 
-  await test(`the ${kind} seeded door applies to the current tree`, () => {
-    assert.doesNotThrow(
-      () =>
-        execFileSync("git", ["apply", "--check", patch], {
-          cwd: skill.repo,
-          stdio: "pipe",
-        }),
-      `${kind}.patch no longer applies; refresh it against the current source`,
-    );
-  });
+await test("flaggedDoors flags nothing for files outside every rule, a null rule included", () => {
+  assert.deepEqual(
+    flaggedDoors(skill, ["package.json", "src/pages/home.ts"]),
+    [],
+  );
+});
 
-  await test(`the ${kind} seeded door flags the ${kind} door`, () => {
-    const flagged = flaggedDoors(skill, patchFiles(patch)).map(
-      (door) => door.kind,
-    );
-    assert.ok(
-      flagged.includes(kind),
-      `${kind}.patch flags ${flagged.join(", ") || "nothing"}`,
-    );
-  });
-}
+await test("patchFiles reads the new paths of a unified diff, not the old ones", (t) => {
+  const dir = mkdtempSync(join(tmpdir(), "dms-control-doors-test-"));
+  t.after(() => rmSync(dir, { recursive: true, force: true }));
+  const patch = join(dir, "change.patch");
+  writeFileSync(
+    patch,
+    [
+      "diff --git a/src/old.ts b/src/crons/purge.ts",
+      "--- a/src/old.ts",
+      "+++ b/src/crons/purge.ts",
+      "@@ -1 +1 @@",
+      "-a",
+      "+b",
+      "",
+    ].join("\n"),
+  );
+  assert.deepEqual(patchFiles(patch), ["src/crons/purge.ts"]);
+});
+
+await test("doorLine lists the flagged kinds, and is empty when none is", () => {
+  assert.equal(
+    doorLine([{ kind: "data" }, { kind: "outbound" }]),
+    "One-way-door: data, outbound",
+  );
+  assert.equal(doorLine([]), "");
+});

package/bin/control/verify/judgement.mjs

@@ -31,7 +31,6 @@ function parseRows(skill, raw) {
     return {
       ...row,
       kind: doorKind(skill, row.kind, `doors.rows[${index}].kind`),
-      containmentJourney: row.containmentJourney ?? "",
     };
   });
 }

package/bin/control/verify/map.mjs

@@ -1,7 +1,6 @@
 import { existsSync, readdirSync } from "node:fs";
 import { join, matchesGlob } from "node:path";
 import { git } from "../git.mjs";
-import { flaggedDoors, patchFiles } from "./doors.mjs";
 import { loadJourneys } from "../journey.mjs";
 import { journeysFile, readFeatures } from "./skill.mjs";
 
@@ -82,20 +81,6 @@ async function featureProblems(skill, feature, tracked) {
       problems.push(`${feature.file}: docs path ${doc} does not exist`);
     }
   }
-  const patch = join(skill.seededBreaksDir, `${feature.name}.patch`);
-  if (!existsSync(patch)) {
-    problems.push(
-      `${feature.file}: seeded-breaks/${feature.name}.patch is missing`,
-    );
-  }
-  const always = feature.name === skill.config.smoke;
-  for (const file of existsSync(patch) && !always ? patchFiles(patch) : []) {
-    if (!matches(file, feature.covers)) {
-      problems.push(
-        `${feature.file}: its seeded break edits ${file}, which its covers globs miss, so plan would not run it`,
-      );
-    }
-  }
   return problems;
 }
 
@@ -108,11 +93,6 @@ function doorProblems(skill, tracked) {
   const problems = [];
   for (const [kind, rule] of Object.entries(skill.config.doors)) {
     if (!rule) continue;
-    if (!existsSync(join(skill.seededDoorsDir, `${kind}.patch`))) {
-      problems.push(
-        `seeded-doors/${kind}.patch is missing for the ${kind} door rule`,
-      );
-    }
     for (const glob of [...rule.globs, ...rule.funnels]) {
       if (!tracked.some((path) => matchesGlob(path, glob))) {
         problems.push(
@@ -126,11 +106,9 @@ function doorProblems(skill, tracked) {
 
 /**
  * Checks the map against the repository: every user-facing file is
- * covered, every feature has journeys, each described in its file, a
- * seeded break that edits only files its own globs cover (the smoke
- * feature runs on every verdict and is exempt), existing docs
- * pages, every feature and door glob
- * matches a tracked file, and every door rule has a seeded door.
+ * covered, every feature has journeys, each described in its file,
+ * existing docs pages, and every feature and door glob matches a tracked
+ * file.
  *
  * @param {import("./skill.mjs").Skill} skill The skill
  * @returns {Promise<string[]>} One line per problem
@@ -159,33 +137,10 @@ export async function checkMap(skill) {
   return [...problems, ...doorProblems(skill, tracked)];
 }
 
-const CONTAINED_KINDS = ["data", "format"];
-
-/**
- * The containment journeys, as `feature/journey`, of the Data and Format
- * doors a set of changed files opens: a door row must name one of them,
- * passing in the run.
- *
- * @param {import("./skill.mjs").Skill} skill The skill
- * @param {string[]} changed Repository paths
- * @returns {string[]} The journeys, each once
- */
-function containmentJourneys(skill, changed) {
-  const kinds = flaggedDoors(skill, changed)
-    .map((door) => door.kind)
-    .filter((kind) => CONTAINED_KINDS.includes(kind));
-  return [
-    ...new Set(
-      kinds.flatMap((kind) => skill.config.doors[kind]?.containments ?? []),
-    ),
-  ];
-}
-
 /**
  * Maps the diff from the merge base of `baseRef` to HEAD onto features:
  * every touched feature plus the smoke feature runs, a user-facing file
- * outside every glob is an unmapped surface, and `containments` lists the
- * journeys that can contain each Data or Format door the diff opens.
+ * outside every glob is an unmapped surface.
  *
  * @param {import("./skill.mjs").Skill} skill The skill
  * @param {string} baseRef The base, such as `origin/main`
@@ -216,7 +171,6 @@ export function planFor(skill, baseRef) {
     ),
   ];
   const smoke = skill.config.smoke;
-  const containments = containmentJourneys(skill, changed);
   return {
     baseRef,
     baseSha,
@@ -225,7 +179,6 @@ export function planFor(skill, baseRef) {
     touched,
     unmapped,
     docs,
-    containments,
     run: [smoke, ...[...touchedNames].filter((name) => name !== smoke)],
   };
 }

package/bin/control/verify/skill.mjs

@@ -10,8 +10,8 @@ const CONFIG_FILE = "verify.config.ts";
 const OUTPUT_LIMIT = 64 * 1024 * 1024;
 
 /**
- * @typedef {{ dir: string, name: string, repo: string, config: SkillConfig, featuresDir: string, journeysDir: string, seededBreaksDir: string, seededDoorsDir: string }} Skill
- * @typedef {{ playground: string, renderer?: string, prepare: string[][], userFacing: string[], notUserFacing: string[], smoke: string, smokeJourney: string, doors: Record<string, { globs: string[], funnels: string[], containments: string[], why: string } | null>, formal: import("./types.mjs").FormalCheck[] }} SkillConfig
+ * @typedef {{ dir: string, name: string, repo: string, config: SkillConfig, featuresDir: string, journeysDir: string }} Skill
+ * @typedef {{ playground: string, renderer?: string, prepare: string[][], userFacing: string[], notUserFacing: string[], smoke: string, smokeJourney: string, doors: Record<string, { globs: string[], funnels: string[], why: string } | null>, formal: import("./types.mjs").FormalCheck[] }} SkillConfig
  */
 
 /**
@@ -60,8 +60,8 @@ function discover(cwd) {
 
 /**
  * Loads a verification skill: its `verify.config.ts` (imported with Node's
- * TypeScript type stripping), its feature files and where its journeys,
- * seeded breaks and seeded doors live. Without `--skill`, the one
+ * TypeScript type stripping), its feature files and where its journeys
+ * live. Without `--skill`, the one
  * `.agents/skills/verify-*` folder of the checkout holding `cwd`.
  *
  * @param {string | undefined} option The `--skill` folder
@@ -86,8 +86,6 @@ export async function loadSkill(option, cwd) {
     config,
     featuresDir: join(dir, "features"),
     journeysDir: join(dir, "journeys"),
-    seededBreaksDir: join(dir, "seeded-breaks"),
-    seededDoorsDir: join(dir, "seeded-doors"),
   };
 }
 

package/bin/control/verify/types.mjs

@@ -10,12 +10,12 @@
  * @typedef {{ exitCode: number | null, violated: string[], passing: string[] }} Rules
  * @typedef {{ name: string, exitCode: number | null, violated: string[], passing: string[], folder: string, commits?: Commits, behaviour?: BehaviourChange, checkChanged?: boolean, base?: Rules | null, fixed?: string[], missing?: string[] }} FormalResult
  * @typedef {{ feature: string, files: string[] }} TouchedFeature
- * @typedef {{ baseRef: string, baseSha: string, headSha: string, changed: string[], touched: TouchedFeature[], unmapped: string[], docs: string[], containments: string[], run: string[] }} Plan
- * @typedef {{ kind?: string, location?: string, irreversible?: string, containment?: string, containmentJourney?: string }} RawDoorRow
+ * @typedef {{ baseRef: string, baseSha: string, headSha: string, changed: string[], touched: TouchedFeature[], unmapped: string[], docs: string[], run: string[] }} Plan
+ * @typedef {{ kind?: string, location?: string, irreversible?: string, containment?: string }} RawDoorRow
  * @typedef {{ kind?: string, location?: string, reason?: string }} RawFalsePositive
  * @typedef {{ page: string, matches?: boolean, note?: string }} RawDocsJudgement
  * @typedef {{ verifier?: string, notVerified?: string[], attention?: string[], docs?: RawDocsJudgement[], doors?: { none?: string, rows?: RawDoorRow[], falsePositives?: RawFalsePositive[] } }} RawJudgement
- * @typedef {{ kind: string, location: string, irreversible: string, containment: string, containmentJourney: string }} DoorRow
+ * @typedef {{ kind: string, location: string, irreversible: string, containment: string }} DoorRow
  * @typedef {{ kind: string, location: string, reason: string }} FalsePositive
  * @typedef {{ page: string, matches: boolean, note: string }} DocsJudgement
  * @typedef {{ notVerified: string[], attention: string[], docs: DocsJudgement[], doorsNone: string | null, doors: DoorRow[], falsePositives: FalsePositive[], verifier: string }} Judgement
@@ -23,7 +23,6 @@
  * @typedef {{ feature: string, journey: string, title: string, entryPoint: string, status: "PASS" | "FAIL", database: string, steps: { name: string, checks: JourneyCheck[] }[], error: string | null, folder: string }} FeatureResult
  * @typedef {{ result: string, headSha: string, skillSha: string, pr: number, reasons: string[] }} VerdictCore
  * @typedef {VerdictCore & { markdown: string }} Verdict
- * @typedef {{ feature: string, caught: boolean, run: string, controlRun: string, caughtBy: string[], failingInControl: string[], harnessErrors: string[], output: string }} SeededOutcome
  */
 
 export {};

package/bin/control/verify/verdict.mjs

@@ -12,8 +12,6 @@ import {
 import { planFor } from "./map.mjs";
 import { journeysFile } from "./skill.mjs";
 
-const CONTAINED_KINDS = new Set(["data", "format"]);
-
 /**
  * The GitHub `owner/repo` of the checkout's origin remote.
  *
@@ -58,15 +56,13 @@ function readResults(state, feature) {
  * @param {import("../run-state.mjs").RunState} state The run
  * @param {import("./types.mjs").Plan} plan The plan
  * @param {(path: string) => string} link The evidence link of a path
- * @returns {Promise<{ rows: string[], reasons: string[], byJourney: Map<string, import("./types.mjs").FeatureResult> }>} The table rows and why the verdict fails
+ * @returns {Promise<{ rows: string[], reasons: string[] }>} The table rows and why the verdict fails
  */
 async function journeyRows(skill, state, plan, link) {
   /** @type {string[]} */
   const rows = [];
   /** @type {string[]} */
   const reasons = [];
-  /** @type {Map<string, import("./types.mjs").FeatureResult>} */
-  const byJourney = new Map();
   for (const feature of plan.run) {
     const results = readResults(state, feature);
     const file = journeysFile(skill, feature);
@@ -85,56 +81,24 @@ async function journeyRows(skill, state, plan, link) {
         );
       if (result.status === "FAIL")
         reasons.push(`${feature}/${result.journey} failed`);
-      byJourney.set(`${feature}/${result.journey}`, result);
       const outcome = result.status === "PASS" ? "pass" : "**fail**";
       rows.push(
         `| ${feature} | \`${result.journey}\`: ${result.entryPoint} | ${outcome}: ${result.title} | [${result.folder}](${link(result.folder)}) |`,
       );
     }
   }
-  return { rows, reasons, byJourney };
-}
-
-/**
- * @param {import("../run-state.mjs").RunState} state The run
- * @param {Map<string, import("./types.mjs").FeatureResult>} byJourney The results of this verdict's journeys
- * @param {string} id The containment journey, as `feature/journey`
- * @returns {import("./types.mjs").FeatureResult | undefined} Its result
- */
-function containmentResult(state, byJourney, id) {
-  const [feature, journey] = id.split("/");
-  return (
-    byJourney.get(id) ??
-    readResults(state, feature).find((result) => result.journey === journey)
-  );
+  return { rows, reasons };
 }
 
 /**
  * @param {import("./skill.mjs").Skill} skill The skill
- * @param {import("../run-state.mjs").RunState} state The run
  * @param {import("./types.mjs").Judgement} judgement The verifier's judgement
- * @param {Map<string, import("./types.mjs").FeatureResult>} byJourney The results of this verdict's journeys
  * @param {import("./types.mjs").Plan} plan The plan
  * @returns {string[]} Why the doors fail the verdict
  */
-function doorReasons(skill, state, judgement, byJourney, plan) {
+function doorReasons(skill, judgement, plan) {
   /** @type {string[]} */
   const reasons = [];
-  for (const row of judgement.doors.filter((door) =>
-    CONTAINED_KINDS.has(door.kind),
-  )) {
-    const allowed = skill.config.doors[row.kind]?.containments ?? [];
-    const journey = containmentResult(state, byJourney, row.containmentJourney);
-    if (!allowed.includes(row.containmentJourney)) {
-      reasons.push(
-        `${row.kind} door at ${row.location} names ${row.containmentJourney || "no journey"}; its containment must be one of ${allowed.join(", ")}`,
-      );
-    } else if (journey?.status !== "PASS") {
-      reasons.push(
-        `${row.kind} door at ${row.location}: containment journey ${row.containmentJourney} did not pass in this run`,
-      );
-    }
-  }
   for (const door of flaggedDoors(skill, plan.changed)) {
     for (const file of door.files) {
       const listed = judgement.doors.some(
@@ -168,12 +132,10 @@ function doorsSection(judgement) {
     ...dismissed,
     "| Kind | Location | What cannot be undone | Containment |",
     "|---|---|---|---|",
-    ...judgement.doors.map((door) => {
-      const journey = door.containmentJourney
-        ? ` (journey \`${door.containmentJourney}\`)`
-        : "";
-      return `| ${door.kind} | \`${door.location}\` | ${door.irreversible} | ${door.containment}${journey} |`;
-    }),
+    ...judgement.doors.map(
+      (door) =>
+        `| ${door.kind} | \`${door.location}\` | ${door.irreversible} | ${door.containment} |`,
+    ),
   ];
 }
 
@@ -266,11 +228,6 @@ function markdown(skill, verdict, parts) {
     "### Touched features",
     ...bullets(touched, "none"),
     `- ${skill.config.smoke}: ${skill.config.smokeJourney}`,
-    ...(plan.containments.length > 0
-      ? [
-          `- containment journeys of the Data and Format doors: ${plan.containments.map((feature) => `\`${feature}\``).join(", ")}`,
-        ]
-      : []),
     "",
     ...(plan.unmapped.length > 0
       ? [
@@ -344,7 +301,7 @@ export async function renderVerdict(skill, state, pr, judgement) {
     ...journeys.reasons,
     ...plan.unmapped.map((file) => `unmapped surface ${file}`),
     ...docsReasons(judgement, plan),
-    ...doorReasons(skill, state, judgement, journeys.byJourney, plan),
+    ...doorReasons(skill, judgement, plan),
     ...formal.reasons,
   );
   const attention = judgement.attention;

package/bin/dms-control.mjs

@@ -28,7 +28,6 @@ Verify a change (the .agents/skills/verify-* folder of the checkout, or --skill
   map                               check the feature map covers every user-facing file
   plan [--base <ref>]               map the diff to features; list unmapped surfaces
   journey <run> <feature> [ids...]  run a feature's journeys and record evidence
-  seeded <feature...>               run each feature unpatched and with its seeded break
   doors [patch] [--base <ref>]      print the One-way-door line for a patch, or for the diff
   formal <run> [--all]              run the formal checks that cover the diff (or every one)
   verdict <run> --pr <n>            render evidence/verdict.md from the results and evidence/judgement.json

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@antelopejs/dms",
-  "version": "0.16.2",
+  "version": "0.17.0",
   "description": "AntelopeJS DMS. Plug in your PostgreSQL, MongoDB or RethinkDB database and your coding agent builds a back office and analytics dashboard as typed TypeScript. Real-time updates on the data the DMS manages.",
   "keywords": [
     "antelopejs",

package/bin/control/verify/seeded.mjs

@@ -1,217 +0,0 @@
-import { spawnSync } from "node:child_process";
-import {
-  cpSync,
-  existsSync,
-  mkdtempSync,
-  rmSync,
-  writeFileSync,
-} from "node:fs";
-import { tmpdir } from "node:os";
-import { join, relative, resolve } from "node:path";
-import { git } from "../git.mjs";
-import { CONTROL_BIN } from "../stack.mjs";
-import { readFeatureResults } from "./decode.mjs";
-import { runPrepare } from "./skill.mjs";
-
-const OUTPUT_LIMIT = 64 * 1024 * 1024;
-
-/**
- * @param {string} cwd Where to run it
- * @param {string} program The program
- * @param {string[]} args Its arguments
- * @returns {import("node:child_process").SpawnSyncReturns<string>} The run
- */
-function run(cwd, program, args) {
-  return spawnSync(program, args, {
-    cwd,
-    encoding: "utf8",
-    env: { ...process.env, CI: "1" },
-    maxBuffer: OUTPUT_LIMIT,
-  });
-}
-
-/**
- * @param {string} cwd Where to run it
- * @param {string} program The program
- * @param {string[]} args Its arguments
- * @returns {string} Its trimmed output
- */
-function mustRun(cwd, program, args) {
-  const result = run(cwd, program, args);
-  if (result.status !== 0) {
-    throw new Error(
-      `${program} ${args.join(" ")} failed in ${cwd}:\n${result.stdout}${result.stderr}`,
-    );
-  }
-  return result.stdout.trim();
-}
-
-/**
- * A scratch worktree of HEAD with the current skill copied in, the patch
- * applied when there is one, and the config's `prepare` commands run. The
- * worktree is the skill's repository, which is also the renderer checkout
- * when the config names a `renderer`: the patch changes what the run serves.
- *
- * @param {import("./skill.mjs").Skill} skill The skill
- * @param {string} label What the worktree is for
- * @param {string | null} patch The patch file, or `null` for the control
- * @returns {{ worktree: string, skill: string }} The worktree and its skill copy
- */
-function prepareWorktree(skill, label, patch) {
-  const worktree = mkdtempSync(
-    join(tmpdir(), `${skill.name}-seeded-${label}-`),
-  );
-  git(["worktree", "add", "--detach", "--force", worktree, "HEAD"], skill.repo);
-  const copy = join(worktree, relative(skill.repo, skill.dir));
-  rmSync(copy, { recursive: true, force: true });
-  cpSync(skill.dir, copy, { recursive: true });
-  if (patch) mustRun(worktree, "git", ["apply", patch]);
-  runPrepare(skill, worktree);
-  return { worktree, skill: copy };
-}
-
-/**
- * @param {import("./skill.mjs").Skill} skill The skill
- * @param {string} worktree The scratch worktree
- */
-function removeWorktree(skill, worktree) {
-  git(["worktree", "remove", "--force", worktree], skill.repo);
-}
-
-/**
- * The `up` arguments for a scratch worktree: the config's playground and
- * renderer, resolved in the worktree unless absolute.
- *
- * @param {import("./skill.mjs").Skill} skill The skill
- * @param {{ worktree: string, skill: string }} prepared The scratch worktree and its skill copy
- * @returns {string[]} The arguments
- */
-export function upArguments(skill, prepared) {
-  const { playground, renderer } = skill.config;
-  return [
-    "up",
-    "--playground",
-    resolve(prepared.worktree, playground),
-    ...(renderer ? ["--renderer", resolve(prepared.worktree, renderer)] : []),
-    "--skill",
-    prepared.skill,
-  ];
-}
-
-/**
- * @param {{ worktree: string, skill: string }} prepared The scratch worktree and its skill copy
- * @param {import("./skill.mjs").Skill} skill The skill
- * @param {string} feature The feature
- * @returns {{ run: string, results: import("./types.mjs").FeatureResult[], output: string }} The run folder, its results and output
- */
-function runFeatureIn(prepared, skill, feature) {
-  /**
-   * @param {string[]} args The dms-control arguments
-   * @returns {import("node:child_process").SpawnSyncReturns<string>} The run
-   */
-  const control = (args) =>
-    run(prepared.worktree, process.execPath, [CONTROL_BIN, ...args]);
-  const started = control(upArguments(skill, prepared));
-  const dir = started.stdout.trim().split("\n").at(-1) ?? "";
-  if (started.status !== 0 || !existsSync(join(dir, "run.json"))) {
-    return {
-      run: dir,
-      results: [],
-      output: `up failed:\n${started.stdout}${started.stderr}`,
-    };
-  }
-  const journeys = control([
-    "journey",
-    dir,
-    feature,
-    "--skill",
-    prepared.skill,
-  ]);
-  control(["down", dir]);
-  const file = join(dir, "evidence", feature, "feature.json");
-  const results = readFeatureResults(file);
-  return { run: dir, results, output: `${journeys.stdout}${journeys.stderr}` };
-}
-
-/**
- * @param {import("./types.mjs").FeatureResult} result A journey result
- * @returns {boolean} Whether one of its checks failed
- */
-function failsACheck(result) {
-  return result.steps.some((step) => step.checks.some((check) => !check.pass));
-}
-
-/**
- * @param {string} feature The feature
- * @param {ReturnType<typeof runFeatureIn>} control The unpatched run
- * @param {ReturnType<typeof runFeatureIn>} seeded The patched run
- * @returns {import("./types.mjs").SeededOutcome} The outcome
- */
-function judge(feature, control, seeded) {
-  const passedInControl = new Set(
-    control.results
-      .filter((result) => result.status === "PASS")
-      .map((result) => result.journey),
-  );
-  const failed = seeded.results.filter((result) => result.status === "FAIL");
-  const caughtBy = failed
-    .filter(
-      (result) => passedInControl.has(result.journey) && failsACheck(result),
-    )
-    .map((result) => result.journey);
-  return {
-    feature,
-    caught: caughtBy.length > 0,
-    run: seeded.run,
-    controlRun: control.run,
-    caughtBy,
-    failingInControl: control.results
-      .filter((result) => result.status === "FAIL")
-      .map((result) => result.journey),
-    harnessErrors: failed
-      .filter((result) => !failsACheck(result))
-      .map((result) => result.journey),
-    output: seeded.output,
-  };
-}
-
-/**
- * Runs each feature's journeys twice from scratch worktrees of HEAD: once
- * unpatched as the control, once with `seeded-breaks/<feature>.patch`. A
- * break is caught only when a journey that passes in the control fails one
- * of its checks with the patch; a failure without a failing check is a
- * harness error and does not count. Worktrees are removed; both runs keep
- * their evidence, and `seeded.json` in the patched run records the outcome.
- *
- * @param {import("./skill.mjs").Skill} skill The skill
- * @param {string[]} features The features
- * @returns {import("./types.mjs").SeededOutcome[]} One outcome per feature
- */
-export function runSeededBreaks(skill, features) {
-  const control = prepareWorktree(skill, "control", null);
-  try {
-    return features.map((feature) => {
-      const unpatched = runFeatureIn(control, skill, feature);
-      const patch = join(skill.seededBreaksDir, `${feature}.patch`);
-      const seeded = prepareWorktree(skill, feature, patch);
-      try {
-        const outcome = judge(
-          feature,
-          unpatched,
-          runFeatureIn(seeded, skill, feature),
-        );
-        if (existsSync(outcome.run)) {
-          writeFileSync(
-            join(outcome.run, "evidence", "seeded.json"),
-            `${JSON.stringify(outcome, null, 2)}\n`,
-          );
-        }
-        return outcome;
-      } finally {
-        removeWorktree(skill, seeded.worktree);
-      }
-    });
-  } finally {
-    removeWorktree(skill, control.worktree);
-  }
-}