@antelopejs/dms 0.16.1 → 0.17.0

package/CHANGELOG.md

@@ -1,5 +1,48 @@
 # 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)
+
+### 🚀 Enhancements
+
+- **header:** Let a header action draw a module component as its icon ([#772](https://github.com/AntelopeJS/dms/pull/772))
+
+### 🔥 Performance
+
+- **store:** Let the modules listing read stale registry answers ([#768](https://github.com/AntelopeJS/dms/pull/768))
+
+### 🩹 Fixes
+
+- **layout:** Keep the platform title in the document title after sign-in ([#767](https://github.com/AntelopeJS/dms/pull/767))
+- **layout:** Keep a closing toast inside the collapsed stack ([#771](https://github.com/AntelopeJS/dms/pull/771))
+- **auth:** List each person once in the account switcher ([#770](https://github.com/AntelopeJS/dms/pull/770))
+- **dms-dev:** Run dev servers side by side across worktrees ([#769](https://github.com/AntelopeJS/dms/pull/769))
+
+### 📦 Build
+
+- **deps:** Move to @antelopejs/core 1.20 and drop the interface-core override ([#765](https://github.com/AntelopeJS/dms/pull/765))
+
+### 🏡 Chore
+
+- Remove the .amp directory ([#766](https://github.com/AntelopeJS/dms/pull/766))
+
+### ❤️ Contributors
+
+- Antony Rizzitelli ([@Upd4ting](http://github.com/Upd4ting))
+
 ## v0.16.1
 
 [compare changes](https://github.com/AntelopeJS/dms/compare/v0.16.0...v0.16.1)

package/README.md

@@ -79,7 +79,7 @@ export class SalesPage extends PageController("sales", {
 
 | Package                                     | Supported          | Tested with |
 | ------------------------------------------- | ------------------ | ----------- |
-| `@antelopejs/core`                          | `>=1.17.0 <2`      | `1.17.0`    |
+| `@antelopejs/core`                          | `>=1.20.0 <2`      | `1.20.0`    |
 | `@antelopejs/interface-api`                 | `>=0.2.0 <1.0.0`   | `0.2.0`     |
 | `@antelopejs/interface-api-util`            | `>=0.3.0 <1.0.0`   | `0.3.0`     |
 | `@antelopejs/interface-core`                | `>=0.4.0 <1.0.0`   | `0.4.0`     |

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/dist/store/cache.d.ts

@@ -2,7 +2,11 @@ export interface CacheLifetimes {
     found: number;
     failed: number;
 }
+export type Freshness = "cached" | "fresh" | "stale";
+export interface LookupOptions {
+    freshness?: Freshness;
+}
 export interface LookupCache<T> {
-    get(key: string, lookup: () => Promise<T | undefined>): Promise<T | undefined>;
+    get(key: string, lookup: () => Promise<T | undefined>, options?: LookupOptions): Promise<T | undefined>;
 }
 export declare function createLookupCache<T>(lifetimes: CacheLifetimes): LookupCache<T>;