@sleepy-hollow/framework 0.3.3 → 0.3.5

package/dist/cli.js

@@ -1,28 +1,30 @@
 #!/usr/bin/env node
 import {
   resolveConfiguration
-} from "./chunk-4PPSJ2LE.js";
+} from "./chunk-2GNHTFCZ.js";
 import {
+  CRITERION_TEST_DISCOVERY,
+  createTestManifest,
   createTraceabilityReport,
   selectAffectedTests
-} from "./chunk-M4D63YC7.js";
+} from "./chunk-YBEJCNGD.js";
 import "./chunk-BAKXP7IR.js";
 import {
   composeProjectSecurity
-} from "./chunk-LZ2HLHDW.js";
+} from "./chunk-AADQFGT4.js";
 import {
   normalizeRoutes
-} from "./chunk-JRFHLLLF.js";
+} from "./chunk-QY3TSXM6.js";
 import {
   discoverRoutes,
   platform
-} from "./chunk-S3Z6CO7J.js";
-import "./chunk-LNJDFJGT.js";
+} from "./chunk-LPPASMRR.js";
+import "./chunk-EHBEUJIZ.js";
 import "./chunk-5WRI5ZAA.js";
 
 // cli/main.ts
 import { realpathSync } from "fs";
-import { pathToFileURL as pathToFileURL4 } from "url";
+import { pathToFileURL as pathToFileURL5 } from "url";
 
 // cli/adapters.ts
 import { isAbsolute as isAbsolute5, join as join4, relative as relative5, sep as sep6 } from "path";
@@ -1006,7 +1008,7 @@ var CreationError = class extends Error {
 };
 
 // cli/create/create.ts
-var VERSION = "0.3.3";
+var VERSION = "0.3.5";
 var NAME = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
 function files(name) {
   return {
@@ -1142,6 +1144,12 @@ owners:
 
 Use the official Sleepy Hollow skill to replace this planning placeholder with
 the complete application requirements before generating endpoints.
+
+## Cross-cutting acceptance criteria
+
+- AC-APP-PLACEHOLDER-001: The application requirements are completed and approved before implementation.
+
+## Governance record
 `,
     "sleepyhollow.config.ts": `import { defineProject } from "./.sleepyhollow/project.ts";
 
@@ -1173,7 +1181,7 @@ async function pathExists(path) {
     throw error;
   }
 }
-var FRAMEWORK_VERSION = "0.3.3";
+var FRAMEWORK_VERSION = "0.3.5";
 async function createProject(options) {
   if (!NAME.test(options.name) || options.name.length > 64) {
     throw creationError(
@@ -1201,10 +1209,10 @@ async function createProject(options) {
   );
   try {
     await platform.mkdir(staging);
-    for (const relative6 of createdFiles) {
-      const target = join2(staging, relative6);
+    for (const relative8 of createdFiles) {
+      const target = join2(staging, relative8);
       await platform.mkdir(resolve(target, ".."), { recursive: true });
-      await platform.writeTextFile(target, contents[relative6], { createNew: true });
+      await platform.writeTextFile(target, contents[relative8], { createNew: true });
     }
     await platform.rename(staging, destination);
   } catch (error) {
@@ -1359,6 +1367,7 @@ async function startWorker(options, expectedRoutes) {
   const child = workerCommand(options, "serve").spawn();
   const stdout = readFirstLine(child.stdout);
   const stderr = readBounded(child.stderr);
+  const status = child.status;
   let timeout;
   const timer = new Promise((_, reject) => {
     timeout = setTimeout(
@@ -1387,9 +1396,34 @@ async function startWorker(options, expectedRoutes) {
     );
   }
   let stopped = false;
+  const failure3 = new Promise((_, reject) => {
+    void status.then(async (result) => {
+      if (stopped) return;
+      if (result.success) {
+        reject(new DevCommandError([{
+          code: "SH_DEV_WORKER_EXITED",
+          severity: "error",
+          summary: "The development worker exited after becoming active",
+          correction: "Inspect the worker diagnostics and retry."
+        }]));
+        return;
+      }
+      reject(await workerFailure(
+        await stderr,
+        "The development worker failed after becoming active"
+      ));
+    }, async () => {
+      if (stopped) return;
+      reject(await workerFailure(
+        await stderr,
+        "The development worker failed after becoming active"
+      ));
+    });
+  });
   return {
     url: `http://${options.hostname}:${options.port}/`,
     routeCount: expectedRoutes,
+    failure: failure3,
     async stop() {
       if (stopped) return;
       stopped = true;
@@ -1620,6 +1654,7 @@ function failure2(error, fallback) {
 }
 function changedPaths(projectRoot, paths) {
   const normalized = [];
+  const runtimeDatabaseArtifact = /^\.sleepyhollow\/[^/]+\.(?:sqlite|db)(?:-(?:wal|shm))?$/;
   for (const path of paths) {
     const absolute = isAbsolute(path) ? resolve2(path) : resolve2(projectRoot, path);
     const local = relative(projectRoot, absolute).split(sep).join("/");
@@ -1630,7 +1665,7 @@ function changedPaths(projectRoot, paths) {
         "Watch only project-contained application inputs."
       );
     }
-    if (local === ".git" || local.startsWith(".git/") || local === "generated" || local.startsWith("generated/") || local.includes("/node_modules/") || /(?:^|\/)(?:\.DS_Store|.*(?:\.swp|~))$/.test(local)) continue;
+    if (local === ".git" || local.startsWith(".git/") || local === "generated" || local.startsWith("generated/") || local.includes("/node_modules/") || runtimeDatabaseArtifact.test(local) || /(?:^|\/)(?:\.DS_Store|.*(?:\.swp|~))$/.test(local)) continue;
     normalized.push(local);
   }
   return Object.freeze([...new Set(normalized)].sort());
@@ -1645,6 +1680,21 @@ function abortReason(signal) {
   }
   return "cancelled";
 }
+async function nextChange(iterator, active) {
+  const change = iterator.next();
+  if (!active?.failure) return change;
+  return Promise.race([
+    change,
+    active.failure.then(() => {
+      throw new DevCommandError([{
+        code: "SH_DEV_WORKER_EXITED",
+        severity: "error",
+        summary: "The active development worker exited unexpectedly",
+        correction: "Inspect the worker diagnostics and retry."
+      }]);
+    })
+  ]);
+}
 async function runDevCommand(args, io, suppliedDependencies) {
   const parsed = parse2(args);
   if ("code" in parsed) {
@@ -1766,7 +1816,11 @@ ${parsed.correction}`
       return 1;
     }
     if (signal.aborted) await closeWatcher();
-    for await (const paths of watcher) {
+    const iterator = watcher[Symbol.asyncIterator]();
+    while (true) {
+      const next = await nextChange(iterator, active);
+      if (next.done) break;
+      const paths = next.value;
       if (signal.aborted) break;
       const changes = changedPaths(projectRoot, paths);
       if (!Array.isArray(changes)) {
@@ -1919,14 +1973,26 @@ function safeDiagnostic(error, intent) {
       ...typeof item.key === "string" ? { configuration: [item.key] } : {}
     }));
   }
-  if (intent === "serve" && (error instanceof platform.errors.AddrInUse || error instanceof platform.errors.PermissionDenied)) {
+  const nodeError = error;
+  const nodeCode = typeof nodeError?.code === "string" ? nodeError.code : void 0;
+  const isListenFailure = error instanceof platform.errors.AddrInUse || error instanceof platform.errors.PermissionDenied || nodeError?.syscall === "listen" || nodeCode === "EADDRINUSE" || nodeCode === "EACCES" || nodeCode === "EPERM";
+  if (intent === "serve" && isListenFailure) {
     return [{
       code: "SH_DEV_BIND_FAILED",
       severity: "error",
-      summary: "The loopback listener could not bind",
+      summary: nodeCode ? `The loopback listener failed with ${nodeCode}` : "The loopback listener could not bind",
       correction: "Choose an available port and confirm local network access."
     }];
   }
+  if (intent === "serve") {
+    const cause = error instanceof Error ? `${error.name}: ${error.message}`.replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, "").replace(/(?:Bearer|token|password|secret|authorization)[=: ]+\S+/gi, "$1=[redacted]").replace(/(?:[A-Za-z]:)?\/[^\s]+/g, "[path]").slice(0, 180) : void 0;
+    return [{
+      code: "SH_DEV_SERVE_FAILED",
+      severity: "error",
+      summary: cause ? `The development server failed: ${cause}` : "The development server failed",
+      correction: "Inspect the bounded server diagnostic and retry after repairing the host boundary."
+    }];
+  }
   return [{
     code: "SH_DEV_PROJECT_INVALID",
     severity: "error",
@@ -1998,20 +2064,20 @@ async function runDevWorker(args) {
   const [intent, projectRoot, hostname, rawPort] = args;
   const port = Number(rawPort);
   if (hostname !== "127.0.0.1" || !Number.isInteger(port) || port < 1 || port > 65535) return 2;
+  let server;
   try {
     const { runtime: runtime2, routeCount } = await loadRuntime(projectRoot);
     if (intent === "validate") {
       console.log(JSON.stringify({ ready: true, routeCount }));
       return 0;
     }
-    const server = platform.serve({ hostname, port }, (request) => runtime2.fetch(request));
+    server = platform.serve({ hostname, port }, (request) => runtime2.fetch(request));
+    await server.ready;
     console.log(JSON.stringify({ ready: true, routeCount }));
-    await new Promise((resolve5, reject) => {
-      server.once("close", resolve5);
-      server.once("error", reject);
-    });
+    await server.finished;
     return 0;
   } catch (error) {
+    await server?.shutdown().catch(() => void 0);
     console.error(
       JSON.stringify({
         ready: false,
@@ -2911,7 +2977,7 @@ function renderArtifacts(inventory2) {
   ];
   const manifestContent = canonicalJson({
     schema: "sleepy-hollow-generated-manifest/v1",
-    generatorVersion: "0.3.3",
+    generatorVersion: "0.3.5",
     serviceId: normalized.serviceId,
     inputDigest: digest2(input),
     artifacts: Object.fromEntries(
@@ -3185,7 +3251,7 @@ function inventoryFromRoutes(routes2, options) {
   return {
     serviceId: options.serviceId,
     title: options.title ?? options.serviceId,
-    version: options.version ?? "0.3.3",
+    version: options.version ?? "0.3.5",
     ...options.description ? { description: options.description } : {},
     operations,
     securitySchemes: options.securitySchemes ?? {}
@@ -3416,7 +3482,7 @@ function invocation(plan2, options) {
   const args = [
     "./node_modules/vitest/vitest.mjs",
     "run",
-    "--reporter=verbose",
+    "--reporter=tap-flat",
     ...plan2.filter ? ["--testNamePattern", plan2.filter] : [],
     ...files2
   ];
@@ -3464,11 +3530,16 @@ function parseTap(source, inventory2, failureEvidence) {
   );
   const events = [];
   for (const line of lines) {
-    const matched = line.match(/^(ok|not ok) \d+ - (.*?)(?: # (SKIP).*)?$/i);
+    const matched = line.match(
+      /^(ok|not ok) \d+ - (.*?)(?:\s+#\s+(SKIP)\b.*|\s+#\s+.*)?$/i
+    );
     if (!matched) continue;
-    const name = matched[2];
+    const rawName = matched[2];
+    const separator = rawName.indexOf(" > ");
+    const file = separator >= 0 ? rawName.slice(0, separator) : byName.get(rawName) ?? "<runner>";
+    const name = separator >= 0 ? rawName.slice(separator + 3) : rawName;
     events.push({
-      file: byName.get(name) ?? "<runner>",
+      file,
       name,
       status: matched[3]?.toUpperCase() === "SKIP" ? "skipped" : matched[1] === "ok" ? "passed" : "failed",
       ...matched[1] === "not ok" && failureEvidence ? { evidence: failureEvidence } : {}
@@ -3829,6 +3900,32 @@ function renderJson(result) {
 }
 
 // cli/test/command.ts
+async function persistEvidence(inventory2, result) {
+  if (!inventory2.manifestPath || !inventory2.resultsPath) return;
+  const results = result.tests.filter((test) => !test.id.startsWith("unmapped:")).map((test) => ({
+    testId: test.id,
+    status: test.status === "unmapped" ? "failed" : test.status,
+    ...test.durationMs === null ? {} : { durationMs: test.durationMs },
+    ...test.evidence ? { evidence: test.evidence } : {}
+  }));
+  await platform.mkdir(inventory2.manifestPath.slice(
+    0,
+    inventory2.manifestPath.lastIndexOf("/")
+  ), { recursive: true });
+  await platform.writeTextFile(
+    inventory2.manifestPath,
+    `${JSON.stringify(inventory2.manifest, null, 2)}
+`
+  );
+  await platform.writeTextFile(
+    inventory2.resultsPath,
+    `${JSON.stringify({
+      schema: "sleepy-hollow-test-results/v1",
+      results
+    }, null, 2)}
+`
+  );
+}
 function parse3(args) {
   let json2 = false;
   let scope = { kind: "full" };
@@ -3954,7 +4051,7 @@ async function execute(args, io, load, runner) {
   } catch {
     return emit(loadFailure(parsed.scope), parsed.json, io);
   }
-  const capturePath = `${io.cwd}/generated/capture.json`;
+  const capturePath = inventory2.captureArtifactPath ?? `${io.cwd}/generated/capture.json`;
   inventory2 = { ...inventory2, captureArtifactPath: capturePath };
   const testPlan = plan(inventory2, parsed.scope);
   if (testPlan.diagnostics.some((item) => item.severity === "error")) {
@@ -4006,6 +4103,26 @@ async function execute(args, io, load, runner) {
     };
   }
   const normalized = normalizeRunnerResult(testPlan, inventory2, runnerResult);
+  let persistedResult = normalized;
+  if (inventory2.manifestPath && inventory2.resultsPath) {
+    try {
+      await persistEvidence(inventory2, normalized);
+    } catch {
+      persistedResult = {
+        ...normalized,
+        ok: false,
+        diagnostics: [
+          ...normalized.diagnostics,
+          {
+            code: "SH_TEST_EVIDENCE_NOT_PERSISTED",
+            severity: "error",
+            summary: "The test run completed but governed test evidence could not be persisted.",
+            correction: "Repair the generated directory and rerun hollow test before checking the project."
+          }
+        ]
+      };
+    }
+  }
   let persisted = true;
   try {
     await platform.stat(capturePath);
@@ -4013,8 +4130,8 @@ async function execute(args, io, load, runner) {
     persisted = false;
   }
   return emit(
-    persisted ? normalized : {
-      ...normalized,
+    persisted ? persistedResult : {
+      ...persistedResult,
       diagnostics: [
         ...normalized.diagnostics,
         {
@@ -4039,7 +4156,7 @@ var CLI_COMMANDS = [
   "generate",
   "deploy"
 ];
-var CLI_VERSION = "0.3.3";
+var CLI_VERSION = "0.3.5";
 var commandMetadata = {
   create: {
     description: "Create one deterministic Sleepy Hollow project.",
@@ -5169,10 +5286,11 @@ function digestOf(source, path) {
 }
 function approvalOf(source, digest3, criteria) {
   const governance = source.slice(source.indexOf("## Governance record"));
-  const approvalStart = governance.indexOf("### Approval");
-  if (approvalStart < 0) return void 0;
+  const approvals = [...governance.matchAll(/^### Approval[^\r\n]*\r?$/gm)];
+  const latest = approvals.at(-1);
+  if (!latest || latest.index === void 0) return void 0;
   const approvalRemainder = governance.slice(
-    approvalStart + "### Approval".length
+    latest.index + latest[0].length
   );
   const next = approvalRemainder.search(/^### /m);
   const approval = next < 0 ? approvalRemainder : approvalRemainder.slice(0, next);
@@ -5181,7 +5299,7 @@ function approvalOf(source, digest3, criteria) {
   const approvedAt = /- Approved at:\s*(.+?)\.?(?:\r?\n|$)/.exec(approval)?.[1]?.replace(/\.$/, "");
   const criterionText = /- Approved criteria:\s*(.+?)\.?(?:\r?\n|$)/.exec(approval)?.[1] ?? "";
   const recordedDigest = /sha256:([a-f0-9]{64})/.exec(approval)?.[1];
-  const decisionSource = /- Decision source:\s*([\s\S]*?)(?=\r?\n- [A-Z]|$)/.exec(approval)?.[1]?.replace(/\r?\n\s+/g, " ").replace(/\.$/, "");
+  const decisionSource = /- Decision source:\s*([\s\S]*?)(?=\r?\n- [A-Z]|$)/.exec(approval)?.[1]?.replace(/\r?\n\s+/g, " ").trim().replace(/\.$/, "");
   const approvedCriteria = criteria.filter(
     (item) => criterionText.includes(item.id)
   ).map((item) => item.id);
@@ -5197,6 +5315,18 @@ function approvalOf(source, digest3, criteria) {
     valid
   };
 }
+function redStateValid(source) {
+  const governance = source.slice(source.indexOf("## Governance record"));
+  const records = [
+    ...governance.matchAll(/^### Red-state evidence[^\r\n]*\r?$/gm)
+  ];
+  const latest = records.at(-1);
+  if (!latest || latest.index === void 0) return false;
+  const remainder = governance.slice(latest.index + latest[0].length);
+  const next = remainder.search(/^### /m);
+  const record = next < 0 ? remainder : remainder.slice(0, next);
+  return /- Status:\s*(?:credible red state captured|failed as expected)\./i.test(record) && /- (?:Base revision|Observed at):\s*\S+/i.test(record) && /- Result:\s*\S+/i.test(record);
+}
 function parseRequirementDocument(source, path, kind) {
   const { metadata, body, bodyOffset } = frontmatterOf(source, path);
   const diagnostics = [];
@@ -5377,7 +5507,8 @@ function parseRequirementDocument(source, path, kind) {
     criteria: criterionResult.criteria,
     sections,
     governedContentDigest,
-    approval
+    approval,
+    redStateValid: redStateValid(source)
   };
 }
 
@@ -5390,7 +5521,7 @@ function parseRequirement(source, path, kind) {
 function issue2(code, path, summary, correction, line) {
   return { code, path, summary, correction, ...line ? { line } : {} };
 }
-async function collect(absoluteRoot, displayRoot, serviceId2, options) {
+async function collect(absoluteRoot, displayRoot, serviceId2, kind, options) {
   const list = options.listDirectory ?? (async (path) => {
     const entries = [];
     for await (const entry of platform.readDir(path)) {
@@ -5422,6 +5553,7 @@ async function collect(absoluteRoot, displayRoot, serviceId2, options) {
           path: nextDisplay,
           absolutePath: nextAbsolute,
           legacy: entry.name === "requirements.md",
+          kind,
           ...serviceId2 ? { serviceId: serviceId2 } : {}
         });
       }
@@ -5442,16 +5574,45 @@ async function requirements(project, options) {
     serviceId: void 0
   }];
   const files2 = [];
+  files2.push({
+    path: project.requirementsFile,
+    absolutePath: `${project.projectRoot}/${project.requirementsFile}`,
+    legacy: project.requirementsFile.endsWith("requirements.md"),
+    kind: "application"
+  });
+  for (const service of project.services) {
+    const absolutePath = `${project.projectRoot}/${service.requirementsPath}`;
+    try {
+      await platform.lstat(absolutePath);
+      files2.push({
+        path: service.requirementsPath,
+        absolutePath,
+        legacy: service.requirementsPath.endsWith("requirements.md"),
+        kind: "application"
+      });
+    } catch (error) {
+      if (!platform.isNotFound(error)) throw error;
+    }
+  }
   for (const root of roots) {
     files2.push(
-      ...await collect(root.absolute, root.display, root.serviceId, options)
+      ...await collect(
+        root.absolute,
+        root.display,
+        root.serviceId,
+        "endpoint",
+        options
+      )
     );
   }
-  files2.sort((left, right) => left.path.localeCompare(right.path));
+  const uniqueFiles = [...new Map(
+    files2.map((file) => [file.absolutePath, file])
+  ).values()];
+  uniqueFiles.sort((left, right) => left.path.localeCompare(right.path));
   const diagnostics = [];
   const loaded = [];
   const seen = /* @__PURE__ */ new Map();
-  for (const file of files2) {
+  for (const file of uniqueFiles) {
     if (file.legacy) {
       diagnostics.push(issue2(
         "SH_EVIDENCE_REQUIREMENT_LEGACY_FILENAME",
@@ -5475,7 +5636,7 @@ async function requirements(project, options) {
     }
     let parsed;
     try {
-      parsed = parseRequirement(source, file.path, "endpoint");
+      parsed = parseRequirement(source, file.path, file.kind);
     } catch (error) {
       if (error instanceof PlanningError) {
         for (const item of error.diagnostics) {
@@ -5527,7 +5688,14 @@ async function requirements(project, options) {
       } : {},
       path: file.path,
       ...file.serviceId ? { serviceId: file.serviceId } : {},
-      approvalBound
+      approvalBound,
+      redStateValid: parsed.redStateValid,
+      ...file.kind === "endpoint" ? {
+        routePath: typeof parsed.metadata.path === "string" ? parsed.metadata.path : void 0,
+        methods: Array.isArray(parsed.metadata.methods) ? parsed.metadata.methods.filter(
+          (method) => typeof method === "string"
+        ) : void 0
+      } : {}
     });
   }
   if (diagnostics.length > 0) throw new EvidenceError(diagnostics);
@@ -5544,12 +5712,15 @@ async function requirements(project, options) {
       criteria: item.criteria,
       ...item.approval ? { approval: item.approval } : {},
       path: item.path,
-      redStateValid: false
+      redStateValid: item.redStateValid,
+      ...item.routePath ? { routePath: item.routePath } : {},
+      ...item.methods ? { methods: item.methods } : {}
     }))
   };
 }
 
 // cli/evidence/behavior.ts
+import { relative as relative6, sep as sep7 } from "path";
 var CAPTURE_FILE = "capture.json";
 async function capture(project, options) {
   const path = `${project.projectRoot}/${project.generatedDirectory}/${CAPTURE_FILE}`;
@@ -5612,7 +5783,16 @@ function authenticationOf(security2) {
   if (typeof declared !== "object" || declared === null) return "none";
   return declared.mode === "required" ? "required" : "none";
 }
-async function routes(project, artifact2) {
+function normalizedRequirementPath(path) {
+  return path.replace(/\[([A-Za-z_][A-Za-z0-9_]*)\]/g, ":$1");
+}
+function ownerOf(route, requirements2) {
+  const owners = requirements2.filter(
+    (requirement) => requirement.routePath !== void 0 && normalizedRequirementPath(requirement.routePath) === route.path && requirement.methods?.includes(route.method)
+  );
+  return owners.length === 1 ? owners[0].id : void 0;
+}
+async function routes(project, artifact2, requirements2 = []) {
   const roots = project.services.length > 0 ? project.services.map((service) => ({
     absolute: `${project.projectRoot}/${service.apiRoot}`,
     display: service.apiRoot
@@ -5645,10 +5825,12 @@ async function routes(project, artifact2) {
         }
         statuses2.add(request.responseStatus);
       }
+      const source = route.source.startsWith("/") ? relative6(root.absolute, route.source).split(sep7).join("/") : route.source;
       found.push({
+        requirementId: ownerOf(route, requirements2),
         method: route.method,
         path: route.path,
-        source: `${root.display}${route.source.startsWith("/") ? "" : "/"}${route.source}`,
+        source: `${root.display}/${source}`,
         requestSchemaLocations: declaredLocations(route.operation.schemas),
         requiredRequestLocations: [...readLocations].sort(),
         responseSchemaStatuses: declaredStatuses(route.operation.schemas),
@@ -5663,11 +5845,172 @@ async function routes(project, artifact2) {
   );
 }
 
+// cli/evidence/tests.ts
+import { relative as relative7, sep as sep8 } from "path";
+import { pathToFileURL as pathToFileURL4 } from "url";
+var MANIFEST_FILE = "test-manifest.json";
+var RESULTS_FILE = "test-results.json";
+var TEST_FILE = /(?:_test|\.test)\.(?:ts|tsx|mts|cts)$/;
+var discoverySequence = 0;
+function relativeProjectPath(root, path) {
+  return relative7(root, path).split(sep8).join("/");
+}
+async function collect2(root, projectRoot) {
+  const found = [];
+  const walk = async (directory) => {
+    let entries;
+    try {
+      entries = [];
+      for await (const entry of platform.readDir(directory)) entries.push(entry);
+    } catch {
+      return;
+    }
+    entries.sort((left, right) => left.name.localeCompare(right.name));
+    for (const entry of entries) {
+      if (entry.isSymlink) continue;
+      const absolute = `${directory}/${entry.name}`;
+      if (entry.isDirectory) {
+        await walk(absolute);
+      } else if (entry.isFile && TEST_FILE.test(entry.name)) {
+        found.push({ absolute, relative: relativeProjectPath(projectRoot, absolute) });
+      }
+    }
+  };
+  await walk(root);
+  return found;
+}
+function testRoots(project) {
+  const roots = project.services.length > 0 ? project.services.flatMap((service) => [
+    `${project.projectRoot}/${service.testsRoot}`,
+    `${project.projectRoot}/${service.apiRoot}`
+  ]) : [
+    `${project.projectRoot}/tests`,
+    `${project.projectRoot}/${project.apiDirectory}`
+  ];
+  return [...new Set(roots)];
+}
+async function discoverFiles(project) {
+  const files2 = (await Promise.all(testRoots(project).map(
+    (root) => collect2(root, project.projectRoot)
+  ))).flat();
+  const unique = new Map(files2.map((file) => [file.absolute, file]));
+  return [...unique.values()].sort(
+    (left, right) => left.relative.localeCompare(right.relative)
+  );
+}
+async function discoverManifest(project) {
+  const descriptors = [];
+  const sources = {};
+  const hook = {
+    onRegistered: (descriptor) => descriptors.push(descriptor)
+  };
+  const registry = globalThis;
+  registry[CRITERION_TEST_DISCOVERY] = hook;
+  try {
+    for (const file of await discoverFiles(project)) {
+      const source = await platform.readTextFile(file.absolute);
+      if (!/\bcriterionTest\s*\(/.test(source)) continue;
+      sources[file.relative] = source;
+      try {
+        discoverySequence += 1;
+        await import(`${pathToFileURL4(file.absolute).href}?sleepy_hollow_discovery=${discoverySequence}`);
+      } catch (error) {
+        throw new EvidenceError([{
+          code: "SH_EVIDENCE_TEST_DISCOVERY_FAILED",
+          path: file.relative,
+          summary: error instanceof Error ? error.message : "A governed test could not be loaded for discovery.",
+          correction: "Repair the criterionTest registration and its imports, then retry."
+        }]);
+      }
+    }
+  } finally {
+    delete registry[CRITERION_TEST_DISCOVERY];
+  }
+  return createTestManifest({ descriptors, sources });
+}
+function emptyManifest() {
+  return { schema: "sleepy-hollow-test-manifest/v1", tests: [] };
+}
+function parseManifest(value, path) {
+  if (!value || typeof value !== "object" || value.schema !== "sleepy-hollow-test-manifest/v1" || !Array.isArray(value.tests)) {
+    throw new EvidenceError([{
+      code: "SH_EVIDENCE_TEST_MANIFEST_INVALID",
+      path,
+      summary: "The persisted test manifest has an unsupported shape.",
+      correction: "Regenerate test evidence with hollow test."
+    }]);
+  }
+  return value;
+}
+function parseResults(value, path) {
+  if (!value || typeof value !== "object" || value.schema !== "sleepy-hollow-test-results/v1" || !Array.isArray(value.results)) {
+    throw new EvidenceError([{
+      code: "SH_EVIDENCE_TEST_RESULTS_INVALID",
+      path,
+      summary: "The persisted test results have an unsupported shape.",
+      correction: "Regenerate test evidence with hollow test."
+    }]);
+  }
+  return value.results;
+}
+async function readJson(path) {
+  let source;
+  try {
+    source = await platform.readTextFile(path);
+  } catch (error) {
+    if (platform.isNotFound(error)) return void 0;
+    throw new EvidenceError([{
+      code: "SH_EVIDENCE_TEST_ARTIFACT_UNREADABLE",
+      path,
+      summary: "A persisted test evidence artifact could not be read.",
+      correction: "Repair the generated evidence permissions and retry."
+    }]);
+  }
+  try {
+    return JSON.parse(source);
+  } catch {
+    throw new EvidenceError([{
+      code: "SH_EVIDENCE_TEST_ARTIFACT_INVALID",
+      path,
+      summary: "A persisted test evidence artifact is not valid JSON.",
+      correction: "Regenerate test evidence with hollow test."
+    }]);
+  }
+}
+async function readTestEvidence(project) {
+  const generated = `${project.projectRoot}/${project.generatedDirectory}`;
+  const manifestPath = `${generated}/${MANIFEST_FILE}`;
+  const resultsPath = `${generated}/${RESULTS_FILE}`;
+  const previousPath = `${generated}/previous-test-manifest.json`;
+  const [manifestSource, resultsSource, previousSource] = await Promise.all([
+    readJson(manifestPath),
+    readJson(resultsPath),
+    readJson(previousPath)
+  ]);
+  const manifest = manifestSource === void 0 ? emptyManifest() : parseManifest(manifestSource, `${project.generatedDirectory}/${MANIFEST_FILE}`);
+  const results = resultsSource === void 0 ? [] : parseResults(resultsSource, `${project.generatedDirectory}/${RESULTS_FILE}`);
+  return {
+    manifest,
+    ...previousSource === void 0 ? {} : { previousManifest: parseManifest(previousSource, `${project.generatedDirectory}/previous-test-manifest.json`) },
+    results
+  };
+}
+async function discoverTestEvidence(project) {
+  return discoverManifest(project);
+}
+function testEvidencePaths(projectRoot, generatedDirectory) {
+  const generated = `${projectRoot}/${generatedDirectory}`;
+  return {
+    manifestPath: `${generated}/${MANIFEST_FILE}`,
+    resultsPath: `${generated}/${RESULTS_FILE}`
+  };
+}
+
 // cli/evidence/inventory.ts
 async function inventory(project, options) {
   const artifact2 = await capture(project, options);
   const governed = await requirements(project, options);
-  const discovered = await routes(project, artifact2);
+  const discovered = await routes(project, artifact2, governed.requirements);
   return {
     projectRootDisplay: project.projectRoot,
     requirements: governed.requirements,
@@ -5692,10 +6035,7 @@ async function inventory(project, options) {
 async function checkLoader(projectRoot, revision2, _scope) {
   const project = await locations({ projectRoot });
   const evidence = await inventory(project, { projectRoot, revision: revision2 });
-  const testManifest = {
-    schema: "sleepy-hollow-test-manifest/v1",
-    tests: []
-  };
+  const testEvidence = await readTestEvidence(project);
   return {
     projectRootDisplay: projectRoot,
     requestedScope: { kind: "full" },
@@ -5707,14 +6047,17 @@ async function checkLoader(projectRoot, revision2, _scope) {
       criteria: item.criteria,
       ...item.approval ? { approval: item.approval } : {},
       path: item.path,
-      redStateValid: item.approvalBound
+      redStateValid: item.redStateValid,
+      ...item.routePath ? { routePath: item.routePath } : {},
+      ...item.methods ? { methods: item.methods } : {}
     })),
     dependencyGraph: evidence.requirements.map((item) => ({
       id: item.id,
       dependsOn: item.dependsOn ?? []
     })),
-    testManifest,
-    testResults: [],
+    testManifest: testEvidence.manifest,
+    previousTestManifest: testEvidence.previousManifest,
+    testResults: testEvidence.results,
     routes: evidence.routes.map((route) => ({
       requirementId: route.requirementId ?? "",
       method: route.method,
@@ -5744,6 +6087,11 @@ async function checkLoader(projectRoot, revision2, _scope) {
 async function testLoader(projectRoot) {
   const project = await locations({ projectRoot });
   const governed = await requirements(project, { projectRoot });
+  const manifest = await discoverTestEvidence(project);
+  const evidencePaths = testEvidencePaths(
+    projectRoot,
+    project.generatedDirectory
+  );
   return {
     projectRootDisplay: projectRoot,
     requirements: governed.requirements.map((item) => ({
@@ -5759,8 +6107,14 @@ async function testLoader(projectRoot) {
       dependsOn: item.dependsOn ?? []
     })),
     routes: [],
-    manifest: { schema: "sleepy-hollow-test-manifest/v1", tests: [] },
-    isolation: []
+    manifest,
+    isolation: manifest.tests.map((test) => ({
+      testId: test.id,
+      policy: "isolated"
+    })),
+    manifestPath: evidencePaths.manifestPath,
+    resultsPath: evidencePaths.resultsPath,
+    captureArtifactPath: `${projectRoot}/${project.generatedDirectory}/capture.json`
   };
 }
 
@@ -5793,7 +6147,7 @@ function runCli(args, io, dependencies = {}) {
 function invokedAsCli(entry = process.argv[1]) {
   if (!entry) return false;
   try {
-    return import.meta.url === pathToFileURL4(realpathSync(entry)).href;
+    return import.meta.url === pathToFileURL5(realpathSync(entry)).href;
   } catch {
     return false;
   }