coding-agent-harness 1.0.2 → 1.0.4

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

@@ -0,0 +1,237 @@
+import fs from "node:fs";
+import path from "node:path";
+
+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 [];
+  const results = [];
+  function walk(dir) {
+    for (const entry of fs.readdirSync(dir)) {
+      const full = path.join(dir, entry);
+      const relativePath = rel(path.relative(targetRoot, full));
+      const stat = fs.statSync(full);
+      if (stat.isDirectory()) {
+        if (relativePath.includes("/_archive/") || relativePath.endsWith("/_task-template")) continue;
+        walk(full);
+      } else if (/\/TASKS\/[^/]+\/task_plan\.md$/.test(relativePath)) {
+        results.push(relativePath);
+      }
+    }
+  }
+  walk(modulesRoot);
+  return results;
+}
+
+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,27 @@ import {
   firstColumn,
   contentHasAny,
 } from "./markdown-utils.mjs";
-import {
-  capabilityDefinitions,
-  validateCapabilities,
-} from "./capability-registry.mjs";
+import { capabilityDefinitions, 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,
-  parseTaskContractInfo,
   readVisualMapContractFile,
   parsePhases,
   taskCutoverCounters,
 } from "./task-scanner.mjs";
+import {
+  normalizeReviewBoolean,
+  reviewFindingColumns,
+} from "./task-review-model.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";
+export { renderDashboard } from "./status-dashboard-renderer.mjs";
 
 export function runLegacyCheck(target) {
   const checkTarget = target.docsOnly ? target.projectRoot : target.input;
@@ -94,10 +101,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 +115,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,11 +135,12 @@ 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 };
 }
 
@@ -177,33 +185,6 @@ 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) {
   const failures = [];
   const allowedMigrationLevels = new Set([
@@ -214,13 +195,38 @@ export function validateTaskPresetContracts(target) {
   ]);
   for (const task of 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 +234,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,6 +319,7 @@ 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");
@@ -326,14 +331,19 @@ export function buildStatus(targetInput, options = {}) {
   const planContracts = validatePlanContracts(target, { strict: contractStrict });
   const presetContracts = validateTaskPresetContracts(target);
   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) {
@@ -372,6 +382,7 @@ export function buildStatus(targetInput, options = {}) {
       details: { failures, warnings },
       legacy,
     },
+    git: gitState.summary,
     summary: {
       tasks: tasks.length,
       briefCoverage: {
@@ -405,106 +416,3 @@ export function buildStatus(targetInput, options = {}) {
     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);
-}

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

@@ -0,0 +1,47 @@
+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";
+
+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`);
+    }
+    for (const fileName of requiredTaskFilesForBudget(budget)) {
+      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) {
+  const simpleFiles = ["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("/");
 }