audit-tools 0.42.1 → 0.43.0

package/dispatch/merge-results.mjs

@@ -1,168 +1,257 @@
 import { join } from "node:path";
 import { readFileSync, writeFileSync, readdirSync, existsSync } from "node:fs";
+import { pathToFileURL } from "node:url";
 import { validateResult } from "./validate.mjs";
-import { PACKET_SCHEMA_FILENAMES } from "../dist/audit/io/runArtifacts.js";
 import { resolveArtifactsDir } from "./artifacts-dir.mjs";
 
-const runIdIdx = process.argv.indexOf("--run-id");
-if (runIdIdx === -1 || !process.argv[runIdIdx + 1]) {
-  console.error("Usage: node dispatch/merge-results.mjs --run-id <run_id> [--artifacts-dir <dir>]");
-  process.exit(1);
-}
-const runId = process.argv[runIdIdx + 1];
-
-// Default must match where the orchestrator/wrapper actually writes runs:
-// <root>/.audit-tools/audit (COR-bf5c7331). The prior `.audit-artifacts`
-// default resolved to a directory the pipeline never populates.
-const artifactsDir = resolveArtifactsDir(process.argv);
-
-const taskResultsDir = join(artifactsDir, "runs", runId, "task-results");
-const auditResultsPath = join(artifactsDir, "runs", runId, "run-results.json");
-const failedTasksPath = join(artifactsDir, "runs", runId, "failed-tasks.json");
-const tasksPath = join(artifactsDir, "runs", runId, "pending-audit-tasks.json");
-
-if (!existsSync(taskResultsDir)) {
-  console.error(`task-results directory not found: ${taskResultsDir}`);
-  process.exit(1);
-}
+/**
+ * Importable merge core (CP-NODE-21 / dispatch-scripts-test-reach). Every
+ * acceptance branch this script owns — fail-closed manifest read, INV-01
+ * array-payload expansion, duplicate-task_id rejection, unknown-task_id
+ * rejection, missing-result-is-a-failure, no-destructive-truncation, and the
+ * INV-03 partial-merge signal (surfaced here as `failing.length > 0`, which
+ * the CLI shim below turns into a non-zero exit) — lives in this function so
+ * a test can drive it in-process against a fabricated run directory, without
+ * spawning a child process and without process.exit ever firing mid-test.
+ * The CLI shim is a byte-compatible wrapper: same argv parsing, same
+ * stdout/stderr text, same exit codes as before this split.
+ *
+ * @param {{ artifactsDir: string, runId: string }} options
+ * @returns {{
+ *   ok: boolean,
+ *   fatal?: { message: string },
+ *   passing: object[],
+ *   failing: { task_id: string, errors: string[] }[],
+ *   total: number,
+ *   auditResultsPath: string,
+ *   failedTasksPath: string,
+ *   wroteAuditResults: boolean,
+ *   wroteFailedTasks: boolean,
+ * }}
+ */
+export function mergeResults({ artifactsDir, runId }) {
+  const taskResultsDir = join(artifactsDir, "runs", runId, "task-results");
+  const auditResultsPath = join(artifactsDir, "runs", runId, "run-results.json");
+  const failedTasksPath = join(artifactsDir, "runs", runId, "failed-tasks.json");
+  const tasksPath = join(artifactsDir, "runs", runId, "pending-audit-tasks.json");
 
-// Manifest-reconciled completeness (COR-7602834d cluster): acceptance is judged against the
-// pending manifest, never against whichever task-results files happen to exist.
-// A missing or unreadable manifest means no task context can be established, so
-// the merge hard-fails BEFORE any write (fail-closed task-identity gate) instead
-// of validating results fail-open with no assigned task.
-let tasks;
-try {
-  tasks = JSON.parse(readFileSync(tasksPath, "utf8"));
-  if (!Array.isArray(tasks)) {
-    throw new Error("pending-audit-tasks.json must be a JSON array of AuditTasks");
+  if (!existsSync(taskResultsDir)) {
+    return {
+      ok: false,
+      fatal: { message: `task-results directory not found: ${taskResultsDir}` },
+      passing: [],
+      failing: [],
+      total: 0,
+      auditResultsPath,
+      failedTasksPath,
+      wroteAuditResults: false,
+      wroteFailedTasks: false,
+    };
   }
-} catch (e) {
-  console.error(
-    `Cannot read pending manifest ${tasksPath}: ${e.message}\n` +
-      "merge-results judges acceptance against the pending manifest (fail-closed); aborting before any write.",
-  );
-  process.exit(1);
-}
-const taskMap = new Map(tasks.filter(t => t && typeof t.task_id === "string").map(t => [t.task_id, t]));
-
-// Result-file selection excludes the schema pointer files prepare-dispatch
-// copies into task-results/ for optional worker self-validation — they are
-// support artifacts, never results, and must not be counted as failures.
-const PACKET_SCHEMA_FILENAME_SET = new Set(PACKET_SCHEMA_FILENAMES);
-const files = readdirSync(taskResultsDir)
-  .filter(f => f.endsWith(".json") && !PACKET_SCHEMA_FILENAME_SET.has(f))
-  .sort();
-
-const failing = [];
-const resultsByTaskId = new Map();
-
-for (const filename of files) {
-  const filePath = join(taskResultsDir, filename);
-  let parsed;
+
+  // Manifest-reconciled completeness (COR-7602834d cluster): acceptance is judged against the
+  // pending manifest, never against whichever task-results files happen to exist.
+  // A missing or unreadable manifest means no task context can be established, so
+  // the merge hard-fails BEFORE any write (fail-closed task-identity gate) instead
+  // of validating results fail-open with no assigned task.
+  let tasks;
   try {
-    parsed = JSON.parse(readFileSync(filePath, "utf8"));
+    tasks = JSON.parse(readFileSync(tasksPath, "utf8"));
+    if (!Array.isArray(tasks)) {
+      throw new Error("pending-audit-tasks.json must be a JSON array of AuditTasks");
+    }
   } catch (e) {
-    failing.push({ task_id: filename, errors: [`Invalid JSON: ${e.message}`] });
-    continue;
+    return {
+      ok: false,
+      fatal: {
+        message:
+          `Cannot read pending manifest ${tasksPath}: ${e.message}\n` +
+          "merge-results judges acceptance against the pending manifest (fail-closed); aborting before any write.",
+      },
+      passing: [],
+      failing: [],
+      total: 0,
+      auditResultsPath,
+      failedTasksPath,
+      wroteAuditResults: false,
+      wroteFailedTasks: false,
+    };
   }
+  const taskMap = new Map(tasks.filter(t => t && typeof t.task_id === "string").map(t => [t.task_id, t]));
+
+  // Schema-pointer-file exclusion was retired along with the rest of the
+  // schema-copy feature in 467b1e8f ("retire the execution substrate: zero
+  // adapters, host-owned execution"), which deleted PACKET_SCHEMA_FILENAMES
+  // and its sole producer (nothing in src/ copies schema files into
+  // task-results/ anymore) but left this import pointing at the deleted
+  // export — an orphaned reference that made this whole script unimportable
+  // (ESM throws on a missing named export). If a schema-pointer-file
+  // convention is reintroduced, re-add the matching exclusion here sourced
+  // from wherever that filename list lives then; there is nothing to exclude
+  // today.
+  const files = readdirSync(taskResultsDir)
+    .filter(f => f.endsWith(".json"))
+    .sort();
 
-  // Expand top-level AuditResult[] arrays — a worker that emits an array
-  // payload must not be treated as one invalid object (INV-01 / COR-bf5c7331).
-  const candidates = Array.isArray(parsed) ? parsed : [parsed];
-  for (const resultObj of candidates) {
-    const taskId =
-      resultObj && typeof resultObj === "object" && !Array.isArray(resultObj) &&
-      typeof resultObj.task_id === "string"
-        ? resultObj.task_id
-        : undefined;
-    if (!taskId) {
-      failing.push({
-        task_id: filename,
-        errors: ["Result has no task_id; cannot bind it to an assigned task."],
-      });
+  const failing = [];
+  const resultsByTaskId = new Map();
+
+  for (const filename of files) {
+    const filePath = join(taskResultsDir, filename);
+    let parsed;
+    try {
+      parsed = JSON.parse(readFileSync(filePath, "utf8"));
+    } catch (e) {
+      failing.push({ task_id: filename, errors: [`Invalid JSON: ${e.message}`] });
       continue;
     }
-    if (resultsByTaskId.has(taskId)) {
-      // Dedup-by-task_id: the first on-disk result for a task is authoritative;
-      // later copies are rejected, never double-merged.
-      failing.push({
-        task_id: taskId,
-        errors: [`Duplicate audit result for assigned task '${taskId}'.`],
-      });
-      continue;
+
+    // Expand top-level AuditResult[] arrays — a worker that emits an array
+    // payload must not be treated as one invalid object (INV-01 / COR-bf5c7331).
+    const candidates = Array.isArray(parsed) ? parsed : [parsed];
+    for (const resultObj of candidates) {
+      const taskId =
+        resultObj && typeof resultObj === "object" && !Array.isArray(resultObj) &&
+        typeof resultObj.task_id === "string"
+          ? resultObj.task_id
+          : undefined;
+      if (!taskId) {
+        failing.push({
+          task_id: filename,
+          errors: ["Result has no task_id; cannot bind it to an assigned task."],
+        });
+        continue;
+      }
+      if (resultsByTaskId.has(taskId)) {
+        // Dedup-by-task_id: the first on-disk result for a task is authoritative;
+        // later copies are rejected, never double-merged.
+        failing.push({
+          task_id: taskId,
+          errors: [`Duplicate audit result for assigned task '${taskId}'.`],
+        });
+        continue;
+      }
+      if (!taskMap.has(taskId)) {
+        // Identity is the tool's authority: a result that matches no assigned
+        // task in the pending manifest never validates (fail-closed).
+        failing.push({
+          task_id: taskId,
+          errors: [`Unknown task_id '${taskId}': not in the pending manifest for run '${runId}'.`],
+        });
+        continue;
+      }
+      resultsByTaskId.set(taskId, resultObj);
     }
-    if (!taskMap.has(taskId)) {
-      // Identity is the tool's authority: a result that matches no assigned
-      // task in the pending manifest never validates (fail-closed).
-      failing.push({
-        task_id: taskId,
-        errors: [`Unknown task_id '${taskId}': not in the pending manifest for run '${runId}'.`],
-      });
+  }
+
+  // Validate each MANIFEST task's result: present → validate in the assigned
+  // task's context; absent → a genuine failure (the manifest, not the file
+  // listing, decides completeness).
+  const passing = [];
+  for (const task of taskMap.values()) {
+    const resultObj = resultsByTaskId.get(task.task_id);
+    if (resultObj === undefined) {
+      failing.push({ task_id: task.task_id, errors: ["Missing audit result for assigned task."] });
       continue;
     }
-    resultsByTaskId.set(taskId, resultObj);
+    const { valid, errors } = validateResult(resultObj, task);
+    if (valid) {
+      passing.push(resultObj);
+    } else {
+      failing.push({ task_id: task.task_id, errors });
+    }
   }
-}
 
-// Validate each MANIFEST task's result: present → validate in the assigned
-// task's context; absent → a genuine failure (the manifest, not the file
-// listing, decides completeness).
-const passing = [];
-for (const task of taskMap.values()) {
-  const resultObj = resultsByTaskId.get(task.task_id);
-  if (resultObj === undefined) {
-    failing.push({ task_id: task.task_id, errors: ["Missing audit result for assigned task."] });
-    continue;
+  let wroteFailedTasks = false;
+  if (failing.length > 0) {
+    writeFileSync(failedTasksPath, JSON.stringify(failing, null, 2));
+    wroteFailedTasks = true;
   }
-  const { valid, errors } = validateResult(resultObj, task);
-  if (valid) {
-    passing.push(resultObj);
-  } else {
-    failing.push({ task_id: task.task_id, errors });
+
+  // No destructive truncation on re-run (COR-44bea9c0 cluster): run-results.json is written
+  // only when there is something to merge. A blocked no-op (nothing passed while
+  // something failed) — e.g. a stray re-invocation after a successful merge —
+  // must never truncate a previously written run-results.json to [].
+  let wroteAuditResults = false;
+  if (passing.length > 0) {
+    writeFileSync(auditResultsPath, JSON.stringify(passing, null, 2));
+    wroteAuditResults = true;
   }
+
+  return {
+    ok: true,
+    passing,
+    failing,
+    total: passing.length + failing.length,
+    auditResultsPath,
+    failedTasksPath,
+    wroteAuditResults,
+    wroteFailedTasks,
+  };
 }
 
-if (failing.length > 0) {
-  writeFileSync(failedTasksPath, JSON.stringify(failing, null, 2));
-  process.stderr.write(`${failing.length} task(s) failed validation and were excluded:\n`);
-  for (const f of failing) {
-    for (const err of f.errors) {
-      process.stderr.write(`  ✗ ${f.task_id}: ${err}\n`);
+function runCli() {
+  const runIdIdx = process.argv.indexOf("--run-id");
+  if (runIdIdx === -1 || !process.argv[runIdIdx + 1]) {
+    console.error("Usage: node dispatch/merge-results.mjs --run-id <run_id> [--artifacts-dir <dir>]");
+    process.exit(1);
+  }
+  const runId = process.argv[runIdIdx + 1];
+
+  // Default must match where the orchestrator/wrapper actually writes runs:
+  // <root>/.audit-tools/audit (COR-bf5c7331). The prior `.audit-artifacts`
+  // default resolved to a directory the pipeline never populates.
+  const artifactsDir = resolveArtifactsDir(process.argv);
+
+  const result = mergeResults({ artifactsDir, runId });
+
+  if (!result.ok) {
+    console.error(result.fatal.message);
+    process.exit(1);
+  }
+
+  const { passing, failing, total, auditResultsPath, failedTasksPath } = result;
+
+  if (failing.length > 0) {
+    process.stderr.write(`${failing.length} task(s) failed validation and were excluded:\n`);
+    for (const f of failing) {
+      for (const err of f.errors) {
+        process.stderr.write(`  ✗ ${f.task_id}: ${err}\n`);
+      }
     }
   }
-}
 
-// No destructive truncation on re-run (COR-44bea9c0 cluster): run-results.json is written
-// only when there is something to merge. A blocked no-op (nothing passed while
-// something failed) — e.g. a stray re-invocation after a successful merge —
-// must never truncate a previously written run-results.json to [].
-if (passing.length > 0) {
-  writeFileSync(auditResultsPath, JSON.stringify(passing, null, 2));
-}
+  // FND-OBS-bf5c7331: emit a structured JSON summary line to stdout so callers
+  // get a machine-readable payload alongside the human-readable text line.
+  // Both are written to stdout; the JSON summary line always comes first so
+  // programmatic consumers can parse it without stripping the text line.
+  process.stdout.write(
+    JSON.stringify({
+      ts: new Date().toISOString(),
+      source: "audit-code:merge-results",
+      event: "merge_summary",
+      total,
+      accepted: passing.length,
+      rejected: failing.length,
+      audit_results_path: auditResultsPath,
+      ...(failing.length > 0 ? { failed_tasks_path: failedTasksPath } : {}),
+    }) + "\n",
+  );
+  console.log(`✓ ${passing.length}/${total} tasks valid → ${auditResultsPath}`);
+  if (failing.length > 0) {
+    console.log("  Re-run those tasks in the next cycle.");
+  }
 
-const total = passing.length + failing.length;
-// FND-OBS-bf5c7331: emit a structured JSON summary line to stdout so callers
-// get a machine-readable payload alongside the human-readable text line.
-// Both are written to stdout; the JSON summary line always comes first so
-// programmatic consumers can parse it without stripping the text line.
-process.stdout.write(
-  JSON.stringify({
-    ts: new Date().toISOString(),
-    source: "audit-code:merge-results",
-    event: "merge_summary",
-    total,
-    accepted: passing.length,
-    rejected: failing.length,
-    audit_results_path: auditResultsPath,
-    ...(failing.length > 0 ? { failed_tasks_path: failedTasksPath } : {}),
-  }) + "\n",
-);
-console.log(`✓ ${passing.length}/${total} tasks valid → ${auditResultsPath}`);
-if (failing.length > 0) {
-  console.log("  Re-run those tasks in the next cycle.");
+  // Exit non-zero when any result failed validation so callers can detect
+  // partial merges and avoid treating them as clean success (INV-03 / COR-bf5c7331-2).
+  process.exit(failing.length > 0 ? 1 : 0);
 }
 
-// Exit non-zero when any result failed validation so callers can detect
-// partial merges and avoid treating them as clean success (INV-03 / COR-bf5c7331-2).
-process.exit(failing.length > 0 ? 1 : 0);
+// Only run the CLI when this file is the process entrypoint — not when a test
+// imports mergeResults() directly. Compares resolved file:// URLs (not raw
+// argv[1] strings) so this is correct on Windows, where argv[1] is a
+// backslash path that never equals import.meta.url's forward-slash form.
+const isMainModule = process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href;
+if (isMainModule) {
+  runCli();
+}

package/dispatch/validate-result.mjs

@@ -1,57 +1,115 @@
 import { join } from "node:path";
 import { readFileSync, existsSync } from "node:fs";
+import { pathToFileURL } from "node:url";
 import { validateResult } from "./validate.mjs";
 import { resolveArtifactsDir } from "./artifacts-dir.mjs";
 
-const runIdIdx = process.argv.indexOf("--run-id");
-const taskIdIdx = process.argv.indexOf("--task-id");
+/**
+ * Resolve the AuditTask context for `taskId` from the run's pending
+ * manifest. Degrades to `task: null` (never throws) when the manifest is
+ * absent or unreadable — validateResult's fail-closed null-task branch is the
+ * single enforcement point downstream; this helper only ever supplies
+ * context, it never itself decides pass/fail.
+ *
+ * @param {{ artifactsDir: string, runId: string, taskId: string }} options
+ * @returns {{ task: object | null, warning?: string }}
+ */
+export function resolveTaskContext({ artifactsDir, runId, taskId }) {
+  const tasksPath = join(artifactsDir, "runs", runId, "pending-audit-tasks.json");
+  if (!existsSync(tasksPath)) {
+    return { task: null };
+  }
+  try {
+    const tasks = JSON.parse(readFileSync(tasksPath, "utf8"));
+    return { task: tasks.find(t => t.task_id === taskId) ?? null };
+  } catch (e) {
+    return {
+      task: null,
+      warning: `[warn] Could not read pending-audit-tasks.json; line-count validation will be skipped: ${e.message}`,
+    };
+  }
+}
 
-const runId = runIdIdx !== -1 ? process.argv[runIdIdx + 1] : undefined;
-const taskId = taskIdIdx !== -1 ? process.argv[taskIdIdx + 1] : undefined;
+/**
+ * Importable core (CP-NODE-21 / dispatch-scripts-test-reach): reads one
+ * task-results file, resolves its task context via {@link resolveTaskContext},
+ * and validates it. No process.exit — the CLI shim below translates the
+ * outcome into console output and an exit code, byte-compatible with this
+ * script's behavior before the split.
+ *
+ * @param {{ artifactsDir: string, runId: string, taskId: string }} options
+ * @returns {{
+ *   ok: boolean,
+ *   fatal?: { message: string },
+ *   warning?: string,
+ *   resultPath: string,
+ *   valid?: boolean,
+ *   errors?: string[],
+ * }}
+ */
+export function validateOneResult({ artifactsDir, runId, taskId }) {
+  const sanitized = taskId.replace(/[^a-zA-Z0-9_-]/g, "_");
+  const resultPath = join(artifactsDir, "runs", runId, "task-results", sanitized + ".json");
+
+  if (!existsSync(resultPath)) {
+    return { ok: false, fatal: { message: `File not found: ${resultPath}` }, resultPath };
+  }
+
+  let resultObj;
+  try {
+    resultObj = JSON.parse(readFileSync(resultPath, "utf8"));
+  } catch (e) {
+    return { ok: false, fatal: { message: `Invalid JSON in ${resultPath}: ${e.message}` }, resultPath };
+  }
 
-if (!runId || !taskId) {
-  console.error("Usage: node dispatch/validate-result.mjs --run-id <run_id> --task-id <task_id> [--artifacts-dir <dir>]");
-  process.exit(1);
+  const { task, warning } = resolveTaskContext({ artifactsDir, runId, taskId });
+  const { valid, errors } = validateResult(resultObj, task);
+  return { ok: true, warning, resultPath, valid, errors };
 }
 
-// Default must match where the orchestrator/wrapper actually writes runs:
-// <root>/.audit-tools/audit (COR-bf5c7331), not the legacy `.audit-artifacts`.
-const artifactsDir = resolveArtifactsDir(process.argv);
+function runCli() {
+  const runIdIdx = process.argv.indexOf("--run-id");
+  const taskIdIdx = process.argv.indexOf("--task-id");
 
-const sanitized = taskId.replace(/[^a-zA-Z0-9_-]/g, "_");
-const resultPath = join(artifactsDir, "runs", runId, "task-results", sanitized + ".json");
+  const runId = runIdIdx !== -1 ? process.argv[runIdIdx + 1] : undefined;
+  const taskId = taskIdIdx !== -1 ? process.argv[taskIdIdx + 1] : undefined;
 
-if (!existsSync(resultPath)) {
-  console.error(`File not found: ${resultPath}`);
-  process.exit(1);
-}
+  if (!runId || !taskId) {
+    console.error("Usage: node dispatch/validate-result.mjs --run-id <run_id> --task-id <task_id> [--artifacts-dir <dir>]");
+    process.exit(1);
+  }
 
-let resultObj;
-try {
-  resultObj = JSON.parse(readFileSync(resultPath, "utf8"));
-} catch (e) {
-  console.error(`Invalid JSON in ${resultPath}: ${e.message}`);
-  process.exit(1);
-}
+  // Default must match where the orchestrator/wrapper actually writes runs:
+  // <root>/.audit-tools/audit (COR-bf5c7331), not the legacy `.audit-artifacts`.
+  const artifactsDir = resolveArtifactsDir(process.argv);
 
-const tasksPath = join(artifactsDir, "runs", runId, "pending-audit-tasks.json");
-let task = null;
-if (existsSync(tasksPath)) {
-  try {
-    const tasks = JSON.parse(readFileSync(tasksPath, "utf8"));
-    task = tasks.find(t => t.task_id === taskId) ?? null;
-  } catch (e) {
-    process.stderr.write(`[warn] Could not read pending-audit-tasks.json; line-count validation will be skipped: ${e.message}\n`);
+  const result = validateOneResult({ artifactsDir, runId, taskId });
+
+  if (!result.ok) {
+    console.error(result.fatal.message);
+    process.exit(1);
+  }
+
+  if (result.warning) {
+    process.stderr.write(result.warning + "\n");
   }
-}
 
-const { valid, errors } = validateResult(resultObj, task);
+  if (result.valid) {
+    console.log("✓ valid:", taskId);
+    process.exit(0);
+  } else {
+    console.error("✗ invalid:", taskId);
+    console.error(JSON.stringify(result.errors, null, 2));
+    process.exit(1);
+  }
+}
 
-if (valid) {
-  console.log("✓ valid:", taskId);
-  process.exit(0);
-} else {
-  console.error("✗ invalid:", taskId);
-  console.error(JSON.stringify(errors, null, 2));
-  process.exit(1);
+// Only run the CLI when this file is the process entrypoint — not when a test
+// imports validateOneResult()/resolveTaskContext() directly. Compares
+// resolved file:// URLs (not raw argv[1] strings) so this is correct on
+// Windows, where argv[1] is a backslash path that never equals
+// import.meta.url's forward-slash form.
+const isMainModule = process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href;
+if (isMainModule) {
+  runCli();
 }

package/dist/audit/cli/conceptualDispatch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"conceptualDispatch.d.ts","sourceRoot":"","sources":["../../../src/audit/cli/conceptualDispatch.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,gBAAgB,EAEtB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAUzD,OAAO,EAML,KAAK,uBAAuB,EAC7B,MAAM,sBAAsB,CAAC;AAE9B,MAAM,WAAW,wBAAwB;IACvC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gBAAgB,EAAE,SAAS,GAAG,MAAM,CAAC;IACrC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;;;OAMG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;;;;;;;OASG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAC/B,UAAU,EAAE,WAAW,CAAC,gBAAgB,CAAC,eAAe,CAAC,CAAC,EAC1D,WAAW,EAAE,MAAM,GAAG,SAAS,EAC/B,aAAa,EAAE,gBAAgB,CAAC,gBAAgB,CAAC,EACjD,aAAa,EAAE,SAAS,GAAG,MAAM,GAChC,MAAM,CAUR;AAED;;;GAGG;AACH,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,cAAc,GACrB,wBAAwB,CA+B1B;AAED,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,OAAO,CAAC;IACd;;;OAGG;IACH,qBAAqB,EAAE,MAAM,CAAC;IAC9B,mEAAmE;IACnE,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,mDAAmD;IACnD,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC,8CAA8C;IAC9C,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,+CAA+C;IAC/C,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,mEAAmE;IACnE,SAAS,EAAE,uBAAuB,CAAC;CACpC;AAED;;;;;;;;GAQG;AACH,wBAAsB,yBAAyB,CAAC,IAAI,EAAE;IACpD,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,cAAc,CAAC;IACvB,QAAQ,EAAE,wBAAwB,CAAC;IACnC;;;;;;;OAOG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAoK9B"}
+{"version":3,"file":"conceptualDispatch.d.ts","sourceRoot":"","sources":["../../../src/audit/cli/conceptualDispatch.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,gBAAgB,EAEtB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAUzD,OAAO,EAML,KAAK,uBAAuB,EAC7B,MAAM,sBAAsB,CAAC;AAE9B,MAAM,WAAW,wBAAwB;IACvC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,gBAAgB,EAAE,SAAS,GAAG,MAAM,CAAC;IACrC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;;;;OAMG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;;;;;;;OASG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAC/B,UAAU,EAAE,WAAW,CAAC,gBAAgB,CAAC,eAAe,CAAC,CAAC,EAC1D,WAAW,EAAE,MAAM,GAAG,SAAS,EAC/B,aAAa,EAAE,gBAAgB,CAAC,gBAAgB,CAAC,EACjD,aAAa,EAAE,SAAS,GAAG,MAAM,GAChC,MAAM,CAUR;AAED;;;GAGG;AACH,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,cAAc,GACrB,wBAAwB,CA+B1B;AAED,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,OAAO,CAAC;IACd;;;OAGG;IACH,qBAAqB,EAAE,MAAM,CAAC;IAC9B,mEAAmE;IACnE,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,mDAAmD;IACnD,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACtC,8CAA8C;IAC9C,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,+CAA+C;IAC/C,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,mEAAmE;IACnE,SAAS,EAAE,uBAAuB,CAAC;CACpC;AAED;;;;;;;;GAQG;AACH,wBAAsB,yBAAyB,CAAC,IAAI,EAAE;IACpD,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,cAAc,CAAC;IACvB,QAAQ,EAAE,wBAAwB,CAAC;IACnC;;;;;;;OAOG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAqM9B"}

package/dist/audit/cli/conceptualDispatch.js

@@ -158,7 +158,22 @@ export async function prepareConceptualDispatch(opts) {
         ...f,
         promptPath: promptPathFor(f.lane),
     }));
-    const perspectiveLines = perspectivePrompts.map((f, i) => `   - Perspective ${i + 1} (${f.name}): prompt \`${f.promptPath}\` → findings \`${f.resultsPath}\``);
+    // Resume (COR-4c8bd93a) narrows the INSTRUCTION surface only. writePaths/
+    // readPaths/artifactPaths below stay the full, stable perspective set —
+    // round identity (conceptual-perspective-round-identity.test.ts) pins a
+    // re-emission of the SAME round to re-declare identical bound paths
+    // regardless of partial delivery, so they are a stable per-round access
+    // declaration, not a must-write list. What resume changes is which lanes
+    // the narrative tells the host to actually run: a delivered lane is never
+    // re-instructed and its landed submission is never clobbered, because the
+    // host is simply never told to write there again.
+    const pendingLaneIds = new Set(fanout.pendingLanes.map((lane) => lane.id));
+    const pendingPerspectives = perspectivePrompts
+        .map((f, i) => ({ ordinal: i + 1, f }))
+        .filter(({ f }) => pendingLaneIds.has(f.lane));
+    const pendingCount = pendingPerspectives.length;
+    const deliveredCount = perspectivePrompts.length - pendingCount;
+    const perspectiveLines = pendingPerspectives.map(({ ordinal, f }) => `   - Perspective ${ordinal} (${f.name}): prompt \`${f.promptPath}\` → findings \`${f.resultsPath}\``);
     const artifactPaths = {
         conceptual_results: conceptualResultsPath,
         conceptual_judge_prompt: judgePromptPath,
@@ -173,8 +188,25 @@ export async function prepareConceptualDispatch(opts) {
         instructionLines: [
             ...(settings.reuse_notice ? [settings.reuse_notice] : []),
             `**Conceptual review** (generative, deep — ${total}-perspective fan-out):`,
-            `1. Execute these ${total} independent perspective lanes — one subagent per lane **in parallel** if a subagent facility exists, else sequentially yourself. Each lane reviews only through its own value system and must NOT see the others' output:`,
-            ...perspectiveLines,
+            // A resumed round with some (but not all) perspectives already delivered
+            // renders this notice so the host sees, in prose, exactly which lanes are
+            // being skipped and why — the mechanical guarantee is the narrowed
+            // perspectiveLines/step-1 list below; this line is purely informational,
+            // the same "state what changed, never rely on the host noticing" pattern
+            // `reuse_notice` above uses for checkpoint reuse.
+            ...(deliveredCount > 0
+                ? [
+                    `_${deliveredCount} of ${total} perspective lane(s) already delivered a submission this round — reusing that output, not re-executing them._`,
+                ]
+                : []),
+            ...(pendingCount > 0
+                ? [
+                    `1. Execute ${pendingCount === total ? `these ${total}` : `these ${pendingCount} still-pending`} independent perspective lane(s) — one subagent per lane **in parallel** if a subagent facility exists, else sequentially yourself. Each lane reviews only through its own value system and must NOT see the others' output:`,
+                    ...perspectiveLines,
+                ]
+                : [
+                    `1. All ${total} perspective lanes have already delivered a submission this round — nothing to execute here.`,
+                ]),
             `2. When all ${total} perspectives have written their findings, execute ONE **independent judge** lane — a fresh subagent that is not any of the perspectives when a facility exists; with no facility, execute it yourself as the explicitly-degraded fallback, setting the perspectives' reasoning aside and merging only their written findings: read the prompt at \`${judgePromptPath}\`, write the merged findings to \`${conceptualResultsPath}\`.`,
             "Each prompt file above is self-contained — it already defines the reviewer's persona, scope, file grants, and output schema. Pass the `prompt_path` to the executor as its instruction verbatim; do NOT restate the persona or re-describe the task in your dispatch message (the parenthesised name is only a label for you).",
         ],