agent-project-sdlc 0.1.18 → 0.1.20

package/dist/lib/validators.js

@@ -6,8 +6,20 @@ import { listFiles, pathExists, readText } from "./fs.js";
 import { parseYaml } from "./yaml.js";
 const execFileAsync = promisify(execFile);
 const PARALLEL_MODES = new Set(["runtime_managed", "user_orchestrated"]);
+const PARALLEL_TRIGGERS = new Set(["user_requested", "workflow_default"]);
+const PARALLEL_RUNTIME_PROVIDERS = new Set(["codex_native_subagents", "user_orchestrated", "codex_exec_worktree"]);
 const TASK_PHASES = new Set(["REQUIREMENT_GATHERING", "ARCHITECTING", "SPRINTING", "REVIEWING", "TESTING", "RELEASING", "RFC_RECALIBRATION"]);
-const PARALLEL_ALLOWED_PHASES = new Set(["REQUIREMENT_GATHERING", "SPRINTING", "TESTING"]);
+const PARALLEL_ALLOWED_PHASES = new Set(["REQUIREMENT_GATHERING", "ARCHITECTING", "SPRINTING", "REVIEWING", "TESTING", "RELEASING", "RFC_RECALIBRATION"]);
+const PARALLEL_READ_ONLY_PHASES = new Set(["REQUIREMENT_GATHERING", "ARCHITECTING", "REVIEWING", "RELEASING", "RFC_RECALIBRATION"]);
+const PARALLEL_PROTECTED_WRITE_PATTERNS = [
+    ".codex/state/**",
+    "<harnessRoot>/state/**",
+    ".docs/INDEX.md",
+    ".docs/**/overview.md",
+    ".docs/04_implementation/**",
+    ".docs/06_review/**",
+    ".docs/08_release/**"
+];
 const TASK_STATUSES = new Set(["pending", "in_progress", "done", "blocked", "pending_revision", "cancelled"]);
 const OPEN_TASK_STATUSES = new Set(["pending", "in_progress", "blocked", "pending_revision"]);
 const EVIDENCE_LEVELS = new Set(["unit", "local_runtime", "external_provider_live", "deployed_runtime", "business_handoff_ready"]);
@@ -87,6 +99,10 @@ const RUNNABLE_ENTRY_EXIT_TERMS = [
     "not applicable"
 ];
 const DEVELOPMENT_EVIDENCE_TERMS = ["development evidence", "开发自测证据"];
+const DEVELOPMENT_SELF_TEST_CONTRACT_TERMS = ["development self-test contract", "开发自测合同"];
+const DEVELOPMENT_SELF_TEST_REPORT_TERMS = ["development self-test report", "开发自测报告"];
+const DEVELOPMENT_SELF_TEST_IMPACT_TERMS = ["development self-test impact", "开发自测影响"];
+const MODULE_KEY_TEST_PATH_TERMS = ["module key test path", "模块关键测试路径"];
 const TESTING_HANDOFF_TERMS = ["testing handoff contract", "测试交接合同"];
 const EVIDENCE_PLACEHOLDER_TERMS = [
     "pending",
@@ -217,6 +233,33 @@ const REVIEW_READINESS_FIELDS = [
     "Config Contract",
     "Testing Handoff Readiness"
 ];
+const SELF_TEST_CONTRACT_STATUSES = new Set(["required", "not_applicable"]);
+const RFC_SELF_TEST_TRIGGER_TERMS = [
+    "entry/exit",
+    "runnable entry",
+    "runnable exit",
+    "runnable entry/exit",
+    "runtime",
+    "environment",
+    "target_runtime_environment",
+    "target runtime",
+    "required_gates",
+    "gate",
+    "handoff",
+    "blocker",
+    "module key test path",
+    "test route",
+    "test path",
+    "debug path",
+    "测试路径",
+    "测试链路",
+    "自测链路",
+    "模块关键测试路径",
+    "入口",
+    "出口",
+    "运行环境",
+    "阻塞"
+];
 const validators = {
     "validate-harness": validateHarness,
     "validate-current": validateCurrent,
@@ -339,26 +382,26 @@ async function validateDesignDraft(projectRoot, root, techPlanFiles) {
     const availableTechPlans = new Set(techPlanFiles.map((file) => repoRelative(projectRoot, file)));
     const developmentTasks = [];
     const primaryRefs = [];
-    rawTasks.forEach((rawTask, index) => {
+    for (const [index, rawTask] of rawTasks.entries()) {
         if (!isRecord(rawTask)) {
             errors.push(`Task draft #${index + 1} must be a mapping`);
-            return;
+            continue;
         }
         validateDraftTaskShape(rawTask, index, errors);
         if (rawTask.status !== "pending") {
             errors.push(`Draft task ${String(rawTask.id ?? "")} should start as pending`);
         }
         if (!isDevelopmentDraft(rawTask))
-            return;
+            continue;
         developmentTasks.push(rawTask);
         if (!isRecord(rawTask.docs)) {
             errors.push(`Draft task ${String(rawTask.id ?? "")} docs must be a mapping`);
-            return;
+            continue;
         }
         const techRefs = asStringList(rawTask.docs.tech_plan);
         if (techRefs.length === 0) {
             errors.push(`Draft task ${String(rawTask.id ?? "")} must reference at least one tech plan slice in docs.tech_plan`);
-            return;
+            continue;
         }
         const normalizedRefs = techRefs.map(normalizeDocRef);
         for (const ref of normalizedRefs) {
@@ -369,8 +412,9 @@ async function validateDesignDraft(projectRoot, root, techPlanFiles) {
                 errors.push(`Draft task ${String(rawTask.id ?? "")} references missing or generated tech plan slice: ${ref}`);
             }
         }
+        errors.push(...(await validateSelfTestContractTechPlanBinding(projectRoot, rawTask, normalizedRefs)));
         primaryRefs.push(normalizedRefs[0]);
-    });
+    }
     if (developmentTasks.length === 0) {
         errors.push("plan.draft.yaml must contain at least one development task with implementation_doc");
     }
@@ -611,14 +655,36 @@ async function validateRfc(projectRoot) {
             errors.push(`Superseded test doc still linked from .docs/INDEX.md: ${superseded}`);
         }
     }
-    const statuses = [...text.matchAll(/status:\s*([a-z_]+)/g)].map((match) => match[1].toUpperCase());
+    const statuses = [...text.matchAll(/^\s*-?\s*Status:\s*([A-Z_]+)/gim)].map((match) => match[1].toUpperCase());
     if (statuses.length === 0)
         errors.push("RFC must include a Status line");
     const invalidStatuses = statuses.filter((status) => !["DRAFT", "APPLIED", "VERIFIED", "ARCHIVED"].includes(status));
     if (invalidStatuses.length > 0)
         errors.push(`Invalid RFC status: ${invalidStatuses.join(", ")}`);
+    errors.push(...(await validateRfcSelfTestImpact(projectRoot, docs)));
     return { info: [`validate-rfc checked ${docs.length} file(s)`], errors };
 }
+async function validateRfcSelfTestImpact(projectRoot, docs) {
+    const errors = [];
+    for (const doc of docs) {
+        const relative = repoRelative(projectRoot, doc);
+        const basename = path.basename(doc);
+        const number = rfcNumber(basename);
+        if (number !== undefined && number < 23)
+            continue;
+        const text = await readText(doc);
+        if (!containsAny(text, RFC_SELF_TEST_TRIGGER_TERMS))
+            continue;
+        if (!containsAny(text, DEVELOPMENT_SELF_TEST_IMPACT_TERMS)) {
+            errors.push(`${relative} must include Development Self-Test Impact when RFC changes entry/exit, runtime, gates, handoff, or blockers`);
+        }
+    }
+    return errors;
+}
+function rfcNumber(fileName) {
+    const match = fileName.match(/^RFC[_-](\d+)/i);
+    return match ? Number(match[1]) : undefined;
+}
 async function validatePlanState(projectRoot, allowOpen) {
     const errors = [];
     const root = await harnessRoot(projectRoot);
@@ -716,7 +782,7 @@ function validateRuntimeEvidenceContract(task) {
     if (String(task.phase ?? "") !== "SPRINTING")
         return errors;
     const context = taskText(task).toLowerCase();
-    const needsRuntimeContract = containsAny(context, [...APPLICATION_READINESS_TASK_TERMS, ...PAGE_TASK_TERMS]);
+    const needsRuntimeContract = needsRunnableTaskContract(task) && !isNotApplicableRuntimeTask(task);
     const evidenceLevel = task.evidence_level;
     const targetRuntime = task.target_runtime_environment;
     if (needsRuntimeContract && !isRecord(evidenceLevel)) {
@@ -769,6 +835,123 @@ function validateRuntimeEvidenceContract(task) {
             }
         }
     }
+    errors.push(...validateSelfTestContract(task, needsRuntimeContract));
+    return errors;
+}
+function needsRunnableTaskContract(task) {
+    const context = taskText(task).toLowerCase();
+    return containsAny(context, [...APPLICATION_READINESS_TASK_TERMS, ...PAGE_TASK_TERMS, ...CALLABLE_TASK_TERMS]);
+}
+function isNotApplicableRuntimeTask(task) {
+    const evidenceLevel = isRecord(task.evidence_level) ? task.evidence_level : undefined;
+    const targetRuntime = isRecord(task.target_runtime_environment) ? task.target_runtime_environment : undefined;
+    return String(evidenceLevel?.required ?? "") === "unit" && String(targetRuntime?.kind ?? "") === "not_applicable";
+}
+function validateSelfTestContract(task, requiredForRunnableBoundary) {
+    const errors = [];
+    const taskId = String(task.id ?? "Task");
+    const contract = task.self_test_contract;
+    if (requiredForRunnableBoundary && !isRecord(contract)) {
+        errors.push(`${taskId} runtime/app task must define self_test_contract`);
+        return errors;
+    }
+    if (contract === undefined)
+        return errors;
+    if (!isRecord(contract)) {
+        errors.push(`${taskId} self_test_contract must be a mapping`);
+        return errors;
+    }
+    const status = String(contract.status ?? "");
+    if (!SELF_TEST_CONTRACT_STATUSES.has(status)) {
+        errors.push(`${taskId} self_test_contract.status must be required or not_applicable`);
+    }
+    if (requiredForRunnableBoundary && status !== "required") {
+        errors.push(`${taskId} runnable boundary task self_test_contract.status must be required`);
+    }
+    if (status === "not_applicable") {
+        const reason = String(contract.not_applicable_reason ?? "").trim();
+        if (reason.length < 24 || isPlaceholderEvidence(reason)) {
+            errors.push(`${taskId} self_test_contract.not_applicable_reason must explain why self-test is not applicable`);
+        }
+        return errors;
+    }
+    if (status !== "required")
+        return errors;
+    for (const field of ["source", "runnable_entry", "observable_exit", "module_key_test_path"]) {
+        if (typeof contract[field] !== "string" || !String(contract[field]).trim() || isPlaceholderEvidence(String(contract[field]))) {
+            errors.push(`${taskId} self_test_contract.${field} must be concrete`);
+        }
+    }
+    if (!Array.isArray(contract.capability_refs) || contract.capability_refs.length === 0) {
+        errors.push(`${taskId} self_test_contract.capability_refs must be a non-empty list`);
+    }
+    const requiredGates = asStringList(contract.required_gates);
+    if (requiredGates.length === 0) {
+        errors.push(`${taskId} self_test_contract.required_gates must be a non-empty list`);
+    }
+    const taskGates = new Set(asStringList(task.required_gates));
+    for (const gate of requiredGates) {
+        if (!taskGates.has(gate)) {
+            errors.push(`${taskId} self_test_contract.required_gates must also appear in task required_gates: ${gate}`);
+        }
+    }
+    const scenarios = Array.isArray(contract.scenarios) ? contract.scenarios : [];
+    if (scenarios.length === 0) {
+        errors.push(`${taskId} self_test_contract.scenarios must be a non-empty list`);
+    }
+    const seen = new Set();
+    scenarios.forEach((scenario, index) => {
+        if (!isRecord(scenario)) {
+            errors.push(`${taskId} self_test_contract.scenarios[${index}] must be a mapping`);
+            return;
+        }
+        const scenarioId = String(scenario.id ?? "").trim();
+        if (!scenarioId) {
+            errors.push(`${taskId} self_test_contract.scenarios[${index}].id must be set`);
+        }
+        else if (seen.has(scenarioId)) {
+            errors.push(`${taskId} self_test_contract scenario id must be unique: ${scenarioId}`);
+        }
+        seen.add(scenarioId);
+        for (const field of ["entry", "expected_exit", "evidence"]) {
+            if (typeof scenario[field] !== "string" || !String(scenario[field]).trim() || isPlaceholderEvidence(String(scenario[field]))) {
+                errors.push(`${taskId} self_test_contract.scenarios[${scenarioId || index}].${field} must be concrete`);
+            }
+        }
+    });
+    return errors;
+}
+async function validateSelfTestContractTechPlanBinding(projectRoot, task, normalizedTechRefs) {
+    const errors = [];
+    const taskId = String(task.id ?? "Task");
+    const contract = isRecord(task.self_test_contract) ? task.self_test_contract : undefined;
+    if (!contract || String(contract.status ?? "") !== "required")
+        return errors;
+    const source = normalizeDocRef(String(contract.source ?? ""));
+    if (!source)
+        return errors;
+    if (!normalizedTechRefs.includes(source)) {
+        errors.push(`${taskId} self_test_contract.source must be listed in docs.tech_plan: ${source}`);
+        return errors;
+    }
+    const sourcePath = path.join(projectRoot, source);
+    if (!(await pathExists(sourcePath)))
+        return errors;
+    const text = await readText(sourcePath);
+    const section = markdownSection(text, DEVELOPMENT_SELF_TEST_CONTRACT_TERMS);
+    if (!section) {
+        errors.push(`${taskId} self_test_contract.source must contain a Development Self-Test Contract section: ${source}`);
+        return errors;
+    }
+    if (!containsAny(section, MODULE_KEY_TEST_PATH_TERMS)) {
+        errors.push(`${taskId} tech plan Development Self-Test Contract must include Module key test path: ${source}`);
+    }
+    for (const scenario of Array.isArray(contract.scenarios) ? contract.scenarios.filter(isRecord) : []) {
+        const scenarioId = String(scenario.id ?? "").trim();
+        if (scenarioId && !section.includes(scenarioId)) {
+            errors.push(`${taskId} tech plan Development Self-Test Contract must include scenario ${scenarioId}: ${source}`);
+        }
+    }
     return errors;
 }
 function validateParallelExecutionContract(plan, currentPhase, errors) {
@@ -781,11 +964,19 @@ function validateParallelExecutionContract(plan, currentPhase, errors) {
     }
     if (contract.enabled !== true)
         errors.push("parallel_execution.enabled must be true when present");
-    if (contract.trigger !== "user_requested")
-        errors.push('parallel_execution.trigger must be "user_requested"');
+    if (!PARALLEL_TRIGGERS.has(String(contract.trigger ?? ""))) {
+        errors.push("parallel_execution.trigger must be user_requested or workflow_default");
+    }
     if (!PARALLEL_MODES.has(String(contract.mode ?? ""))) {
         errors.push("parallel_execution.mode must be runtime_managed or user_orchestrated");
     }
+    const provider = parallelRuntimeProvider(contract, errors);
+    if (provider && !PARALLEL_RUNTIME_PROVIDERS.has(provider)) {
+        errors.push("parallel_execution.runtime.provider must be codex_native_subagents, user_orchestrated, or codex_exec_worktree");
+    }
+    if (contract.trigger === "workflow_default" && provider !== "codex_native_subagents") {
+        errors.push('parallel_execution.runtime.provider must be "codex_native_subagents" when trigger is workflow_default');
+    }
     if ("phase" in contract) {
         errors.push("parallel_execution must not define phase; lifecycle.yaml is the single source for current_phase");
     }
@@ -793,7 +984,7 @@ function validateParallelExecutionContract(plan, currentPhase, errors) {
         errors.push("parallel_execution must not define linked_task_id; use plan.yaml current_task_id");
     }
     if (!PARALLEL_ALLOWED_PHASES.has(currentPhase)) {
-        errors.push("parallel_execution is only supported during REQUIREMENT_GATHERING, SPRINTING, or TESTING");
+        errors.push("parallel_execution is only supported during REQUIREMENT_GATHERING, ARCHITECTING, SPRINTING, REVIEWING, TESTING, RELEASING, or RFC_RECALIBRATION");
     }
     if (contract.coordinator !== "main_agent")
         errors.push('parallel_execution.coordinator must be "main_agent"');
@@ -806,6 +997,7 @@ function validateParallelExecutionContract(plan, currentPhase, errors) {
     }
     else {
         const seen = new Set();
+        const writeOwnedPaths = [];
         workers.forEach((worker, index) => {
             const prefix = `parallel_execution.workers[${index}]`;
             if (!isRecord(worker)) {
@@ -832,18 +1024,36 @@ function validateParallelExecutionContract(plan, currentPhase, errors) {
             if (Array.isArray(worker.required_gates) && worker.required_gates.length === 0) {
                 errors.push(`${prefix}.required_gates must not be empty`);
             }
+            if (PARALLEL_READ_ONLY_PHASES.has(currentPhase) && worker.writes_repo !== false) {
+                errors.push(`${prefix}.writes_repo must be false during ${currentPhase}`);
+            }
             if (worker.writes_repo === true) {
-                if (typeof worker.branch !== "string" || !worker.branch.trim()) {
-                    errors.push(`${prefix}.branch is required when writes_repo is true`);
-                }
-                if (typeof worker.worktree !== "string" || !worker.worktree.trim()) {
-                    errors.push(`${prefix}.worktree is required when writes_repo is true`);
+                if (provider !== "codex_native_subagents") {
+                    if (typeof worker.branch !== "string" || !worker.branch.trim()) {
+                        errors.push(`${prefix}.branch is required when writes_repo is true outside codex_native_subagents runtime`);
+                    }
+                    if (typeof worker.worktree !== "string" || !worker.worktree.trim()) {
+                        errors.push(`${prefix}.worktree is required when writes_repo is true outside codex_native_subagents runtime`);
+                    }
                 }
                 if (!Array.isArray(worker.owned_paths) || worker.owned_paths.length === 0) {
                     errors.push(`${prefix}.owned_paths must not be empty when writes_repo is true`);
                 }
+                validateParallelWorkerPathLock(plan, worker, index, errors);
+                for (const owned of stringArray(worker.owned_paths).map(normalizeParallelPattern)) {
+                    writeOwnedPaths.push({ index, path: owned });
+                }
             }
         });
+        for (let left = 0; left < writeOwnedPaths.length; left += 1) {
+            for (let right = left + 1; right < writeOwnedPaths.length; right += 1) {
+                const leftOwned = writeOwnedPaths[left];
+                const rightOwned = writeOwnedPaths[right];
+                if (globPatternsOverlap(leftOwned.path, rightOwned.path)) {
+                    errors.push(`parallel_execution write worker owned_paths must not overlap: workers[${leftOwned.index}] ${leftOwned.path} vs workers[${rightOwned.index}] ${rightOwned.path}`);
+                }
+            }
+        }
     }
     const integration = contract.integration;
     if (!isRecord(integration)) {
@@ -862,6 +1072,63 @@ function validateParallelExecutionContract(plan, currentPhase, errors) {
         errors.push("parallel_execution.integration.fact_source_updates must be a non-empty list");
     }
 }
+function parallelRuntimeProvider(contract, errors) {
+    const runtime = contract.runtime;
+    if (runtime === undefined || runtime === null)
+        return "";
+    if (!isRecord(runtime)) {
+        errors.push("parallel_execution.runtime must be a mapping when present");
+        return "";
+    }
+    return String(runtime.provider ?? "");
+}
+function validateParallelWorkerPathLock(plan, worker, index, errors) {
+    const currentTask = currentPlanTask(plan);
+    if (!currentTask)
+        return;
+    const taskAllowed = stringArray(currentTask.allowed_paths).map(normalizeParallelPattern);
+    const workerOwned = stringArray(worker.owned_paths).map(normalizeParallelPattern);
+    const workerForbidden = stringArray(worker.forbidden_paths).map(normalizeParallelPattern);
+    const protectedPatterns = PARALLEL_PROTECTED_WRITE_PATTERNS.map(normalizeParallelPattern);
+    for (const owned of workerOwned) {
+        if (!matchesAny(owned, taskAllowed)) {
+            errors.push(`parallel_execution.workers[${index}].owned_paths must be within current task allowed_paths: ${owned}`);
+        }
+        for (const forbidden of [...workerForbidden, ...protectedPatterns]) {
+            if (globPatternsOverlap(owned, forbidden)) {
+                errors.push(`parallel_execution.workers[${index}].owned_paths must not overlap forbidden paths: ${owned} vs ${forbidden}`);
+            }
+        }
+    }
+}
+function currentPlanTask(plan) {
+    const currentTaskId = String(plan.current_task_id ?? "");
+    const tasks = Array.isArray(plan.tasks) ? plan.tasks.filter(isRecord) : [];
+    return tasks.find((task) => String(task.id ?? "") === currentTaskId);
+}
+function stringArray(value) {
+    return Array.isArray(value) ? value.map((item) => String(item)) : [];
+}
+function normalizeParallelPattern(pattern) {
+    return pattern.replace(/\\/g, "/").replaceAll("<harnessRoot>", ".codex");
+}
+function globPrefix(pattern) {
+    const normalized = normalizeParallelPattern(pattern);
+    const positions = ["*", "[", "?"].map((token) => normalized.indexOf(token)).filter((index) => index >= 0);
+    const prefix = positions.length > 0 ? normalized.slice(0, Math.min(...positions)) : normalized;
+    return prefix.replace(/\/+$/, "");
+}
+function globPatternsOverlap(left, right) {
+    const leftClean = normalizeParallelPattern(left);
+    const rightClean = normalizeParallelPattern(right);
+    if (matchesGlob(leftClean, rightClean) || matchesGlob(rightClean, leftClean))
+        return true;
+    const leftPrefix = globPrefix(leftClean);
+    const rightPrefix = globPrefix(rightClean);
+    if (!leftPrefix || !rightPrefix)
+        return leftPrefix === rightPrefix;
+    return leftPrefix === rightPrefix || leftPrefix.startsWith(`${rightPrefix}/`) || rightPrefix.startsWith(`${leftPrefix}/`);
+}
 async function validateChangedPaths(projectRoot, plan, allowOpen) {
     if (!allowOpen)
         return [];
@@ -1017,8 +1284,75 @@ function validateDevelopmentEvidenceText(text, task, implementationDoc) {
         }
     }
     errors.push(...validateEvidenceLevelAgainstContract(section, text, task, implementationDoc));
+    errors.push(...validateDevelopmentSelfTestReport(text, section, task, implementationDoc));
+    return errors;
+}
+function validateDevelopmentSelfTestReport(fullText, developmentEvidenceSection, task, implementationDoc) {
+    const errors = [];
+    const taskId = String(task.id ?? "current task");
+    const contract = isRecord(task.self_test_contract) ? task.self_test_contract : undefined;
+    if (!contract || String(contract.status ?? "") !== "required")
+        return errors;
+    const report = markdownSection(fullText, DEVELOPMENT_SELF_TEST_REPORT_TERMS);
+    if (!report) {
+        return [`${taskId} implementation_doc must include Development Self-Test Report for self_test_contract: ${implementationDoc}`];
+    }
+    const basicSelfTest = evidenceFieldValue(developmentEvidenceSection, "Basic Self-test Evidence") ?? "";
+    if (!containsAny(basicSelfTest, ["Development Self-Test Report", "开发自测报告", "self-test report"])) {
+        errors.push(`${taskId} Basic Self-test Evidence must reference the Development Self-Test Report in ${implementationDoc}`);
+    }
+    for (const field of ["Contract Source", "Scenario Results", "Executed Gates", "Module Key Test Path", "Actual Evidence", "Missing / Blockers", "Testing Handoff Readiness"]) {
+        const value = evidenceFieldValue(report, field);
+        const allowsNone = field === "Missing / Blockers";
+        if (!value || (!allowsNone && isPlaceholderEvidence(value))) {
+            errors.push(`${taskId} Development Self-Test Report ${field} must contain executed evidence in ${implementationDoc}`);
+        }
+    }
+    const source = String(contract.source ?? "").trim();
+    if (source && !report.includes(source)) {
+        errors.push(`${taskId} Development Self-Test Report must reference contract source ${source} in ${implementationDoc}`);
+    }
+    for (const gate of asStringList(contract.required_gates)) {
+        if (!report.includes(gate)) {
+            errors.push(`${taskId} Development Self-Test Report must record required gate ${gate} in ${implementationDoc}`);
+        }
+    }
+    const moduleKeyTestPath = evidenceFieldValue(report, "Module Key Test Path") ?? "";
+    const runnableEntry = String(contract.runnable_entry ?? "").trim();
+    if (runnableEntry && !moduleKeyTestPath.includes(runnableEntry)) {
+        errors.push(`${taskId} Development Self-Test Report Module Key Test Path must include runnable entry ${runnableEntry} in ${implementationDoc}`);
+    }
+    const scenarios = Array.isArray(contract.scenarios) ? contract.scenarios.filter(isRecord) : [];
+    for (const scenario of scenarios) {
+        const scenarioId = String(scenario.id ?? "").trim();
+        if (!scenarioId)
+            continue;
+        if (!moduleKeyTestPath.includes(scenarioId)) {
+            errors.push(`${taskId} Development Self-Test Report Module Key Test Path must include scenario ${scenarioId} in ${implementationDoc}`);
+        }
+        const status = scenarioStatus(report, scenarioId);
+        if (!status) {
+            errors.push(`${taskId} Development Self-Test Report must record scenario ${scenarioId} as PASS or BLOCKED in ${implementationDoc}`);
+        }
+        else if (status === "BLOCKED") {
+            errors.push(`${taskId} Development Self-Test Report scenario ${scenarioId} is BLOCKED; keep task open or record a blocker`);
+        }
+    }
     return errors;
 }
+function scenarioStatus(text, scenarioId) {
+    const escaped = scenarioId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const patterns = [
+        new RegExp("^.*" + escaped + ".*\\b(PASS|BLOCKED)\\b.*$", "im"),
+        new RegExp("\\|[^\\n|]*" + escaped + "[^\\n|]*\\|[^\\n|]*\\b(PASS|BLOCKED)\\b[^\\n|]*\\|", "i")
+    ];
+    for (const pattern of patterns) {
+        const match = text.match(pattern);
+        if (match)
+            return match[1].toUpperCase();
+    }
+    return undefined;
+}
 function hasConcreteDevelopmentEvidenceFields(section) {
     return ["Evidence Level", "Target Runtime Environment", "Runnable Entry", "Observable Exit", "Client / Server Initialization", "Config Contract"].some((field) => {
         const value = evidenceFieldValue(section, field);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-project-sdlc",
-  "version": "0.1.18",
+  "version": "0.1.20",
   "description": "CLI and canonical assets for the AI SDLC Harness workflow.",
   "type": "module",
   "bin": {

package/source-mappings.yaml

@@ -19,6 +19,12 @@ source_mappings:
   - source: ".codex/pjsdlc_managed/make/sdlc-harness.mk"
     target: "packages/sdlc-harness/assets/make/sdlc-harness.mk"
     mode: "copy-file"
+  - source: "tools"
+    target: "packages/sdlc-harness/assets/tools"
+    mode: "copy-tree"
+    exclude:
+      - "consumer_lab_full_test.mjs"
+      - "release_npm.mjs"
   - source: ".github/workflows/harness.yml"
     target: "packages/sdlc-harness/assets/github/harness.yml"
     mode: "copy-file"