agent-project-sdlc 0.1.21 → 0.1.23

package/dist/lib/validators.js

@@ -9,6 +9,8 @@ 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 RESERVED_SUSPENDED_PHASE_TARGET = "<suspended_phase>";
+const TRANSITION_KINDS = new Set(["normal", "return", "interrupt", "resume"]);
 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 = [
@@ -89,6 +91,7 @@ const TEST_REPORT_PLACEHOLDER_TERMS = ["pending", "tbd", "todo", "待填", "待
 const TEST_FACT_SOURCE_PHASES = new Set(["TESTING", "RFC_RECALIBRATION"]);
 const TEST_FACT_SOURCE_PATTERNS = [".docs/07_test/**", ".docs/07_test/"];
 const TEST_FACT_SOURCE_REF = /\.docs\/07_test\/[^\s`,)]+/g;
+const RUNBOOK_DOC_PREFIX = ".docs/09_runbooks/";
 const RUNNABLE_ENTRY_EXIT_TERMS = [
     "runnable entry/exit",
     "entry/exit",
@@ -103,6 +106,9 @@ 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 MODULE_KEY_TEST_GRAPH_TERMS = ["module key test graph", "module_key_test_graph", "模块关键测试图"];
+const GATE_BREAKDOWN_TERMS = ["gate breakdown", "gate 分层", "gate breakdown（gate 分层）"];
+const CURRENT_OPERATOR_PATH_TERMS = ["current operator path", "operator path", "当前操作路径", "当前 operator path"];
 const TESTING_HANDOFF_TERMS = ["testing handoff contract", "测试交接合同"];
 const EVIDENCE_PLACEHOLDER_TERMS = [
     "pending",
@@ -122,7 +128,132 @@ const SELF_TEST_REPORT_PLACEHOLDER_TERMS = [
     "all self-test scenarios",
     "all task/module promised runnable entries",
     "actual internal key paths",
-    "observable completion evidence"
+    "observable completion evidence",
+    "required only when",
+    "compact dag pointer",
+    "复杂 / high-risk",
+    "只记录实际 handoff"
+];
+const SELF_TEST_REPORT_STATUSES = new Set(["PASS", "BLOCKED", "IN_PROGRESS", "STALE"]);
+const SELF_TEST_REPORT_REQUIRED_FIELDS = [
+    "Contract Source",
+    "Module Application Entry",
+    "Module Key Test Path",
+    "Scenario Results",
+    "Executed Gates",
+    "Observable Exit",
+    "Current Blocker",
+    "Testing Handoff Readiness",
+    "Evidence Index Refs"
+];
+const SELF_TEST_REPORT_NONE_ALLOWED_FIELDS = new Set(["Current Blocker"]);
+const MAX_SELF_TEST_REPORT_LINES = 80;
+const MAX_HIGH_RISK_SELF_TEST_REPORT_LINES = 120;
+const SELF_TEST_REPORT_DISALLOWED_SECTION_TERMS = [
+    "debug log",
+    "operator log",
+    "operation log",
+    "runbook",
+    "exploration",
+    "diagnostic attempts",
+    "fallback attempts",
+    "history log",
+    "remote operation log",
+    "调试日志",
+    "操作日志",
+    "远端操作日志",
+    "探索流水",
+    "失败探索",
+    "诊断尝试",
+    "历史流水"
+];
+const SELF_TEST_REPORT_DISALLOWED_FIELD_TERMS = [
+    "Actual Evidence"
+];
+const IMPLEMENTATION_MAINLINE_DISALLOWED_SECTION_TERMS = [
+    "debug log",
+    "operator log",
+    "operation log",
+    "evidence dump",
+    "screenshot index",
+    "full screenshot",
+    "runbook body",
+    "failed attempts",
+    "failure exploration",
+    "diagnostic attempts",
+    "diagnostic path",
+    "remote operation log",
+    "recovery notes",
+    "task changelog",
+    "old task",
+    "historical task",
+    "调试日志",
+    "操作日志",
+    "证据正文",
+    "截图索引",
+    "失败探索",
+    "诊断尝试",
+    "诊断路径",
+    "恢复备注",
+    "旧 task",
+    "历史 task"
+];
+const HARD_CONSTRAINT_TERMS = [
+    "hard constraint",
+    "hard constraints",
+    "strategy constraint",
+    "strategy constraints",
+    "恢复硬约束",
+    "硬约束",
+    "策略约束"
+];
+const STRATEGY_CHANGING_DECISION_GROUPS = [
+    [
+        "session persistence/reset",
+        [
+            "session persistence",
+            "session reset",
+            "session_reset",
+            "session 异常",
+            "rule_assumption_gap",
+            "operator_induced_logout_or_session_reset",
+            "operator induced logout",
+            "logout",
+            "logged out",
+            "退登",
+            "qr",
+            "二维码",
+            "扫码",
+            "重新扫码"
+        ]
+    ],
+    [
+        "canonical path change",
+        [
+            "canonical path changed",
+            "canonical path change",
+            "canonical path switched",
+            "canonical path reset",
+            "主路径变化",
+            "主路径切换",
+            "恢复路径变化"
+        ]
+    ],
+    [
+        "do-not-retry decision",
+        [
+            "do not retry",
+            "do-not-retry",
+            "don't retry",
+            "not retry",
+            "must not retry",
+            "不得重试",
+            "不要重试",
+            "不要再试",
+            "不要重复",
+            "不得直接"
+        ]
+    ]
 ];
 const SELF_TEST_OBSERVABLE_EVIDENCE_TERMS = [
     "pass output",
@@ -143,6 +274,25 @@ const SELF_TEST_OBSERVABLE_EVIDENCE_TERMS = [
     "queue",
     "file"
 ];
+const RESUME_CAPSULE_REQUIRED_EVIDENCE_LEVELS = new Set(["external_provider_live", "deployed_runtime", "business_handoff_ready"]);
+const RESUME_CAPSULE_REQUIRED_TARGET_KINDS = new Set(["cloud_vm", "managed_service", "browser", "worker"]);
+const RESUME_CAPSULE_FIELDS = [
+    "task_id",
+    "state",
+    "canonical_path",
+    "next_step",
+    "blocker",
+    "last_passed_gate",
+    "do_not_retry",
+    "recovery_refs"
+];
+const MAX_WORKING_NOTES = 8;
+const GATE_BREAKDOWN_LAYER_GROUPS = [
+    ["local gate", ["local", "unit", "lint", "test", "本地"]],
+    ["cloud/service gate", ["cloud", "service", "runtime", "server", "managed_service", "cloud_vm", "服务", "云端"]],
+    ["executor/operator readiness", ["executor", "operator", "worker", "browser", "provider", "adapter", "readiness", "执行器", "操控", "就绪"]],
+    ["live smoke or handoff", ["live", "smoke", "handoff", "external_provider_live", "deployed_runtime", "business_handoff_ready", "冒烟", "交接"]]
+];
 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", "页面可加载", "浏览器验证"];
@@ -264,6 +414,27 @@ const REVIEW_READINESS_FIELDS = [
     "Testing Handoff Readiness"
 ];
 const SELF_TEST_CONTRACT_STATUSES = new Set(["required", "not_applicable"]);
+const SELF_TEST_GRAPH_NODE_KINDS = new Set(["entry", "checkpoint", "branch", "scenario", "observable_exit"]);
+const SELF_TEST_GRAPH_ORDINARY_NODE_LIMIT = 12;
+const SELF_TEST_GRAPH_HIGH_RISK_NODE_LIMIT = 25;
+const SELF_TEST_GRAPH_EVIDENCE_BODY_TERMS = [
+    "```",
+    "|---",
+    "actual evidence",
+    "command transcript",
+    "full command output",
+    "stdout",
+    "stderr",
+    "traceback",
+    "debug log",
+    "operator log",
+    "evidence dump",
+    "screenshot process",
+    "截图过程",
+    "调试日志",
+    "操作日志",
+    "证据正文"
+];
 const RFC_SELF_TEST_TRIGGER_TERMS = [
     "entry/exit",
     "runnable entry",
@@ -278,6 +449,11 @@ const RFC_SELF_TEST_TRIGGER_TERMS = [
     "handoff",
     "blocker",
     "module key test path",
+    "module key test graph",
+    "module_key_test_graph",
+    "checkpoint",
+    "observable exit",
+    "evidence refs",
     "test route",
     "test path",
     "debug path",
@@ -319,6 +495,7 @@ async function validateHarness(projectRoot) {
     for (const required of [
         "AGENTS.md",
         ".docs/INDEX.md",
+        ".docs/09_runbooks",
         harnessPath(root, "config.yaml"),
         harnessPath(root, "state", "lifecycle.yaml"),
         harnessPath(root, "state", "plan.yaml"),
@@ -330,6 +507,9 @@ async function validateHarness(projectRoot) {
             errors.push(`missing ${required}`);
         }
     }
+    const phaseContractPath = path.join(projectRoot, harnessPath(root, "pjsdlc_managed", "policies", "phase_contracts.yaml"));
+    const phaseContracts = await readYamlObject(phaseContractPath);
+    errors.push(...validatePhaseTransitionContract(phaseContracts));
     return { info: [`validate-harness checked ${projectRoot} (${root})`], errors };
 }
 async function validateCurrent(projectRoot) {
@@ -786,6 +966,7 @@ async function validatePlanState(projectRoot, allowOpen) {
             if (!Array.isArray(task.acceptance_criteria) || task.acceptance_criteria.length === 0) {
                 errors.push(`Open task ${task.id} must define acceptance_criteria`);
             }
+            errors.push(...validateWorkingNotesLimit(task));
             errors.push(...validateRuntimeEvidenceContract(task));
             errors.push(...testingBoundaryErrorsForAllowedPaths(task));
         }
@@ -804,8 +985,90 @@ async function validatePlanState(projectRoot, allowOpen) {
     if (currentTaskId && !tasks.some((task) => isRecord(task) && task.id === currentTaskId)) {
         errors.push(`current_task_id does not match a task: ${currentTaskId}`);
     }
+    errors.push(...(await validateResumeCapsule(projectRoot, tasksData)));
     return { taskCount: tasks.length, errors, plan: tasksData };
 }
+function validateWorkingNotesLimit(task) {
+    if (!("working_notes" in task))
+        return [];
+    const taskId = String(task.id ?? "Open task");
+    const notes = task.working_notes;
+    if (typeof notes !== "string" && !Array.isArray(notes)) {
+        return [`Open task ${taskId} working_notes must be a short string or list with at most ${MAX_WORKING_NOTES} items`];
+    }
+    const count = Array.isArray(notes) ? notes.length : notes.trim() ? 1 : 0;
+    if (count > MAX_WORKING_NOTES) {
+        return [`Open task ${taskId} working_notes must stay resume-first and contain at most ${MAX_WORKING_NOTES} items; found ${count}`];
+    }
+    return [];
+}
+async function validateResumeCapsule(projectRoot, plan) {
+    const errors = [];
+    const currentTask = currentOpenSprintTask(plan);
+    const capsule = plan.resume_capsule;
+    if (!currentTask) {
+        if (capsule !== undefined) {
+            errors.push("plan.yaml resume_capsule must only be present for the current open SPRINTING task");
+        }
+        return errors;
+    }
+    const taskId = String(currentTask.id ?? "current task");
+    const required = requiresResumeCapsule(currentTask);
+    if (!required && capsule === undefined)
+        return errors;
+    if (!isRecord(capsule)) {
+        errors.push(`${taskId} high-risk runtime task must define top-level resume_capsule`);
+        return errors;
+    }
+    for (const field of RESUME_CAPSULE_FIELDS) {
+        if (!(field in capsule)) {
+            errors.push(`${taskId} resume_capsule missing field: ${field}`);
+        }
+    }
+    const capsuleTaskId = String(capsule.task_id ?? "").trim();
+    if (capsuleTaskId !== taskId) {
+        errors.push(`${taskId} resume_capsule.task_id must match current_task_id`);
+    }
+    for (const field of ["state", "canonical_path", "next_step", "blocker", "last_passed_gate"]) {
+        const value = String(capsule[field] ?? "").trim();
+        if (!value || isPlaceholderEvidence(value)) {
+            errors.push(`${taskId} resume_capsule.${field} must contain concrete recovery information`);
+        }
+    }
+    const doNotRetry = asStringList(capsule.do_not_retry);
+    if (doNotRetry.length === 0 || doNotRetry.some((item) => isPlaceholderEvidence(item))) {
+        errors.push(`${taskId} resume_capsule.do_not_retry must list concrete paths or attempts not to repeat`);
+    }
+    const refs = asStringList(capsule.recovery_refs);
+    if (refs.length === 0) {
+        errors.push(`${taskId} resume_capsule.recovery_refs must link implementation doc and runbook/evidence documents`);
+        return errors;
+    }
+    const implementationDoc = String(currentTask.implementation_doc ?? "").trim();
+    if (implementationDoc && !refs.includes(implementationDoc)) {
+        errors.push(`${taskId} resume_capsule.recovery_refs must include current implementation_doc ${implementationDoc}`);
+    }
+    if (!refs.some((ref) => ref.startsWith(RUNBOOK_DOC_PREFIX))) {
+        errors.push(`${taskId} resume_capsule.recovery_refs must include a runbook/evidence document under ${RUNBOOK_DOC_PREFIX}`);
+    }
+    for (const ref of refs) {
+        if (!ref.startsWith(".docs/04_implementation/") && !ref.startsWith(RUNBOOK_DOC_PREFIX)) {
+            errors.push(`${taskId} resume_capsule.recovery_refs may only point to implementation docs or runbook/evidence docs: ${ref}`);
+            continue;
+        }
+        if (!(await pathExists(path.join(projectRoot, ref)))) {
+            errors.push(`${taskId} resume_capsule recovery_ref does not exist: ${ref}`);
+        }
+    }
+    return errors;
+}
+function requiresResumeCapsule(task) {
+    if (String(task.phase ?? "") !== "SPRINTING")
+        return false;
+    const evidenceLevel = isRecord(task.evidence_level) ? String(task.evidence_level.required ?? "") : "";
+    const targetKind = isRecord(task.target_runtime_environment) ? String(task.target_runtime_environment.kind ?? "") : "";
+    return RESUME_CAPSULE_REQUIRED_EVIDENCE_LEVELS.has(evidenceLevel) || RESUME_CAPSULE_REQUIRED_TARGET_KINDS.has(targetKind);
+}
 function validateRuntimeEvidenceContract(task) {
     const errors = [];
     const taskId = String(task.id ?? "Task");
@@ -877,6 +1140,205 @@ function isNotApplicableRuntimeTask(task) {
     const targetRuntime = isRecord(task.target_runtime_environment) ? task.target_runtime_environment : undefined;
     return String(evidenceLevel?.required ?? "") === "unit" && String(targetRuntime?.kind ?? "") === "not_applicable";
 }
+function selfTestGraphEvidenceRefIsBody(value) {
+    const trimmed = value.trim();
+    const lowered = trimmed.toLowerCase();
+    return trimmed.includes("\n") || trimmed.length > 180 || SELF_TEST_GRAPH_EVIDENCE_BODY_TERMS.some((term) => lowered.includes(term));
+}
+function graphHasCycle(nodeIds, adjacency) {
+    const visiting = new Set();
+    const visited = new Set();
+    const visit = (nodeId) => {
+        if (visiting.has(nodeId))
+            return true;
+        if (visited.has(nodeId))
+            return false;
+        visiting.add(nodeId);
+        for (const target of adjacency.get(nodeId) ?? []) {
+            if (visit(target))
+                return true;
+        }
+        visiting.delete(nodeId);
+        visited.add(nodeId);
+        return false;
+    };
+    for (const nodeId of nodeIds) {
+        if (!visited.has(nodeId) && visit(nodeId))
+            return true;
+    }
+    return false;
+}
+function reachableFrom(entryId, adjacency) {
+    const reached = new Set();
+    const stack = [entryId];
+    while (stack.length > 0) {
+        const nodeId = stack.pop();
+        if (reached.has(nodeId))
+            continue;
+        reached.add(nodeId);
+        stack.push(...(adjacency.get(nodeId) ?? []));
+    }
+    return reached;
+}
+function nodesThatCanReachExits(nodeIds, adjacency, exits) {
+    const reverse = new Map();
+    for (const nodeId of nodeIds)
+        reverse.set(nodeId, []);
+    for (const [source, targets] of adjacency.entries()) {
+        for (const target of targets) {
+            const incoming = reverse.get(target) ?? [];
+            incoming.push(source);
+            reverse.set(target, incoming);
+        }
+    }
+    const reached = new Set();
+    const stack = [...exits];
+    while (stack.length > 0) {
+        const nodeId = stack.pop();
+        if (reached.has(nodeId))
+            continue;
+        reached.add(nodeId);
+        stack.push(...(reverse.get(nodeId) ?? []));
+    }
+    return reached;
+}
+function validateSelfTestGraph(taskId, contract, scenarioIds, highRiskRuntime) {
+    const errors = [];
+    const graphRequired = contract.graph_required;
+    if (graphRequired !== undefined && typeof graphRequired !== "boolean") {
+        errors.push(`${taskId} self_test_contract.graph_required must be a boolean when set`);
+    }
+    const graph = contract.module_key_test_graph;
+    if (graphRequired === true && !isRecord(graph)) {
+        errors.push(`${taskId} self_test_contract.module_key_test_graph is required when graph_required is true`);
+    }
+    if (graph === undefined)
+        return errors;
+    if (!isRecord(graph)) {
+        errors.push(`${taskId} self_test_contract.module_key_test_graph must be a mapping`);
+        return errors;
+    }
+    const nodes = graph.nodes;
+    const edges = graph.edges;
+    if (!Array.isArray(nodes) || nodes.length === 0) {
+        errors.push(`${taskId} self_test_contract.module_key_test_graph.nodes must be a non-empty list`);
+        return errors;
+    }
+    if (!Array.isArray(edges) || edges.length === 0) {
+        errors.push(`${taskId} self_test_contract.module_key_test_graph.edges must be a non-empty list`);
+        return errors;
+    }
+    const nodeLimit = highRiskRuntime ? SELF_TEST_GRAPH_HIGH_RISK_NODE_LIMIT : SELF_TEST_GRAPH_ORDINARY_NODE_LIMIT;
+    if (nodes.length > nodeLimit) {
+        errors.push(`${taskId} self_test_contract.module_key_test_graph has ${nodes.length} nodes; keep ordinary graphs <= ${SELF_TEST_GRAPH_ORDINARY_NODE_LIMIT} nodes and high-risk graphs <= ${SELF_TEST_GRAPH_HIGH_RISK_NODE_LIMIT} nodes`);
+    }
+    const nodeIds = new Set();
+    const entryIds = [];
+    const observableExitIds = new Set();
+    const scenarioNodesByRef = new Map();
+    const adjacency = new Map();
+    nodes.forEach((node, index) => {
+        if (!isRecord(node)) {
+            errors.push(`${taskId} self_test_contract.module_key_test_graph.nodes[${index}] must be a mapping`);
+            return;
+        }
+        const nodeId = String(node.id ?? "").trim();
+        const kind = String(node.kind ?? "").trim();
+        const label = String(node.label ?? "").trim();
+        if (!nodeId) {
+            errors.push(`${taskId} self_test_contract.module_key_test_graph.nodes[${index}].id must be set`);
+            return;
+        }
+        if (nodeIds.has(nodeId)) {
+            errors.push(`${taskId} self_test_contract.module_key_test_graph node id must be unique: ${nodeId}`);
+        }
+        nodeIds.add(nodeId);
+        adjacency.set(nodeId, adjacency.get(nodeId) ?? []);
+        if (!SELF_TEST_GRAPH_NODE_KINDS.has(kind)) {
+            errors.push(`${taskId} self_test_contract.module_key_test_graph.nodes[${nodeId}].kind must be one of ${[...SELF_TEST_GRAPH_NODE_KINDS].join(", ")}`);
+        }
+        if (!label || isPlaceholderEvidence(label)) {
+            errors.push(`${taskId} self_test_contract.module_key_test_graph.nodes[${nodeId}].label must be concrete`);
+        }
+        if (kind === "entry")
+            entryIds.push(nodeId);
+        if (kind === "observable_exit")
+            observableExitIds.add(nodeId);
+        if (kind === "scenario") {
+            const scenarioRef = String(node.scenario_ref ?? "").trim();
+            if (!scenarioRef) {
+                errors.push(`${taskId} self_test_contract.module_key_test_graph scenario node ${nodeId} must set scenario_ref`);
+            }
+            else if (!scenarioIds.has(scenarioRef)) {
+                errors.push(`${taskId} self_test_contract.module_key_test_graph scenario node ${nodeId} references unknown scenario: ${scenarioRef}`);
+            }
+            else {
+                const current = scenarioNodesByRef.get(scenarioRef) ?? [];
+                current.push(nodeId);
+                scenarioNodesByRef.set(scenarioRef, current);
+            }
+        }
+        if (node.evidence_ref !== undefined) {
+            const evidenceRef = String(node.evidence_ref).trim();
+            if (!evidenceRef || isPlaceholderEvidence(evidenceRef) || selfTestGraphEvidenceRefIsBody(evidenceRef)) {
+                errors.push(`${taskId} self_test_contract.module_key_test_graph.nodes[${nodeId}].evidence_ref must be a short evidence pointer, not evidence body`);
+            }
+        }
+    });
+    if (entryIds.length !== 1) {
+        errors.push(`${taskId} self_test_contract.module_key_test_graph must have exactly one entry node`);
+    }
+    if (observableExitIds.size === 0) {
+        errors.push(`${taskId} self_test_contract.module_key_test_graph must have at least one observable_exit node`);
+    }
+    edges.forEach((edge, index) => {
+        if (!isRecord(edge)) {
+            errors.push(`${taskId} self_test_contract.module_key_test_graph.edges[${index}] must be a mapping`);
+            return;
+        }
+        const source = String(edge.from ?? "").trim();
+        const target = String(edge.to ?? "").trim();
+        if (!nodeIds.has(source)) {
+            errors.push(`${taskId} self_test_contract.module_key_test_graph edge references unknown from node: ${source || "<empty>"}`);
+            return;
+        }
+        if (!nodeIds.has(target)) {
+            errors.push(`${taskId} self_test_contract.module_key_test_graph edge references unknown to node: ${target || "<empty>"}`);
+            return;
+        }
+        const current = adjacency.get(source) ?? [];
+        current.push(target);
+        adjacency.set(source, current);
+    });
+    if (graphHasCycle(nodeIds, adjacency)) {
+        errors.push(`${taskId} self_test_contract.module_key_test_graph must be a DAG; cycles are not allowed`);
+    }
+    let reachedFromEntry = new Set();
+    if (entryIds.length === 1) {
+        reachedFromEntry = reachableFrom(entryIds[0], adjacency);
+        const unreachable = [...nodeIds].filter((nodeId) => !reachedFromEntry.has(nodeId)).sort();
+        if (unreachable.length > 0) {
+            errors.push(`${taskId} self_test_contract.module_key_test_graph nodes must be reachable from entry: ${unreachable.join(", ")}`);
+        }
+    }
+    const canReachExit = nodesThatCanReachExits(nodeIds, adjacency, observableExitIds);
+    for (const scenarioId of [...scenarioIds].sort()) {
+        const scenarioNodeIds = scenarioNodesByRef.get(scenarioId) ?? [];
+        if (scenarioNodeIds.length === 0) {
+            errors.push(`${taskId} self_test_contract.module_key_test_graph must include a scenario node for ${scenarioId}`);
+            continue;
+        }
+        for (const nodeId of scenarioNodeIds) {
+            if (reachedFromEntry.size > 0 && !reachedFromEntry.has(nodeId)) {
+                errors.push(`${taskId} self_test_contract.module_key_test_graph scenario ${scenarioId} must be reachable from entry`);
+            }
+            if (!canReachExit.has(nodeId)) {
+                errors.push(`${taskId} self_test_contract.module_key_test_graph scenario ${scenarioId} must reach an observable_exit`);
+            }
+        }
+    }
+    return errors;
+}
 function validateSelfTestContract(task, requiredForRunnableBoundary) {
     const errors = [];
     const taskId = String(task.id ?? "Task");
@@ -930,6 +1392,7 @@ function validateSelfTestContract(task, requiredForRunnableBoundary) {
         errors.push(`${taskId} self_test_contract.scenarios must be a non-empty list`);
     }
     const seen = new Set();
+    const scenarioIds = new Set();
     scenarios.forEach((scenario, index) => {
         if (!isRecord(scenario)) {
             errors.push(`${taskId} self_test_contract.scenarios[${index}] must be a mapping`);
@@ -942,6 +1405,9 @@ function validateSelfTestContract(task, requiredForRunnableBoundary) {
         else if (seen.has(scenarioId)) {
             errors.push(`${taskId} self_test_contract scenario id must be unique: ${scenarioId}`);
         }
+        else {
+            scenarioIds.add(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]))) {
@@ -949,6 +1415,7 @@ function validateSelfTestContract(task, requiredForRunnableBoundary) {
             }
         }
     });
+    errors.push(...validateSelfTestGraph(taskId, contract, scenarioIds, requiresResumeCapsule(task)));
     return errors;
 }
 async function validateSelfTestContractTechPlanBinding(projectRoot, task, normalizedTechRefs) {
@@ -976,6 +1443,9 @@ async function validateSelfTestContractTechPlanBinding(projectRoot, task, normal
     if (!containsAny(section, MODULE_KEY_TEST_PATH_TERMS)) {
         errors.push(`${taskId} tech plan Development Self-Test Contract must include Module key test path: ${source}`);
     }
+    if (contract.graph_required === true && !containsAny(section, MODULE_KEY_TEST_GRAPH_TERMS)) {
+        errors.push(`${taskId} tech plan Development Self-Test Contract must include Module Key Test Graph when graph_required is true: ${source}`);
+    }
     for (const scenario of Array.isArray(contract.scenarios) ? contract.scenarios.filter(isRecord) : []) {
         const scenarioId = String(scenario.id ?? "").trim();
         if (scenarioId && !section.includes(scenarioId)) {
@@ -1192,6 +1662,95 @@ function matchesGlob(file, pattern) {
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
+function validatePhaseTransitionContract(contract) {
+    const errors = [];
+    const phases = contract.phases;
+    if (!isRecord(phases)) {
+        return ["phase_contracts.yaml must contain phases"];
+    }
+    for (const [phaseName, phaseContract] of Object.entries(phases)) {
+        if (!isRecord(phaseContract)) {
+            errors.push(`${phaseName} phase contract must be a mapping`);
+            continue;
+        }
+        for (const legacyKey of ["next", "returns"]) {
+            if (legacyKey in phaseContract) {
+                errors.push(`${phaseName} must not define legacy ${legacyKey}; use top-level transitions`);
+            }
+        }
+    }
+    const transitions = contract.transitions;
+    if (!Array.isArray(transitions)) {
+        errors.push("phase_contracts.yaml must contain top-level transitions");
+        return errors;
+    }
+    const phaseNames = new Set(Object.keys(phases));
+    const seen = new Set();
+    const outgoing = new Set();
+    transitions.forEach((transition, index) => {
+        const prefix = `transition #${index + 1}`;
+        if (!isRecord(transition)) {
+            errors.push(`${prefix} must be a mapping`);
+            return;
+        }
+        const fromPhase = String(transition.from ?? "");
+        const toPhase = String(transition.to ?? "");
+        const trigger = String(transition.trigger ?? "");
+        const kind = String(transition.kind ?? "");
+        for (const [field, value] of [
+            ["from", fromPhase],
+            ["to", toPhase],
+            ["trigger", trigger],
+            ["kind", kind]
+        ]) {
+            if (!value.trim())
+                errors.push(`${prefix} missing ${field}`);
+        }
+        if (!fromPhase || !toPhase || !trigger || !kind)
+            return;
+        if (!phaseNames.has(fromPhase)) {
+            errors.push(`${prefix} from references unknown phase: ${fromPhase}`);
+        }
+        if (toPhase === RESERVED_SUSPENDED_PHASE_TARGET) {
+            if (fromPhase !== "BLOCKED" || kind !== "resume") {
+                errors.push(`${prefix} may use ${RESERVED_SUSPENDED_PHASE_TARGET} only for BLOCKED resume`);
+            }
+        }
+        else if (!phaseNames.has(toPhase)) {
+            errors.push(`${prefix} to references unknown phase: ${toPhase}`);
+        }
+        if (!TRANSITION_KINDS.has(kind)) {
+            errors.push(`${prefix} has invalid kind: ${kind}`);
+        }
+        const duplicateKey = `${fromPhase}\0${toPhase}\0${trigger}`;
+        if (seen.has(duplicateKey)) {
+            errors.push(`${prefix} duplicates transition ${fromPhase} -> ${toPhase} (${trigger})`);
+        }
+        seen.add(duplicateKey);
+        outgoing.add(fromPhase);
+        if ("effects" in transition && transition.effects !== undefined) {
+            if (!isRecord(transition.effects)) {
+                errors.push(`${prefix} effects must be a mapping`);
+            }
+            else {
+                for (const [effectName, effectValue] of Object.entries(transition.effects)) {
+                    if (!["set_suspended_phase", "clear_suspended_phase"].includes(effectName)) {
+                        errors.push(`${prefix} has unknown effect: ${effectName}`);
+                    }
+                    if (typeof effectValue !== "boolean") {
+                        errors.push(`${prefix} effect ${effectName} must be boolean`);
+                    }
+                }
+            }
+        }
+    });
+    for (const phaseName of phaseNames) {
+        if (!outgoing.has(phaseName)) {
+            errors.push(`${phaseName} must have at least one outgoing transition`);
+        }
+    }
+    return errors;
+}
 async function readYamlObject(filePath) {
     if (!(await pathExists(filePath)))
         return {};
@@ -1250,7 +1809,10 @@ async function validateCurrentTaskDevelopmentEvidence(projectRoot, plan) {
         return [`${taskId} implementation_doc is missing: ${implementationDoc}`];
     }
     const text = await readText(docPath);
-    return validateDevelopmentEvidenceText(text, currentTask, implementationDoc);
+    return [
+        ...validateDevelopmentEvidenceText(text, currentTask, implementationDoc),
+        ...(await validateHighRiskRecoveryBoundaries(projectRoot, text, plan, currentTask, implementationDoc))
+    ];
 }
 function currentOpenSprintTask(plan) {
     const currentTaskId = String(plan.current_task_id ?? "");
@@ -1327,17 +1889,31 @@ function validateDevelopmentSelfTestReport(fullText, developmentEvidenceSection,
     if (!report) {
         return [`${taskId} implementation_doc must include Development Self-Test Report for self_test_contract: ${implementationDoc}`];
     }
+    const reportStatus = normalizeSelfTestReportStatus(evidenceFieldValue(report, "Report Status"));
+    if (!reportStatus) {
+        errors.push(`${taskId} Development Self-Test Report must include Report Status: PASS | BLOCKED | IN_PROGRESS | STALE in ${implementationDoc}`);
+    }
+    else if (reportStatus !== "PASS") {
+        errors.push(`${taskId} Development Self-Test Report Report Status is ${reportStatus}; validate-dev cannot handoff until the report status is PASS`);
+    }
+    const highRiskRuntime = requiresResumeCapsule(task);
+    errors.push(...validateSelfTestReportBoundary(report, taskId, implementationDoc));
+    errors.push(...validateSelfTestReportLength(report, taskId, implementationDoc, highRiskRuntime));
     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"]) {
+    for (const field of SELF_TEST_REPORT_REQUIRED_FIELDS) {
         const value = evidenceFieldValue(report, field);
-        const allowsNone = field === "Missing / Blockers";
+        const allowsNone = SELF_TEST_REPORT_NONE_ALLOWED_FIELDS.has(field);
         if (!value || (!allowsNone && isPlaceholderEvidence(value))) {
             errors.push(`${taskId} Development Self-Test Report ${field} must contain executed evidence in ${implementationDoc}`);
         }
     }
+    const evidenceIndexRefs = evidenceFieldValue(report, "Evidence Index Refs") ?? "";
+    if (highRiskRuntime && !evidenceIndexRefs.includes(RUNBOOK_DOC_PREFIX)) {
+        errors.push(`${taskId} high-risk Development Self-Test Report Evidence Index Refs must link evidence under ${RUNBOOK_DOC_PREFIX} 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}`);
@@ -1351,10 +1927,18 @@ function validateDevelopmentSelfTestReport(fullText, developmentEvidenceSection,
     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 graphRequired = contract.graph_required === true || isRecord(contract.module_key_test_graph);
+    const moduleKeyTestGraph = (markdownSection(report, MODULE_KEY_TEST_GRAPH_TERMS) ?? evidenceFieldValue(report, "Module Key Test Graph") ?? "").trim();
+    if (graphRequired && (!moduleKeyTestGraph || isPlaceholderSelfTestReportValue(moduleKeyTestGraph))) {
+        errors.push(`${taskId} Development Self-Test Report must include Module Key Test Graph because self_test_contract graph is required or present 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}`);
     }
+    if (graphRequired && moduleKeyTestGraph && runnableEntry && !moduleKeyTestGraph.includes(runnableEntry)) {
+        errors.push(`${taskId} Development Self-Test Report Module Key Test Graph must include runnable entry ${runnableEntry} in ${implementationDoc}`);
+    }
     const scenarios = Array.isArray(contract.scenarios) ? contract.scenarios.filter(isRecord) : [];
     const exitEvidenceTerms = [
         String(contract.observable_exit ?? "").trim(),
@@ -1368,6 +1952,13 @@ function validateDevelopmentSelfTestReport(fullText, developmentEvidenceSection,
         && !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}`);
     }
+    if (graphRequired
+        && moduleKeyTestGraph
+        && exitEvidenceTerms.length > 0
+        && !exitEvidenceTerms.some((term) => normalizedIncludes(moduleKeyTestGraph, term))
+        && !containsAny(moduleKeyTestGraph, ["observable_exit", "observable exit", "exit", "出口"])) {
+        errors.push(`${taskId} Development Self-Test Report Module Key Test Graph 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)
@@ -1375,15 +1966,18 @@ function validateDevelopmentSelfTestReport(fullText, developmentEvidenceSection,
         if (!moduleKeyTestPath.includes(scenarioId)) {
             errors.push(`${taskId} Development Self-Test Report Module Key Test Path must include scenario ${scenarioId} in ${implementationDoc}`);
         }
+        if (graphRequired && moduleKeyTestGraph && !moduleKeyTestGraph.includes(scenarioId)) {
+            errors.push(`${taskId} Development Self-Test Report Module Key Test Graph 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}`);
+            errors.push(`${taskId} Development Self-Test Report must record scenario ${scenarioId} as PASS, BLOCKED, IN_PROGRESS, or STALE 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}`);
+            errors.push(`${taskId} Development Self-Test Report scenario ${scenarioId} must choose exactly one status in ${implementationDoc}`);
         }
-        else if (status === "BLOCKED") {
-            errors.push(`${taskId} Development Self-Test Report scenario ${scenarioId} is BLOCKED; keep task open or record a blocker`);
+        else if (status !== "PASS") {
+            errors.push(`${taskId} Development Self-Test Report scenario ${scenarioId} is ${status}; validate-dev cannot handoff until every scenario is PASS`);
         }
         errors.push(...validateScenarioTableEvidence(report, scenarioId, taskId, implementationDoc));
     }
@@ -1398,23 +1992,215 @@ function validateDevelopmentSelfTestReport(fullText, developmentEvidenceSection,
             errors.push(`${taskId} page Development Self-Test Report must include browser, Playwright, screenshot, or equivalent interaction evidence in ${implementationDoc}`);
         }
     }
+    if (highRiskRuntime) {
+        errors.push(...validateCurrentOperatorPath(fullText, taskId, implementationDoc));
+        errors.push(...validateGateBreakdown(fullText, taskId, implementationDoc));
+    }
+    return errors;
+}
+function normalizeSelfTestReportStatus(value) {
+    if (!value)
+        return undefined;
+    const normalized = value.replace(/`/g, "").trim().toUpperCase().replace(/[\s-]+/g, "_");
+    return SELF_TEST_REPORT_STATUSES.has(normalized) ? normalized : undefined;
+}
+function validateSelfTestReportBoundary(report, taskId, implementationDoc) {
+    const errors = [];
+    for (const line of report.split(/\r?\n/)) {
+        const fieldMatch = line.match(/^\s*[-*]\s*([^:]+)\s*:/);
+        if (fieldMatch) {
+            const field = fieldMatch[1].trim().toLowerCase();
+            const blockedField = SELF_TEST_REPORT_DISALLOWED_FIELD_TERMS.find((term) => field === term.toLowerCase());
+            if (blockedField) {
+                errors.push(`${taskId} Development Self-Test Report must not use ${blockedField}; put evidence bodies in an Evidence Index and reference them with Evidence Index Refs in ${implementationDoc}`);
+            }
+        }
+        const match = line.match(/^(#{1,6})\s+(.+)$/);
+        if (!match)
+            continue;
+        const title = match[2].trim().toLowerCase();
+        const blockedTerm = SELF_TEST_REPORT_DISALLOWED_SECTION_TERMS.find((term) => title.includes(term));
+        if (blockedTerm) {
+            errors.push(`${taskId} Development Self-Test Report must not include debug/operator/runbook/exploration log section "${match[2].trim()}" in ${implementationDoc}; link a runbook or exploration appendix instead`);
+        }
+    }
+    return errors;
+}
+function validateSelfTestReportLength(report, taskId, implementationDoc, highRiskRuntime) {
+    const limit = highRiskRuntime ? MAX_HIGH_RISK_SELF_TEST_REPORT_LINES : MAX_SELF_TEST_REPORT_LINES;
+    const lineCount = report.split(/\r?\n/).filter((line) => line.trim()).length;
+    if (lineCount <= limit)
+        return [];
+    return [
+        `${taskId} Development Self-Test Report must stay as a short handoff card (${limit} non-empty lines max); move logs, evidence bodies, runbook steps, and exploration history out of ${implementationDoc}`
+    ];
+}
+async function validateHighRiskRecoveryBoundaries(projectRoot, implementationText, plan, task, implementationDoc) {
+    if (!requiresResumeCapsule(task))
+        return [];
+    const taskId = String(task.id ?? "current task");
+    const errors = validateImplementationDocMainlineBoundary(implementationText, taskId, implementationDoc);
+    errors.push(...(await validateStrategyChangingDecisionPromotion(projectRoot, implementationText, plan, task, implementationDoc)));
+    return errors;
+}
+function validateImplementationDocMainlineBoundary(fullText, taskId, implementationDoc) {
+    const errors = [];
+    for (const line of fullText.split(/\r?\n/)) {
+        const match = line.match(/^(#{1,6})\s+(.+)$/);
+        if (!match)
+            continue;
+        const title = match[2].trim().toLowerCase();
+        const blockedTerm = IMPLEMENTATION_MAINLINE_DISALLOWED_SECTION_TERMS.find((term) => title.includes(term));
+        if (blockedTerm) {
+            errors.push(`${taskId} implementation_doc must not keep ${blockedTerm} as a mainline section in ${implementationDoc}; move it to a runbook, evidence index, exploration appendix, or external artifact`);
+        }
+    }
+    return errors;
+}
+async function validateStrategyChangingDecisionPromotion(projectRoot, implementationText, plan, task, implementationDoc) {
+    const taskId = String(task.id ?? "current task");
+    const capsule = isRecord(plan.resume_capsule) ? plan.resume_capsule : {};
+    const recoveryRefs = asStringList(capsule.recovery_refs);
+    const runbookTexts = await readExistingRunbookRefs(projectRoot, recoveryRefs);
+    const promotionText = [
+        asStringList(capsule.do_not_retry).join("\n"),
+        markdownSection(implementationText, CURRENT_OPERATOR_PATH_TERMS) ?? "",
+        ...runbookTexts.map((text) => markdownSection(text, HARD_CONSTRAINT_TERMS) ?? "")
+    ].join("\n");
+    const sourceText = [
+        asStringList(task.working_notes).join("\n"),
+        removeMarkdownSections(implementationText, CURRENT_OPERATOR_PATH_TERMS),
+        ...runbookTexts.map((text) => removeMarkdownSections(text, HARD_CONSTRAINT_TERMS))
+    ].join("\n");
+    const errors = [];
+    for (const [label, terms] of STRATEGY_CHANGING_DECISION_GROUPS) {
+        if (containsAny(sourceText, terms) && !containsAny(promotionText, terms)) {
+            errors.push(`${taskId} strategy-changing ${label} judgment appears outside promoted hard constraints; promote it to resume_capsule.do_not_retry, runbook Hard Constraints, or Current Operator Path in ${implementationDoc}`);
+        }
+    }
+    return errors;
+}
+async function readExistingRunbookRefs(projectRoot, refs) {
+    const texts = [];
+    for (const ref of refs) {
+        if (!ref.startsWith(RUNBOOK_DOC_PREFIX) || !ref.endsWith(".md"))
+            continue;
+        const fullPath = path.join(projectRoot, ref);
+        if (await pathExists(fullPath)) {
+            texts.push(await readText(fullPath));
+        }
+    }
+    return texts;
+}
+function removeMarkdownSections(text, headerTerms) {
+    const lines = text.split(/\r?\n/);
+    const kept = [];
+    let skippingLevel = 0;
+    for (const line of lines) {
+        const match = line.match(/^(#{1,6})\s+(.+)$/);
+        if (match) {
+            const level = match[1].length;
+            if (skippingLevel > 0 && level <= skippingLevel) {
+                skippingLevel = 0;
+            }
+            const title = match[2].toLowerCase();
+            if (skippingLevel === 0 && headerTerms.some((term) => title.includes(term.toLowerCase()))) {
+                skippingLevel = level;
+                continue;
+            }
+        }
+        if (skippingLevel === 0)
+            kept.push(line);
+    }
+    return kept.join("\n");
+}
+function validateCurrentOperatorPath(fullText, taskId, implementationDoc) {
+    const section = markdownSection(fullText, CURRENT_OPERATOR_PATH_TERMS);
+    if (!section) {
+        return [`${taskId} high-risk runtime task must include a short Current Operator Path section in ${implementationDoc}`];
+    }
+    const errors = [];
+    const requiredFields = [
+        ["canonical operator path", ["Canonical operator path", "Canonical path"]],
+        ["runbook link", ["Operator runbook", "Runbook"]],
+        ["credential reference name", ["Credential reference", "Credential reference name"]],
+        ["command/UI channel", ["Command/UI channel", "Command channel", "UI channel"]],
+        ["do-not-retry summary", ["Do-not-retry summary", "Do not retry summary"]],
+        ["hard constraints", ["Hard Constraints", "Hard Constraint", "Strategy Constraints", "Strategy Constraint"]]
+    ];
+    for (const [label, fields] of requiredFields) {
+        const value = fields.map((field) => evidenceFieldValue(section, field)).find((candidate) => candidate && candidate.trim());
+        if (!value) {
+            errors.push(`${taskId} Current Operator Path must record ${label} in ${implementationDoc}`);
+        }
+        else if (label !== "credential reference name" && isPlaceholderEvidence(value)) {
+            errors.push(`${taskId} Current Operator Path ${label} must be concrete in ${implementationDoc}`);
+        }
+    }
+    const runbookValue = evidenceFieldValue(section, "Operator runbook") ?? evidenceFieldValue(section, "Runbook") ?? section;
+    if (!runbookValue.includes(RUNBOOK_DOC_PREFIX)) {
+        errors.push(`${taskId} Current Operator Path must link a runbook/evidence document under ${RUNBOOK_DOC_PREFIX} in ${implementationDoc}`);
+    }
+    if (!containsAny(section, HARD_CONSTRAINT_TERMS)) {
+        errors.push(`${taskId} Current Operator Path must promote strategy-changing recovery decisions as Hard Constraints in ${implementationDoc}`);
+    }
+    return errors;
+}
+function validateGateBreakdown(fullText, taskId, implementationDoc) {
+    const section = markdownSection(fullText, GATE_BREAKDOWN_TERMS);
+    if (!section) {
+        return [`${taskId} high-risk runtime task Development Self-Test Report must include Gate Breakdown in ${implementationDoc}`];
+    }
+    const errors = [];
+    const lowered = section.toLowerCase();
+    for (const [label, terms] of GATE_BREAKDOWN_LAYER_GROUPS) {
+        if (!containsAny(lowered, terms)) {
+            errors.push(`${taskId} Gate Breakdown must include ${label} status/evidence in ${implementationDoc}`);
+        }
+    }
+    const rows = markdownTableRows(section).filter((cells) => !cells.some((cell) => /gate layer|layer|层级/i.test(cell)));
+    const concreteRows = rows.filter((cells) => cells.some((cell) => !isPlaceholderSelfTestReportValue(cell)));
+    if (concreteRows.length < 2) {
+        errors.push(`${taskId} Gate Breakdown must split evidence into multiple concrete gate layers in ${implementationDoc}`);
+    }
+    if (concreteRows.length <= 1 && lowered.includes("validate-dev")) {
+        errors.push(`${taskId} Gate Breakdown cannot collapse high-risk runtime progress into only validate-dev in ${implementationDoc}`);
+    }
     return errors;
 }
 function scenarioStatus(text, scenarioId) {
     const escaped = scenarioId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     const pattern = new RegExp("^.*" + escaped + ".*$", "gim");
+    const seen = new Set();
     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;
+        const status = selfTestLineStatus(match[0]);
+        if (status === "AMBIGUOUS")
+            return status;
+        if (status)
+            seen.add(status);
+    }
+    if (seen.size > 1)
+        return "AMBIGUOUS";
+    return [...seen][0];
+}
+function selfTestLineStatus(line) {
+    const normalized = line.toUpperCase().replace(/\bIN[\s-]+PROGRESS\b/g, "IN_PROGRESS");
+    const matches = [];
+    if (hasStatusToken(normalized, "PASS"))
+        matches.push("PASS");
+    if (hasStatusToken(normalized, "BLOCKED"))
+        matches.push("BLOCKED");
+    if (hasStatusToken(normalized, "IN_PROGRESS"))
+        matches.push("IN_PROGRESS");
+    if (hasStatusToken(normalized, "STALE"))
+        matches.push("STALE");
+    if (matches.length > 1)
+        return "AMBIGUOUS";
+    return matches[0];
+}
+function hasStatusToken(line, status) {
+    const escaped = status.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    return new RegExp(`(^|[^A-Z0-9_])${escaped}([^A-Z0-9_]|$)`).test(line);
 }
 function validateScenarioTableEvidence(report, scenarioId, taskId, implementationDoc) {
     const errors = [];
@@ -1434,8 +2220,12 @@ function validateScenarioTableEvidence(report, scenarioId, taskId, implementatio
                 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}`);
+        const tableStatus = result ? scenarioStatus(`| ${cells.join(" | ")} |`, scenarioId) : undefined;
+        if (tableStatus === "AMBIGUOUS") {
+            errors.push(`${taskId} Development Self-Test Report scenario ${scenarioId} table Result must choose exactly one status in ${implementationDoc}`);
+        }
+        else if (tableStatus && tableStatus !== "PASS") {
+            errors.push(`${taskId} Development Self-Test Report scenario ${scenarioId} table Result is ${tableStatus}; validate-dev cannot handoff until every scenario is PASS`);
         }
     }
     return errors;