coding-agent-harness 1.0.2 → 1.0.5

package/scripts/check-harness.mjs

@@ -2,6 +2,7 @@
 
 import fs from "node:fs";
 import path from "node:path";
+import { checkModuleParallelStructure } from "./lib/check-module-parallel.mjs";
 
 const targetRoot = path.resolve(process.argv[2] || process.cwd());
 const requireGlobalModuleSync = process.env.HARNESS_REQUIRE_GLOBAL_MODULE_SYNC === "1";
@@ -23,7 +24,6 @@ const requiredFiles = [
   "docs/10-WALKTHROUGH/Closeout-SSoT.md",
   "docs/05-TEST-QA/Regression-SSoT.md",
   "docs/05-TEST-QA/Cadence-Ledger.md",
-  "docs/01-GOVERNANCE/Lessons-SSoT.md",
 ];
 
 const legacyPlanningFiles = [
@@ -41,7 +41,6 @@ const agAgentsRefs = [
   "adversarial-review-standard.md",
   "review-routing-standard.md",
   "walkthrough-standard.md",
-  "Lessons-SSoT.md",
   "harness-ledger-standard.md",
   "Closeout-SSoT.md",
 ];
@@ -109,7 +108,18 @@ function checkRequiredFiles() {
 
 function checkPlanningStructure() {
   if (exists("docs/09-PLANNING/Module-Registry.md")) {
-    checkModuleParallelStructure();
+    checkModuleParallelStructure({
+      exists,
+      fail,
+      filePath,
+      markdownTable,
+      read,
+      rel,
+      requireFile,
+      requireGlobalModuleSync,
+      targetRoot,
+      warn,
+    });
     return;
   }
   for (const legacyFile of legacyPlanningFiles) {
@@ -117,239 +127,6 @@ function checkPlanningStructure() {
   }
 }
 
-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 checkModuleParallelStructure() {
-  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);
-}
-
-function checkModuleTaskSsotIndex(registryRows) {
-  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();
-
-  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);
-    const taskProgressStatus = readTaskProgressStatus(taskPlanPath);
-    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`);
-  }
-}
-
-function listModuleTaskPlans() {
-  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) {
-  const progressPath = taskPlanPath.replace(/task_plan\.md$/, "progress.md");
-  return exists(progressPath) ? read(progressPath) : "";
-}
-
-function readTaskProgressStatus(taskPlanPath) {
-  const progress = readTaskProgress(taskPlanPath);
-  if (!progress) return "";
-  const match = progress.match(/^##\s*(?:Status|状态)\s*[:：]?\s*(?:\n\s*)?([^\n]+)/im);
-  return match ? normalizeModuleTaskStatus(stripMarkdownCode(match[1])) : "";
-}
-
-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 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 checkAgentsIndex() {
   if (!exists("AGENTS.md")) return;
   const content = read("AGENTS.md");
@@ -517,10 +294,6 @@ function findHeaderIndex(rows, pattern) {
   return rows.findIndex((cells) => cells.some((cell) => pattern.test(cell)));
 }
 
-function columnIndex(header, pattern) {
-  return header.findIndex((cell) => pattern.test(cell));
-}
-
 function contentIncludesAny(content, terms) {
   return terms.some((term) => (term instanceof RegExp ? term.test(content) : content.includes(term)));
 }
@@ -602,7 +375,7 @@ function checkCloseoutSsot() {
       if (!createdMatch && !candidateMatch && !lessonsNonePattern.test(lessonsCheck)) {
         fail(`${closeoutPath} row ${id} needs Lessons Check value: checked-created:<lesson-id>, checked-candidate:<candidate-id>, queued-promotion:<candidate-id>, or checked-none:<reason>`);
       } else if (createdMatch && !lessonIds.has(createdMatch[1])) {
-        fail(`${closeoutPath} row ${id} references missing Lessons SSoT id: ${createdMatch[1]}`);
+        fail(`${closeoutPath} row ${id} references missing lesson detail doc id: ${createdMatch[1]}`);
       } else if (candidateMatch && !lessonCandidateIds.has(candidateMatch[1])) {
         fail(`${closeoutPath} row ${id} references missing lesson candidate id: ${candidateMatch[1]}`);
       }
@@ -615,7 +388,7 @@ function checkCloseoutSsot() {
       if (!ledgerCreatedMatch && !ledgerCandidateMatch && !lessonsNonePattern.test(ledgerLessonsCheck)) {
         fail(`docs/Harness-Ledger.md row ${id} needs Lessons Check value: checked-created:<lesson-id>, checked-candidate:<candidate-id>, queued-promotion:<candidate-id>, or checked-none:<reason>`);
       } else if (ledgerCreatedMatch && !lessonIds.has(ledgerCreatedMatch[1])) {
-        fail(`docs/Harness-Ledger.md row ${id} references missing Lessons SSoT id: ${ledgerCreatedMatch[1]}`);
+        fail(`docs/Harness-Ledger.md row ${id} references missing lesson detail doc id: ${ledgerCreatedMatch[1]}`);
       } else if (ledgerCandidateMatch && !lessonCandidateIds.has(ledgerCandidateMatch[1])) {
         fail(`docs/Harness-Ledger.md row ${id} references missing lesson candidate id: ${ledgerCandidateMatch[1]}`);
       }
@@ -624,18 +397,20 @@ function checkCloseoutSsot() {
 }
 
 function collectLessonIds() {
-  const lessonsPath = "docs/01-GOVERNANCE/Lessons-SSoT.md";
-  if (!exists(lessonsPath)) return new Set();
-  const table = markdownTable(read(lessonsPath));
-  const headerIndex = findHeaderIndex(table, /^ID$/i);
-  const header = headerIndex >= 0 ? table[headerIndex] : [];
-  const idColumn = columnIndex(header, /^ID$/i);
-  if (idColumn < 0) return new Set();
-  return new Set(
-    table
-      .map((cells) => cells[idColumn] || "")
-      .filter((id) => /^L-\d{4}(-\d{2}-\d{2})?-\d+/i.test(id)),
-  );
+  const root = filePath("docs/01-GOVERNANCE/lessons");
+  const ids = new Set();
+  if (!fs.existsSync(root)) return ids;
+  for (const entry of fs.readdirSync(root)) {
+    if (!entry.endsWith(".md")) continue;
+    const full = path.join(root, entry);
+    if (!fs.statSync(full).isFile()) continue;
+    const content = fs.readFileSync(full, "utf8");
+    const pathMatch = entry.match(/(L-\d{4}(?:-\d{2}-\d{2})?-\d+)/i);
+    const titleMatch = content.match(/#\s*(L-\d{4}(?:-\d{2}-\d{2})?-\d+)/i);
+    const id = titleMatch?.[1] || pathMatch?.[1];
+    if (id) ids.add(id);
+  }
+  return ids;
 }
 
 function collectLessonCandidateIds() {
@@ -662,52 +437,16 @@ function collectLessonCandidateIds() {
   return ids;
 }
 
-function checkLessonsSsot() {
-  const lessonsPath = "docs/01-GOVERNANCE/Lessons-SSoT.md";
-  if (!exists(lessonsPath)) return;
-
-  const content = read(lessonsPath);
-  if (!contentIncludesAny(content, [/Detail Doc/i, "详情文档"])) {
-    fail(`${lessonsPath} missing Detail Doc column`);
-  }
-
-  const table = markdownTable(content);
-  const headerIndex = findHeaderIndex(table, /^ID$/i);
-  const header = headerIndex >= 0 ? table[headerIndex] : [];
-  const detailColumn = columnIndexAny(header, [/^(Detail Doc|Detail)$/i, /^详情文档$/i, /^详情文档\s*\/\s*Detail Doc$/i]);
-  const idColumn = columnIndex(header, /^ID$/i);
-  const statusColumn = columnIndexAny(header, [/^Status$/i, /^状态$/i, /^状态\s*\/\s*Status$/i]);
-  if (idColumn < 0) fail(`${lessonsPath} missing ID column`);
-  if (detailColumn < 0) fail(`${lessonsPath} missing Detail Doc column`);
-  if (statusColumn < 0) fail(`${lessonsPath} missing Status column`);
-  if (idColumn < 0 || detailColumn < 0 || statusColumn < 0) return;
-
-  const lessonRows = table.filter((cells) => /^L-\d{4}(-\d{2}-\d{2})?-\d+/i.test(cells[idColumn] || ""));
-  for (const cells of lessonRows) {
-    const id = cells[idColumn] || "";
-    const status = cells[statusColumn] || "";
-    const detail = cells[detailColumn] || "";
-    if (!/pending|approved|merged|rejected|superseded|🟡|🟢|✅|❌|🔀/i.test(status)) {
-      fail(`${lessonsPath} row ${id} has unrecognized status: ${status}`);
-    }
-    const detailMatch = detail.match(/docs\/01-GOVERNANCE\/lessons\/[^|\s`]+\.md/);
-    if (!detailMatch) {
-      fail(`${lessonsPath} row ${id} Detail Doc must point to docs/01-GOVERNANCE/lessons/*.md`);
-      continue;
-    }
-    const detailPath = detailMatch[0];
-    if (!exists(detailPath)) {
-      fail(`${lessonsPath} row ${id} Detail Doc missing file: ${detailPath}`);
-      continue;
-    }
-    const detailContent = read(detailPath);
-    if (!detailContent.includes(id)) {
-      fail(`${detailPath} does not include lesson id ${id}`);
-    }
-    for (const requiredTerm of ["背景", "冲突声明"]) {
-      if (!detailContent.includes(requiredTerm)) {
-        fail(`${detailPath} missing required lesson section: ${requiredTerm}`);
-      }
+function checkLessonDetailDocs() {
+  const root = filePath("docs/01-GOVERNANCE/lessons");
+  if (!fs.existsSync(root)) return;
+  for (const entry of fs.readdirSync(root)) {
+    if (!entry.endsWith(".md")) continue;
+    const relativePath = `docs/01-GOVERNANCE/lessons/${entry}`;
+    const content = read(relativePath);
+    const id = entry.match(/(L-\d{4}(?:-\d{2}-\d{2})?-\d+)/i)?.[1];
+    if (id && !content.includes(id)) {
+      fail(`${relativePath} does not include lesson id ${id}`);
     }
   }
 }
@@ -748,7 +487,7 @@ function main() {
   checkReviewTemplate();
   checkHarnessLedger();
   checkCloseoutSsot();
-  checkLessonsSsot();
+  checkLessonDetailDocs();
   checkWalkthroughTemplate();
   checkReferencePlaceholders();
 

package/scripts/commands/dashboard-command.mjs

@@ -0,0 +1,67 @@
+import fs from "node:fs";
+import path from "node:path";
+import {
+  serveDashboardWorkbench,
+  writeDashboardFolder,
+  writeDashboardSingleFile,
+} from "../lib/harness-core.mjs";
+
+export async function runDashboardCommand({ takeFlag, takeOption, targetArg }) {
+  const watch = takeFlag("--watch");
+  const workbench = takeFlag("--workbench");
+  const out = takeOption("--out", path.join("tmp", "harness-dashboard.html"));
+  const outDir = takeOption("--out-dir", "");
+  const host = takeOption("--host", "127.0.0.1");
+  const port = takeOption("--port", "0");
+  const localeOverride = takeOption("--locale", "");
+  const opts = localeOverride ? { localeOverride } : {};
+  if (workbench) {
+    if (!outDir) {
+      console.error("dashboard --workbench requires --out-dir so regenerated data has a stable folder");
+      process.exit(2);
+    }
+    try {
+      await serveDashboardWorkbench(outDir, targetArg(), { ...opts, host, port });
+    } catch (error) {
+      console.error(error.message);
+      process.exit(1);
+    }
+  }
+  if (watch) {
+    if (!outDir) {
+      console.error("dashboard --watch requires --out-dir so updates are written to a stable folder");
+      process.exit(2);
+    }
+    const target = targetArg();
+    const docsRoot = path.basename(path.resolve(target)) === "docs" ? path.resolve(target) : path.join(path.resolve(target), "docs");
+    const regenerate = () => {
+      try {
+        console.log(writeDashboardFolder(outDir, target, opts));
+        console.log(`dashboard regenerated: ${new Date().toISOString()}`);
+      } catch (error) {
+        console.error(`dashboard regeneration failed: ${error.message}`);
+      }
+    };
+    regenerate();
+    let timer = null;
+    const watcher = fs.watch(docsRoot, { recursive: true }, () => {
+      clearTimeout(timer);
+      timer = setTimeout(regenerate, 300);
+    });
+    const close = () => {
+      watcher.close();
+      clearTimeout(timer);
+      process.exit(0);
+    };
+    process.on("SIGINT", close);
+    process.on("SIGTERM", close);
+    console.log(`watching ${docsRoot}`);
+    await new Promise(() => {});
+  }
+  if (outDir) {
+    console.log(writeDashboardFolder(outDir, targetArg(), opts));
+  } else {
+    console.log(writeDashboardSingleFile(out, targetArg(), opts));
+  }
+  process.exit(0);
+}

package/scripts/commands/migration-command.mjs

@@ -0,0 +1,126 @@
+import {
+  buildMigrationPlan,
+  runMigration,
+  verifyMigrationSession,
+} from "../lib/harness-core.mjs";
+import {
+  applyTaskAuditIndexMigration,
+  planTaskAuditIndexMigration,
+} from "../lib/task-audit-migration.mjs";
+
+export function runMigrationCommand(command, { args, takeFlag, takeOption, targetArg }) {
+  if (command === "migrate-task-audit-index") {
+    const json = takeFlag("--json");
+    const apply = takeFlag("--apply");
+    const planOnly = takeFlag("--plan");
+    try {
+      const result = apply && !planOnly
+        ? applyTaskAuditIndexMigration(targetArg())
+        : planTaskAuditIndexMigration(targetArg());
+      if (json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        console.log(`Task audit INDEX migration ${result.result}: ${result.target}`);
+        console.log(`actions: ${result.summary.actions}`);
+        console.log(`legacy audit blocks: ${result.summary.legacyAuditBlocks}`);
+        console.log(`failures: ${result.summary.failures}`);
+        for (const action of result.actions || []) console.log(`- ${action.taskId}: ${action.legacyBlocks.join(", ")}`);
+        for (const failure of result.failures || []) console.error(`Failure: ${failure.taskId}: ${failure.failure}`);
+      }
+      process.exit(result.failures?.length ? 1 : 0);
+    } catch (error) {
+      if (json && error.plan) console.error(JSON.stringify(error.plan, null, 2));
+      else console.error(error.message);
+      process.exit(1);
+    }
+  }
+
+  if (command === "migrate-plan") {
+    const json = takeFlag("--json");
+    const limit = Number.parseInt(takeOption("--limit", "20"), 10) || 20;
+    try {
+      const plan = buildMigrationPlan(targetArg(), { limit });
+      if (json) {
+        console.log(JSON.stringify(plan, null, 2));
+      } else {
+        console.log(`Migration Plan: ${plan.target}`);
+        console.log(`mode: ${plan.mode}`);
+        console.log(`warnings: ${plan.summary.warnings}`);
+        console.log(`task actions: ${plan.summary.taskActions}`);
+        console.log(`visual map actions: ${plan.summary.visualMapActions}`);
+        console.log(`legacy visual-only tasks: ${plan.summary.legacyVisualOnly}`);
+        console.log(`weak briefs: ${plan.summary.weakBrief}`);
+        console.log(`unknown classifications: ${plan.summary.unknownClassification}`);
+        console.log(`full cutover eligible: ${plan.summary.fullCutoverEligible ? "yes" : "no"}`);
+        console.log(`review actions: ${plan.summary.reviewSchemaGaps}`);
+        console.log(`legacy actions: ${plan.summary.legacyReferenceGaps}`);
+        console.log(`legacy residuals: ${plan.summary.legacyResiduals}`);
+        console.log(`recommended capabilities: ${plan.summary.recommendedCapabilities.join(", ") || "none"}`);
+        console.log("\nPhases:");
+        for (const phase of plan.phases) console.log(`- ${phase.id}: ${phase.title}`);
+        console.log("\nTop task actions:");
+        for (const action of plan.taskActions) console.log(`- ${action.taskId}: add ${action.files.join(", ")}`);
+        console.log("\nTop review actions:");
+        for (const action of plan.reviewActions) console.log(`- ${action.path}: add ${action.missing.join(", ")}`);
+        console.log("\nTop legacy residuals:");
+        for (const action of plan.legacyResiduals) console.log(`- ${action.taskId}: ${action.missing} (${action.reason})`);
+        console.log("\nNext commands:");
+        for (const next of plan.nextCommands) console.log(`- ${next}`);
+      }
+    } catch (error) {
+      console.error(error.message);
+      process.exit(1);
+    }
+    return;
+  }
+
+  if (command === "migrate-run") {
+    const locale = takeOption("--locale", "");
+    const assumeLocale = takeFlag("--assume-locale");
+    const allowDirty = takeFlag("--allow-dirty");
+    const planOnly = takeFlag("--plan-only");
+    const outDir = takeOption("--out-dir", "");
+    const sessionDir = takeOption("--session-dir", "");
+    try {
+      console.log(
+        JSON.stringify(
+          runMigration(targetArg(), {
+            locale,
+            assumeLocale,
+            allowDirty,
+            planOnly,
+            outDir,
+            sessionDir,
+          }),
+          null,
+          2,
+        ),
+      );
+    } catch (error) {
+      console.error(error.message);
+      process.exit(1);
+    }
+    return;
+  }
+
+  if (command === "migrate-verify") {
+    const json = takeFlag("--json");
+    const fullCutover = takeFlag("--full-cutover");
+    const sessionPath = args.shift();
+    if (!sessionPath) {
+      console.error("Missing session.json path");
+      process.exit(2);
+    }
+    const result = verifyMigrationSession(sessionPath, { fullCutover });
+    if (json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      for (const failure of result.failures) console.error(`Failure: ${failure}`);
+      for (const warning of result.warnings) console.log(`Warning: ${warning}`);
+      console.log(`Migration verify ${result.status}: ${result.sessionPath}`);
+    }
+    process.exit(result.status === "pass" ? 0 : 1);
+  }
+
+  throw new Error(`Unsupported migration command: ${command}`);
+}

package/scripts/commands/preset-command.mjs

@@ -0,0 +1,73 @@
+import {
+  checkPresetPackage,
+  inspectPresetPackage,
+  installPresetPackage,
+  listPresetPackages,
+  seedBundledPresets,
+  uninstallPresetPackage,
+} from "../lib/harness-core.mjs";
+
+export function runPresetCommand({ args, takeFlag, targetArg }) {
+  const subcommand = args.shift() || "list";
+  const json = takeFlag("--json");
+  const project = takeFlag("--project");
+  try {
+    if (subcommand === "list") {
+      const target = targetArg();
+      const presets = listPresetPackages({ targetInput: target }).map((preset) => ({
+        id: preset.id,
+        version: preset.version,
+        purpose: preset.purpose,
+        compatibleBudgets: preset.compatibleBudgets,
+        source: preset.source,
+        manifestPath: preset.manifestRelativePath,
+      }));
+      if (json) console.log(JSON.stringify({ presets }, null, 2));
+      else for (const preset of presets) console.log(`${preset.id}@${preset.version} [${preset.source}] ${preset.compatibleBudgets.join(",")} - ${preset.purpose}`);
+    } else if (subcommand === "inspect") {
+      const id = args.shift();
+      if (!id) throw new Error("Missing preset id");
+      const preset = inspectPresetPackage(id, { targetInput: targetArg() });
+      if (json) console.log(JSON.stringify(preset, null, 2));
+      else console.log(`${preset.id}@${preset.version}\n${preset.purpose}`);
+    } else if (subcommand === "check") {
+      const id = args.shift();
+      if (!id) throw new Error("Missing preset id");
+      const report = checkPresetPackage(id, { targetInput: targetArg() });
+      if (json) console.log(JSON.stringify(report, null, 2));
+      else {
+        for (const failure of report.failures) console.error(`Failure: ${failure}`);
+        for (const warning of report.warnings) console.log(`Warning: ${warning}`);
+        console.log(`Preset check ${report.status}: ${report.id}@${report.version}`);
+      }
+      process.exit(report.status === "pass" ? 0 : 1);
+    } else if (subcommand === "install") {
+      const force = takeFlag("--force");
+      const source = args.shift();
+      if (!source) throw new Error("Missing preset source");
+      const result = installPresetPackage(source, { force, scope: project ? "project" : "user", targetInput: targetArg() });
+      if (json) console.log(JSON.stringify(result, null, 2));
+      else console.log(`Installed preset ${result.id}@${result.version} to ${result.destination}`);
+    } else if (subcommand === "seed") {
+      const force = takeFlag("--force");
+      const dryRun = takeFlag("--dry-run");
+      const result = seedBundledPresets({ force, dryRun, scope: project ? "project" : "user", targetInput: targetArg() });
+      if (json) console.log(JSON.stringify(result, null, 2));
+      else {
+        console.log(`Seeded bundled presets to ${result.target}`);
+        for (const preset of result.presets) console.log(`${preset.action}: ${preset.id}@${preset.version}`);
+      }
+    } else if (subcommand === "uninstall") {
+      const id = args.shift();
+      if (!id) throw new Error("Missing preset id");
+      const result = uninstallPresetPackage(id, { scope: project ? "project" : "user", targetInput: targetArg() });
+      if (json) console.log(JSON.stringify(result, null, 2));
+      else console.log(`${result.removed ? "Removed" : "Preset not installed"}: ${result.id}`);
+    } else {
+      throw new Error(`Unknown preset subcommand: ${subcommand}`);
+    }
+  } catch (error) {
+    console.error(error.message);
+    process.exit(1);
+  }
+}