coding-agent-harness 1.0.7 → 1.1.0

package/dist/lib/capability-registry.mjs

@@ -1,11 +1,14 @@
-// @ts-nocheck
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import crypto from "node:crypto";
 import { spawnSync } from "node:child_process";
-import { repoRoot, visualMapFile, normalizeTarget, toPosix, exists, existsInDocs, readFileSafe, readJsonSafe, readBundledTemplate, walkFiles, normalizeLocale, localizedTemplateSource, userPresetRootForHome, } from "./core-shared.mjs";
+import { repoRoot, visualMapFile, normalizeTarget, toPosix, exists, existsInDocs, readFileSafe, readJsonSafe, readBundledTemplate, renderHarnessTemplate, walkFiles, normalizeLocale, localizedTemplateSource, userPresetRootForHome, } from "./core-shared.mjs";
 import { listBundledPresetIds, seedBundledPresets } from "./preset-registry.mjs";
-import { legacyCloseoutFile, legacyCompatMode, legacyLedgerFile, legacyModuleRoot, legacyPath, legacyPlanningRoot, legacyTaskRoot, legacyWalkthroughRoot, safeAdoptionCapability, v2HarnessRoot, } from "./harness-paths.mjs";
+import { legacyCloseoutFile, legacyCompatMode, legacyLedgerFile, legacyModuleRoot, legacyPath, legacyPlanningRoot, legacyTaskRoot, legacyWalkthroughRoot, safeAdoptionCapability, assertRenderableHarnessManifest, renderHarnessManifest, v2HarnessRoot, } from "./harness-paths.mjs";
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error || "unknown error");
+}
 export const capabilityDefinitions = {
     core: {
         description: "Planning loop and task execution records.",
@@ -15,7 +18,7 @@ export const capabilityDefinitions = {
         artifacts: [legacyPath(legacyPlanningRoot)],
     },
     "module-parallel": {
-        description: "Module registry, module plans, session prompts, and worker handoff.",
+        description: "YAML-backed module registry, module briefs/plans, and global worker handoff prompt pack.",
         selectWhen: "Use only when the project has two or more independent modules that need parallel ownership.",
         default: false,
         dependencies: ["core"],
@@ -72,7 +75,7 @@ export function readCapabilityRegistry(target) {
     if (target.harness?.version === 2 && target.harness.manifest) {
         return {
             mode: "v2-manifest",
-            path: target.harness.manifestPath,
+            path: target.harness.manifestPath || target.manifestPath || "",
             capabilities: (target.harness.manifest.capabilities || ["core"]).map((name) => ({
                 name: normalizeCapabilityName(name),
                 state: "configured",
@@ -96,18 +99,19 @@ export function readCapabilityRegistry(target) {
     let readError = null;
     const raw = readJsonSafe(registryPath, null, { onError: (error) => { readError = error; } });
     if (raw) {
-        const locale = normalizeLocale(raw.locale);
+        const locale = normalizeLocale(String(raw.locale || ""));
         const capabilities = Array.isArray(raw.capabilities)
             ? raw.capabilities.map((entry) => typeof entry === "string"
                 ? { name: normalizeCapabilityName(entry), state: "scaffolded" }
-                : { name: normalizeCapabilityName(entry.name), state: entry.state || "scaffolded" })
+                : { name: normalizeCapabilityName(entry.name), state: String(entry.state || "scaffolded") })
             : [];
         return { mode: "declared-capability", path: registryPath, capabilities, raw, locale, errors: [] };
     }
-    return { mode: "declared-capability", path: registryPath, capabilities: [], raw: null, errors: [readError?.message || "invalid .harness-capabilities.json"] };
+    return { mode: "declared-capability", path: registryPath, capabilities: [], locale: "en-US", raw: null, errors: [errorMessage(readError) || "invalid .harness-capabilities.json"] };
 }
 export function normalizeCapabilityName(name) {
-    return capabilityAliases[name] || name;
+    const normalized = String(name || "");
+    return capabilityAliases[normalized] || normalized;
 }
 export function validateSourcePackageBoundary(targetInput = ".") {
     const root = path.resolve(targetInput || ".");
@@ -165,17 +169,17 @@ function validateDashboardAssetAssembly(root, manifestName, assetName, driftMess
         return trackedAsset === assembled ? [] : [driftMessage];
     }
     catch (error) {
-        return [`could not validate dashboard asset assembly (${assetName}): ${error.message}`];
+        return [`could not validate dashboard asset assembly (${assetName}): ${errorMessage(error)}`];
     }
 }
 export function detectCapabilities(target) {
     const detected = new Set(["core"]);
     if (target.harness?.version === 2) {
-        if (fs.existsSync(path.join(target.harness.modulesRoot, "Module-Registry.md")))
+        if (fs.existsSync(path.join(target.harness.modulesRoot || "", "Module-Registry.md")))
             detected.add("module-parallel");
-        if (fs.existsSync(path.join(target.harness.governanceRoot, "standards/adversarial-review-standard.md")))
+        if (fs.existsSync(path.join(target.harness.governanceRoot || "", "standards/adversarial-review-standard.md")))
             detected.add("adversarial-review");
-        if (fs.existsSync(path.join(target.harness.tasksRoot, "_task-template/long-running-task-contract.md")))
+        if (fs.existsSync(path.join(target.harness.tasksRoot || "", "_task-template/long-running-task-contract.md")))
             detected.add("long-running-task");
         return [...detected];
     }
@@ -224,7 +228,7 @@ export function buildInstallReport({ target, locale, capabilities, changes, dryR
 function packageVersion() {
     try {
         const pkg = readJsonSafe(path.join(repoRoot, "package.json"), {});
-        return pkg.version || "";
+        return String(pkg.version || "");
     }
     catch {
         return "";
@@ -319,7 +323,7 @@ export function installUserSkill({ agent = "codex", home = "", dryRun = false, f
 function readInstalledVersion(targetRoot) {
     try {
         const pkg = readJsonSafe(path.join(targetRoot, "package.json"), {});
-        return pkg.version || "";
+        return String(pkg.version || "");
     }
     catch {
         return "";
@@ -422,13 +426,13 @@ function capabilityArtifactsForTarget(target, capabilityName) {
     const paths = target.harness;
     switch (capabilityName) {
         case "core":
-            return [relative(paths.planningRoot)];
+            return [relative(paths.planningRoot || "")];
         case "module-parallel":
-            return [relative(path.join(paths.modulesRoot, "Module-Registry.md")), relative(paths.modulesRoot)];
+            return [relative(path.join(paths.modulesRoot || "", "Module-Registry.md")), relative(paths.modulesRoot || "")];
         case "subagent-worker":
-            return [relative(paths.modulesRoot)];
+            return [relative(paths.modulesRoot || "")];
         case "adversarial-review":
-            return [relative(paths.tasksRoot)];
+            return [relative(paths.tasksRoot || "")];
         case "long-running-task":
             return [];
         default:
@@ -436,11 +440,11 @@ function capabilityArtifactsForTarget(target, capabilityName) {
     }
 }
 export function plannedInitFiles(capabilities = ["core"], { locale = "en-US", paths = null } = {}) {
-    const root = paths ? toPosix(path.relative(paths.projectRoot, paths.harnessRoot)) : v2HarnessRoot;
-    const modulesRoot = paths ? toPosix(path.relative(paths.projectRoot, paths.modulesRoot)) : `${root}/planning/modules`;
-    const regressionRoot = paths ? toPosix(path.relative(paths.projectRoot, paths.regressionRoot)) : `${root}/governance/regression`;
+    const root = paths ? toPosix(path.relative(paths.projectRoot || "", paths.harnessRoot || "")) : v2HarnessRoot;
+    const modulesRoot = paths ? toPosix(path.relative(paths.projectRoot || "", paths.modulesRoot || "")) : `${root}/planning/modules`;
+    const regressionRoot = paths ? toPosix(path.relative(paths.projectRoot || "", paths.regressionRoot || "")) : `${root}/governance/regression`;
     const contextRoot = `${root}/context`;
-    const governanceRoot = paths ? toPosix(path.relative(paths.projectRoot, paths.governanceRoot)) : `${root}/governance`;
+    const governanceRoot = paths ? toPosix(path.relative(paths.projectRoot || "", paths.governanceRoot || "")) : `${root}/governance`;
     const files = [
         ["AGENTS.md", "templates/AGENTS.md.template"],
         ["CLAUDE.md", "templates/CLAUDE.md.template"],
@@ -470,16 +474,16 @@ export function plannedInitFiles(capabilities = ["core"], { locale = "en-US", pa
         [`${governanceRoot}/standards/external-source-intake-standard.md`, "templates/reference/external-source-intake-standard.md"],
     ];
     if (capabilities.includes("module-parallel")) {
-        files.push([`${modulesRoot}/Module-Registry.md`, "templates/ssot/Module-Registry.md"]);
-        files.push([`${modulesRoot}/Session-Prompt-Pack.md`, "templates/planning/module_session_prompt.md"]);
+        files.push([`${modulesRoot}/Module-Registry.md`, "templates/modules/registry_view.md"]);
+        files.push([`${modulesRoot}/Session-Prompt-Pack.md`, "templates/modules/session_prompt_pack.md"]);
     }
     return files.map(([destination, source]) => [destination, localizedTemplateSource(source, locale)]);
 }
 function plannedInitDirectories(capabilities = ["core"], { paths = null } = {}) {
-    const planningRoot = paths ? toPosix(path.relative(paths.projectRoot, paths.planningRoot)) : `${v2HarnessRoot}/planning`;
-    const tasksRoot = paths ? toPosix(path.relative(paths.projectRoot, paths.tasksRoot)) : `${v2HarnessRoot}/planning/tasks`;
-    const modulesRoot = paths ? toPosix(path.relative(paths.projectRoot, paths.modulesRoot)) : `${v2HarnessRoot}/planning/modules`;
-    const generatedRoot = paths ? toPosix(path.relative(paths.projectRoot, paths.generatedRoot)) : `${v2HarnessRoot}/governance/generated`;
+    const planningRoot = paths ? toPosix(path.relative(paths.projectRoot || "", paths.planningRoot || "")) : `${v2HarnessRoot}/planning`;
+    const tasksRoot = paths ? toPosix(path.relative(paths.projectRoot || "", paths.tasksRoot || "")) : `${v2HarnessRoot}/planning/tasks`;
+    const modulesRoot = paths ? toPosix(path.relative(paths.projectRoot || "", paths.modulesRoot || "")) : `${v2HarnessRoot}/planning/modules`;
+    const generatedRoot = paths ? toPosix(path.relative(paths.projectRoot || "", paths.generatedRoot || "")) : `${v2HarnessRoot}/governance/generated`;
     const directories = [
         planningRoot,
         tasksRoot,
@@ -505,6 +509,7 @@ export function writeInitFiles(targetInput, capabilities, { dryRun = true, local
     }
     const planned = plannedInitFiles(normalizedCapabilities, { locale: normalizedLocale });
     const changes = [];
+    const projectionEntries = [];
     const manifestDestination = `${v2HarnessRoot}/harness.yaml`;
     const manifestPath = path.join(target.projectRoot, manifestDestination);
     const manifestExists = fs.existsSync(manifestPath);
@@ -528,9 +533,13 @@ export function writeInitFiles(targetInput, capabilities, { dryRun = true, local
         changes.push({ destination, source, action: existsAlready ? "skip-existing" : dryRun ? "would-create" : "create" });
         if (!dryRun && !existsAlready) {
             fs.mkdirSync(path.dirname(destinationPath), { recursive: true });
-            fs.copyFileSync(sourcePath, destinationPath);
+            const rendered = renderInstallTemplate(source, target);
+            fs.writeFileSync(destinationPath, rendered);
+            projectionEntries.push(templateProjectionEntry({ destination, source, target, rendered }));
         }
     }
+    if (!dryRun)
+        writeTemplateProjectionManifest(target, projectionEntries);
     if (addNpmScripts) {
         changes.push(...writeNpmScripts(target, { dryRun }));
     }
@@ -538,26 +547,6 @@ export function writeInitFiles(targetInput, capabilities, { dryRun = true, local
     const report = buildInstallReport({ target, locale: normalizedLocale, capabilities: normalizedCapabilities, changes, dryRun, operation: "init" });
     return { target, capabilities: normalizedCapabilities, locale: normalizedLocale, changes, presetSeed, nextCommands: initNextCommands(), report };
 }
-function renderHarnessManifest({ locale, capabilities, structure = null }) {
-    const manifestStructure = structure || {
-        harnessRoot: v2HarnessRoot,
-        planningRoot: `${v2HarnessRoot}/planning`,
-        tasksRoot: `${v2HarnessRoot}/planning/tasks`,
-        modulesRoot: `${v2HarnessRoot}/planning/modules`,
-        externalRoot: `${v2HarnessRoot}/planning/external`,
-        governanceRoot: `${v2HarnessRoot}/governance`,
-        generatedRoot: `${v2HarnessRoot}/governance/generated`,
-    };
-    return [
-        "version: 2",
-        `locale: ${locale}`,
-        "capabilities:",
-        ...capabilities.map((capability) => `  - ${capability}`),
-        "structure:",
-        ...Object.entries(manifestStructure).map(([key, value]) => `  ${key}: ${value}`),
-        "",
-    ].join("\n");
-}
 function initNextCommands() {
     return [
         "npx --yes coding-agent-harness dev .",
@@ -591,6 +580,102 @@ function writeNpmScripts(target, { dryRun = true } = {}) {
     }
     return [{ destination: "package.json", source: "npm-scripts", action: dryRun ? "would-update-scripts" : "update-scripts" }, ...scriptChanges];
 }
+function renderInstallTemplate(source, target) {
+    return renderHarnessTemplate(readBundledTemplate(source), { paths: targetPathContext(target) });
+}
+function targetPathContext(target) {
+    const paths = target.harness || {};
+    const projectRoot = String(paths.projectRoot || target.projectRoot);
+    const fields = [
+        "harnessRoot",
+        "planningRoot",
+        "tasksRoot",
+        "modulesRoot",
+        "externalRoot",
+        "governanceRoot",
+        "generatedRoot",
+        "regressionRoot",
+        "ledgerPath",
+        "closeoutIndexPath",
+    ];
+    return Object.fromEntries(fields.map((field) => {
+        const value = String(paths[field] || "");
+        const rendered = value && path.isAbsolute(value) ? toPosix(path.relative(projectRoot, value)) : toPosix(String(value || ""));
+        return [field, rendered];
+    }));
+}
+function templateProjectionManifestPath(target) {
+    const effectiveTarget = target.harness?.version === 2 || !fs.existsSync(path.join(target.projectRoot, v2HarnessRoot, "harness.yaml"))
+        ? target
+        : normalizeTarget(target.projectRoot);
+    const generatedRoot = effectiveTarget.harness?.generatedRoot || path.join(effectiveTarget.projectRoot, v2HarnessRoot, "governance/generated");
+    return path.join(generatedRoot, "Template-Projections.json");
+}
+function readTemplateProjectionManifest(target) {
+    const currentPath = templateProjectionManifestPath(target);
+    if (fs.existsSync(currentPath))
+        return readJsonSafe(currentPath, { schemaVersion: "template-projections/v1", entries: [] });
+    const fallback = walkFiles(target.projectRoot)
+        .find((filePath) => path.basename(filePath) === "Template-Projections.json");
+    return fallback ? readJsonSafe(fallback, { schemaVersion: "template-projections/v1", entries: [] }) : { schemaVersion: "template-projections/v1", entries: [] };
+}
+function writeTemplateProjectionManifest(target, entries) {
+    if (!entries.length)
+        return;
+    const manifestPath = templateProjectionManifestPath(target);
+    const current = readTemplateProjectionManifest(target);
+    const byDestination = new Map((current.entries || []).map((entry) => [entry.destination, entry]));
+    for (const entry of entries)
+        byDestination.set(entry.destination, entry);
+    const next = {
+        schemaVersion: "template-projections/v1",
+        generatedAt: new Date().toISOString(),
+        entries: [...byDestination.values()].sort((a, b) => a.destination.localeCompare(b.destination)),
+    };
+    fs.mkdirSync(path.dirname(manifestPath), { recursive: true });
+    fs.writeFileSync(manifestPath, `${JSON.stringify(next, null, 2)}\n`);
+}
+function templateProjectionEntry({ destination, source, target, rendered }) {
+    return {
+        destination,
+        source,
+        ownership: "package-template-pristine",
+        renderedSha256: sha256(rendered),
+        sourceSha256: sha256(readBundledTemplate(source)),
+        paths: targetPathContext(target),
+        updatedAt: new Date().toISOString(),
+    };
+}
+function pathFindings(content, target) {
+    const findings = [];
+    const text = String(content || "");
+    if (text.includes("{{paths."))
+        findings.push("unresolved-path-token");
+    const defaultRootPattern = /\bcoding-agent-harness\/(?:planning|governance|context)\//g;
+    if (target.harness?.version === 2 && targetPathContext(target).harnessRoot !== v2HarnessRoot && defaultRootPattern.test(text)) {
+        findings.push("default-root-literal");
+    }
+    if (/docs\/09-PLANNING|docs\/10-WALKTHROUGH|docs\/Harness-Ledger\.md/.test(text))
+        findings.push("legacy-path-literal");
+    return [...new Set(findings)];
+}
+function scanProjectAuthoredPathFindings(target, plannedDestinations) {
+    const root = target.harness?.harnessRoot || target.docsRoot;
+    if (!root || !fs.existsSync(root))
+        return [];
+    return walkFiles(root)
+        .map((filePath) => toPosix(path.relative(target.projectRoot, filePath)))
+        .filter((relative) => !plannedDestinations.has(relative))
+        .filter((relative) => !relative.includes("/governance/archive/") && !relative.includes("/planning/tasks/") && !relative.includes("/governance/generated/"))
+        .map((relative) => {
+        const findings = pathFindings(readFileSafe(path.join(target.projectRoot, relative)), target);
+        return findings.length ? { destination: relative, ownership: "project-authored", action: "report-only", pathFindings: findings } : null;
+    })
+        .filter((change) => Boolean(change));
+}
+function sha256(content) {
+    return crypto.createHash("sha256").update(String(content)).digest("hex");
+}
 export function addCapability(targetInput, capabilityName, { dryRun = true, locale = "" } = {}) {
     const target = normalizeTarget(targetInput);
     const normalizedCapability = normalizeCapabilityName(capabilityName);
@@ -608,6 +693,7 @@ export function addCapability(targetInput, capabilityName, { dryRun = true, loca
     const nextCapabilities = [...capabilityMap.keys()];
     const scaffold = plannedInitFiles([...capabilityMap.keys()], { locale: normalizedLocale, paths: target.harness?.version === 2 ? target.harness : null });
     const changes = [];
+    const projectionEntries = [];
     for (const directory of plannedInitDirectories(nextCapabilities, { paths: target.harness?.version === 2 ? target.harness : null })) {
         const destinationPath = path.join(target.projectRoot, directory);
         const existsAlready = fs.existsSync(destinationPath);
@@ -622,15 +708,19 @@ export function addCapability(targetInput, capabilityName, { dryRun = true, loca
         changes.push({ destination, source, action: existsAlready ? "skip-existing" : dryRun ? "would-create" : "create" });
         if (!dryRun && !existsAlready) {
             fs.mkdirSync(path.dirname(destinationPath), { recursive: true });
-            fs.copyFileSync(sourcePath, destinationPath);
+            const rendered = renderInstallTemplate(source, target);
+            fs.writeFileSync(destinationPath, rendered);
+            projectionEntries.push(templateProjectionEntry({ destination, source, target, rendered }));
         }
     }
     if (!dryRun) {
-        const manifestPath = target.harness.version === 2
+        const manifestPath = target.harness?.version === 2 && target.manifestPath
             ? target.manifestPath
             : path.join(target.projectRoot, v2HarnessRoot, "harness.yaml");
+        assertRenderableHarnessManifest(target.harness?.manifest);
         fs.mkdirSync(path.dirname(manifestPath), { recursive: true });
-        fs.writeFileSync(manifestPath, renderHarnessManifest({ locale: normalizedLocale, capabilities: nextCapabilities, structure: target.harness.manifest?.structure }));
+        fs.writeFileSync(manifestPath, renderHarnessManifest({ locale: normalizedLocale, capabilities: nextCapabilities, structure: target.harness?.manifest?.structure, modules: target.harness?.manifest?.modules || null }));
+        writeTemplateProjectionManifest(target, projectionEntries);
     }
     const report = buildInstallReport({ target, locale: normalizedLocale, capabilities: [...capabilityMap.keys()], changes, dryRun, operation: "add-capability" });
     return {
@@ -641,3 +731,89 @@ export function addCapability(targetInput, capabilityName, { dryRun = true, loca
         report,
     };
 }
+export function auditTemplateProjections(targetInput = ".") {
+    const target = normalizeTarget(targetInput);
+    const registry = readCapabilityRegistry(target);
+    const capabilities = registry.capabilities.map((capability) => capability.name);
+    const planned = plannedInitFiles(capabilities, { locale: registry.locale, paths: target.harness?.version === 2 ? target.harness : null });
+    const manifest = readTemplateProjectionManifest(target);
+    const entriesByDestination = new Map((manifest.entries || []).map((entry) => [entry.destination, entry]));
+    const plannedDestinations = new Set(planned.map(([destination]) => destination));
+    const projections = planned.map(([destination, source]) => {
+        const destinationPath = path.join(target.projectRoot, destination);
+        const rendered = renderInstallTemplate(source, target);
+        const renderedSha256 = sha256(rendered);
+        const existsAlready = fs.existsSync(destinationPath);
+        const current = existsAlready ? fs.readFileSync(destinationPath, "utf8") : "";
+        const currentSha256 = existsAlready ? sha256(current) : "";
+        const recorded = entriesByDestination.get(destination);
+        const ownership = !existsAlready
+            ? "missing"
+            : currentSha256 === renderedSha256
+                ? "package-template-pristine"
+                : recorded && currentSha256 === recorded.renderedSha256
+                    ? "package-template-pristine"
+                    : recorded
+                        ? "package-template-modified"
+                        : "project-authored";
+        const action = !existsAlready
+            ? "would-create"
+            : currentSha256 === renderedSha256
+                ? "no-op"
+                : ownership === "package-template-pristine"
+                    ? "would-refresh"
+                    : "report-only";
+        return {
+            destination,
+            source,
+            exists: existsAlready,
+            ownership,
+            action,
+            currentSha256: currentSha256 || null,
+            expectedSha256: renderedSha256,
+            recordedSha256: recorded?.renderedSha256 || null,
+            pathFindings: pathFindings(current, target),
+        };
+    });
+    const authoredFindings = scanProjectAuthoredPathFindings(target, plannedDestinations);
+    return {
+        operation: "template-projection-audit",
+        target: target.projectRoot,
+        manifestPath: templateProjectionManifestPath(target),
+        projections,
+        projectAuthoredFindings: authoredFindings,
+        summary: {
+            total: projections.length,
+            missing: projections.filter((item) => item.ownership === "missing").length,
+            refreshable: projections.filter((item) => item.action === "would-refresh").length,
+            reportOnly: projections.filter((item) => item.action === "report-only").length + authoredFindings.length,
+        },
+    };
+}
+export function refreshTemplateProjections(targetInput = ".", { apply = false } = {}) {
+    const target = normalizeTarget(targetInput);
+    const audit = auditTemplateProjections(targetInput);
+    const changes = [];
+    const entries = [];
+    for (const item of audit.projections) {
+        if (!["would-create", "would-refresh"].includes(item.action))
+            continue;
+        const rendered = renderInstallTemplate(item.source, target);
+        changes.push({ destination: item.destination, source: item.source, action: apply ? item.action.replace("would-", "") : item.action });
+        entries.push(templateProjectionEntry({ destination: item.destination, source: item.source, target, rendered }));
+        if (!apply)
+            continue;
+        const destinationPath = path.join(target.projectRoot, item.destination);
+        fs.mkdirSync(path.dirname(destinationPath), { recursive: true });
+        fs.writeFileSync(destinationPath, rendered);
+    }
+    if (apply)
+        writeTemplateProjectionManifest(target, entries);
+    return {
+        operation: "template-projection-refresh",
+        dryRun: !apply,
+        target: target.projectRoot,
+        changes,
+        audit,
+    };
+}

package/dist/lib/check-module-parallel.mjs

@@ -1,4 +1,3 @@
-// @ts-nocheck
 // Module-parallel private harness checks stay behavior-first until legacy module context types are modeled.
 import fs from "node:fs";
 import path from "node:path";
@@ -197,12 +196,8 @@ export function checkModuleParallelStructure(context) {
             fail(`${moduleRegistryPath} row ${key} branch must use codex/ prefix: ${branch}`);
         }
         const block = modulePromptBlock(promptPack, key);
-        if (!block) {
-            if (!exists(legacyPath(legacyModuleRoot, key, "session_prompt.md"))) {
-                fail(`missing module session prompt for ${key}`);
-            }
+        if (!block)
             continue;
-        }
         for (const term of [
             "Current Step",
             branchName,

package/dist/lib/check-profiles.mjs

@@ -1,4 +1,3 @@
-// @ts-nocheck
 import fs from "node:fs";
 import path from "node:path";
 import { spawnSync } from "node:child_process";
@@ -6,9 +5,9 @@ import { repoRoot, bundledCheckScript, visualMapFile, legacyVisualRoadmapFile, a
 import { tableAfterHeading, getColumn, getColumnAny, splitList, firstColumn, contentHasAny, } from "./markdown-utils.mjs";
 import { validateCapabilities } from "./capability-registry.mjs";
 import { readPresetPackage } from "./preset-registry.mjs";
-import { validateTaskPresetAuditSnapshot } from "./preset-audit-contracts.mjs";
-import { validatePresetResourcesForTask } from "./preset-resource-contracts.mjs";
-import { collectTasks, listTaskPlanPaths, parseTaskBudget, readVisualMapContractFile, parsePhases } from "./task-scanner.mjs";
+import { validateRegularTaskPresetContract } from "./task-preset-contract-drift.mjs";
+import { parseTaskBudget } from "./task-metadata.mjs";
+import { createScannerTaskRepository, parsePhases, readVisualMapContractFile, taskPlanPathFromRecord } from "./task-repository.mjs";
 import { normalizeReviewBoolean, reviewFindingColumns } from "./task-review-model.mjs";
 import { allowedPhaseActors, allowedPhaseKinds } from "./phase-kind.mjs";
 import { validateTaskCompletionConsistency } from "./task-completion-consistency.mjs";
@@ -19,6 +18,9 @@ import { summarizeGitState } from "./git-status-summary.mjs";
 import { buildStatusData } from "./status-builder.mjs";
 import { legacyCloseoutFile, legacyCompatMode, legacyLedgerFile, legacyPath, legacyPlanningRoot, legacyWalkthroughRoot, safeAdoptionCapability, } from "./harness-paths.mjs";
 export { renderDashboard } from "./status-dashboard-renderer.mjs";
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
 export function runCompatibilityCheck(target) {
     const checkTarget = target.docsOnly ? target.projectRoot : target.input;
     const result = spawnSync(process.execPath, [bundledCheckScript, checkTarget], {
@@ -125,10 +127,12 @@ export function validateReviewSchema(target, { strict = true } = {}) {
     }
     return { failures, warnings };
 }
-export function validateVisualMaps(target, { taskPlanPaths } = {}) {
+export function validateVisualMaps(target, { tasks } = {}) {
     const failures = [];
     const warnings = [];
-    for (const taskPlanPath of taskPlanPaths || listTaskPlanPaths(target)) {
+    const taskRecords = tasks || createScannerTaskRepository(target).list();
+    for (const task of taskRecords) {
+        const taskPlanPath = taskPlanPathFromRecord(target, task);
         const taskDir = path.dirname(taskPlanPath);
         const visualMapPath = path.join(taskDir, visualMapFile);
         const legacyPath = path.join(taskDir, legacyVisualRoadmapFile);
@@ -180,14 +184,14 @@ export function validateVisualMaps(target, { taskPlanPaths } = {}) {
     return { failures, warnings };
 }
 export function validateTaskPresetContracts(target, { tasks } = {}) {
-    const failures = [];
+    const failures = [], warnings = [];
     const allowedMigrationLevels = new Set([
         "migration-baseline",
         "migration-current-cutover",
         "migration-full-cutover",
         "migration-deferred",
     ]);
-    for (const task of tasks || collectTasks(target)) {
+    for (const task of tasks || createScannerTaskRepository(target).list()) {
         if (!task.taskPreset || task.taskPreset === "none")
             continue;
         let presetPackage = null;
@@ -195,26 +199,14 @@ export function validateTaskPresetContracts(target, { tasks } = {}) {
             presetPackage = readPresetPackage(task.taskPreset, { targetInput: target.projectRoot });
         }
         catch (error) {
-            failures.push(`${task.path} unsupported Task Preset: ${task.taskPreset} (${error.message})`);
+            failures.push(`${task.path} unsupported Task Preset: ${task.taskPreset} (${errorMessage(error)})`);
             continue;
         }
-        if (presetPackage?.task?.kind && task.taskKind !== presetPackage.task.kind) {
-            failures.push(`${task.path} ${task.taskPreset} preset Task Kind mismatch: expected ${presetPackage.task.kind}, got ${task.taskKind || "(missing)"}`);
-        }
-        if (String(task.presetVersion || "") !== String(presetPackage.version)) {
-            failures.push(`${task.path} ${task.taskPreset} preset missing Preset Version ${presetPackage.version}`);
-        }
-        if (task.taskPreset !== "lesson-sedimentation" && (presetPackage.evidence?.bundleDir || presetPackage.audit?.evidenceFiles?.length || Object.keys(presetPackage.evidence?.files || {}).length)) {
-            if (!task.evidenceBundle)
-                failures.push(`${task.path} ${task.taskPreset} preset missing Evidence Bundle`);
-            else if (!fs.existsSync(path.join(target.projectRoot, String(task.evidenceBundle).replace(/^TARGET:/, "").replace(/^\/+/, "")))) {
-                failures.push(`${task.path} ${task.taskPreset} preset Evidence Bundle missing: ${task.evidenceBundle}`);
-            }
-        }
         if (task.taskPreset !== "lesson-sedimentation") {
-            failures.push(...validateTaskPresetAuditSnapshot(target, task, presetPackage));
+            const regularPreset = validateRegularTaskPresetContract(target, task, presetPackage);
+            failures.push(...regularPreset.failures);
+            warnings.push(...regularPreset.warnings);
         }
-        failures.push(...validatePresetResourcesForTask(target, task, presetPackage));
         if (task.taskPreset === "lesson-sedimentation") {
             if (!["standard", "complex"].includes(task.budget))
                 failures.push(`${task.path} lesson-sedimentation preset requires Selected budget: standard or complex`);
@@ -222,9 +214,8 @@ export function validateTaskPresetContracts(target, { tasks } = {}) {
                 failures.push(`${task.path} lesson-sedimentation preset missing task plan`);
             continue;
         }
-        if (task.taskPreset !== "legacy-migration") {
+        if (task.taskPreset !== "legacy-migration")
             continue;
-        }
         if (task.budget !== "complex")
             failures.push(`${task.path} legacy-migration preset requires Selected budget: complex`);
         if (!allowedMigrationLevels.has(task.migrationTargetLevel)) {
@@ -241,34 +232,34 @@ export function validateTaskPresetContracts(target, { tasks } = {}) {
             failures.push(`${task.path} legacy-migration preset Evidence Bundle missing session.json`);
         }
         if (achievedLevel === "migration-full-cutover") {
-            const snapshot = task.migrationSnapshot || {};
+            const snapshot = task.migrationSnapshot;
             const blockers = [];
-            if (!snapshot.sessionPresent)
+            if (!snapshot?.sessionPresent)
                 blockers.push("missing session evidence");
-            if (snapshot.sessionResult !== "complete")
-                blockers.push(`session result is ${snapshot.sessionResult || "(missing)"}`);
-            if (snapshot.strictDeferred)
+            if (snapshot?.sessionResult !== "complete")
+                blockers.push(`session result is ${snapshot?.sessionResult || "(missing)"}`);
+            if (snapshot?.strictDeferred)
                 blockers.push("strictDeferred is present");
-            if (snapshot.strictStatus !== "pass")
-                blockers.push(`strict status is ${snapshot.strictStatus || "(missing)"}`);
+            if (snapshot?.strictStatus !== "pass")
+                blockers.push(`strict status is ${snapshot?.strictStatus || "(missing)"}`);
             for (const [field, value] of [
-                ["warnings", snapshot.warnings],
-                ["taskActions", snapshot.taskActions],
-                ["reviewSchemaGaps", snapshot.reviewSchemaGaps],
-                ["legacyReferenceGaps", snapshot.legacyReferenceGaps],
-                ["legacyResiduals", snapshot.legacyResiduals],
+                ["warnings", snapshot?.warnings],
+                ["taskActions", snapshot?.taskActions],
+                ["reviewSchemaGaps", snapshot?.reviewSchemaGaps],
+                ["legacyReferenceGaps", snapshot?.legacyReferenceGaps],
+                ["legacyResiduals", snapshot?.legacyResiduals],
             ]) {
                 if (Number(value || 0) !== 0)
                     blockers.push(`${field}=${value}`);
             }
-            if (snapshot.fullCutoverEligible !== true)
+            if (snapshot?.fullCutoverEligible !== true)
                 blockers.push("fullCutoverEligible is not true");
             if (blockers.length) {
                 failures.push(`${task.path} migration-full-cutover is not proven: ${blockers.join("; ")}`);
             }
         }
     }
-    return { failures, warnings: [] };
+    return { failures, warnings };
 }
 export function validateContextDocs(target, { strict = true } = {}) {
     const failures = [];
@@ -351,12 +342,11 @@ export function buildStatus(targetInput, options = {}) {
     const shouldRunLegacy = target.harness?.version !== 2 && !options.skipLegacyCheck && (capabilityState.registry.mode === legacyCompatMode || safeAdoptionMode);
     const legacy = shouldRunLegacy ? runCompatibilityCheck(target) : { status: "skipped", code: 0, stdout: "", stderr: "" };
     const contractStrict = Boolean(options.strict) || (capabilityState.registry.mode !== legacyCompatMode && !safeAdoptionMode);
-    const taskPlanPaths = listTaskPlanPaths(target);
     const closeoutContent = target.harness?.version === 2 ? "" : readFileSafe(path.join(target.projectRoot, legacyPath(legacyCloseoutFile)));
-    const tasks = collectTasks(target, { requireGeneratedScaffoldProvenance: contractStrict, taskPlanPaths, closeoutContent });
+    const tasks = createScannerTaskRepository(target, { requireGeneratedScaffoldProvenance: contractStrict, closeoutContent }).list();
     const reviews = validateReviewSchema(target, { strict: contractStrict });
-    const visualMaps = validateVisualMaps(target, { taskPlanPaths });
-    const planContracts = validatePlanContracts(target, { strict: contractStrict, taskPlanPaths });
+    const visualMaps = validateVisualMaps(target, { tasks });
+    const planContracts = validatePlanContracts(target, { strict: contractStrict, tasks });
     const presetContracts = validateTaskPresetContracts(target, { tasks });
     const contextDocs = validateContextDocs(target, { strict: contractStrict });
     const governanceBoundaries = validateGovernanceTableBoundaries(target);
@@ -379,10 +369,13 @@ export function buildStatus(targetInput, options = {}) {
     const briefMissing = tasks.length - briefReady;
     for (const task of tasks) {
         for (const issue of task.materialIssues || []) {
-            if (!String(issue.code || "").startsWith("missing-task-audit") && !String(issue.code || "").startsWith("legacy-"))
+            const forceFailure = Boolean(issue.enforceFailure);
+            if (!String(issue.code || "").startsWith("missing-task-audit") &&
+                !String(issue.code || "").startsWith("legacy-") &&
+                issue.code !== "unedited-template-material")
                 continue;
             const message = `${String(issue.sourcePath || task.path).replace(/^TARGET:/, "")} ${issue.message}`;
-            if (contractStrict || options.strictLegacy)
+            if (forceFailure || contractStrict || options.strictLegacy)
                 failures.push(message);
             else
                 warnings.push(`adoption-needed: ${message}`);