coding-agent-harness 1.0.2 → 1.0.5

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

@@ -0,0 +1,230 @@
+import fs from "node:fs";
+import path from "node:path";
+import { walkFiles } from "./core-shared.mjs";
+
+function stripMarkdownCode(value) {
+  return String(value || "").replace(/`/g, "").trim();
+}
+
+function modulePromptBlock(content, key) {
+  const heading = `## Module: ${key}`;
+  const start = content.indexOf(heading);
+  if (start < 0) return "";
+  const rest = content.slice(start + heading.length);
+  const next = rest.search(/\n## Module: /);
+  return next >= 0 ? rest.slice(0, next) : rest;
+}
+
+function listModuleTaskPlans({ targetRoot, rel, filePath }) {
+  const modulesRoot = filePath("docs/09-PLANNING/MODULES");
+  if (!fs.existsSync(modulesRoot)) return [];
+  return walkFiles(modulesRoot, {
+    dirFilter: (_dirName, fullPath) => {
+      const relativePath = rel(path.relative(targetRoot, fullPath));
+      return !relativePath.includes("/_archive/") && !relativePath.endsWith("/_task-template");
+    },
+  })
+    .map((file) => rel(path.relative(targetRoot, file)))
+    .filter((relativePath) => /\/TASKS\/[^/]+\/task_plan\.md$/.test(relativePath));
+}
+
+function parseModuleTaskPath(taskPlanPath) {
+  const match = taskPlanPath.match(/^docs\/09-PLANNING\/MODULES\/([^/]+)\/TASKS\/([^/]+)\/task_plan\.md$/);
+  if (!match) return null;
+  return { moduleKey: match[1], taskDir: match[2] };
+}
+
+function extractStepId(taskPlanContent, taskDir) {
+  const fromPlan = taskPlanContent.match(/^- Step ID:\s*`?([A-Z]{2,5}-\d{2})`?/m);
+  if (fromPlan) return fromPlan[1];
+  const fromModuleSection = taskPlanContent.match(/^- Step:\s*`?([A-Z]{2,5}-\d{2})`?/m);
+  if (fromModuleSection) return fromModuleSection[1];
+  const fromDir = taskDir.match(/^([A-Z]{2,5}-\d{2})-/);
+  return fromDir ? fromDir[1] : "";
+}
+
+function readTaskProgress(taskPlanPath, { exists, read }) {
+  const progressPath = taskPlanPath.replace(/task_plan\.md$/, "progress.md");
+  return exists(progressPath) ? read(progressPath) : "";
+}
+
+function normalizeModuleTaskStatus(status) {
+  const value = String(status || "").trim().toLowerCase();
+  const aliases = new Map([
+    ["未开始", "not-started"],
+    ["未启动", "not-started"],
+    ["进行中", "in-progress"],
+    ["开发中", "in-progress"],
+    ["规划审查", "planning-review"],
+    ["已完成", "completed"],
+    ["完成", "completed"],
+    ["已关闭", "closed"],
+    ["关闭", "closed"],
+    ["已阻塞", "blocked"],
+    ["阻塞", "blocked"],
+  ]);
+  return aliases.get(value) || value;
+}
+
+function readTaskProgressStatus(taskPlanPath, context) {
+  const progress = readTaskProgress(taskPlanPath, context);
+  if (!progress) return "";
+  const match = progress.match(/^##\s*(?:Status|状态)\s*[:：]?\s*(?:\n\s*)?([^\n]+)/im);
+  return match ? normalizeModuleTaskStatus(stripMarkdownCode(match[1])) : "";
+}
+
+function isActiveModuleTaskStatus(status) {
+  if (!status) return false;
+  return !new Set([
+    "not-started",
+    "blocked-not-started",
+    "complete",
+    "completed",
+    "closed",
+    "closed-with-residual",
+    "closed-local-only",
+    "superseded",
+  ]).has(status);
+}
+
+function hasPendingCoordinatorHandoff(taskPlanContent, progressContent) {
+  const combined = `${taskPlanContent}\n${progressContent}`;
+  return /Coordinator Handoff/i.test(combined) && /pending-coordinator-pass/i.test(combined);
+}
+
+function checkModuleTaskSsotIndex(registryRows, context) {
+  const { exists, read, fail, warn, requireGlobalModuleSync } = context;
+  const registryByModule = new Map(registryRows.map((cells) => [cells[0], cells]));
+  const ledgerContent = exists("docs/Harness-Ledger.md") ? read("docs/Harness-Ledger.md") : "";
+  const taskPlans = listModuleTaskPlans(context);
+
+  for (const taskPlanPath of taskPlans) {
+    const parsed = parseModuleTaskPath(taskPlanPath);
+    if (!parsed) continue;
+    const { moduleKey, taskDir } = parsed;
+    const modulePlanPath = `docs/09-PLANNING/MODULES/${moduleKey}/module_plan.md`;
+    if (!exists(modulePlanPath)) continue;
+
+    const taskPlan = read(taskPlanPath);
+    const taskProgress = readTaskProgress(taskPlanPath, context);
+    const taskProgressStatus = readTaskProgressStatus(taskPlanPath, context);
+    const taskIsActive = isActiveModuleTaskStatus(taskProgressStatus);
+    const stepId = extractStepId(taskPlan, taskDir);
+    if (!stepId) {
+      if (taskIsActive) {
+        fail(`${taskPlanPath} does not expose a Step ID and task directory does not start with <PREFIX-NN>`);
+      }
+      continue;
+    }
+
+    const modulePlan = read(modulePlanPath);
+    const moduleRelativeTaskPlan = `TASKS/${taskDir}/task_plan.md`;
+    if (!modulePlan.includes(stepId) || !modulePlan.includes(moduleRelativeTaskPlan)) {
+      fail(`${modulePlanPath} does not index ${stepId} task plan ${moduleRelativeTaskPlan}`);
+    }
+
+    if (!taskIsActive) continue;
+
+    const registryRow = registryByModule.get(moduleKey);
+    const reviewPath = taskPlanPath.replace(/task_plan\.md$/, "review.md");
+    const registrySynced = Boolean(registryRow && registryRow[4] === stepId);
+    const ledgerSynced = ledgerContent.includes(taskPlanPath) && (!exists(reviewPath) || ledgerContent.includes(reviewPath));
+    if (registrySynced && ledgerSynced) continue;
+
+    if (requireGlobalModuleSync) {
+      if (!registryRow) {
+        fail(`docs/09-PLANNING/Module-Registry.md does not include active module ${moduleKey} for ${taskPlanPath}`);
+      } else if (registryRow[4] !== stepId) {
+        fail(`docs/09-PLANNING/Module-Registry.md row ${moduleKey} current step is ${registryRow[4]}, but active task is ${stepId}`);
+      }
+      if (!ledgerContent.includes(taskPlanPath)) {
+        fail(`docs/Harness-Ledger.md does not index active module task plan ${taskPlanPath}`);
+      }
+      if (exists(reviewPath) && !ledgerContent.includes(reviewPath)) {
+        fail(`docs/Harness-Ledger.md does not index active module review ${reviewPath}`);
+      }
+      continue;
+    }
+
+    if (hasPendingCoordinatorHandoff(taskPlan, taskProgress)) {
+      warn(`${taskPlanPath} has pending coordinator handoff; run coordinator pass before final integration or set HARNESS_REQUIRE_GLOBAL_MODULE_SYNC=1 for strict gate`);
+      continue;
+    }
+    fail(`${taskPlanPath} is active but is neither globally synced nor marked with Coordinator Handoff: pending-coordinator-pass`);
+  }
+}
+
+export function checkModuleParallelStructure(context) {
+  const { exists, read, fail, requireFile, markdownTable } = context;
+  if (!exists("docs/09-PLANNING/Module-Registry.md")) return;
+
+  requireFile("docs/09-PLANNING/MODULES/Session-Prompt-Pack.md");
+  const hasPromptPack = exists("docs/09-PLANNING/MODULES/Session-Prompt-Pack.md");
+  for (const templateFile of [
+    "docs/09-PLANNING/MODULES/_task-template/task_plan.md",
+    "docs/09-PLANNING/MODULES/_task-template/progress.md",
+    "docs/09-PLANNING/MODULES/_task-template/findings.md",
+    "docs/09-PLANNING/MODULES/_task-template/review.md",
+  ]) {
+    requireFile(templateFile);
+  }
+
+  const registryContent = read("docs/09-PLANNING/Module-Registry.md");
+  for (const term of ["PREFIX", "Current Step", "Status", "Write Scope"]) {
+    if (!registryContent.includes(term)) {
+      fail(`docs/09-PLANNING/Module-Registry.md missing registry column or section: ${term}`);
+    }
+  }
+
+  const registryRows = markdownTable(registryContent)
+    .filter((cells) => cells.length >= 6)
+    .filter((cells) => /^(_shared|[a-z][a-z0-9-]*)$/.test(cells[0] || "") && /^[A-Z]{2,5}$/.test(cells[2] || ""));
+
+  if (registryRows.length === 0) {
+    fail("docs/09-PLANNING/Module-Registry.md has no active module rows");
+  }
+
+  const promptPack = hasPromptPack ? read("docs/09-PLANNING/MODULES/Session-Prompt-Pack.md") : "";
+  if (hasPromptPack && !/Subagent Worker Invariant|worker[\s\S]{0,120}worktree[\s\S]{0,120}commit SHA/i.test(promptPack)) {
+    fail("docs/09-PLANNING/MODULES/Session-Prompt-Pack.md missing subagent worker worktree/commit handoff rule");
+  }
+  for (const cells of registryRows) {
+    const [key, , prefix, branch, currentStep, status] = cells;
+    requireFile(`docs/09-PLANNING/MODULES/${key}/module_plan.md`);
+    if (!/^(planned|in-progress|paused|completed)$/.test(status)) {
+      fail(`docs/09-PLANNING/Module-Registry.md row ${key} has invalid status: ${status}`);
+    }
+    if (currentStep !== `${prefix}-00` && !currentStep.startsWith(`${prefix}-`)) {
+      fail(`docs/09-PLANNING/Module-Registry.md row ${key} current step does not match prefix ${prefix}: ${currentStep}`);
+    }
+    const branchName = stripMarkdownCode(branch);
+    if (!branchName.startsWith("codex/")) {
+      fail(`docs/09-PLANNING/Module-Registry.md row ${key} branch must use codex/ prefix: ${branch}`);
+    }
+
+    const block = modulePromptBlock(promptPack, key);
+    if (!block) {
+      if (!exists(`docs/09-PLANNING/MODULES/${key}/session_prompt.md`)) {
+        fail(`missing module session prompt for ${key}`);
+      }
+      continue;
+    }
+    for (const term of [
+      "Current Step",
+      branchName,
+      "Preflight:",
+      "Before code edits:",
+      "Write scope:",
+      "Forbidden without coordination:",
+      "Shared Coordination:",
+      "Verification:",
+      "Closeout:",
+      "Stop conditions:",
+    ]) {
+      if (!block.includes(term)) {
+        fail(`module session prompt for ${key} missing required term: ${term}`);
+      }
+    }
+  }
+  checkModuleTaskSsotIndex(registryRows, context);
+}

package/scripts/lib/check-profiles.mjs

@@ -6,7 +6,6 @@ import {
   legacyChecker,
   visualMapFile,
   legacyVisualRoadmapFile,
-  lessonCandidatesFile,
   allowedReviewDispositions,
   allowedPhaseStates,
   allowedEvidenceStatus,
@@ -23,19 +22,20 @@ import {
   firstColumn,
   contentHasAny,
 } from "./markdown-utils.mjs";
-import {
-  capabilityDefinitions,
-  validateCapabilities,
-} from "./capability-registry.mjs";
-import {
-  collectTasks,
-  listTaskPlanPaths,
-  parseTaskBudget,
-  parseTaskContractInfo,
-  readVisualMapContractFile,
-  parsePhases,
-  taskCutoverCounters,
-} from "./task-scanner.mjs";
+import { validateCapabilities } from "./capability-registry.mjs";
+import { readPresetPackage } from "./preset-registry.mjs";
+import { validateTaskPresetAuditSnapshot } from "./preset-audit-contracts.mjs";
+import { validatePresetResourcesForTask } from "./preset-resource-contracts.mjs";
+import { collectTasks, listTaskPlanPaths, parseTaskBudget, readVisualMapContractFile, parsePhases } from "./task-scanner.mjs";
+import { normalizeReviewBoolean, reviewFindingColumns } from "./task-review-model.mjs";
+import { allowedPhaseActors, allowedPhaseKinds } from "./phase-kind.mjs";
+import { validateTaskCompletionConsistency } from "./task-completion-consistency.mjs";
+import { validatePlanContracts } from "./check-task-contracts.mjs";
+import { validateGovernanceTableBoundaries } from "./governance-table-boundary.mjs";
+import { validateSubagentAuthorization } from "./subagent-authorization-audit.mjs";
+import { summarizeGitState } from "./git-status-summary.mjs";
+import { buildStatusData } from "./status-builder.mjs";
+export { renderDashboard } from "./status-dashboard-renderer.mjs";
 
 export function runLegacyCheck(target) {
   const checkTarget = target.docsOnly ? target.projectRoot : target.input;
@@ -94,10 +94,10 @@ export function validateReviewSchema(target, { strict = true } = {}) {
     }
     const { header, rows } = tableAfterHeading(content, /^ID$/i);
     if (rows.length === 0) continue;
-    const severityIndex = getColumnAny(header, ["Severity", "严重级别"]);
-    const openIndex = getColumnAny(header, ["Open", "是否开放"]);
-    const dispositionIndex = getColumnAny(header, ["Disposition", "处置"]);
-    const blocksIndex = getColumnAny(header, ["Blocks Release", "是否阻塞发布"]);
+    const severityIndex = getColumnAny(header, reviewFindingColumns.severity);
+    const openIndex = getColumnAny(header, reviewFindingColumns.open);
+    const dispositionIndex = getColumnAny(header, reviewFindingColumns.disposition);
+    const blocksIndex = getColumnAny(header, reviewFindingColumns.blocksRelease);
     const followUpIndex = getColumnAny(header, ["Follow-up", "跟进"]);
     const evidenceCheckedIndex = getColumnAny(header, ["Evidence Checked", "已检查证据"]);
     if ([severityIndex, openIndex, dispositionIndex, blocksIndex].some((index) => index < 0)) {
@@ -108,9 +108,9 @@ export function validateReviewSchema(target, { strict = true } = {}) {
       const id = row[0] || "";
       const severity = row[severityIndex] || "";
       if (!/^P[0-3]$/.test(severity) && !/^(R|SR)-\d+/i.test(id)) continue;
-      const open = (row[openIndex] || "").toLowerCase();
+      const open = normalizeReviewBoolean(row[openIndex] || "");
       const disposition = (row[dispositionIndex] || "").toLowerCase();
-      const blocks = (row[blocksIndex] || "").toLowerCase();
+      const blocks = normalizeReviewBoolean(row[blocksIndex] || "");
       const followUp = row[followUpIndex] || "";
       if (!/^P[0-3]$/.test(severity)) report(`${relative} ${id} invalid severity: ${severity}`);
       if (!["yes", "no"].includes(open)) report(`${relative} ${id} invalid Open value: ${open}`);
@@ -128,18 +128,19 @@ export function validateReviewSchema(target, { strict = true } = {}) {
         for (const ref of refs) {
           if (ref !== "none" && /^E-\d+/i.test(ref) && !evidenceIds.has(ref)) {
             failures.push(`${relative} ${id} references missing evidence id: ${ref}`);
-          }
-        }
       }
     }
   }
+}
+
+  }
   return { failures, warnings };
 }
 
-export function validateVisualMaps(target) {
+export function validateVisualMaps(target, { taskPlanPaths } = {}) {
   const failures = [];
   const warnings = [];
-  for (const taskPlanPath of listTaskPlanPaths(target)) {
+  for (const taskPlanPath of taskPlanPaths || listTaskPlanPaths(target)) {
     const taskDir = path.dirname(taskPlanPath);
     const visualMapPath = path.join(taskDir, visualMapFile);
     const legacyPath = path.join(taskDir, legacyVisualRoadmapFile);
@@ -153,7 +154,10 @@ export function validateVisualMaps(target) {
       }
     }
     const phases = parsePhases(visualMap.content);
+    const budget = parseTaskBudget(taskPlan);
     for (const phase of phases) {
+      if (!allowedPhaseKinds.has(phase.kind)) failures.push(`${relative} phase ${phase.id} invalid kind: ${phase.kind}`);
+      if (!allowedPhaseActors.has(phase.actor)) failures.push(`${relative} phase ${phase.id} invalid actor: ${phase.actor}`);
       if (!allowedPhaseStates.has(phase.state)) failures.push(`${relative} phase ${phase.id} invalid state: ${phase.state}`);
       if (!allowedEvidenceStatus.has(phase.evidenceStatus)) {
         failures.push(`${relative} phase ${phase.id} invalid evidence status: ${phase.evidenceStatus}`);
@@ -168,6 +172,9 @@ export function validateVisualMaps(target) {
       failures.push(`${relative} missing Visual Map Contract: v1.0`);
     }
     if (visualMap.source === "canonical" && phases.length === 0) warnings.push(`${relative} has no Visual Map phase table`);
+    if (visualMap.source === "canonical" && budget !== "simple" && phases.length > 0 && !phases.some((phase) => phase.kind === "execution" && phase.state !== "skipped")) {
+      failures.push(`${relative} requires at least one non-skipped execution phase`);
+    }
     if (visualMap.source === "legacy" && fs.existsSync(legacyPath)) {
       warnings.push(`${relative} missing; legacy visual_roadmap.md is rewrite input only`);
     } else if (visualMap.source === "legacy" && phases.length > 0) {
@@ -177,34 +184,7 @@ export function validateVisualMaps(target) {
   return { failures, warnings };
 }
 
-export function validatePlanContracts(target, { strict = true } = {}) {
-  const failures = [];
-  const warnings = [];
-  const report = (message) => {
-    if (strict) failures.push(message);
-    else warnings.push(`adoption-needed: ${message}`);
-  };
-  for (const taskPlanPath of listTaskPlanPaths(target)) {
-    const taskDir = path.dirname(taskPlanPath);
-    const relativeDir = toPosix(path.relative(target.projectRoot, taskDir));
-    const taskPlanContent = readFileSafe(taskPlanPath);
-    const budget = parseTaskBudget(taskPlanContent);
-    const taskContract = parseTaskContractInfo(taskPlanContent);
-    if (!taskContract.generated) {
-      warnings.push(`adoption-needed: ${relativeDir} missing Task Contract: harness-task/v1 marker`);
-    }
-    const requiredFiles = budget === "simple" ? [visualMapFile] : ["execution_strategy.md", visualMapFile, lessonCandidatesFile];
-    for (const fileName of requiredFiles) {
-      if (!fs.existsSync(path.join(taskDir, fileName))) {
-        if (taskContract.generated) failures.push(`${relativeDir} missing ${fileName}`);
-        else report(`${relativeDir} missing ${fileName}`);
-      }
-    }
-  }
-  return { failures, warnings };
-}
-
-export function validateTaskPresetContracts(target) {
+export function validateTaskPresetContracts(target, { tasks } = {}) {
   const failures = [];
   const allowedMigrationLevels = new Set([
     "migration-baseline",
@@ -212,15 +192,40 @@ export function validateTaskPresetContracts(target) {
     "migration-full-cutover",
     "migration-deferred",
   ]);
-  for (const task of collectTasks(target)) {
+  for (const task of tasks || collectTasks(target)) {
     if (!task.taskPreset || task.taskPreset === "none") continue;
+    let presetPackage = null;
+    try {
+      presetPackage = readPresetPackage(task.taskPreset, { targetInput: target.projectRoot });
+    } catch (error) {
+      failures.push(`${task.path} unsupported Task Preset: ${task.taskPreset} (${error.message})`);
+      continue;
+    }
+    if (presetPackage?.task?.kind && task.taskKind !== presetPackage.task.kind) {
+      failures.push(`${task.path} ${task.taskPreset} preset Task Kind mismatch: expected ${presetPackage.task.kind}, got ${task.taskKind || "(missing)"}`);
+    }
+    if (String(task.presetVersion || "") !== String(presetPackage.version)) {
+      failures.push(`${task.path} ${task.taskPreset} preset missing Preset Version ${presetPackage.version}`);
+    }
+    if (task.taskPreset !== "lesson-sedimentation" && (presetPackage.evidence?.bundleDir || presetPackage.audit?.evidenceFiles?.length || Object.keys(presetPackage.evidence?.files || {}).length)) {
+      if (!task.evidenceBundle) failures.push(`${task.path} ${task.taskPreset} preset missing Evidence Bundle`);
+      else if (!fs.existsSync(path.join(target.projectRoot, String(task.evidenceBundle).replace(/^TARGET:/, "").replace(/^\/+/, "")))) {
+        failures.push(`${task.path} ${task.taskPreset} preset Evidence Bundle missing: ${task.evidenceBundle}`);
+      }
+    }
+    if (task.taskPreset !== "lesson-sedimentation") {
+      failures.push(...validateTaskPresetAuditSnapshot(target, task, presetPackage));
+    }
+    failures.push(...validatePresetResourcesForTask(target, task, presetPackage));
+    if (task.taskPreset === "lesson-sedimentation") {
+      if (!["standard", "complex"].includes(task.budget)) failures.push(`${task.path} lesson-sedimentation preset requires Selected budget: standard or complex`);
+      if (!task.taskPlanPath) failures.push(`${task.path} lesson-sedimentation preset missing task plan`);
+      continue;
+    }
     if (task.taskPreset !== "legacy-migration") {
-      failures.push(`${task.path} unsupported Task Preset: ${task.taskPreset}`);
       continue;
     }
     if (task.budget !== "complex") failures.push(`${task.path} legacy-migration preset requires Selected budget: complex`);
-    if (!task.presetVersion) failures.push(`${task.path} legacy-migration preset missing Preset Version`);
-    if (!task.taskKind || task.taskKind === "general") failures.push(`${task.path} legacy-migration preset missing Task Kind`);
     if (!allowedMigrationLevels.has(task.migrationTargetLevel)) {
       failures.push(`${task.path} legacy-migration preset invalid Migration Target Level: ${task.migrationTargetLevel || "(missing)"}`);
     }
@@ -228,9 +233,7 @@ export function validateTaskPresetContracts(target) {
     if (achievedLevel !== "pending" && !allowedMigrationLevels.has(achievedLevel)) {
       failures.push(`${task.path} legacy-migration preset invalid Migration Achieved Level: ${achievedLevel || "(missing)"}`);
     }
-    if (!task.evidenceBundle) {
-      failures.push(`${task.path} legacy-migration preset missing Evidence Bundle`);
-    } else if (!task.migrationSnapshot?.evidencePresent) {
+    if (task.evidenceBundle && !task.migrationSnapshot?.evidencePresent) {
       failures.push(`${task.path} legacy-migration preset Evidence Bundle missing: ${task.evidenceBundle}`);
     } else if (!task.migrationSnapshot?.sessionPresent) {
       failures.push(`${task.path} legacy-migration preset Evidence Bundle missing session.json`);
@@ -315,196 +318,55 @@ export function validateContextDocs(target, { strict = true } = {}) {
 
 export function buildStatus(targetInput, options = {}) {
   const target = normalizeTarget(targetInput);
+  const gitState = summarizeGitState(target);
   const capabilityState = validateCapabilities(target);
   const declaredCapabilities = new Set(capabilityState.registry.capabilities.map((capability) => capability.name));
   const safeAdoptionMode = declaredCapabilities.has("safe-adoption");
   const shouldRunLegacy = !options.skipLegacyCheck && (capabilityState.registry.mode === "legacy-compat" || safeAdoptionMode);
   const legacy = shouldRunLegacy ? runLegacyCheck(target) : { status: "skipped", code: 0, stdout: "", stderr: "" };
   const contractStrict = Boolean(options.strict) || (capabilityState.registry.mode !== "legacy-compat" && !safeAdoptionMode);
+  const taskPlanPaths = listTaskPlanPaths(target);
+  const closeoutContent = readFileSafe(path.join(target.docsRoot, "10-WALKTHROUGH/Closeout-SSoT.md"));
+  const tasks = collectTasks(target, { requireGeneratedScaffoldProvenance: contractStrict, taskPlanPaths, closeoutContent });
   const reviews = validateReviewSchema(target, { strict: contractStrict });
-  const visualMaps = validateVisualMaps(target);
-  const planContracts = validatePlanContracts(target, { strict: contractStrict });
-  const presetContracts = validateTaskPresetContracts(target);
+  const visualMaps = validateVisualMaps(target, { taskPlanPaths });
+  const planContracts = validatePlanContracts(target, { strict: contractStrict, taskPlanPaths });
+  const presetContracts = validateTaskPresetContracts(target, { tasks });
   const contextDocs = validateContextDocs(target, { strict: contractStrict });
-  const failures = [...capabilityState.failures, ...reviews.failures, ...visualMaps.failures, ...planContracts.failures, ...presetContracts.failures, ...contextDocs.failures];
-  const warnings = [...capabilityState.warnings, ...reviews.warnings, ...visualMaps.warnings, ...planContracts.warnings, ...presetContracts.warnings, ...contextDocs.warnings];
+  const governanceBoundaries = validateGovernanceTableBoundaries(target);
+  const subagentAuthorization = validateSubagentAuthorization(target, { strict: contractStrict });
+  const failures = [...capabilityState.failures, ...reviews.failures, ...visualMaps.failures, ...planContracts.failures, ...presetContracts.failures, ...contextDocs.failures, ...governanceBoundaries.failures, ...subagentAuthorization.failures];
+  const warnings = [...capabilityState.warnings, ...reviews.warnings, ...visualMaps.warnings, ...planContracts.warnings, ...presetContracts.warnings, ...contextDocs.warnings, ...governanceBoundaries.warnings, ...subagentAuthorization.warnings, ...gitState.warnings];
   if (legacy.status === "fail") {
     if (options.strictLegacy) failures.push("legacy check failed");
     else warnings.push(`adoption-needed: legacy check failed: ${(legacy.stderr || legacy.stdout).trim()}`);
   }
 
-  const tasks = collectTasks(target);
+  const taskCompletionConsistency = validateTaskCompletionConsistency(tasks);
+  failures.push(...taskCompletionConsistency.failures);
+  warnings.push(...taskCompletionConsistency.warnings);
   const briefReady = tasks.filter((task) => task.briefSource === "standalone").length;
   const briefMissing = tasks.length - briefReady;
   for (const task of tasks) {
+    for (const issue of task.materialIssues || []) {
+      if (!String(issue.code || "").startsWith("missing-task-audit") && !String(issue.code || "").startsWith("legacy-")) continue;
+      const message = `${String(issue.sourcePath || task.path).replace(/^TARGET:/, "")} ${issue.message}`;
+      if (contractStrict || options.strictLegacy) failures.push(message);
+      else warnings.push(`adoption-needed: ${message}`);
+    }
     if (task.stateSource === "invalid") {
       const message = `${task.path}/progress.md invalid task state: ${task.stateRaw}`;
       if (contractStrict || options.strictLegacy) failures.push(message);
       else warnings.push(`adoption-needed: ${message}`);
     }
   }
-  const capabilityNames = new Map(capabilityState.registry.capabilities.map((capability) => [capability.name, capability]));
-  for (const detected of capabilityState.detected) {
-    if (!capabilityNames.has(detected)) capabilityNames.set(detected, { name: detected, state: "configured" });
-  }
-  const cutoverCounters = taskCutoverCounters(tasks);
-  const fullCutoverEligible =
-    failures.length === 0 &&
-    warnings.length === 0 &&
-    cutoverCounters.legacyVisualOnlyCount === 0 &&
-    cutoverCounters.unknownClassificationCount === 0 &&
-    cutoverCounters.weakBriefCount === 0 &&
-    cutoverCounters.missingCanonicalVisualMapCount === 0;
-
-  return {
-    project: {
-      name: path.basename(target.projectRoot),
-      root: `TARGET:${target.docsOnly ? toPosix(path.relative(target.projectRoot, target.docsRoot)) : "."}`,
-      docsOnly: target.docsOnly,
-    },
-    schemaVersion: 2,
-    generatedAt: new Date().toISOString(),
-    mode: capabilityState.registry.mode,
-    checkState: {
-      status: failures.length > 0 ? "fail" : warnings.length > 0 ? "warn" : "pass",
-      failures: failures.length,
-      warnings: warnings.length,
-      details: { failures, warnings },
-      legacy,
-    },
-    summary: {
-      tasks: tasks.length,
-      briefCoverage: {
-        ready: briefReady,
-        missing: briefMissing,
-        total: tasks.length,
-      },
-      visualMapCoverage: {
-        canonical: tasks.filter((task) => task.visualMapSource === "canonical").length,
-        legacyOnly: cutoverCounters.legacyVisualOnlyCount,
-        missing: tasks.filter((task) => task.visualMapStatus === "missing").length,
-        total: tasks.length,
-      },
-      fullCutoverEligible,
-      legacyVisualOnlyCount: cutoverCounters.legacyVisualOnlyCount,
-      unknownClassificationCount: cutoverCounters.unknownClassificationCount,
-      weakBriefCount: cutoverCounters.weakBriefCount,
-      visualMapRequiredCount: cutoverCounters.visualMapRequiredCount,
-      missingCanonicalVisualMapCount: cutoverCounters.missingCanonicalVisualMapCount,
-    },
-    capabilities: [...capabilityNames.values()].map((capability) => ({
-      name: capability.name,
-      state: capability.state || "configured",
-      dependencyStatus: capabilityDefinitions[capability.name]?.dependencies.every((dependency) => capabilityNames.has(dependency))
-        ? "valid"
-        : "invalid",
-      warnings: capabilityState.warnings.filter((warning) => warning.includes(capability.name)),
-    })),
+  return buildStatusData(target, {
+    capabilityState,
+    gitState,
+    legacy,
+    failures,
+    warnings,
     tasks,
-    handoffs: tasks.flatMap((task) => task.handoffs || []),
-    recentActivity: tasks.slice(0, 8).map((task) => ({ at: new Date().toISOString(), type: "task", summary: task.title })),
-  };
-}
-
-export function renderDashboard(status) {
-  const taskCards = status.tasks
-    .map((task) => {
-      const phases = task.phases
-        .map(
-          (phase) => `<div class="phase ${escapeHtml(phase.state)}">
-            <div class="phase-top"><strong>${escapeHtml(phase.id)}</strong><span>${phase.completion}%</span></div>
-            <div class="phase-output">${escapeHtml(phase.output)}</div>
-            <div class="meter"><i style="width:${phase.completion}%"></i></div>
-            <div class="muted">${escapeHtml(phase.state)} · evidence ${escapeHtml(phase.evidenceStatus)}</div>
-          </div>`,
-        )
-        .join("");
-      const risks = task.risks
-        .map((risk) => `<span class="risk ${risk.open || risk.blocksRelease ? "open" : ""}">${escapeHtml(risk.severity)} ${escapeHtml(risk.summary)}</span>`)
-        .join("");
-      const evidence = task.evidence
-        .map((item) => `<span class="evidence">${escapeHtml(item.type)} · ${escapeHtml(item.summary)}</span>`)
-        .join("");
-      const evidenceMeter = evidenceCompletion(task.phases);
-      return `<section class="task">
-        <div class="task-head">
-          <div><h2>${escapeHtml(task.title)}</h2><p>${escapeHtml(task.path)}</p></div>
-          <div class="score">${task.completion}%</div>
-        </div>
-        <div class="meter"><i style="width:${task.completion}%"></i></div>
-        <div class="phases">${phases || '<div class="empty">No phase table</div>'}</div>
-        <div class="evidence-row"><strong>Evidence</strong><div class="meter small"><i style="width:${evidenceMeter}%"></i></div>${evidence || '<span class="empty">No evidence</span>'}</div>
-        <div class="risks">${risks || '<span class="ok">No open visual risk</span>'}</div>
-      </section>`;
-    })
-    .join("");
-  const chips = status.capabilities
-    .map((capability) => `<span class="chip ${escapeHtml(capability.state)}">${escapeHtml(capability.name)} · ${escapeHtml(capability.state)}</span>`)
-    .join("");
-  const failures = status.checkState.details.failures.map((failure) => `<li>${escapeHtml(failure)}</li>`).join("");
-  const warnings = status.checkState.details.warnings.map((warning) => `<li>${escapeHtml(warning)}</li>`).join("");
-  const handoffs = status.handoffs
-    .map((handoff) => `<span class="handoff">${escapeHtml(handoff.state)} · ${escapeHtml(handoff.summary)}</span>`)
-    .join("");
-  const activity = status.recentActivity
-    .map((item) => `<li><strong>${escapeHtml(item.type)}</strong> ${escapeHtml(item.summary)}</li>`)
-    .join("");
-  return `<!doctype html>
-<html lang="zh-CN">
-<head>
-  <meta charset="utf-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1">
-  <title>${escapeHtml(status.project.name)} Harness Dashboard</title>
-  <style>
-    :root{font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif;color:#17202a;background:#f6f7f9}
-    body{margin:0}.shell{max-width:1180px;margin:0 auto;padding:28px}
-    header{display:flex;justify-content:space-between;gap:24px;align-items:flex-start;margin-bottom:24px}
-    h1,h2{margin:0;letter-spacing:0}h1{font-size:30px}h2{font-size:18px}p{margin:6px 0;color:#687382}
-    .pill,.chip,.risk,.ok{display:inline-flex;align-items:center;border-radius:999px;padding:6px 10px;font-size:12px;margin:4px;background:#e8edf3;color:#273444}
-    .pass,.verified{background:#dff5e8;color:#125c32}.warn,.configured{background:#fff0cc;color:#765100}.fail,.open{background:#ffe1df;color:#8a1c12}.scaffolded{background:#e8edf3;color:#273444}
-    .grid{display:grid;grid-template-columns:repeat(4,minmax(0,1fr));gap:12px;margin-bottom:20px}.stat,.task{background:#fff;border:1px solid #e4e8ee;border-radius:8px;padding:16px}
-    .stat strong{font-size:24px;display:block}.capabilities{margin-bottom:20px}.task{margin-bottom:16px}.task-head{display:flex;justify-content:space-between;gap:16px}
-    .score{font-size:28px;font-weight:700;color:#223047}.meter{height:8px;background:#edf1f5;border-radius:99px;overflow:hidden;margin:10px 0}.meter i{display:block;height:100%;background:#2f6fed}.meter.small{height:6px;max-width:180px}
-    .evidence,.handoff{display:inline-flex;padding:5px 8px;margin:4px;border-radius:6px;background:#edf7ff;color:#214d72;font-size:12px}.handoff{background:#fff3d8;color:#745000}
-    .phases{display:grid;grid-template-columns:repeat(auto-fit,minmax(210px,1fr));gap:10px;margin-top:12px}.phase{border:1px solid #e5eaf0;border-radius:8px;padding:12px;background:#fbfcfe}.phase-top{display:flex;justify-content:space-between}.phase-output{min-height:38px;margin-top:8px}
-    .risks{margin-top:12px}.empty{color:#8a95a3}.panel{background:#fff;border:1px solid #e4e8ee;border-radius:8px;padding:16px;margin-top:16px}
-    @media(max-width:760px){.shell{padding:16px}header{display:block}.grid{grid-template-columns:1fr 1fr}.task-head{display:block}}
-  </style>
-</head>
-<body><main class="shell">
-  <header>
-    <div><h1>${escapeHtml(status.project.name)} Harness Dashboard</h1><p>${escapeHtml(status.project.root)} · ${escapeHtml(status.generatedAt)}</p></div>
-    <span class="pill ${escapeHtml(status.checkState.status)}">${escapeHtml(status.checkState.status)} · ${escapeHtml(status.mode)}</span>
-  </header>
-  <section class="grid">
-    <div class="stat"><strong>${status.tasks.length}</strong><span>Tasks</span></div>
-    <div class="stat"><strong>${status.capabilities.length}</strong><span>Capabilities</span></div>
-    <div class="stat"><strong>${status.checkState.failures}</strong><span>Failures</span></div>
-    <div class="stat"><strong>${status.checkState.warnings}</strong><span>Warnings</span></div>
-  </section>
-  <section class="capabilities">${chips}</section>
-  <section class="panel"><h2>Handoffs</h2>${handoffs || '<span class="ok">No pending handoff</span>'}</section>
-  ${taskCards || '<section class="task">No tasks found.</section>'}
-  <section class="panel"><h2>Recent Activity</h2><ul>${activity || "<li>None</li>"}</ul></section>
-  <section class="panel"><h2>Failures</h2><ul>${failures || "<li>None</li>"}</ul><h2>Warnings</h2><ul>${warnings || "<li>None</li>"}</ul></section>
-</main></body></html>`;
-}
-
-function escapeHtml(value) {
-  return String(value ?? "")
-    .replaceAll("&", "&amp;")
-    .replaceAll("<", "&lt;")
-    .replaceAll(">", "&gt;")
-    .replaceAll('"', "&quot;");
-}
-
-function evidenceCompletion(phases) {
-  const scored = phases.filter((phase) => phase.state !== "skipped");
-  if (scored.length === 0) return 0;
-  const score = scored.reduce((sum, phase) => {
-    if (["present", "waived"].includes(phase.evidenceStatus)) return sum + 100;
-    if (phase.evidenceStatus === "partial") return sum + 50;
-    return sum;
-  }, 0);
-  return Math.round(score / scored.length);
+    validationMode: "validated",
+  });
 }