coding-agent-harness 1.0.2 → 1.0.5

package/scripts/lib/check-task-contracts.mjs

@@ -0,0 +1,55 @@
+import fs from "node:fs";
+import path from "node:path";
+import {
+  lessonCandidatesFile,
+  readFileSafe,
+  toPosix,
+  visualMapFile,
+} from "./core-shared.mjs";
+import {
+  listTaskPlanPaths,
+  parseTaskBudget,
+  parseTaskContractInfo,
+} from "./task-scanner.mjs";
+import { parseTaskAuditMetadata } from "./task-audit-metadata.mjs";
+
+export function validatePlanContracts(target, { strict = true, taskPlanPaths } = {}) {
+  const failures = [];
+  const warnings = [];
+  const report = (message) => {
+    if (strict) failures.push(message);
+    else warnings.push(`adoption-needed: ${message}`);
+  };
+  for (const taskPlanPath of taskPlanPaths || listTaskPlanPaths(target)) {
+    const taskDir = path.dirname(taskPlanPath);
+    const relativeDir = toPosix(path.relative(target.projectRoot, taskDir));
+    const taskPlanContent = readFileSafe(taskPlanPath);
+    const indexContent = readFileSafe(path.join(taskDir, "INDEX.md"));
+    const budget = parseTaskBudget(taskPlanContent);
+    const taskContract = parseTaskContractInfo(taskPlanContent);
+    const taskAudit = parseTaskAuditMetadata(indexContent, { required: strict && taskContract.generated });
+    if (!taskContract.generated) {
+      warnings.push(`adoption-needed: ${relativeDir} missing Task Contract: harness-task/v1 marker`);
+    }
+    for (const issue of taskAudit.issues) {
+      if (taskContract.generated || taskAudit.present) failures.push(`${relativeDir}/INDEX.md ${issue.message}`);
+      else report(`${relativeDir}/INDEX.md ${issue.message}`);
+    }
+    const indexRequired = /^Task Package Index\s*[:：]\s*(required|yes|true|必需|必须|required)\s*$/im.test(taskPlanContent);
+    for (const fileName of requiredTaskFilesForBudget(budget, { indexRequired })) {
+      if (!fs.existsSync(path.join(taskDir, fileName))) {
+        if (taskContract.generated) failures.push(`${relativeDir} missing ${fileName}`);
+        else report(`${relativeDir} missing ${fileName}`);
+      }
+    }
+  }
+  return { failures, warnings };
+}
+
+function requiredTaskFilesForBudget(budget, { indexRequired = false } = {}) {
+  const simpleFiles = [...(indexRequired ? ["INDEX.md"] : []), "brief.md", "task_plan.md", visualMapFile, "progress.md"];
+  if (budget === "simple") return simpleFiles;
+  const standardFiles = [...simpleFiles, "execution_strategy.md", "findings.md", lessonCandidatesFile, "review.md"];
+  if (budget === "complex") return [...standardFiles, "references/INDEX.md", "artifacts/INDEX.md"];
+  return standardFiles;
+}

package/scripts/lib/core-shared.mjs

@@ -1,4 +1,5 @@
 import fs from "node:fs";
+import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 
@@ -10,6 +11,11 @@ export const legacyVisualRoadmapFile = "visual_roadmap.md";
 export const lessonCandidatesFile = "lesson_candidates.md";
 export const longRunningTaskContractFile = "long-running-task-contract.md";
 export const taskContractMarker = "Task Contract: harness-task/v1";
+export const builtinPresetRoot = path.join(repoRoot, "presets");
+export function userPresetRootForHome(home = "") {
+  return path.join(path.resolve(home || os.homedir()), ".coding-agent-harness/presets");
+}
+export const userPresetRoot = userPresetRootForHome();
 
 
 export const supportedLocales = new Set(["zh-CN", "en-US"]);
@@ -40,6 +46,10 @@ export function normalizeTarget(input = ".") {
   };
 }
 
+export function projectPresetRoot(targetInput = ".") {
+  return path.join(normalizeTarget(targetInput).projectRoot, ".coding-agent-harness/presets");
+}
+
 export function toPosix(value) {
   return value.split(path.sep).join("/");
 }
@@ -60,6 +70,15 @@ export function readFileSafe(filePath) {
   }
 }
 
+export function readJsonSafe(filePath, fallback = null, { onError } = {}) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch (error) {
+    if (typeof onError === "function") onError(error);
+    return fallback;
+  }
+}
+
 export function readBundledTemplate(source) {
   const sourcePath = path.join(repoRoot, source);
   if (!fs.existsSync(sourcePath)) throw new Error(`Bundled template missing: ${source}`);
@@ -68,15 +87,17 @@ export function readBundledTemplate(source) {
   return content;
 }
 
-export function walkFiles(root) {
+export function walkFiles(root, options = {}) {
   const results = [];
   if (!fs.existsSync(root)) return results;
+  const dirFilter = typeof options.dirFilter === "function" ? options.dirFilter : () => true;
   function walk(dir) {
     for (const entry of fs.readdirSync(dir)) {
       const full = path.join(dir, entry);
       const stat = fs.statSync(full);
       if (stat.isDirectory()) {
         if ([".git", "node_modules", "tmp"].includes(entry)) continue;
+        if (!dirFilter(entry, full)) continue;
         walk(full);
       } else {
         results.push(full);
@@ -170,14 +191,56 @@ export function normalizeTaskId(value) {
   return slug(value || "task");
 }
 
-export function renderTaskTemplate(content, { taskId, title, locale, budget = "standard" }) {
+export function renderTaskTemplate(content, { taskId, title, locale, budget = "standard", moduleKey = "", preset = "none", presetVersion = "", evidenceBundle = "", longRunning = false, scaffoldProvenance = {}, taskAudit = {} }) {
   const date = todayDate();
+  const provenance = {
+    createdBy: scaffoldProvenance.createdBy || "harness new-task",
+    command: scaffoldProvenance.command || "harness new-task [task-id] <target>",
+    createdAt: scaffoldProvenance.createdAt || date,
+    budget: scaffoldProvenance.budget || budget,
+    templateSource: scaffoldProvenance.templateSource || "templates/planning/brief.md",
+    exceptionReason: scaffoldProvenance.exceptionReason || "n/a",
+  };
   return String(content)
     .replaceAll("{{TASK_ID}}", taskId)
     .replaceAll("{{TASK_TITLE}}", title)
     .replaceAll("{{DATE}}", date)
     .replaceAll("{{LOCALE}}", normalizeLocale(locale))
     .replaceAll("{{TASK_BUDGET}}", budget)
+    .replaceAll("{{TASK_MODULE}}", moduleKey || "n/a")
+    .replaceAll("{{TASK_PRESET}}", preset || "none")
+    .replaceAll("{{TASK_PRESET_VERSION}}", presetVersion || "n/a")
+    .replaceAll("{{TASK_EVIDENCE_BUNDLE}}", evidenceBundle || "n/a")
+    .replaceAll("{{TASK_LONG_RUNNING}}", longRunning ? "yes" : "no")
+    .replaceAll("{{SCAFFOLD_CREATED_BY}}", provenance.createdBy)
+    .replaceAll("{{SCAFFOLD_COMMAND}}", provenance.command)
+    .replaceAll("{{SCAFFOLD_CREATED_AT}}", provenance.createdAt)
+    .replaceAll("{{SCAFFOLD_BUDGET}}", provenance.budget)
+    .replaceAll("{{SCAFFOLD_TEMPLATE_SOURCE}}", provenance.templateSource)
+    .replaceAll("{{SCAFFOLD_EXCEPTION_REASON}}", provenance.exceptionReason)
+    .replaceAll("{{TASK_AUDIT_CREATED_BY}}", taskAudit["Created By"] || provenance.createdBy)
+    .replaceAll("{{TASK_AUDIT_CREATED_AT}}", taskAudit["Created At"] || provenance.createdAt)
+    .replaceAll("{{TASK_AUDIT_COMMAND_SHAPE}}", taskAudit["Command Shape"] || provenance.command)
+    .replaceAll("{{TASK_AUDIT_BUDGET}}", taskAudit.Budget || provenance.budget)
+    .replaceAll("{{TASK_AUDIT_TEMPLATE_SOURCE}}", taskAudit["Template Source"] || provenance.templateSource)
+    .replaceAll("{{TASK_AUDIT_TASK_CREATOR}}", taskAudit["Task Creator"] || "n/a")
+    .replaceAll("{{TASK_AUDIT_TASK_CREATOR_SOURCE}}", taskAudit["Task Creator Source"] || "git-unavailable")
+    .replaceAll("{{TASK_AUDIT_HUMAN_REVIEW_STATUS}}", taskAudit["Human Review Status"] || "not-confirmed")
+    .replaceAll("{{TASK_AUDIT_CONFIRMATION_ID}}", taskAudit["Confirmation ID"] || "n/a")
+    .replaceAll("{{TASK_AUDIT_CONFIRMED_AT}}", taskAudit["Confirmed At"] || "n/a")
+    .replaceAll("{{TASK_AUDIT_REVIEWER}}", taskAudit.Reviewer || "n/a")
+    .replaceAll("{{TASK_AUDIT_REVIEWER_EMAIL}}", taskAudit["Reviewer Email"] || "n/a")
+    .replaceAll("{{TASK_AUDIT_CONFIRM_TEXT}}", taskAudit["Confirm Text"] || "n/a")
+    .replaceAll("{{TASK_AUDIT_EVIDENCE_CHECKED}}", taskAudit["Evidence Checked"] || "n/a")
+    .replaceAll("{{TASK_AUDIT_REVIEW_COMMIT_SHA}}", taskAudit["Review Commit SHA"] || "n/a")
+    .replaceAll("{{TASK_AUDIT_AUDIT_SOURCE}}", taskAudit["Audit Source"] || "native-index")
+    .replaceAll("{{TASK_AUDIT_AUDIT_STATUS}}", taskAudit["Audit Status"] || "created")
+    .replaceAll("{{TASK_AUDIT_EXCEPTION_REASON}}", taskAudit["Exception Reason"] || provenance.exceptionReason)
+    .replaceAll("{{TASK_AUDIT_MESSAGE}}", taskAudit.Message || "n/a")
+    .replaceAll("{{TASK_AUDIT_MIGRATION_STATUS}}", taskAudit["Migration Status"] || "native")
+    .replaceAll("{{TASK_AUDIT_MIGRATED_FROM}}", taskAudit["Migrated From"] || "n/a")
+    .replaceAll("{{TASK_AUDIT_LEGACY_EXTRA_FIELDS}}", taskAudit["Legacy Extra Fields"] || "{}")
+    .replaceAll("{{TASK_AUDIT_MIGRATION_NOTES}}", taskAudit["Migration Notes"] || "n/a")
     .replaceAll("[simple / standard / complex]", budget)
     .replaceAll("[simple / standard / long-running / module-parallel]", budget)
     .replaceAll("[simple / complex]", budget)

package/scripts/lib/dashboard-data.mjs

@@ -1,8 +1,12 @@
 import fs from "node:fs";
 import path from "node:path";
+import { spawnSync } from "node:child_process";
 import {
+  legacyChecker,
   repoRoot,
+  builtinPresetRoot,
   normalizeTarget,
+  projectPresetRoot,
   readFileSafe,
   sanitizeText,
   sanitizeDeep,
@@ -15,24 +19,29 @@ import {
   legacyVisualRoadmapFile,
   lessonCandidatesFile,
   longRunningTaskContractFile,
+  userPresetRoot,
 } from "./core-shared.mjs";
 import {
   parseAllMarkdownTables,
   getCell,
   splitDependencies,
 } from "./markdown-utils.mjs";
-import { readCapabilityRegistry } from "./capability-registry.mjs";
-import { buildStatus } from "./check-profiles.mjs";
+import { readCapabilityRegistry, validateCapabilities } from "./capability-registry.mjs";
+import { buildStatusData } from "./status-builder.mjs";
 import {
   listTaskPlanPaths,
   parseTaskState,
   isActiveTaskState,
 } from "./task-scanner.mjs";
 import { writeDashboardDirectory, writeDashboardFile } from "./dashboard-writer.mjs";
+import { listPresetPackageLayers } from "./preset-registry.mjs";
+import { validateGovernanceTableBoundaries } from "./governance-table-boundary.mjs";
+import { summarizeGitState } from "./git-status-summary.mjs";
 
-export function collectMarkdownDocuments(target) {
-  const docs = collectDashboardDocumentPaths(target);
-  return docs.map((file, index) => {
+export function collectMarkdownDocuments(target, options = {}) {
+  const docs = collectDashboardDocumentPaths(target, options);
+  return docs.map((entry, index) => {
+    const file = typeof entry === "string" ? entry : entry.file;
     const content = sanitizeText(readFileSafe(file));
     const source = prefixedPath(target, file);
     return {
@@ -41,12 +50,14 @@ export function collectMarkdownDocuments(target) {
       title: titleFromMarkdown(content, path.basename(file)),
       type: documentKind(source),
       content,
+      ...(entry.partial ? { partial: true, partialReason: entry.partialReason || "partial", taskId: entry.taskId || "" } : {}),
     };
   });
 }
 
-function collectDashboardDocumentPaths(target) {
+function collectDashboardDocumentPaths(target, options = {}) {
   const selected = new Set();
+  const partial = new Map();
   const addDocsPath = (relativePath) => {
     const file = path.join(target.docsRoot, relativePath);
     if (fs.existsSync(file)) selected.add(file);
@@ -56,7 +67,6 @@ function collectDashboardDocumentPaths(target) {
     "09-PLANNING/Module-Registry.md",
     "05-TEST-QA/Regression-SSoT.md",
     "05-TEST-QA/Cadence-Ledger.md",
-    "01-GOVERNANCE/Lessons-SSoT.md",
     "10-WALKTHROUGH/Closeout-SSoT.md",
   ]) {
     addDocsPath(relativePath);
@@ -67,21 +77,38 @@ function collectDashboardDocumentPaths(target) {
     if (path.basename(file).startsWith("_")) continue;
     selected.add(file);
   }
-  for (const taskPlanPath of listTaskPlanPaths(target)) {
+  const tasksByPlanPath = new Map((options.tasks || []).map((task) => [
+    path.join(target.projectRoot, String(task.taskPlanPath || "").replace(/^TARGET:/, "")),
+    task,
+  ]));
+  for (const taskPlanPath of options.taskPlanPaths || listTaskPlanPaths(target)) {
     const taskDir = path.dirname(taskPlanPath);
     const progress = readFileSafe(path.join(taskDir, "progress.md"));
     const state = parseTaskState(progress);
     const active = isActiveTaskState(state);
-    const documentNames = active
-      ? ["brief.md", "task_plan.md", "execution_strategy.md", visualMapFile, legacyVisualRoadmapFile, lessonCandidatesFile, longRunningTaskContractFile, "progress.md", "review.md", "findings.md"]
+    const task = tasksByPlanPath.get(taskPlanPath);
+    const historicalClosed = !active && task?.closeoutStatus === "closed";
+    const documentNames = historicalClosed
+      ? ["brief.md"]
       : ["brief.md", "task_plan.md", "execution_strategy.md", visualMapFile, legacyVisualRoadmapFile, lessonCandidatesFile, longRunningTaskContractFile, "progress.md", "review.md", "findings.md"];
     for (const fileName of documentNames) {
       const file = path.join(taskDir, fileName);
-      if (fs.existsSync(file)) selected.add(file);
+      if (fs.existsSync(file)) {
+        selected.add(file);
+        if (historicalClosed) {
+          partial.set(file, {
+            partial: true,
+            partialReason: "historical-closed",
+            taskId: task?.id || path.basename(taskDir),
+          });
+        }
+      }
     }
-    for (const indexFile of ["references/INDEX.md", "artifacts/INDEX.md"]) {
-      const file = path.join(taskDir, indexFile);
-      if (fs.existsSync(file)) selected.add(file);
+    if (!historicalClosed) {
+      for (const indexFile of ["references/INDEX.md", "artifacts/INDEX.md"]) {
+        const file = path.join(taskDir, indexFile);
+        if (fs.existsSync(file)) selected.add(file);
+      }
     }
   }
   for (const file of walkFiles(path.join(target.docsRoot, "09-PLANNING/MODULES"))) {
@@ -95,7 +122,8 @@ function collectDashboardDocumentPaths(target) {
     .filter((file) => !file.includes(`${path.sep}_archive${path.sep}`))
     .filter((file) => !file.includes(`${path.sep}_task-template${path.sep}`))
     .filter((file) => !file.includes(`${path.sep}_optional-structures${path.sep}`))
-    .sort();
+    .sort()
+    .map((file) => ({ file, ...(partial.get(file) || {}) }));
 }
 
 function documentKind(source) {
@@ -104,7 +132,7 @@ function documentKind(source) {
   if (lower.includes("module-registry.md")) return "module-registry";
   if (lower.includes("regression-ssot.md")) return "regression-ssot";
   if (lower.includes("cadence-ledger.md")) return "cadence-ledger";
-  if (lower.includes("lessons-ssot.md")) return "lessons-ssot";
+  if (/\/01-governance\/lessons\/[^/]+\.md$/i.test(lower)) return "lesson-detail";
   if (lower.endsWith("/progress.md")) return "task-progress";
   if (lower.endsWith("/brief.md")) return "task-brief";
   if (lower.endsWith("/review.md")) return "task-review";
@@ -146,7 +174,17 @@ export function collectGraph(status, tables = { tables: [] }) {
     addNode({ id: `task:${task.id}`, type: "task", label: task.title, state: task.state, completion: task.completion });
     for (const phase of task.phases || []) {
       const phaseId = `phase:${task.id}:${phase.id}`;
-      addNode({ id: phaseId, type: "phase", label: phase.id, state: phase.state, completion: phase.completion, taskId: task.id });
+      addNode({
+        id: phaseId,
+        type: "phase",
+        label: phase.id,
+        state: phase.state,
+        completion: phase.completion,
+        kind: phase.kind,
+        actor: phase.actor,
+        exitCommand: phase.exitCommand,
+        taskId: task.id,
+      });
       addEdge({ from: `task:${task.id}`, to: phaseId, type: "contains" });
       for (const dependency of phase.dependsOn || []) {
         addEdge({ from: `phase:${task.id}:${dependency}`, to: phaseId, type: "depends_on" });
@@ -200,6 +238,7 @@ export function collectGraph(status, tables = { tables: [] }) {
 }
 
 export function categorizeWarning(message) {
+  if (/governance-table-entropy/i.test(message)) return "Governance Table Boundary";
   if (/missing execution_strategy\.md|missing visual_(?:map|roadmap)\.md|Visual (?:Map|Roadmap)/i.test(message)) return "Plan Contract Missing";
   if (/legacy-compat|adoption-needed|legacy check/i.test(message)) return "Adoption Advice";
   if (/Evidence|evidence/i.test(message)) return "Missing Evidence";
@@ -213,6 +252,7 @@ function warningType(message) {
   if (/missing visual_map\.md|Visual Map/i.test(message)) return "missing-visual-map";
   if (/missing visual_roadmap\.md|Visual Roadmap/i.test(message)) return "missing-visual-roadmap";
   if (/Reviewer Identity|Confidence Challenge|Final Confidence Basis|Evidence Checked/i.test(message)) return "review-schema-gap";
+  if (/governance-table-entropy/i.test(message)) return "governance-table-entropy";
   if (/Evidence|evidence/i.test(message)) return "missing-evidence";
   if (/missing required file/i.test(message)) return "legacy-reference-gap";
   if (/legacy-compat|legacy check|adoption-needed/i.test(message)) return "capability-adoption";
@@ -231,6 +271,7 @@ function warningScope(message) {
 
 function warningPhase(type, scope) {
   if (type === "capability-adoption") return "baseline";
+  if (type === "governance-table-entropy") return "global-table-boundary";
   if (type === "missing-brief" || type === "missing-execution-strategy" || type === "missing-visual-map" || type === "missing-visual-roadmap") return "active-task-contracts";
   if (scope === "module") return "module-classification";
   if (type === "review-schema-gap" || type === "missing-evidence") return "review-evidence";
@@ -240,6 +281,7 @@ function warningPhase(type, scope) {
 
 function warningFixability(type, scope) {
   if (["missing-brief", "missing-execution-strategy", "missing-visual-map", "missing-visual-roadmap"].includes(type)) return "guided";
+  if (type === "governance-table-entropy") return "manual";
   if (type === "legacy-reference-gap" || scope === "reference") return "template";
   if (type === "capability-adoption") return "decision";
   if (type === "review-schema-gap" || type === "missing-evidence") return "human-evidence";
@@ -248,6 +290,7 @@ function warningFixability(type, scope) {
 
 function warningPriority(type, scope, message) {
   if (/fail|invalid|blocked/i.test(message) || type === "schema-drift") return "P1";
+  if (type === "governance-table-entropy") return /legacy-report-only/i.test(message) ? "P3" : "P2";
   if (["missing-brief", "missing-execution-strategy", "missing-visual-map", "missing-visual-roadmap"].includes(type) && scope === "task") return "P2";
   if (type === "review-schema-gap" || type === "missing-evidence") return "P2";
   if (type === "capability-adoption") return "P3";
@@ -284,19 +327,24 @@ function summarizeWarnings(warnings) {
 }
 
 export function collectAdoption(status) {
-  const warnings = status.checkState.details.warnings.flatMap((message) => splitWarningMessage(message)).map((message, index) => {
+  const dashboardMessages = [
+    ...(status.checkState.details.warnings || []),
+    ...(status.checkState.details.failures || []).filter((message) => /governance-table-entropy/i.test(message)),
+  ];
+  const warnings = dashboardMessages.flatMap((message) => splitWarningMessage(message)).map((message, index) => {
     const type = warningType(message);
     const scope = warningScope(message);
     const affectedPaths = warningAffectedPaths(message);
+    const stableSuffix = type === "governance-table-entropy" ? `-${stableWarningIdPart(governanceWarningRowKey(message))}` : "";
     return {
-      id: `AD-${String(index + 1).padStart(3, "0")}`,
+      id: `AD-${String(index + 1).padStart(3, "0")}${stableSuffix}`,
       category: categorizeWarning(message),
       type,
       scope,
       priority: warningPriority(type, scope, message),
       phase: warningPhase(type, scope),
       fixability: warningFixability(type, scope),
-      status: "open",
+      status: /legacy-report-only/i.test(message) ? "legacy-report-only" : "open",
       confidence: warningConfidence(message),
       severity: status.mode === "legacy-compat" ? "advice" : "warning",
       title: warningTitle(message),
@@ -330,6 +378,18 @@ export function collectAdoption(status) {
   };
 }
 
+function governanceWarningRowKey(message) {
+  const match = String(message || "").match(/\brow\s+([^:]+)/i);
+  return match ? match[1].trim() : "global-table";
+}
+
+function stableWarningIdPart(value) {
+  return String(value || "global-table")
+    .replace(/[^A-Za-z0-9_-]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 80) || "global-table";
+}
+
 export function splitWarningMessage(message) {
   return String(message || "")
     .split(/\n-\s+/)
@@ -338,6 +398,7 @@ export function splitWarningMessage(message) {
 }
 
 function warningTitle(message) {
+  if (/governance-table-entropy/i.test(message)) return "Global table boundary";
   if (/missing execution_strategy\.md/i.test(message)) return "Missing execution strategy";
   if (/missing visual_map\.md|Visual Map/i.test(message)) return "Missing visual map";
   if (/missing visual_roadmap\.md|Visual Roadmap/i.test(message)) return "Missing legacy visual roadmap";
@@ -354,6 +415,7 @@ function warningAffected(message) {
 }
 
 function warningAction(message) {
+  if (/governance-table-entropy/i.test(message)) return "Move local detail to module/task docs; keep the global row to summary, state, route, and audit result.";
   if (/execution_strategy\.md/i.test(message)) return "Add standalone execution strategy file.";
   if (/visual_map\.md|Visual Map/i.test(message)) return "Add standalone visual map file.";
   if (/visual_roadmap\.md|Visual Roadmap/i.test(message)) return "Rewrite legacy visual_roadmap.md into canonical visual_map.md.";
@@ -363,13 +425,82 @@ function warningAction(message) {
 }
 
 export function buildDashboardBundle(targetInput, options = {}) {
-  const status = buildStatus(targetInput, options);
   const target = normalizeTarget(targetInput);
-  const documents = { documents: collectMarkdownDocuments(target) };
+  const taskPlanPaths = listTaskPlanPaths(target);
+  const capabilityState = validateCapabilities(target);
+  const gitState = summarizeGitState(target);
+  const declaredCapabilities = new Set(capabilityState.registry.capabilities.map((capability) => capability.name));
+  const shouldRunLegacy = !options.skipLegacyCheck && (capabilityState.registry.mode === "legacy-compat" || declaredCapabilities.has("safe-adoption"));
+  const legacy = shouldRunLegacy ? runDashboardLegacyCheck(target) : { status: "skipped", code: 0, stdout: "", stderr: "" };
+  const legacyWarnings = legacy.status === "fail" ? [`adoption-needed: legacy check failed: ${(legacy.stderr || legacy.stdout).trim()}`] : [];
+  const governanceBoundaries = validateGovernanceTableBoundaries(target);
+  const status = buildStatusData(target, {
+    ...options,
+    capabilityState,
+    gitState,
+    taskPlanPaths,
+    legacy,
+    failures: [...capabilityState.failures, ...governanceBoundaries.failures],
+    warnings: [...capabilityState.warnings, ...legacyWarnings, ...governanceBoundaries.warnings, ...gitState.warnings],
+  });
+  const documents = { documents: collectMarkdownDocuments(target, { taskPlanPaths, tasks: status.tasks }) };
   const tables = collectTables(documents.documents);
   const graph = collectGraph(status, tables);
   const adoption = collectAdoption(status);
-  return sanitizeDeep({ status, tables, documents, graph, adoption });
+  const presetCatalog = collectPresetCatalog(targetInput, target, options);
+  return sanitizeDeep({ status, tables, documents, graph, adoption, presetCatalog });
+}
+
+function runDashboardLegacyCheck(target) {
+  const checkTarget = target.docsOnly ? target.projectRoot : target.input;
+  const result = spawnSync(process.execPath, [legacyChecker, checkTarget], {
+    cwd: repoRoot,
+    encoding: "utf8",
+  });
+  return {
+    status: result.status === 0 ? "pass" : "fail",
+    code: result.status ?? 1,
+    stdout: result.stdout || "",
+    stderr: result.stderr || "",
+  };
+}
+
+export function collectPresetCatalog(targetInput, target = normalizeTarget(targetInput), options = {}) {
+  const home = options.home || "";
+  const presets = listPresetPackageLayers({ targetInput: target.projectRoot, home }).map((preset) => ({
+    key: `${preset.source}:${preset.id}`,
+    id: preset.id,
+    version: preset.version,
+    source: preset.source,
+    effective: preset.effective === true,
+    purpose: preset.purpose,
+    compatibleBudgets: preset.compatibleBudgets,
+    manifestPath: preset.manifestRelativePath,
+    manifestSha256: preset.manifestSha256,
+    taskKind: preset.task?.kind || "",
+    inputCount: Object.keys(preset.inputs || {}).length,
+    referenceCount: Object.keys(preset.resources?.references || {}).length,
+    artifactCount: Object.keys(preset.resources?.artifacts || {}).length,
+    writeScopeCount: Object.keys(preset.writeScopes || {}).length,
+    evidenceFileCount: Object.keys(preset.evidence?.files || {}).length,
+    requiredReadCount: Array.isArray(preset.context?.requiredReads) ? preset.context.requiredReads.length : 0,
+    checkStatus: "unknown",
+  }));
+  const countSource = (source) => presets.filter((preset) => preset.source === source).length;
+  return {
+    summary: {
+      total: presets.length,
+      project: countSource("project"),
+      user: countSource("user"),
+      builtin: countSource("builtin"),
+    },
+    roots: [
+      { source: "project", path: projectPresetRoot(target.projectRoot) },
+      { source: "user", path: home ? path.join(path.resolve(home), ".coding-agent-harness/presets") : userPresetRoot },
+      { source: "builtin", path: builtinPresetRoot },
+    ],
+    presets,
+  };
 }
 
 export function writeDashboardFolder(outDir, targetInput, options = {}) {
@@ -377,7 +508,7 @@ export function writeDashboardFolder(outDir, targetInput, options = {}) {
   const registry = readCapabilityRegistry(target);
   const locale = options.localeOverride || registry.locale;
   const bundle = buildDashboardBundle(targetInput, options);
-  return writeDashboardDirectory(outDir, bundle, { repoRoot, projectRoot: target.projectRoot, docsRoot: target.docsRoot, locale, workbenchRuntime: options.workbenchRuntime === true });
+  return writeDashboardDirectory(outDir, bundle, { repoRoot, projectRoot: target.projectRoot, docsRoot: target.docsRoot, locale, workbenchRuntime: options.workbenchRuntime === true, recoverGeneratedDashboard: options.recoverGeneratedDashboard === true });
 }
 
 export function writeDashboardSingleFile(outFile, targetInput, options = {}) {