agent-project-sdlc 0.1.19 → 0.1.21

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"]);
@@ -101,6 +113,36 @@ const EVIDENCE_PLACEHOLDER_TERMS = [
     "待补",
     "待确认"
 ];
+const SELF_TEST_REPORT_PLACEHOLDER_TERMS = [
+    "pass / blocked",
+    "pass or blocked",
+    "pass/block",
+    "pass/blocker",
+    "local start / invocation",
+    "all self-test scenarios",
+    "all task/module promised runnable entries",
+    "actual internal key paths",
+    "observable completion evidence"
+];
+const SELF_TEST_OBSERVABLE_EVIDENCE_TERMS = [
+    "pass output",
+    "response",
+    "output",
+    "side effect",
+    "log",
+    "artifact",
+    "health",
+    "status",
+    "audit",
+    "rendered",
+    "page state",
+    "screenshot",
+    "browser check",
+    "playwright",
+    "command output",
+    "queue",
+    "file"
+];
 const PAGE_TASK_TERMS = ["frontend", "front-end", "browser", "page", "页面", "前端", "按钮", "表单", "跳转"];
 const PAGE_ENTRY_TERMS = ["http://", "https://", "localhost", "127.0.0.1", "page url", "页面 url", "dev server"];
 const PAGE_BROWSER_CHECK_TERMS = ["browser check", "playwright", "screenshot", "click", "button", "form", "页面可加载", "浏览器验证"];
@@ -952,11 +994,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");
     }
@@ -964,7 +1014,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"');
@@ -977,6 +1027,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)) {
@@ -1003,18 +1054,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)) {
@@ -1033,6 +1102,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 [];
@@ -1222,11 +1348,26 @@ function validateDevelopmentSelfTestReport(fullText, developmentEvidenceSection,
         }
     }
     const moduleKeyTestPath = evidenceFieldValue(report, "Module Key Test Path") ?? "";
+    if (isPlaceholderSelfTestReportValue(moduleKeyTestPath) || isTemplateModuleKeyTestPath(moduleKeyTestPath)) {
+        errors.push(`${taskId} Development Self-Test Report Module Key Test Path must replace template placeholders with actual executed path evidence in ${implementationDoc}`);
+    }
     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) : [];
+    const exitEvidenceTerms = [
+        String(contract.observable_exit ?? "").trim(),
+        ...scenarios.flatMap((scenario) => [
+            String(scenario.expected_exit ?? "").trim(),
+            String(scenario.evidence ?? "").trim()
+        ])
+    ].filter(Boolean);
+    if (exitEvidenceTerms.length > 0
+        && !exitEvidenceTerms.some((term) => normalizedIncludes(moduleKeyTestPath, term))
+        && !containsAny(moduleKeyTestPath, SELF_TEST_OBSERVABLE_EVIDENCE_TERMS)) {
+        errors.push(`${taskId} Development Self-Test Report Module Key Test Path must include observable exit or evidence from self_test_contract in ${implementationDoc}`);
+    }
     for (const scenario of scenarios) {
         const scenarioId = String(scenario.id ?? "").trim();
         if (!scenarioId)
@@ -1238,25 +1379,94 @@ function validateDevelopmentSelfTestReport(fullText, developmentEvidenceSection,
         if (!status) {
             errors.push(`${taskId} Development Self-Test Report must record scenario ${scenarioId} as PASS or BLOCKED in ${implementationDoc}`);
         }
+        else if (status === "AMBIGUOUS") {
+            errors.push(`${taskId} Development Self-Test Report scenario ${scenarioId} must choose exactly one of 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`);
         }
+        errors.push(...validateScenarioTableEvidence(report, scenarioId, taskId, implementationDoc));
+    }
+    const targetRuntime = isRecord(task.target_runtime_environment) ? task.target_runtime_environment : undefined;
+    const reportContext = `${taskText(task)}\n${report}\n${Object.values(contract).map((value) => String(value ?? "")).join("\n")}`;
+    if (String(targetRuntime?.kind ?? "") === "browser" || containsAny(reportContext, PAGE_TASK_TERMS)) {
+        const loweredReport = report.toLowerCase();
+        if (!containsAny(loweredReport, PAGE_ENTRY_TERMS)) {
+            errors.push(`${taskId} page Development Self-Test Report must include a dev server or page URL in ${implementationDoc}`);
+        }
+        if (!containsAny(loweredReport, PAGE_BROWSER_CHECK_TERMS)) {
+            errors.push(`${taskId} page Development Self-Test Report must include browser, Playwright, screenshot, or equivalent interaction evidence in ${implementationDoc}`);
+        }
     }
     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();
+    const pattern = new RegExp("^.*" + escaped + ".*$", "gim");
+    for (const match of text.matchAll(pattern)) {
+        const line = match[0];
+        const hasPass = /\bPASS\b/i.test(line);
+        const hasBlocked = /\bBLOCKED\b/i.test(line);
+        if (hasPass && hasBlocked)
+            return "AMBIGUOUS";
+        if (hasPass)
+            return "PASS";
+        if (hasBlocked)
+            return "BLOCKED";
     }
     return undefined;
 }
+function validateScenarioTableEvidence(report, scenarioId, taskId, implementationDoc) {
+    const errors = [];
+    const rows = markdownTableRows(report).filter((cells) => cells.some((cell) => normalizeCell(cell) === scenarioId));
+    for (const cells of rows) {
+        const [id, result, executedEntry, actualExit, evidence] = cells;
+        if (!id || normalizeCell(id) !== scenarioId)
+            continue;
+        const requiredCells = [
+            ["Result", result],
+            ["Executed Entry", executedEntry],
+            ["Actual Exit", actualExit],
+            ["Evidence", evidence]
+        ];
+        for (const [label, value] of requiredCells) {
+            if (!value || isPlaceholderSelfTestReportValue(value)) {
+                errors.push(`${taskId} Development Self-Test Report scenario ${scenarioId} table ${label} must contain concrete evidence in ${implementationDoc}`);
+            }
+        }
+        if (result && scenarioStatus(`| ${cells.join(" | ")} |`, scenarioId) === "AMBIGUOUS") {
+            errors.push(`${taskId} Development Self-Test Report scenario ${scenarioId} table Result must choose exactly one of PASS or BLOCKED in ${implementationDoc}`);
+        }
+    }
+    return errors;
+}
+function markdownTableRows(section) {
+    return section
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.startsWith("|") && line.endsWith("|") && !/^\|\s*:?-{3,}:?\s*(\|\s*:?-{3,}:?\s*)+\|$/.test(line))
+        .map((line) => line.slice(1, -1).split("|").map((cell) => cell.trim()));
+}
+function normalizeCell(value) {
+    return value.replace(/`/g, "").trim();
+}
+function isTemplateModuleKeyTestPath(value) {
+    const lowered = value.toLowerCase();
+    return [
+        "local start / invocation",
+        "all self-test scenarios",
+        "all task/module promised runnable entries",
+        "actual internal key paths",
+        "observable completion evidence"
+    ].some((term) => lowered.includes(term));
+}
+function isPlaceholderSelfTestReportValue(value) {
+    const normalized = value.trim().toLowerCase();
+    return isPlaceholderEvidence(value) || SELF_TEST_REPORT_PLACEHOLDER_TERMS.some((term) => normalized.includes(term));
+}
+function normalizedIncludes(text, needle) {
+    return text.toLowerCase().includes(needle.toLowerCase());
+}
 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.19",
+  "version": "0.1.21",
   "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"