coding-agent-harness 1.0.1 → 1.0.2

package/scripts/test-harness.mjs

@@ -3,7 +3,7 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { spawnSync } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 
 const repoRoot = path.resolve(path.dirname(new URL(import.meta.url).pathname), "..");
 const packageVersion = JSON.parse(fs.readFileSync(path.join(repoRoot, "package.json"), "utf8")).version;
@@ -17,6 +17,14 @@ const sampleOpenFindingPattern = /^\|\s*(?:F|R|SR|V|RR|HL)-\d+\s*\|.*\|\s*(?:ope
 const englishFirstZhHeadingPattern = /^#{1,6}\s+(?:Reviewer Identity|Confidence Challenge|Material Findings|Non-Material Notes|Evidence Checked|Final Confidence Basis|Follow-Up Routing|Phase Graph|Phase Table|Context Packet|Artifact Index|Stop Condition|Pause Conditions|Deliverables|Module Session Prompt|Subagent\s*\/\s*Worker|Coordinator|Worktree|Slice ID|Parent Phase|Inputs|Verifier\b|Harness\b|Closeout\b|Lessons\b)/m;
 const zhMechanicalEnglishWorkflowPattern = /^\s*\d+\.\s*(?:implement|run locally|self-review|rerun evidence)\b/im;
 const zhMechanicalEvidencePhrasePattern = /\b(?:local smoke|browser or UI inspection|live environment smoke|reviewer findings|PR checks\s*\/\s*workflow run)\b/i;
+const { taskMigrationClassification, requiresCanonicalVisualMap } = await import("./lib/harness-core.mjs");
+const todayLocal = (() => {
+  const now = new Date();
+  const y = now.getFullYear();
+  const m = String(now.getMonth() + 1).padStart(2, "0");
+  const d = String(now.getDate()).padStart(2, "0");
+  return `${y}-${m}-${d}`;
+})();
 
 function run(args, options = {}) {
   const result = spawnSync(node, [cli, ...args], {
@@ -42,6 +50,44 @@ function expectJson(args) {
   return JSON.parse(result.stdout);
 }
 
+function waitForWorkbench(child) {
+  return new Promise((resolve, reject) => {
+    let stdout = "";
+    let stderr = "";
+    const timer = setTimeout(() => {
+      child.kill("SIGTERM");
+      reject(new Error(`workbench did not start\nSTDOUT:\n${stdout}\nSTDERR:\n${stderr}`));
+    }, 8000);
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+      const match = stdout.match(/(?:dashboard workbench|harness dev):\s+(http:\/\/127\.0\.0\.1:\d+\/)\s+csrf=([a-f0-9]+)/i);
+      if (!match) return;
+      clearTimeout(timer);
+      resolve({ url: match[1], csrf: match[2], stdout, stderr });
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("exit", (code) => {
+      if (code !== null && code !== 0) {
+        clearTimeout(timer);
+        reject(new Error(`workbench exited with ${code}\nSTDOUT:\n${stdout}\nSTDERR:\n${stderr}`));
+      }
+    });
+  });
+}
+
+async function waitForCondition(fn, message, { timeout = 8000, interval = 200 } = {}) {
+  const started = Date.now();
+  let lastValue;
+  while (Date.now() - started < timeout) {
+    lastValue = await fn();
+    if (lastValue) return lastValue;
+    await new Promise((resolve) => setTimeout(resolve, interval));
+  }
+  throw new Error(`${message}: ${JSON.stringify(lastValue)}`);
+}
+
 function commandExists(command) {
   const result = spawnSync(command, ["-v"], { encoding: "utf8" });
   return !result.error && result.status === 0;
@@ -85,20 +131,71 @@ function tclWord(value) {
   return `{${String(value).replace(/\\/g, "\\\\").replace(/}/g, "\\}")}}`;
 }
 
+function acceptNoLessonCandidate(taskDir) {
+  const candidatePath = path.join(taskDir, "lesson_candidates.md");
+  let content = fs.readFileSync(candidatePath, "utf8");
+  content = content
+    .replace("| Task-level status | pending-review |", "| Task-level status | no-candidate-accepted |")
+    .replace("| Review decision | pending-human-review |", "| Review decision | accepted-no-candidate |")
+    .replace("| Closeout token | pending |", "| Closeout token | checked-candidate:LC-TEST-000 |")
+    .replace(
+      "Not decided yet. Fill this only when review accepts that the task produced no reusable lesson candidate.",
+      "Human review accepted that this fixture produced no reusable lesson candidate.",
+    )
+    .replace("尚未判定。只有人工审查接受本任务没有可复用候选时，才填写这里。", "人工审查已接受该测试夹具没有可复用教训候选。");
+  fs.writeFileSync(candidatePath, content);
+}
+
+const skillContent = fs.readFileSync(path.join(repoRoot, "SKILL.md"), "utf8");
+assert(!skillContent.includes("Historical 12-Phase Bootstrap"), "SKILL.md should not carry the legacy 12-phase reference body");
+assert(
+  skillContent.includes("references/legacy-12-phase-bootstrap.md"),
+  "SKILL.md should route legacy bootstrap details to the reference document",
+);
+assert(
+  fs.readFileSync(path.join(repoRoot, "references/legacy-12-phase-bootstrap.md"), "utf8").includes("Historical 12-Phase Bootstrap"),
+  "legacy 12-phase bootstrap reference should exist",
+);
+
 expectPass(["check", "--profile", "source-package", "."]);
 if (fs.existsSync(path.join(repoRoot, ".harness-private"))) {
   expectPass(["check", "--profile", "private-harness", ".harness-private"]);
+  const privateStatus = expectJson(["status", "--json", ".harness-private"]);
+  assert(privateStatus.tasks.length >= 1, "private-harness status JSON should be complete and parseable");
 }
 
+const sourceBoundaryTarget = path.join(tmpRoot, "source-boundary-target");
+fs.mkdirSync(path.join(sourceBoundaryTarget, "scripts"), { recursive: true });
+fs.mkdirSync(path.join(sourceBoundaryTarget, "templates/planning"), { recursive: true });
+fs.mkdirSync(path.join(sourceBoundaryTarget, "docs/private"), { recursive: true });
+fs.mkdirSync(path.join(sourceBoundaryTarget, ".harness-private"), { recursive: true });
+fs.writeFileSync(path.join(sourceBoundaryTarget, "package.json"), "{}\n");
+fs.writeFileSync(path.join(sourceBoundaryTarget, "scripts/harness.mjs"), "#!/usr/bin/env node\n");
+fs.writeFileSync(path.join(sourceBoundaryTarget, "scripts/check-harness.mjs"), "#!/usr/bin/env node\n");
+fs.writeFileSync(path.join(sourceBoundaryTarget, "templates/planning/task_plan.md"), "# Task\n");
+fs.writeFileSync(path.join(sourceBoundaryTarget, "AGENTS.md"), "# Local only\n");
+fs.writeFileSync(path.join(sourceBoundaryTarget, "docs/private/plan.md"), "# Private\n");
+fs.writeFileSync(path.join(sourceBoundaryTarget, ".harness-private/AGENTS.md"), "# Private harness\n");
+spawnSync("git", ["init"], { cwd: sourceBoundaryTarget, encoding: "utf8" });
+spawnSync("git", ["add", "-f", "AGENTS.md", "docs/private/plan.md", ".harness-private/AGENTS.md"], { cwd: sourceBoundaryTarget, encoding: "utf8" });
+const sourceBoundaryCheck = run(["check", "--profile", "source-package", sourceBoundaryTarget]);
+assert(sourceBoundaryCheck.status !== 0, "source-package check should reject staged local-only harness files");
+assert(sourceBoundaryCheck.stderr.includes("private local-only file staged: AGENTS.md"), "source-package check should report staged AGENTS.md");
+assert(sourceBoundaryCheck.stderr.includes("private local-only file staged: docs/private/plan.md"), "source-package check should report staged docs/");
+assert(sourceBoundaryCheck.stderr.includes("private local-only file staged: .harness-private/AGENTS.md"), "source-package check should report staged .harness-private/");
+
 const englishTemplateFiles = relativeFiles(path.join(repoRoot, "templates"));
 const chineseTemplateFiles = relativeFiles(path.join(repoRoot, "templates-zh-CN"));
+const englishNonDashboardTemplateFiles = englishTemplateFiles.filter((file) => !file.startsWith("dashboard/"));
+const chineseNonDashboardTemplateFiles = chineseTemplateFiles.filter((file) => !file.startsWith("dashboard/"));
 assert(englishTemplateFiles.length > 0, "templates/ should contain English templates");
 assert(chineseTemplateFiles.length > 0, "templates-zh-CN/ should contain Chinese templates");
 assert(
-  JSON.stringify(englishTemplateFiles) === JSON.stringify(chineseTemplateFiles),
-  "templates/ and templates-zh-CN/ should expose the same template file set",
+  JSON.stringify(englishNonDashboardTemplateFiles) === JSON.stringify(chineseNonDashboardTemplateFiles),
+  "templates/ and templates-zh-CN/ should expose the same non-dashboard template file set",
 );
-for (const relativeFile of englishTemplateFiles) {
+assert(!chineseTemplateFiles.some((file) => file.startsWith("dashboard/")), "templates-zh-CN/dashboard should be removed; dashboard uses runtime i18n");
+for (const relativeFile of englishNonDashboardTemplateFiles) {
   const content = fs.readFileSync(path.join(repoRoot, "templates", relativeFile), "utf8");
   assert(!chineseCharacterPattern.test(content), `English template contains Chinese text: ${relativeFile}`);
   assert(!brokenMechanicalTemplatePattern.test(content), `English template contains mechanical placeholder text: ${relativeFile}`);
@@ -109,16 +206,25 @@ assert(
   fs.readFileSync(path.join(repoRoot, "templates-zh-CN", "AGENTS.md.template"), "utf8").includes("项目概况"),
   "templates-zh-CN should provide Chinese AGENTS.md content",
 );
-for (const relativeFile of chineseTemplateFiles) {
+for (const relativeFile of chineseNonDashboardTemplateFiles) {
   const content = fs.readFileSync(path.join(repoRoot, "templates-zh-CN", relativeFile), "utf8");
   assert(!brokenMechanicalTemplatePattern.test(content), `Chinese template contains mechanical placeholder text: ${relativeFile}`);
   assert(!staleDispositionPattern.test(content), `Chinese template contains stale disposition vocabulary: ${relativeFile}`);
   assert(!sampleOpenFindingPattern.test(content), `Chinese template contains a real open sample finding row: ${relativeFile}`);
   assert(!englishFirstZhHeadingPattern.test(content), `Chinese template contains English-first review heading: ${relativeFile}`);
   assert(!zhMechanicalEnglishWorkflowPattern.test(content), `Chinese template contains unlocalized workflow phrase: ${relativeFile}`);
-  assert(!zhMechanicalEvidencePhrasePattern.test(content), `Chinese template contains unlocalized evidence phrase: ${relativeFile}`);
+assert(!zhMechanicalEvidencePhrasePattern.test(content), `Chinese template contains unlocalized evidence phrase: ${relativeFile}`);
 }
 
+assert(taskMigrationClassification("unknown", "legacy-only") === "unknown-needs-human", "unknown legacy-only task should require human classification");
+assert(taskMigrationClassification("done", "not-needed") === "historical-no-map-needed", "done task with not-needed visual map should not require migration action");
+assert(taskMigrationClassification("active", "present") === "active", "active task with canonical visual map should remain active");
+assert(taskMigrationClassification("reopened", "missing") === "active", "reopened task should be treated as active migration work");
+assert(
+  requiresCanonicalVisualMap({ migrationClassification: "historical-no-map-needed" }) === false,
+  "historical-no-map-needed should not generate a canonical visual map action",
+);
+
 const exampleStatus = expectJson(["status", "--json", "examples/minimal-project"]);
 assert(exampleStatus.project.name === "minimal-project", "example status project name mismatch");
 assert(Array.isArray(exampleStatus.tasks), "example status missing tasks array");
@@ -131,8 +237,11 @@ expectPass(["dashboard", "--out", dashboardPath, "examples/minimal-project"]);
 assert(fs.existsSync(dashboardPath), "dashboard file was not created");
 const dashboardHtml = fs.readFileSync(dashboardPath, "utf8");
 assert(dashboardHtml.includes("Harness Dashboard"), "dashboard HTML missing title");
-assert(dashboardHtml.includes("Evidence"), "dashboard HTML missing evidence section");
-assert(dashboardHtml.includes("Recent Activity"), "dashboard HTML missing recent activity section");
+assert(dashboardHtml.includes("window.__HARNESS_DASHBOARD__"), "dashboard HTML missing inline data bundle");
+assert(dashboardHtml.includes("Human Visibility Dashboard"), "dashboard HTML missing v2 visibility copy");
+assert(dashboardHtml.includes("#/tasks"), "dashboard HTML missing task index route");
+assert(dashboardHtml.includes("#/review"), "dashboard HTML missing review queue route");
+assert(dashboardHtml.includes("function reviewQueue()"), "dashboard HTML missing review queue page implementation");
 
 const dashboardDir = path.join(tmpRoot, "dashboard-folder");
 expectPass(["dashboard", "--out-dir", dashboardDir, "examples/minimal-project"]);
@@ -156,10 +265,20 @@ const folderIndex = fs.readFileSync(path.join(dashboardDir, "index.html"), "utf8
 assert(folderIndex.includes("dashboard-data.js"), "dashboard folder index missing embedded data script");
 assert(folderIndex.includes("rel=\"icon\""), "dashboard index should suppress favicon request");
 const folderStatus = JSON.parse(fs.readFileSync(path.join(dashboardDir, "data/status.json"), "utf8"));
-assert(folderStatus.tasks[0].roadmapSource === "standalone", "folder status should use standalone visual_roadmap.md");
+assert(folderStatus.tasks[0].visualMapSource === "canonical", "folder status should use canonical visual_map.md");
+assert(folderStatus.tasks[0].roadmapSource === "canonical", "folder status should preserve roadmapSource compatibility as canonical");
+assert(folderStatus.schemaVersion === 2, "dashboard folder status should expose schemaVersion 2");
+assert(folderStatus.summary.fullCutoverEligible === true, "minimal project should expose fullCutoverEligible=true");
+assert(folderStatus.summary.legacyVisualOnlyCount === 0, "minimal project should expose zero legacy visual-only tasks");
+assert(folderStatus.summary.weakBriefCount === 0, "minimal project should expose zero weak briefs");
+assert(folderStatus.summary.unknownClassificationCount === 0, "minimal project should expose zero unknown migration classifications");
+assert(folderStatus.summary.missingCanonicalVisualMapCount === 0, "minimal project should expose zero missing canonical visual maps");
 const documents = JSON.parse(fs.readFileSync(path.join(dashboardDir, "data/documents.json"), "utf8"));
+assert(documents.documents.some((doc) => doc.path.endsWith("/brief.md")), "documents should include task briefs");
+assert(documents.documents.some((doc) => doc.path.endsWith("/task_plan.md")), "documents should include task plan fallback");
 assert(documents.documents.some((doc) => doc.path.endsWith("execution_strategy.md")), "documents missing execution strategy");
-assert(documents.documents.some((doc) => doc.path.endsWith("visual_roadmap.md")), "documents missing visual roadmap");
+assert(documents.documents.some((doc) => doc.path.endsWith("visual_map.md")), "documents missing visual map");
+assert(documents.documents.some((doc) => doc.path.endsWith("lesson_candidates.md")), "documents missing lesson candidates");
 const tables = JSON.parse(fs.readFileSync(path.join(dashboardDir, "data/tables.json"), "utf8"));
 assert(tables.tables.some((table) => table.kind === "harness-ledger"), "documents missing harness ledger table");
 assert(JSON.stringify(tables).includes("alpha|beta"), "markdown table parser should preserve escaped pipes");
@@ -169,10 +288,30 @@ assertGraphIntegrity(graph, "example graph");
 const dashboardApp = fs.readFileSync(path.join(dashboardDir, "assets/app.js"), "utf8");
 const dashboardMarkdown = fs.readFileSync(path.join(dashboardDir, "assets/markdown-reader.js"), "utf8");
 const dashboardMermaid = fs.readFileSync(path.join(dashboardDir, "assets/mermaid-renderer.js"), "utf8");
-assert(dashboardApp.includes("data-render-mode"), "dashboard missing render/source toggle");
-assert(dashboardApp.includes("escapeHtml(pageTitle())"), "dashboard page title must be escaped");
+assert(dashboardApp.includes("hashchange"), "dashboard should use hash routing");
+assert(dashboardApp.includes("taskDetail("), "dashboard should implement task detail route");
+assert(dashboardApp.includes("data-render-toggle"), "dashboard missing render/source toggle");
+assert(dashboardApp.includes("data-search"), "dashboard missing task search control");
+assert(dashboardApp.includes("taskGroupsPerPage"), "dashboard missing global task group paging");
+assert(dashboardApp.includes("taskStatsBar"), "dashboard missing task stats bar");
+assert(dashboardApp.includes("task-row-card"), "dashboard missing upgraded task row card");
+assert(dashboardApp.includes("fullCutoverEligible"), "dashboard missing full cutover summary field");
+assert(dashboardApp.includes("legacyVisualOnlyCount"), "dashboard missing legacy visual-only summary field");
+assert(dashboardApp.includes("weakBriefCount"), "dashboard missing weak brief summary field");
+assert(dashboardApp.includes("warningQueue()"), "dashboard missing warning queue workbench");
+assert(dashboardApp.includes("reviewWorkspace("), "dashboard missing review workspace route implementation");
+assert(dashboardApp.includes("[\"lessonCandidates\", \"lesson_candidates.md\"]"), "dashboard should expose lesson candidate documents");
+assert(dashboardApp.includes("migrationRunwayBreakdown"), "dashboard missing aggregate migration runway drilldown");
+assert(dashboardApp.includes("[\"brief\", \"brief.md\"]"), "dashboard should make brief.md the first task detail tab");
+assert(dashboardApp.includes("[\"visualMap\", \"visual_map.md\"]"), "dashboard should expose canonical visual_map.md tab");
+assert(dashboardApp.includes("projectMermaid"), "dashboard should render project flow from graph data");
+assert(dashboardApp.includes("escapeHtml(projectName())"), "dashboard project title must be escaped");
 assert(dashboardMarkdown.includes("rendered-table"), "dashboard missing rendered markdown table support");
 assert(dashboardMermaid.includes("mermaid-rendered"), "dashboard missing rendered mermaid output");
+const dashboardCss = fs.readFileSync(path.join(dashboardDir, "assets/app.css"), "utf8");
+assert(dashboardCss.includes(".runtime-banner"), "dashboard missing static read-only banner styling");
+assert(dashboardCss.includes("max-height: min(68vh, 620px)"), "dashboard missing mermaid viewport containment");
+assert(dashboardCss.includes(".review-workspace-grid"), "dashboard missing review workspace layout");
 for (const generated of ["data/status.json", "data/tables.json", "data/documents.json", "data/graph.json", "data/adoption.json", "assets/dashboard-data.js"]) {
   const content = fs.readFileSync(path.join(dashboardDir, generated), "utf8");
   assert(!content.includes(repoRoot), `${generated} leaked absolute repo path`);
@@ -187,6 +326,18 @@ const unsafeDocsOut = run(["dashboard", "--out-dir", "examples/minimal-project/d
 assert(unsafeDocsOut.status !== 0, "dashboard --out-dir target docs should be refused");
 const unsafeDocsChildOut = run(["dashboard", "--out-dir", "examples/minimal-project/docs/generated-dashboard", "examples/minimal-project"]);
 assert(unsafeDocsChildOut.status !== 0, "dashboard --out-dir inside target docs should be refused");
+const staticWorkbenchFlagDir = path.join(tmpRoot, "static-workbench-flag");
+expectPass(["dashboard", "--out-dir", staticWorkbenchFlagDir, "examples/minimal-project"]);
+assert(
+  fs.readFileSync(path.join(staticWorkbenchFlagDir, "index.html"), "utf8").includes("__HARNESS_WORKBENCH__ = false"),
+  "static dashboard folder should not enable workbench runtime",
+);
+assert(
+  fs.readFileSync(path.join(staticWorkbenchFlagDir, "assets/app.js"), "utf8").includes("staticReadOnly"),
+  "static dashboard app should render a visible read-only runtime boundary",
+);
+const helpOutput = expectPass(["help"]).stdout;
+assert(helpOutput.includes("harness dev"), "help should advertise harness dev as the daily dynamic workbench entry");
 
 const redactionTarget = path.join(tmpRoot, "redaction-target");
 fs.mkdirSync(path.join(redactionTarget, "docs/09-PLANNING/TASKS/path-check"), { recursive: true });
@@ -207,7 +358,11 @@ fs.mkdirSync(dryRunTarget);
 const dryRun = expectJson(["init", "--dry-run", "--locale", "zh-CN", "--capabilities", "core,dashboard", dryRunTarget]);
 assert(dryRun.dryRun === true, "init dry-run did not report dryRun true");
 assert(dryRun.locale === "zh-CN", "init dry-run did not preserve zh-CN locale");
-assert(!dryRun.changes.some((change) => change.destination.startsWith("docs/11-REFERENCE/")), "init scaffold should not mechanically copy reference standards");
+assert(dryRun.nextCommands?.some((command) => command.includes("coding-agent-harness dev")), "init output should recommend harness dev as the next human dashboard command");
+assert(
+  dryRun.changes.filter((change) => change.destination.startsWith("docs/11-REFERENCE/")).every((change) => change.destination === "docs/11-REFERENCE/external-source-intake-standard.md"),
+  "init scaffold should only copy the external source intake standard as a core reference",
+);
 assert(
   dryRun.changes.some((change) => change.source === "templates-zh-CN/planning/task_plan.md"),
   "init zh-CN dry-run should use localized task_plan template when available",
@@ -244,9 +399,15 @@ assert(zhInit.report?.locale === "zh-CN", "init output should include install re
 assert(zhInit.report?.capabilities?.some((capability) => capability.name === "core" && capability.default === true), "install report should explain core as default");
 assert(zhInit.report?.capabilities?.some((capability) => capability.name === "dashboard" && capability.selected === true), "install report should mark selected capabilities");
 assert(zhInit.report?.agentInstructions?.some((item) => item.includes("--locale")), "install report should remind agents to pass --locale explicitly");
+assert(zhInit.nextCommands?.some((command) => command.includes("coding-agent-harness dev")), "init should print a dev workbench next command");
 const zhRegistry = JSON.parse(fs.readFileSync(path.join(zhInitTarget, ".harness-capabilities.json"), "utf8"));
 assert(zhRegistry.locale === "zh-CN", "init should persist zh-CN locale");
 assert(fs.readFileSync(path.join(zhInitTarget, "AGENTS.md"), "utf8").includes("项目概况"), "zh-CN init should write Chinese AGENTS.md");
+assert(fs.existsSync(path.join(zhInitTarget, "docs/11-REFERENCE/external-source-intake-standard.md")), "zh-CN init should create external source intake standard");
+assert(
+  fs.readFileSync(path.join(zhInitTarget, "docs/04-DEVELOPMENT/external-source-packs/README.md"), "utf8").includes("外部资料包索引"),
+  "zh-CN init should create localized external source pack registry",
+);
 const zhReviewTemplate = fs.readFileSync(path.join(zhInitTarget, "docs/09-PLANNING/TASKS/_task-template/review.md"), "utf8");
 assert(zhReviewTemplate.includes("| ID | Severity | Finding | Evidence Checked | Required Action | Open | Disposition | Blocks Release | Follow-up |"), "zh-CN review template should preserve checker table headers");
 const zhInitCheck = expectJson(["status", "--json", zhInitTarget]);
@@ -256,8 +417,26 @@ const zhDashboardDir = path.join(tmpRoot, "zh-dashboard");
 expectPass(["dashboard", "--out-dir", zhDashboardDir, zhInitTarget]);
 const zhDashboardIndex = fs.readFileSync(path.join(zhDashboardDir, "index.html"), "utf8");
 const zhDashboardApp = fs.readFileSync(path.join(zhDashboardDir, "assets/app.js"), "utf8");
+const zhDashboardI18n = fs.readFileSync(path.join(zhDashboardDir, "assets/i18n.js"), "utf8");
 assert(zhDashboardIndex.includes("Harness 控制台"), "zh-CN dashboard should use localized index template");
-assert(zhDashboardApp.includes("项目驾驶舱"), "zh-CN dashboard should use localized app template");
+assert(zhDashboardApp.includes("projectCockpit"), "zh-CN dashboard should render through localized labels");
+assert(zhDashboardI18n.includes("控制台"), "zh-CN dashboard should include localized app labels");
+assert(zhDashboardApp.includes("data-language-toggle"), "dashboard should expose runtime language toggle");
+assert(zhDashboardIndex.includes("__HARNESS_LOCALE__"), "dashboard should bootstrap locale explicitly");
+
+const packageScriptTarget = path.join(tmpRoot, "package-script-target");
+fs.mkdirSync(packageScriptTarget);
+fs.writeFileSync(path.join(packageScriptTarget, "package.json"), JSON.stringify({ scripts: { test: "node --version" } }, null, 2));
+const packageScriptInit = expectJson(["init", "--locale", "en-US", "--capabilities", "core,dashboard", "--add-npm-scripts", packageScriptTarget]);
+assert(packageScriptInit.changes.some((change) => change.destination === "package.json" && change.action === "update-scripts"), "init --add-npm-scripts should report package.json script update");
+const packageScripts = JSON.parse(fs.readFileSync(path.join(packageScriptTarget, "package.json"), "utf8")).scripts;
+assert(packageScripts.test === "node --version", "init --add-npm-scripts should preserve existing scripts");
+assert(packageScripts["harness:dev"] === "coding-agent-harness dev .", "init --add-npm-scripts should add harness:dev");
+assert(packageScripts["harness:dashboard"] === "coding-agent-harness dashboard --out-dir tmp/harness-dashboard .", "init --add-npm-scripts should add static dashboard script");
+const noPackageScriptTarget = path.join(tmpRoot, "no-package-script-target");
+fs.mkdirSync(noPackageScriptTarget);
+const noPackageScripts = run(["init", "--dry-run", "--locale", "en-US", "--capabilities", "core", "--add-npm-scripts", noPackageScriptTarget]);
+assert(noPackageScripts.status !== 0, "init --add-npm-scripts should require an existing package.json");
 
 const enRunTarget = path.join(tmpRoot, "en-run-target");
 fs.mkdirSync(enRunTarget);
@@ -270,10 +449,476 @@ assert(
 const enInitTarget = path.join(tmpRoot, "en-init-target");
 fs.mkdirSync(enInitTarget);
 expectJson(["init", "--locale", "en-US", "--capabilities", "core,dashboard", enInitTarget]);
+assert(
+  fs.readFileSync(path.join(enInitTarget, "docs/11-REFERENCE/external-source-intake-standard.md"), "utf8").includes("External Source Intake Standard"),
+  "en-US init should create English external source intake standard",
+);
+assert(
+  fs.readFileSync(path.join(enInitTarget, "docs/04-DEVELOPMENT/external-source-packs/README.md"), "utf8").includes("External Source Packs"),
+  "en-US init should create English external source pack registry",
+);
 const enInitStatus = expectJson(["status", "--json", enInitTarget]);
 assert(enInitStatus.checkState.status === "pass", "en-US core+dashboard init should pass status check");
 assert(enInitStatus.checkState.warnings === 0, "en-US core+dashboard init should not warn about safe-adoption");
 
+const lifecycleTarget = path.join(tmpRoot, "lifecycle-target");
+fs.mkdirSync(lifecycleTarget);
+expectJson(["init", "--locale", "zh-CN", "--capabilities", "core,dashboard", lifecycleTarget]);
+const lifecycleDryRun = expectJson(["new-task", "phase-2-lifecycle", "--title", "阶段二任务生命周期", "--locale", "zh-CN", "--dry-run", lifecycleTarget]);
+assert(lifecycleDryRun.dryRun === true, "new-task dry-run should report dryRun true");
+assert(
+  lifecycleDryRun.changes.some((change) => change.destination.endsWith("brief.md") && change.action === "would-create"),
+  "new-task dry-run should plan brief.md",
+);
+assert(!fs.existsSync(path.join(lifecycleTarget, `docs/09-PLANNING/TASKS/${todayLocal}-phase-2-lifecycle`)), "new-task dry-run should not mutate target");
+const lifecycleCreate = expectJson(["new-task", "phase-2-lifecycle", "--title", "阶段二任务生命周期", "--locale", "zh-CN", lifecycleTarget]);
+assert(lifecycleCreate.task?.shortId === `${todayLocal}-phase-2-lifecycle`, "new-task should report normalized short task id");
+assert(lifecycleCreate.task?.id === `TASKS/${todayLocal}-phase-2-lifecycle`, "new-task should report relative task id");
+for (const required of ["brief.md", "task_plan.md", "execution_strategy.md", "visual_map.md", "findings.md", "lesson_candidates.md", "progress.md", "review.md"]) {
+  assert(
+    fs.existsSync(path.join(lifecycleTarget, `docs/09-PLANNING/TASKS/${todayLocal}-phase-2-lifecycle`, required)),
+    `new-task should create ${required}`,
+  );
+}
+assert(
+  fs.readFileSync(path.join(lifecycleTarget, `docs/09-PLANNING/TASKS/${todayLocal}-phase-2-lifecycle/brief.md`), "utf8").includes("阶段二任务生命周期"),
+  "new-task should render the requested title into brief.md",
+);
+assert(
+  fs.readFileSync(path.join(lifecycleTarget, `docs/09-PLANNING/TASKS/${todayLocal}-phase-2-lifecycle/task_plan.md`), "utf8").includes("Task Contract: harness-task/v1"),
+  "new-task should render the durable task contract marker",
+);
+const duplicateLifecycle = run(["new-task", `${todayLocal}-phase-2-lifecycle`, "--title", "duplicate", lifecycleTarget]);
+assert(duplicateLifecycle.status !== 0, "new-task should refuse to overwrite an existing task directory");
+const simpleLifecycle = expectJson(["new-task", "simple-lifecycle", "--budget", "simple", "--title", "简单任务", "--locale", "zh-CN", lifecycleTarget]);
+assert(simpleLifecycle.task?.budget === "simple", "new-task --budget simple should report simple budget");
+for (const required of ["brief.md", "task_plan.md", "visual_map.md", "progress.md"]) {
+  assert(
+    fs.existsSync(path.join(lifecycleTarget, `docs/09-PLANNING/TASKS/${todayLocal}-simple-lifecycle`, required)),
+    `simple task should create ${required}`,
+  );
+}
+for (const omitted of ["execution_strategy.md", "findings.md", "review.md", "lesson_candidates.md"]) {
+  assert(
+    !fs.existsSync(path.join(lifecycleTarget, `docs/09-PLANNING/TASKS/${todayLocal}-simple-lifecycle`, omitted)),
+    `simple task should not create ${omitted}`,
+  );
+}
+const simpleTaskPlan = fs.readFileSync(path.join(lifecycleTarget, `docs/09-PLANNING/TASKS/${todayLocal}-simple-lifecycle/task_plan.md`), "utf8");
+assert(/Selected budget\s*:\s*simple/i.test(simpleTaskPlan) || /选择预算\s*[:：]\s*simple/i.test(simpleTaskPlan), "simple task should persist selected budget");
+const longRunningLifecycle = expectJson(["new-task", "long-running-lifecycle", "--long-running", "--title", "长程任务", "--locale", "zh-CN", lifecycleTarget]);
+assert(longRunningLifecycle.task?.longRunning === true, "new-task --long-running should report longRunning true");
+assert(
+  fs.existsSync(path.join(lifecycleTarget, `docs/09-PLANNING/TASKS/${todayLocal}-long-running-lifecycle/long-running-task-contract.md`)),
+  "new-task --long-running should create long-running-task-contract.md",
+);
+const legacyPresetSessionDir = path.join(tmpRoot, "legacy-preset-session");
+fs.mkdirSync(path.join(legacyPresetSessionDir, "dashboard"), { recursive: true });
+fs.writeFileSync(path.join(legacyPresetSessionDir, "dashboard/index.html"), "<html>legacy migration dashboard</html>\n");
+fs.writeFileSync(path.join(legacyPresetSessionDir, "migrate-plan.json"), JSON.stringify({ operation: "migrate-plan", summary: { warnings: 2, legacyResiduals: 1 } }, null, 2));
+const legacyPresetSessionPath = path.join(legacyPresetSessionDir, "session.json");
+fs.writeFileSync(
+  legacyPresetSessionPath,
+  JSON.stringify(
+    {
+      operation: "migrate-run",
+      schemaVersion: 1,
+      generatedAt: "2026-05-22T00:00:00.000Z",
+      result: "adopted-with-strict-deferred",
+      target: lifecycleTarget,
+      sessionDir: legacyPresetSessionDir,
+      planOnly: false,
+      dashboard: { dir: path.join(legacyPresetSessionDir, "dashboard"), indexPath: path.join(legacyPresetSessionDir, "dashboard/index.html"), kind: "html-folder" },
+      plan: {
+        mode: "legacy-compat",
+        summary: {
+          warnings: 2,
+          visualMapActions: 0,
+          legacyVisualOnly: 0,
+          unknownClassification: 0,
+          weakBrief: 0,
+          missingCanonicalVisualMap: 0,
+          taskActions: 0,
+          reviewSchemaGaps: 0,
+          legacyReferenceGaps: 0,
+          legacyResiduals: 1,
+          fullCutoverEligible: false,
+          recommendedCapabilities: ["safe-adoption"],
+        },
+      },
+      checks: {
+        normal: { status: "warn", failures: 0, warnings: 2, failureDetails: [], warningDetails: ["legacy residual"] },
+        strict: { status: "fail", failures: 1, warnings: 2, failureDetails: ["strict residual"], warningDetails: [] },
+      },
+      strictDeferred: {
+        owner: "migration-owner",
+        trigger: "strict-cutover",
+        nextAction: "Assign real owner before full cutover.",
+        reason: "Historical residual remains.",
+        failureCount: 1,
+        failures: ["strict residual"],
+      },
+      git: {
+        before: { inGit: false, branch: "", entries: [], staged: [], dirty: false },
+        after: { inGit: false, branch: "", entries: [], staged: [], dirty: false },
+      },
+    },
+    null,
+    2,
+  ),
+);
+const legacyPresetDryRun = expectJson(["new-task", "--budget", "complex", "--preset", "legacy-migration", "--from-session", legacyPresetSessionPath, "--dry-run"]);
+assert(legacyPresetDryRun.task?.preset === "legacy-migration", "new-task legacy-migration dry-run should report preset");
+assert(!fs.existsSync(path.join(lifecycleTarget, `docs/09-PLANNING/TASKS/${todayLocal}-harness-v1-migration`)), "legacy-migration dry-run should not mutate target");
+const legacyPresetTask = expectJson(["new-task", "--budget", "complex", "--preset", "legacy-migration", "--from-session", legacyPresetSessionPath]);
+assert(legacyPresetTask.task?.id === `TASKS/${todayLocal}-harness-v1-migration`, "legacy-migration preset should derive a default task id");
+assert(legacyPresetTask.task?.kind === "project-migration", "legacy-migration preset should report project-migration kind");
+assert(legacyPresetTask.task?.preset === "legacy-migration", "legacy-migration preset should report preset");
+assert(legacyPresetTask.task?.evidenceBundle, "legacy-migration preset should report evidence bundle");
+const legacyPresetTaskDir = path.join(lifecycleTarget, `docs/09-PLANNING/TASKS/${todayLocal}-harness-v1-migration`);
+const legacyPresetTaskPlan = fs.readFileSync(path.join(legacyPresetTaskDir, "task_plan.md"), "utf8");
+assert(legacyPresetTaskPlan.includes("Task Preset: legacy-migration"), "legacy-migration task plan should persist preset metadata");
+assert(legacyPresetTaskPlan.includes("Migration Achieved Level: migration-deferred"), "strict-deferred session should start as migration-deferred");
+for (const required of ["session.json", "migrate-plan.json", "normal-check.json", "strict-check.json", "migrate-verify.json", "dashboard.hash.txt", "target-git-status.txt", "target-commit.txt", "harness-version.txt", "generated-at.txt"]) {
+  assert(
+    fs.existsSync(path.join(lifecycleTarget, legacyPresetTask.task.evidenceBundle, required)),
+    `legacy-migration preset should copy evidence file ${required}`,
+  );
+}
+const legacyPresetStatus = expectJson(["status", "--json", lifecycleTarget]);
+const legacyPresetStatusTask = legacyPresetStatus.tasks.find((task) => task.id === `TASKS/${todayLocal}-harness-v1-migration`);
+assert(legacyPresetStatusTask?.taskKind === "project-migration", "status should expose taskKind");
+assert(legacyPresetStatusTask?.taskPreset === "legacy-migration", "status should expose taskPreset");
+assert(legacyPresetStatusTask?.migrationSnapshot?.strictDeferred === true, "status should expose migration snapshot strictDeferred");
+const legacyPresetDashboardDir = path.join(tmpRoot, "legacy-preset-dashboard");
+expectPass(["dashboard", "--out-dir", legacyPresetDashboardDir, lifecycleTarget]);
+const legacyPresetDashboardData = fs.readFileSync(path.join(legacyPresetDashboardDir, "assets/dashboard-data.js"), "utf8");
+assert(legacyPresetDashboardData.includes("migrationSnapshot"), "dashboard bundle should expose migrationSnapshot");
+fs.writeFileSync(
+  path.join(legacyPresetTaskDir, "task_plan.md"),
+  legacyPresetTaskPlan.replace("Migration Achieved Level: migration-deferred", "Migration Achieved Level: migration-full-cutover"),
+);
+const falseFullCutoverCheck = run(["check", "--profile", "target-project", lifecycleTarget]);
+assert(falseFullCutoverCheck.status !== 0, "check should reject migration-full-cutover when evidence still has residuals");
+assert(falseFullCutoverCheck.stderr.includes("migration-full-cutover"), "full-cutover preset failure should explain achieved level");
+fs.writeFileSync(path.join(legacyPresetTaskDir, "task_plan.md"), legacyPresetTaskPlan);
+const promotableCandidatePath = path.join(lifecycleTarget, `docs/09-PLANNING/TASKS/${todayLocal}-long-running-lifecycle/lesson_candidates.md`);
+fs.writeFileSync(
+  promotableCandidatePath,
+  fs.readFileSync(promotableCandidatePath, "utf8")
+    .replace("| Task-level status | pending-review |", "| Task-level status | needs-promotion |")
+    .replace("| Review decision | pending-human-review |", "| Review decision | accepted-for-promotion |")
+    .replace("| Promotion state | not-promoted |", "| Promotion state | queued |")
+    .replace("| Closeout token | pending |", "| Closeout token | queued-promotion:LC-20260521-001 |")
+    .replace(
+      "| --- | --- | --- | --- | --- | --- |",
+      "| --- | --- | --- | --- | --- | --- |\n| LC-20260521-001 | needs-promotion | Commit contract must be explicit | Agents forget proactive commits when contracts are implicit | accepted-for-promotion | references/execution-workflow-standard.md |",
+    ),
+);
+const promoteDryRun = expectJson(["lesson-promote", "long-running-lifecycle", "LC-20260521-001", "--dry-run", lifecycleTarget]);
+assert(promoteDryRun.dryRun === true && promoteDryRun.lessonId === "L-2026-05-21-001", "lesson-promote --dry-run should derive the lesson id");
+const promoteRun = expectJson(["lesson-promote", "long-running-lifecycle", "LC-20260521-001", lifecycleTarget]);
+assert(promoteRun.lessonId === "L-2026-05-21-001", "lesson-promote should return the created lesson id");
+assert(
+  fs.existsSync(path.join(lifecycleTarget, "docs/01-GOVERNANCE/lessons/L-2026-05-21-001-commit-contract-must-be-explicit.md")),
+  "lesson-promote should create a detail document",
+);
+assert(
+  fs.readFileSync(path.join(lifecycleTarget, "docs/01-GOVERNANCE/Lessons-SSoT.md"), "utf8").includes("L-2026-05-21-001"),
+  "lesson-promote should append Lessons SSoT",
+);
+assert(fs.readFileSync(promotableCandidatePath, "utf8").includes("| LC-20260521-001 | promoted |"), "lesson-promote should mark the candidate row promoted");
+const promoteAgain = expectJson(["lesson-promote", "long-running-lifecycle", "LC-20260521-001", lifecycleTarget]);
+assert(promoteAgain.changes.length === 0, "lesson-promote should be idempotent after promotion");
+expectPass(["check", "--profile", "target-project", lifecycleTarget]);
+expectJson(["task-start", "simple-lifecycle", "--message", "开始简单任务", lifecycleTarget]);
+const simpleComplete = expectJson(["task-complete", "simple-lifecycle", "--message", "简单任务完成", lifecycleTarget]);
+assert(simpleComplete.task?.state === "done", "simple task should be able to complete without review");
+const earlyReview = run(["task-review", "review-too-early", lifecycleTarget]);
+assert(earlyReview.status !== 0, "task-review should reject unknown tasks");
+const tooEarlyTask = expectJson(["new-task", "review-too-early", "--title", "Too early review", "--locale", "zh-CN", lifecycleTarget]);
+assert(tooEarlyTask.task?.id === `TASKS/${todayLocal}-review-too-early`, "new-task should create review-too-early fixture");
+const tooEarlyReview = run(["task-review", "review-too-early", "--message", "too early", lifecycleTarget]);
+assert(tooEarlyReview.status !== 0, "task-review should reject tasks that are not in_progress");
+assert(tooEarlyReview.stderr.includes("in_progress"), "task-review invalid transition should explain required state");
+expectJson(["task-start", "phase-2-lifecycle", "--message", "开始实现生命周期切片", lifecycleTarget]);
+expectJson(["task-log", "phase-2-lifecycle", "--message", "补齐 CLI 与模板", "--evidence", "command:TARGET:npm-test:passed", lifecycleTarget]);
+const noPhaseProgressReview = run(["task-review", "phase-2-lifecycle", "--message", "阶段表尚未更新", lifecycleTarget]);
+assert(noPhaseProgressReview.status !== 0, "task-review should reject standard tasks whose visual map has no recorded phase progress");
+assert(
+  noPhaseProgressReview.stderr.includes("task-phase"),
+  "task-review phase-progress failure should tell the agent to run task-phase",
+);
+const lifecycleBlocked = expectJson(["task-block", "phase-2-lifecycle", "--message", "等待旧项目迁移验证", lifecycleTarget]);
+assert(lifecycleBlocked.task?.state === "blocked", "task-block should report blocked state");
+const lifecyclePhase = expectJson(["task-phase", "phase-2-lifecycle", "PH-01", "--state", "done", "--completion", "100", "--evidence", "present", lifecycleTarget]);
+assert(lifecyclePhase.task?.phases?.some((phase) => phase.id === "PH-01" && phase.state === "done" && phase.completion === 100), "task-phase should update visual map row");
+assert(
+  fs.readFileSync(path.join(lifecycleTarget, `docs/09-PLANNING/TASKS/${todayLocal}-phase-2-lifecycle/visual_map.md`), "utf8").includes("Visual Map Contract: v1.0"),
+  "new-task should render canonical visual map contract",
+);
+expectJson(["task-phase", "phase-2-lifecycle", "PH-01", "--state", "done", "--completion", "100", "--evidence", "present", lifecycleTarget]);
+const missingPhase = run(["task-phase", "phase-2-lifecycle", "NO_SUCH_PHASE", "--state", "done", lifecycleTarget]);
+assert(missingPhase.status !== 0, "task-phase should fail for unknown phase id");
+assert(missingPhase.stderr.includes("Phase not found"), "task-phase unknown phase should explain missing phase");
+const directComplete = run(["task-complete", "phase-2-lifecycle", "--message", "跳过审查完成", lifecycleTarget]);
+assert(directComplete.status !== 0, "standard task-complete should require review state");
+assert(directComplete.stderr.includes("task-review"), "standard task-complete failure should tell the user to run task-review first");
+expectJson(["task-start", "phase-2-lifecycle", "--message", "恢复执行生命周期切片", lifecycleTarget]);
+const lifecycleReview = expectJson(["task-review", "phase-2-lifecycle", "--message", "进入执行审查", lifecycleTarget]);
+assert(lifecycleReview.task?.state === "review", "task-review should report review state");
+const lifecycleReviewPath = path.join(lifecycleTarget, `docs/09-PLANNING/TASKS/${todayLocal}-phase-2-lifecycle/review.md`);
+fs.writeFileSync(
+  lifecycleReviewPath,
+  fs.readFileSync(lifecycleReviewPath, "utf8").replace(
+    "| --- | --- | --- | --- | --- | --- | --- | --- | --- |",
+    `| --- | --- | --- | --- | --- | --- | --- | --- | --- |\n| RR-001 | P1 | Human review is still pending | TARGET:docs/09-PLANNING/TASKS/${todayLocal}-phase-2-lifecycle/progress.md | confirm in dashboard | yes | open | yes | dashboard |`,
+  ),
+);
+const blockedComplete = run(["task-complete", "phase-2-lifecycle", "--message", "带阻塞审查项完成", lifecycleTarget]);
+assert(blockedComplete.status !== 0, "task-complete should reject open blocking review findings");
+assert(blockedComplete.stderr.includes("Open blocking review findings"), "task-complete blocked review failure should explain open findings");
+const blockedConfirm = run(["review-confirm", `TASKS/${todayLocal}-phase-2-lifecycle`, "--reviewer", "Human Reviewer", "--confirm", `${todayLocal}-phase-2-lifecycle`, lifecycleTarget]);
+assert(blockedConfirm.status !== 0, "review-confirm should reject tasks with open blocking review findings");
+assert(blockedConfirm.stderr.includes("Open blocking review findings"), "review-confirm blocked failure should explain open findings");
+fs.writeFileSync(
+  lifecycleReviewPath,
+  fs.readFileSync(lifecycleReviewPath, "utf8").replace(`| RR-001 | P1 | Human review is still pending | TARGET:docs/09-PLANNING/TASKS/${todayLocal}-phase-2-lifecycle/progress.md | confirm in dashboard | yes | open | yes | dashboard |`, `| RR-001 | P1 | Human review is closed | TARGET:docs/09-PLANNING/TASKS/${todayLocal}-phase-2-lifecycle/progress.md | confirmed in dashboard | no | closed | no | none |`),
+);
+const unconfirmedComplete = run(["task-complete", "phase-2-lifecycle", "--message", "未确认审查完成", lifecycleTarget]);
+assert(unconfirmedComplete.status !== 0, "task-complete should require human review confirmation");
+assert(unconfirmedComplete.stderr.includes("review-confirm"), "unconfirmed review failure should tell the user to run review-confirm");
+const missingWalkthroughConfirm = run(["review-confirm", `TASKS/${todayLocal}-phase-2-lifecycle`, "--reviewer", "Human Reviewer", "--message", "walkthrough reviewed", "--confirm", `${todayLocal}-phase-2-lifecycle`, lifecycleTarget]);
+assert(missingWalkthroughConfirm.status !== 0, "review-confirm should require a walkthrough before human confirmation");
+assert(missingWalkthroughConfirm.stderr.includes("walkthrough"), "missing walkthrough confirmation failure should explain the walkthrough requirement");
+const lifecycleWalkthrough = path.join(lifecycleTarget, `docs/10-WALKTHROUGH/${todayLocal}-phase-2-lifecycle-walkthrough.md`);
+fs.writeFileSync(
+  lifecycleWalkthrough,
+  "# Walkthrough: Phase 2 lifecycle\n\n## Summary\n\nHuman-readable walkthrough for review before completion.\n",
+);
+fs.appendFileSync(
+  path.join(lifecycleTarget, "docs/10-WALKTHROUGH/Closeout-SSoT.md"),
+  `\n| CL-PHASE-2-LIFECYCLE | 2026-05-21 | Phase 2 lifecycle | \`docs/09-PLANNING/TASKS/${todayLocal}-phase-2-lifecycle/task_plan.md\` | \`docs/09-PLANNING/TASKS/${todayLocal}-phase-2-lifecycle/review.md\` | \`docs/10-WALKTHROUGH/${todayLocal}-phase-2-lifecycle-walkthrough.md\` | pending human review | none | checked-none | pending |\n`,
+);
+acceptNoLessonCandidate(path.join(lifecycleTarget, `docs/09-PLANNING/TASKS/${todayLocal}-phase-2-lifecycle`));
+const preCompleteStatus = expectJson(["status", "--json", lifecycleTarget]);
+const preCompleteTask = preCompleteStatus.tasks.find((task) => task.id === `TASKS/${todayLocal}-phase-2-lifecycle`);
+assert(preCompleteTask?.walkthroughPath?.endsWith(`docs/10-WALKTHROUGH/${todayLocal}-phase-2-lifecycle-walkthrough.md`), "status should expose walkthrough before human review confirmation");
+const preCompleteConfirm = expectJson(["review-confirm", `TASKS/${todayLocal}-phase-2-lifecycle`, "--reviewer", "Human Reviewer", "--message", "walkthrough reviewed", "--confirm", `${todayLocal}-phase-2-lifecycle`, lifecycleTarget]);
+assert(preCompleteConfirm.task?.reviewStatus === "confirmed", "review-confirm should confirm review before task-complete");
+const lifecycleComplete = expectJson(["task-complete", "phase-2-lifecycle", "--message", "生命周期闭环完成", lifecycleTarget]);
+assert(lifecycleComplete.task?.state === "done", "task-complete should report done state");
+const lifecycleTasks = expectJson(["task-list", "--json", lifecycleTarget]);
+assert(lifecycleTasks.tasks.some((task) => task.id === `TASKS/${todayLocal}-phase-2-lifecycle` && task.state === "done"), "task-list should include completed task");
+assert(lifecycleTasks.tasks.some((task) => task.id === `TASKS/${todayLocal}-simple-lifecycle` && task.budget === "simple"), "task-list should expose parsed task budget");
+const doneLifecycleTasks = expectJson(["task-list", "--json", "--state", "done", lifecycleTarget]);
+assert(doneLifecycleTasks.tasks.every((task) => task.state === "done"), "task-list --state should filter states");
+const lifecycleStatus = expectJson(["status", "--json", lifecycleTarget]);
+assert(lifecycleStatus.schemaVersion === 2, "status should expose dashboard schemaVersion 2");
+const lifecycleTask = lifecycleStatus.tasks.find((task) => task.id === `TASKS/${todayLocal}-phase-2-lifecycle`);
+assert(lifecycleTask?.briefSource === "standalone", "status should expose standalone task brief");
+assert(lifecycleTask?.briefPath?.endsWith("/brief.md"), "status should expose the task brief path");
+assert(lifecycleTask?.classificationBucket === "current", "new v1 tasks should not be classified as legacy");
+assert(lifecycleStatus.summary?.briefCoverage?.missing === 0, "status should expose explicit brief coverage summary");
+assert(lifecycleTask?.state === "done", "status should read lifecycle task state from progress.md");
+assert(lifecycleTask?.lifecycleState === "closing", "done task with pending closeout should remain in closing lifecycle state");
+assert(lifecycleTask?.evidence?.some((item) => item.summary.includes("passed")), "status should collect task-log evidence");
+const confirmedStatus = expectJson(["status", "--json", lifecycleTarget]);
+const confirmedTask = confirmedStatus.tasks.find((task) => task.id === `TASKS/${todayLocal}-phase-2-lifecycle`);
+assert(confirmedTask?.reviewStatus === "confirmed", "status should expose confirmed review status");
+assert(confirmedTask?.closeoutStatus === "pending", "status should keep pending closeout separate from review confirmation");
+assert(fs.readFileSync(lifecycleReviewPath, "utf8").includes("Human Review Confirmation"), "review-confirm should write a human review confirmation block");
+assert(fs.readFileSync(path.join(lifecycleTarget, `docs/09-PLANNING/TASKS/${todayLocal}-phase-2-lifecycle/progress.md`), "utf8").includes("review-confirm"), "review-confirm should append a progress log entry");
+const moduleLifecycle = expectJson(["new-task", "module-lifecycle", "--module", "auth", "--budget", "complex", "--title", "模块生命周期", "--locale", "zh-CN", lifecycleTarget]);
+assert(moduleLifecycle.task?.id === `MODULES/auth/${todayLocal}-module-lifecycle`, "new-task --module should create a module task id");
+assert(fs.existsSync(path.join(lifecycleTarget, `docs/09-PLANNING/MODULES/auth/${todayLocal}-module-lifecycle/references/INDEX.md`)), "complex module task should create references index");
+assert(fs.existsSync(path.join(lifecycleTarget, `docs/09-PLANNING/MODULES/auth/${todayLocal}-module-lifecycle/artifacts/INDEX.md`)), "complex module task should create artifacts index");
+assert(fs.existsSync(path.join(lifecycleTarget, "docs/09-PLANNING/MODULES/auth/brief.md")), "new-task --module should create a module brief when missing");
+assert(fs.existsSync(path.join(lifecycleTarget, "docs/09-PLANNING/MODULES/auth/module_plan.md")), "new-task --module should create a module plan when missing");
+assert(fs.existsSync(path.join(lifecycleTarget, "docs/09-PLANNING/MODULES/auth/execution_strategy.md")), "new-task --module should create module-level execution strategy when missing");
+assert(fs.existsSync(path.join(lifecycleTarget, "docs/09-PLANNING/MODULES/auth/visual_map.md")), "new-task --module should create module-level visual map when missing");
+assert(fs.existsSync(path.join(lifecycleTarget, "docs/09-PLANNING/MODULES/auth/session_prompt.md")), "new-task --module should create a module session prompt when missing");
+fs.writeFileSync(
+  path.join(lifecycleTarget, "docs/09-PLANNING/Module-Registry.md"),
+  "# Module Registry\n\n## Active Modules\n\n| ID | Module | Path Scope | Owner | Status | Branch or Worktree | Task Plan | Shared Files | Depends On | Handoff Evidence | Residual | Updated |\n| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |\n| M-AUTH | Auth | src/auth/** | coordinator | reserved | n/a | docs/09-PLANNING/MODULES/auth/module_plan.md | none | none | pending | none | 2026-05-19 |\n",
+);
+fs.writeFileSync(
+  path.join(lifecycleTarget, "docs/09-PLANNING/MODULES/auth/module_plan.md"),
+  `# Auth Module Plan\n\n## Steps\n\n| Step ID | Name | Status | Task Plan | Depends On |\n| --- | --- | --- | --- | --- |\n| AUTH-01 | Setup | planned | docs/09-PLANNING/MODULES/auth/${todayLocal}-module-lifecycle/task_plan.md | none |\n`,
+);
+const moduleStep = expectJson(["module-step", "auth", "AUTH-01", "--state", "done", lifecycleTarget]);
+assert(moduleStep.moduleKey === "auth" && moduleStep.stepId === "AUTH-01", "module-step should report updated module step");
+assert(fs.readFileSync(path.join(lifecycleTarget, "docs/09-PLANNING/MODULES/auth/module_plan.md"), "utf8").includes("| AUTH-01 | Setup | done |"), "module-step should update module_plan status");
+assert(fs.readFileSync(path.join(lifecycleTarget, "docs/09-PLANNING/Module-Registry.md"), "utf8").includes("| M-AUTH | Auth | src/auth/** | coordinator | merged |"), "module-step should update module registry status when done");
+expectJson(["module-step", "auth", "AUTH-01", "--state", "done", lifecycleTarget]);
+const missingModuleStep = run(["module-step", "auth", "NO_SUCH_STEP", "--state", "done", lifecycleTarget]);
+assert(missingModuleStep.status !== 0, "module-step should fail for unknown step id");
+assert(missingModuleStep.stderr.includes("Module step not found"), "module-step unknown step should explain missing step");
+expectJson(["task-start", `MODULES/auth/${todayLocal}-module-lifecycle`, "--message", "开始模块任务审查夹具", lifecycleTarget]);
+expectJson(["task-phase", `MODULES/auth/${todayLocal}-module-lifecycle`, "PH-01", "--state", "done", "--completion", "100", "--evidence", "present", lifecycleTarget]);
+expectJson(["task-review", `MODULES/auth/${todayLocal}-module-lifecycle`, "--message", "模块任务进入审查", lifecycleTarget]);
+const moduleWalkthrough = path.join(lifecycleTarget, `docs/10-WALKTHROUGH/${todayLocal}-module-lifecycle-walkthrough.md`);
+fs.writeFileSync(
+  moduleWalkthrough,
+  "# Walkthrough: Module lifecycle\n\n## Summary\n\nHuman-readable module walkthrough for review confirmation.\n",
+);
+fs.appendFileSync(
+  path.join(lifecycleTarget, "docs/10-WALKTHROUGH/Closeout-SSoT.md"),
+  `\n| CL-MODULE-LIFECYCLE | 2026-05-21 | Module lifecycle | \`docs/09-PLANNING/MODULES/auth/${todayLocal}-module-lifecycle/task_plan.md\` | \`docs/09-PLANNING/MODULES/auth/${todayLocal}-module-lifecycle/review.md\` | \`docs/10-WALKTHROUGH/${todayLocal}-module-lifecycle-walkthrough.md\` | pending human review | none | checked-none | pending |\n`,
+);
+acceptNoLessonCandidate(path.join(lifecycleTarget, `docs/09-PLANNING/MODULES/auth/${todayLocal}-module-lifecycle`));
+const moduleConfirm = expectJson(["review-confirm", `MODULES/auth/${todayLocal}-module-lifecycle`, "--reviewer", "Human Reviewer", "--confirm", `${todayLocal}-module-lifecycle`, lifecycleTarget]);
+assert(moduleConfirm.task?.id === `MODULES/auth/${todayLocal}-module-lifecycle`, "review-confirm should accept full module task ids");
+const workbenchReviewTask = expectJson(["new-task", "workbench-review", "--title", "Workbench review gate", "--locale", "zh-CN", lifecycleTarget]);
+assert(workbenchReviewTask.task?.id === `TASKS/${todayLocal}-workbench-review`, "new-task should create workbench review gate fixture");
+const workbenchReviewProgress = path.join(lifecycleTarget, `docs/09-PLANNING/TASKS/${todayLocal}-workbench-review/progress.md`);
+const workbenchClosedReviewTask = expectJson(["new-task", "workbench-closed-review", "--title", "Closed review debt", "--locale", "zh-CN", lifecycleTarget]);
+assert(workbenchClosedReviewTask.task?.id === `TASKS/${todayLocal}-workbench-closed-review`, "new-task should create closed review debt fixture");
+const workbenchClosedReviewProgress = path.join(lifecycleTarget, `docs/09-PLANNING/TASKS/${todayLocal}-workbench-closed-review/progress.md`);
+fs.writeFileSync(
+  workbenchClosedReviewProgress,
+  fs.readFileSync(workbenchClosedReviewProgress, "utf8").replace(/^## 状态：.*$/m, "## 状态：done"),
+);
+const closedReviewWalkthrough = path.join(lifecycleTarget, "docs/10-WALKTHROUGH/workbench-closed-walkthrough.md");
+fs.writeFileSync(
+  closedReviewWalkthrough,
+  "# Walkthrough: Closed review debt\n\n## Summary\n\nHuman-readable closeout walkthrough for dashboard review.\n",
+);
+fs.appendFileSync(
+  path.join(lifecycleTarget, "docs/10-WALKTHROUGH/Closeout-SSoT.md"),
+  `\n| CL-WORKBENCH-CLOSED | 2026-05-21 | Closed review debt | \`docs/09-PLANNING/TASKS/${todayLocal}-workbench-closed-review/task_plan.md\` | \`docs/09-PLANNING/TASKS/${todayLocal}-workbench-closed-review/review.md\` | \`docs/10-WALKTHROUGH/workbench-closed-walkthrough.md\` | test evidence | none | checked-none | closed |\n`,
+);
+const closedReviewStatus = expectJson(["status", "--json", lifecycleTarget]);
+const closedReviewTask = closedReviewStatus.tasks.find((task) => task.id === `TASKS/${todayLocal}-workbench-closed-review`);
+assert(closedReviewTask?.walkthroughPath?.endsWith("docs/10-WALKTHROUGH/workbench-closed-walkthrough.md"), "status should expose task walkthrough path from Closeout SSoT");
+const workbenchDir = path.join(tmpRoot, "review-workbench");
+const workbench = spawn(node, [cli, "dashboard", "--workbench", "--out-dir", workbenchDir, "--host", "127.0.0.1", "--port", "0", lifecycleTarget], {
+  cwd: repoRoot,
+  stdio: ["ignore", "pipe", "pipe"],
+});
+const runtime = await waitForWorkbench(workbench);
+try {
+  const runtimeResponse = await fetch(new URL("api/runtime", runtime.url));
+  assert(runtimeResponse.status === 200, "workbench should expose runtime metadata");
+  const runtimePayload = await runtimeResponse.json();
+  assert(runtimePayload.mode === "workbench" && runtimePayload.csrfToken === runtime.csrf, "workbench runtime should expose mode and csrf token");
+  const dashboardData = fs.readFileSync(path.join(workbenchDir, "assets/dashboard-data.js"), "utf8");
+  assert(dashboardData.includes("Walkthrough: Closed review debt"), "dashboard data should include closeout walkthrough documents");
+  const badOrigin = await fetch(new URL("api/tasks/review-complete", runtime.url), {
+    method: "POST",
+    headers: { "content-type": "application/json", "x-harness-csrf": runtime.csrf, origin: "http://127.0.0.1:9" },
+    body: JSON.stringify({ taskId: `MODULES/auth/${todayLocal}-module-lifecycle`, confirmText: `${todayLocal}-module-lifecycle`, reviewer: "Human Reviewer" }),
+  });
+  assert(badOrigin.status === 403, "workbench should reject mismatched origins");
+  const badTask = await fetch(new URL("api/tasks/review-complete", runtime.url), {
+    method: "POST",
+    headers: { "content-type": "application/json", "x-harness-csrf": runtime.csrf, origin: runtime.url.replace(/\/$/, "") },
+    body: JSON.stringify({ taskId: "../bad", confirmText: "bad", reviewer: "Human Reviewer" }),
+  });
+  assert(badTask.status === 404, "workbench should reject unknown task ids");
+  const plannedReview = await fetch(new URL("api/tasks/review-complete", runtime.url), {
+    method: "POST",
+    headers: { "content-type": "application/json", "x-harness-csrf": runtime.csrf, origin: runtime.url.replace(/\/$/, "") },
+    body: JSON.stringify({ taskId: `TASKS/${todayLocal}-workbench-review`, confirmText: `${todayLocal}-workbench-review`, reviewer: "Human Reviewer" }),
+  });
+  assert(plannedReview.status === 409, "workbench review completion should reject tasks that are not in review state");
+  fs.writeFileSync(
+    workbenchReviewProgress,
+    fs.readFileSync(workbenchReviewProgress, "utf8").replace(/^## 状态：.*$/m, "## 状态：review"),
+  );
+  const missingWalkthroughResponse = await fetch(new URL("api/tasks/review-complete", runtime.url), {
+    method: "POST",
+    headers: { "content-type": "application/json", "x-harness-csrf": runtime.csrf, origin: runtime.url.replace(/\/$/, "") },
+    body: JSON.stringify({ taskId: `TASKS/${todayLocal}-workbench-review`, confirmText: `${todayLocal}-workbench-review`, reviewer: "Human Reviewer", message: "confirmed without walkthrough" }),
+  });
+  const missingWalkthroughText = await missingWalkthroughResponse.text();
+  assert(missingWalkthroughResponse.status === 400, `workbench review completion should require walkthrough, got ${missingWalkthroughResponse.status}: ${missingWalkthroughText}`);
+  assert(missingWalkthroughText.includes("walkthrough"), "workbench missing walkthrough rejection should explain walkthrough requirement");
+  const workbenchReviewWalkthrough = path.join(lifecycleTarget, "docs/10-WALKTHROUGH/workbench-review-walkthrough.md");
+  fs.writeFileSync(
+    workbenchReviewWalkthrough,
+    "# Walkthrough: Workbench review gate\n\n## Summary\n\nHuman-readable walkthrough for dashboard review confirmation.\n",
+  );
+  fs.appendFileSync(
+    path.join(lifecycleTarget, "docs/10-WALKTHROUGH/Closeout-SSoT.md"),
+    `\n| CL-WORKBENCH-REVIEW | 2026-05-21 | Workbench review gate | \`docs/09-PLANNING/TASKS/${todayLocal}-workbench-review/task_plan.md\` | \`docs/09-PLANNING/TASKS/${todayLocal}-workbench-review/review.md\` | \`docs/10-WALKTHROUGH/workbench-review-walkthrough.md\` | pending human review | none | checked-none | pending |\n`,
+  );
+  acceptNoLessonCandidate(path.join(lifecycleTarget, `docs/09-PLANNING/TASKS/${todayLocal}-workbench-review`));
+  const okResponse = await fetch(new URL("api/tasks/review-complete", runtime.url), {
+    method: "POST",
+    headers: { "content-type": "application/json", "x-harness-csrf": runtime.csrf, origin: runtime.url.replace(/\/$/, "") },
+    body: JSON.stringify({ taskId: `TASKS/${todayLocal}-workbench-review`, confirmText: `${todayLocal}-workbench-review`, reviewer: "Human Reviewer", message: "confirmed from workbench" }),
+  });
+  const okText = await okResponse.text();
+  assert(okResponse.status === 200, `workbench review completion should pass, got ${okResponse.status}: ${okText}`);
+  const okPayload = JSON.parse(okText);
+  assert(okPayload.task?.reviewStatus === "confirmed", "workbench review completion should return confirmed task status");
+  const closedReviewResponse = await fetch(new URL("api/tasks/review-complete", runtime.url), {
+    method: "POST",
+    headers: { "content-type": "application/json", "x-harness-csrf": runtime.csrf, origin: runtime.url.replace(/\/$/, "") },
+    body: JSON.stringify({ taskId: `TASKS/${todayLocal}-workbench-closed-review`, confirmText: `${todayLocal}-workbench-closed-review`, reviewer: "Human Reviewer", message: "closed debt confirmed from workbench" }),
+  });
+  const closedReviewText = await closedReviewResponse.text();
+  assert(closedReviewResponse.status === 409, `workbench review completion should reject closed closeout tasks, got ${closedReviewResponse.status}: ${closedReviewText}`);
+  assert(closedReviewText.includes("review"), "workbench closed closeout rejection should explain review stage boundary");
+} finally {
+  workbench.kill("SIGTERM");
+}
+const devDir = path.join(tmpRoot, "dev-workbench");
+const dev = spawn(node, [cli, "dev", "--no-open", "--out-dir", devDir, "--host", "127.0.0.1", "--port", "0", lifecycleTarget], {
+  cwd: repoRoot,
+  stdio: ["ignore", "pipe", "pipe"],
+});
+const devRuntime = await waitForWorkbench(dev);
+try {
+  assert(devRuntime.stdout.includes("outDir="), "harness dev should print the generated outDir");
+  const initialRuntime = await (await fetch(new URL("api/runtime", devRuntime.url))).json();
+  assert(initialRuntime.mode === "workbench" && initialRuntime.autoRefresh === true, "harness dev should start auto-refreshing workbench runtime");
+  assert(fs.readFileSync(path.join(devDir, "index.html"), "utf8").includes("__HARNESS_WORKBENCH__ = true"), "harness dev should enable workbench runtime in generated index");
+  const marker = `dev-refresh-${Date.now()}`;
+  fs.appendFileSync(
+    path.join(lifecycleTarget, `docs/09-PLANNING/TASKS/${todayLocal}-phase-2-lifecycle/progress.md`),
+    `\n\n## Dev Refresh Marker\n\n${marker}\n`,
+  );
+  await waitForCondition(async () => {
+    const runtimePayload = await (await fetch(new URL("api/runtime", devRuntime.url))).json();
+    if (runtimePayload.snapshotVersion === initialRuntime.snapshotVersion) return false;
+    const dashboardData = fs.readFileSync(path.join(devDir, "assets/dashboard-data.js"), "utf8");
+    return dashboardData.includes(marker) ? runtimePayload : false;
+  }, "harness dev should regenerate dashboard data after docs changes");
+} finally {
+  dev.kill("SIGTERM");
+}
+
+const zhRegistryTarget = path.join(tmpRoot, "zh-module-registry-target");
+fs.mkdirSync(zhRegistryTarget);
+expectJson(["init", "--locale", "zh-CN", "--capabilities", "core,module-parallel", zhRegistryTarget]);
+assert(fs.existsSync(path.join(zhRegistryTarget, "docs/09-PLANNING/MODULES/Session-Prompt-Pack.md")), "module-parallel init should create a session prompt pack");
+assert(fs.existsSync(path.join(zhRegistryTarget, "docs/09-PLANNING/MODULES/_module-template/module_plan.md")), "module-parallel init should create a module plan template");
+assert(fs.existsSync(path.join(zhRegistryTarget, "docs/09-PLANNING/MODULES/_module-template/session_prompt.md")), "module-parallel init should create a module session prompt template");
+assert(fs.existsSync(path.join(zhRegistryTarget, "docs/09-PLANNING/MODULES/_task-template/review.md")), "module-parallel init should create complete module task templates");
+expectJson(["new-task", "zh-task", "--module", "example", "--title", "中文模块任务", "--locale", "zh-CN", zhRegistryTarget]);
+fs.mkdirSync(path.join(zhRegistryTarget, "docs/09-PLANNING/MODULES/example"), { recursive: true });
+fs.writeFileSync(
+  path.join(zhRegistryTarget, "docs/09-PLANNING/MODULES/example/module_plan.md"),
+  `# 示例模块计划\n\n## 步骤\n\n| 步骤 ID | 名称 | 状态 | 任务计划 | 依赖 |\n| --- | --- | --- | --- | --- |\n| EXM-01 | 启动 | planned | docs/09-PLANNING/MODULES/example/${todayLocal}-zh-task/task_plan.md | none |\n`,
+);
+expectJson(["module-step", "example", "EXM-01", "--state", "done", zhRegistryTarget]);
+const zhRegistryContent = fs.readFileSync(path.join(zhRegistryTarget, "docs/09-PLANNING/Module-Registry.md"), "utf8");
+assert(zhRegistryContent.includes("| example | 示例模块 | EXM | `codex/example` | EXM-01 | completed |"), "module-step should update zh-CN module registry status/current step");
+const zhGraphDir = path.join(tmpRoot, "zh-module-dashboard");
+expectPass(["dashboard", "--out-dir", zhGraphDir, zhRegistryTarget]);
+const zhGraph = JSON.parse(fs.readFileSync(path.join(zhGraphDir, "data/graph.json"), "utf8"));
+assert(zhGraph.nodes.some((node) => node.type === "module" && node.id === "module:example" && node.state === "completed" && node.currentStep === "EXM-01"), "zh-CN module registry should populate dashboard graph");
+assert(zhGraph.nodes.some((node) => node.type === "step" && node.id === "step:EXM-01" && node.state === "done"), "zh-CN module plan should populate step graph");
+const moduleFiltered = expectJson(["task-list", "--json", "--module", "auth", lifecycleTarget]);
+assert(moduleFiltered.tasks.length === 1 && moduleFiltered.tasks[0].id === `MODULES/auth/${todayLocal}-module-lifecycle`, "task-list --module should filter module tasks");
+expectJson(["new-task", "module-lifecycle", "--title", "同名根任务", "--locale", "zh-CN", lifecycleTarget]);
+const ambiguousTask = run(["task-start", "module-lifecycle", "--message", "ambiguous", lifecycleTarget]);
+assert(ambiguousTask.status !== 0, "ambiguous task short name should fail");
+assert(ambiguousTask.stderr.includes("Ambiguous task reference"), "ambiguous task error should explain ambiguity");
+assert(ambiguousTask.stderr.includes(`TASKS/${todayLocal}-module-lifecycle`) && ambiguousTask.stderr.includes(`MODULES/auth/${todayLocal}-module-lifecycle`), "ambiguous task error should list candidate task paths");
+
 const capTarget = path.join(tmpRoot, "cap-target");
 fs.mkdirSync(capTarget);
 expectPass(["add-capability", "dashboard", capTarget]);
@@ -353,6 +998,49 @@ assert(legacyLoose.status === 0, "legacy contract gaps should be advisory withou
 const legacyStrict = run(["check", "--profile", "target-project", "--strict", legacyContractTarget]);
 assert(legacyStrict.status !== 0, "strict legacy contract gaps should fail");
 
+const invalidTaskStateTarget = path.join(tmpRoot, "invalid-task-state");
+fs.mkdirSync(path.join(invalidTaskStateTarget, "docs/09-PLANNING/TASKS/bad-state"), { recursive: true });
+fs.writeFileSync(path.join(invalidTaskStateTarget, "AGENTS.md"), "# AGENTS\n");
+fs.writeFileSync(
+  path.join(invalidTaskStateTarget, ".harness-capabilities.json"),
+  JSON.stringify({ version: 1, locale: "en-US", capabilities: [{ name: "core", state: "configured" }] }, null, 2),
+);
+fs.writeFileSync(path.join(invalidTaskStateTarget, "docs/09-PLANNING/TASKS/bad-state/task_plan.md"), "# Bad State\n");
+fs.writeFileSync(path.join(invalidTaskStateTarget, "docs/09-PLANNING/TASKS/bad-state/progress.md"), "# Progress\n\n## Status\n\nin progresss\n");
+const invalidTaskState = run(["check", "--profile", "target-project", invalidTaskStateTarget]);
+assert(invalidTaskState.status !== 0, "invalid explicit task state should fail for declared v1 targets");
+assert(invalidTaskState.stderr.includes("invalid task state"), "invalid task state failure should be explicit");
+fs.writeFileSync(path.join(invalidTaskStateTarget, "docs/09-PLANNING/TASKS/bad-state/progress.md"), "# Progress\n\n## Status\n\nunknown\n");
+const explicitUnknownTaskState = run(["check", "--profile", "target-project", invalidTaskStateTarget]);
+assert(explicitUnknownTaskState.status !== 0, "explicit unknown task state should fail for declared v1 targets");
+assert(explicitUnknownTaskState.stderr.includes("invalid task state"), "explicit unknown state failure should be explicit");
+
+const legacyPhaseTableTarget = path.join(tmpRoot, "legacy-phase-table");
+fs.mkdirSync(path.join(legacyPhaseTableTarget, "docs/09-PLANNING/TASKS/table-active"), { recursive: true });
+fs.writeFileSync(path.join(legacyPhaseTableTarget, "AGENTS.md"), "# Legacy Agents\n");
+fs.writeFileSync(path.join(legacyPhaseTableTarget, "docs/09-PLANNING/TASKS/table-active/task_plan.md"), "# Table Active\n");
+fs.writeFileSync(
+  path.join(legacyPhaseTableTarget, "docs/09-PLANNING/TASKS/table-active/progress.md"),
+  "# Progress\n\n## 阶段状态表\n| Phase | Status | Notes |\n| --- | --- | --- |\n| Phase 1 | Done | ok |\n| Phase 2 | In Progress | active |\n| Phase 3 | Pending | next |\n",
+);
+const legacyPhaseStatus = expectJson(["status", "--json", legacyPhaseTableTarget]);
+assert(legacyPhaseStatus.tasks[0].state === "in_progress", "Agora-style legacy phase table should infer active task state");
+
+const legacyChineseTarget = path.join(tmpRoot, "legacy-chinese");
+fs.mkdirSync(path.join(legacyChineseTarget, "docs/09-PLANNING/TASKS/old"), { recursive: true });
+fs.writeFileSync(path.join(legacyChineseTarget, "AGENTS.md"), "# 中文项目\n\n这是旧 harness 项目。\n");
+fs.writeFileSync(path.join(legacyChineseTarget, "docs/09-PLANNING/TASKS/old/task_plan.md"), "# 旧任务\n");
+const legacyChinesePlan = expectJson(["migrate-plan", "--json", legacyChineseTarget]);
+assert(legacyChinesePlan.locale === "zh-CN", "migrate-plan should infer zh-CN from Chinese legacy project text");
+assert(
+  legacyChinesePlan.nextCommands.some((command) => command.includes("migrate-run --locale zh-CN")),
+  "migrate-plan should recommend zh-CN migration run for Chinese legacy projects",
+);
+assert(
+  legacyChinesePlan.nextCommands.some((command) => command.includes(legacyChineseTarget)),
+  "migrate-plan should keep executable target paths in CLI output",
+);
+
 const legacyAdoptionTarget = path.join(tmpRoot, "legacy-adoption");
 fs.mkdirSync(path.join(legacyAdoptionTarget, "docs/09-PLANNING/TASKS/old"), { recursive: true });
 const legacyAgents = "# Legacy Agents\n\nLEGACY_DO_NOT_OVERWRITE\n";
@@ -395,9 +1083,176 @@ assert(
   adoptedStatus.checkState.details.warnings.some((warning) => warning.includes("adoption-needed")),
   "safe-adoption warnings should be routed as adoption-needed",
 );
+assert(adoptedStatus.tasks[0].inferredModule, "legacy task status should expose inferred module classification");
+assert(adoptedStatus.tasks[0].classificationBucket, "legacy task status should expose classification bucket");
+const legacyAdoptionDashboard = path.join(tmpRoot, "legacy-adoption-dashboard");
+expectPass(["dashboard", "--out-dir", legacyAdoptionDashboard, legacyAdoptionTarget]);
+const legacyAdoptionWarnings = JSON.parse(fs.readFileSync(path.join(legacyAdoptionDashboard, "data/adoption.json"), "utf8"));
+const firstAdoptionWarning = legacyAdoptionWarnings.warnings?.[0];
+assert(firstAdoptionWarning?.type, "adoption warning should expose stable type");
+assert(firstAdoptionWarning?.scope, "adoption warning should expose scope");
+assert(firstAdoptionWarning?.priority, "adoption warning should expose priority");
+assert(firstAdoptionWarning?.phase, "adoption warning should expose migration phase");
+assert(firstAdoptionWarning?.fixability, "adoption warning should expose fixability");
+assert(firstAdoptionWarning?.status, "adoption warning should expose queue status");
+assert(firstAdoptionWarning?.confidence, "adoption warning should expose confidence");
+assert(Array.isArray(firstAdoptionWarning?.affectedPaths), "adoption warning should expose affectedPaths array");
+assert(firstAdoptionWarning?.affected && firstAdoptionWarning?.requiredAction, "adoption warning should preserve affected and requiredAction fields");
+const migrationPlan = expectJson(["migrate-plan", "--json", "--limit", "5", legacyAdoptionTarget]);
+assert(migrationPlan.operation === "migrate-plan", "migrate-plan should report its operation");
+assert(migrationPlan.compatibility?.preserves?.some((item) => item.includes("AGENTS.md")), "migrate-plan should state preservation rules");
+assert(migrationPlan.phases?.some((phase) => phase.id === "MP-03"), "migrate-plan should include active task migration phase");
+assert(migrationPlan.summary?.missingExecutionStrategy >= 1, "migrate-plan should count missing execution strategies");
+assert(migrationPlan.summary?.missingVisualMap >= 1, "migrate-plan should count missing canonical visual maps");
+assert(migrationPlan.summary?.visualMapActions >= 1, "migrate-plan should expose visual map action count");
+assert(migrationPlan.summary?.legacyVisualOnly >= 1, "migrate-plan should expose legacy visual-only count");
+assert(migrationPlan.summary?.weakBrief >= 1, "migrate-plan should expose weak brief count");
+assert(migrationPlan.summary?.missingCanonicalVisualMap >= 1, "migrate-plan should expose missing canonical visual map count");
+assert(migrationPlan.summary?.fullCutoverEligible === false, "legacy migrate-plan should not be full-cutover eligible");
+assert(migrationPlan.taskActions?.some((action) => action.taskId === "old" && action.files.includes("execution_strategy.md")), "migrate-plan should include task-level file actions");
+assert(migrationPlan.taskActions?.some((action) => action.taskId === "old" && action.files.includes("visual_map.md")), "migrate-plan should include canonical visual map action");
+assert(migrationPlan.taskActions?.some((action) => action.taskId === "old" && action.files.includes("brief.md")), "migrate-plan should include active brief migration action");
+assert(migrationPlan.visualMapActions?.some((action) => action.taskId === "old"), "migrate-plan should expose visual map actions separately");
+assert(migrationPlan.legacyVisualOnlyTasks?.some((action) => action.taskId === "old"), "migrate-plan should expose legacy visual-only tasks separately");
+assert(migrationPlan.weakBriefTasks?.some((action) => action.taskId === "old"), "migrate-plan should expose weak brief tasks separately");
+assert(migrationPlan.taskActions?.some((action) => action.commands.some((command) => command.includes("_task-template/brief.md"))), "migrate-plan should emit a command per active task file");
+assert(migrationPlan.nextCommands?.some((command) => command.includes("migrate-run")), "migrate-plan should include migrate-run command");
+assert(migrationPlan.nextCommands?.some((command) => command.includes("migrate-verify --full-cutover")), "migrate-plan should include full-cutover verify command");
+const migrationPlanText = expectPass(["migrate-plan", "--limit", "3", legacyAdoptionTarget]).stdout;
+assert(migrationPlanText.includes("Migration Plan"), "migrate-plan text output should have a readable heading");
+assert(migrationPlanText.includes("legacy residuals:"), "migrate-plan text output should show residual counts");
+assert(migrationPlanText.includes("full cutover eligible:"), "migrate-plan text output should show full cutover eligibility");
 const adoptedStrict = run(["status", "--json", "--strict", legacyAdoptionTarget]);
 assert(adoptedStrict.status !== 0, "safe-adoption strict status should still fail on historical contract gaps");
 
+const migrationRunTarget = path.join(tmpRoot, "migration-run");
+fs.mkdirSync(path.join(migrationRunTarget, "docs/09-PLANNING/TASKS/old"), { recursive: true });
+fs.writeFileSync(path.join(migrationRunTarget, "AGENTS.md"), "# 旧项目 Agents\n\nLegacy English notes are still present.\n");
+fs.writeFileSync(path.join(migrationRunTarget, "docs/09-PLANNING/TASKS/old/task_plan.md"), "# Old Task\n\nThis active task predates v1.\n");
+fs.writeFileSync(path.join(migrationRunTarget, "docs/09-PLANNING/TASKS/old/progress.md"), "# Progress\n\n## Status\n\nplanned\n");
+spawnSync("git", ["init"], { cwd: migrationRunTarget, encoding: "utf8" });
+spawnSync("git", ["add", "."], { cwd: migrationRunTarget, encoding: "utf8" });
+spawnSync("git", ["-c", "user.name=Harness Test", "-c", "user.email=harness@example.test", "commit", "-m", "legacy baseline"], {
+  cwd: migrationRunTarget,
+  encoding: "utf8",
+});
+const migrationSessionDir = path.join(tmpRoot, "migration-session");
+const migrationDashboardDir = path.join(tmpRoot, "migration-dashboard");
+const migrationRun = expectJson([
+  "migrate-run",
+  "--locale",
+  "zh-CN",
+  "--session-dir",
+  migrationSessionDir,
+  "--out-dir",
+  migrationDashboardDir,
+  migrationRunTarget,
+]);
+assert(migrationRun.operation === "migrate-run", "migrate-run should report its operation");
+assert(migrationRun.result === "adopted-with-strict-deferred", "legacy migrate-run should keep strict cutover deferred");
+assert(migrationRun.checks.normal.status !== "fail", "legacy migrate-run should keep normal check usable");
+assert(migrationRun.checks.strict.status === "fail", "legacy migrate-run should record strict failure");
+assert(migrationRun.strictDeferred?.owner && migrationRun.strictDeferred?.trigger && migrationRun.strictDeferred?.nextAction, "strict-deferred migration should include owner, trigger, and nextAction");
+assert(fs.existsSync(migrationRun.sessionPath), "migrate-run should write session.json");
+assert(fs.existsSync(migrationRun.reportPath), "migrate-run should write report.md");
+assert(fs.existsSync(path.join(migrationDashboardDir, "index.html")), "migrate-run should generate an HTML dashboard folder");
+const migrationRegistry = JSON.parse(fs.readFileSync(path.join(migrationRunTarget, ".harness-capabilities.json"), "utf8"));
+assert(migrationRegistry.locale === "zh-CN", "migrate-run should persist selected locale");
+assert(migrationRegistry.capabilities.some((capability) => capability.name === "safe-adoption"), "migrate-run should declare safe-adoption");
+assert(migrationRegistry.capabilities.some((capability) => capability.name === "dashboard"), "migrate-run should declare dashboard");
+assert(!migrationRun.git.after.staged.length, "migrate-run should not stage target files");
+assert(
+  spawnSync("git", ["-C", migrationRunTarget, "diff", "--cached", "--name-only"], { encoding: "utf8" }).stdout.trim() === "",
+  "migrate-run should leave the target git index untouched",
+);
+const migrationVerify = expectJson(["migrate-verify", "--json", migrationRun.sessionPath]);
+assert(migrationVerify.status === "pass", "migrate-verify should pass for migrate-run output");
+assert(migrationVerify.dashboard?.indexPath?.endsWith("index.html"), "migrate-verify should preserve HTML dashboard evidence");
+const migrationFullCutover = run(["migrate-verify", "--json", "--full-cutover", migrationRun.sessionPath]);
+assert(migrationFullCutover.status !== 0, "full cutover verify should reject baseline legacy-only migration output");
+
+const falseSessionPath = path.join(tmpRoot, "false-session.json");
+fs.writeFileSync(
+  falseSessionPath,
+  JSON.stringify(
+    {
+      ...JSON.parse(fs.readFileSync(migrationRun.sessionPath, "utf8")),
+      dashboard: { dir: migrationRunTarget, indexPath: path.join(migrationRunTarget, "docs/Harness-Ledger.md"), kind: "html-folder" },
+    },
+    null,
+    2,
+  ),
+);
+const falseVerify = run(["migrate-verify", "--json", falseSessionPath]);
+assert(falseVerify.status !== 0, "migrate-verify should reject non-HTML dashboard evidence");
+
+const mixedLocaleTarget = path.join(tmpRoot, "mixed-locale");
+fs.mkdirSync(path.join(mixedLocaleTarget, "docs/09-PLANNING/TASKS/mixed"), { recursive: true });
+fs.writeFileSync(path.join(mixedLocaleTarget, "AGENTS.md"), "# 中文入口\n\n这是一个中文项目，迁移时需要选择中文或英文模板。\n");
+fs.writeFileSync(
+  path.join(mixedLocaleTarget, "docs/09-PLANNING/TASKS/mixed/task_plan.md"),
+  "# Legacy task\n\nThis English task plan intentionally contains enough words to make the language decision ambiguous for migration.\n",
+);
+const mixedLocaleFail = run(["migrate-run", "--plan-only", mixedLocaleTarget]);
+assert(mixedLocaleFail.status !== 0, "migrate-run should require --locale for mixed-language targets");
+assert(mixedLocaleFail.stderr.includes("--locale zh-CN"), "mixed-language failure should tell agents how to choose locale");
+const mixedLocalePlan = expectJson(["migrate-run", "--plan-only", "--locale", "zh-CN", "--session-dir", path.join(tmpRoot, "mixed-locale-session"), mixedLocaleTarget]);
+assert(mixedLocalePlan.result === "plan-only", "migrate-run --plan-only should produce a plan-only session");
+assert(mixedLocalePlan.localeDecision.selected === "zh-CN", "migrate-run --locale should resolve mixed-language decision");
+const planOnlyVerify = run(["migrate-verify", "--json", mixedLocalePlan.sessionPath]);
+assert(planOnlyVerify.status !== 0, "migrate-verify should reject plan-only sessions as completion evidence");
+
+const dirtyMigrationTarget = path.join(tmpRoot, "dirty-migration");
+fs.mkdirSync(dirtyMigrationTarget);
+fs.writeFileSync(path.join(dirtyMigrationTarget, "AGENTS.md"), "# Legacy\n");
+spawnSync("git", ["init"], { cwd: dirtyMigrationTarget, encoding: "utf8" });
+spawnSync("git", ["add", "."], { cwd: dirtyMigrationTarget, encoding: "utf8" });
+spawnSync("git", ["-c", "user.name=Harness Test", "-c", "user.email=harness@example.test", "commit", "-m", "baseline"], {
+  cwd: dirtyMigrationTarget,
+  encoding: "utf8",
+});
+fs.writeFileSync(path.join(dirtyMigrationTarget, "unreviewed.txt"), "dirty\n");
+const dirtyMigration = run(["migrate-run", "--locale", "en-US", dirtyMigrationTarget]);
+assert(dirtyMigration.status !== 0, "migrate-run should stop on dirty git targets by default");
+assert(dirtyMigration.stderr.includes("--allow-dirty"), "dirty guard should explain --allow-dirty escape hatch");
+
+const forgedStrictSessionPath = path.join(tmpRoot, "forged-strict-session.json");
+const forgedStrictSession = {
+  ...JSON.parse(fs.readFileSync(migrationRun.sessionPath, "utf8")),
+  result: "complete",
+  checks: { ...migrationRun.checks, strict: { status: "pass", failures: 0, warnings: 0 } },
+  strictDeferred: null,
+};
+fs.writeFileSync(forgedStrictSessionPath, `${JSON.stringify(forgedStrictSession, null, 2)}\n`);
+const forgedStrictVerify = run(["migrate-verify", "--json", forgedStrictSessionPath]);
+assert(forgedStrictVerify.status !== 0, "migrate-verify should rerun strict and reject forged strict pass sessions");
+
+const fakeDashboardDir = path.join(tmpRoot, "fake-dashboard");
+const fakeDashboardPath = path.join(fakeDashboardDir, "index.html");
+fs.mkdirSync(path.join(fakeDashboardDir, "assets"), { recursive: true });
+fs.mkdirSync(path.join(fakeDashboardDir, "data"), { recursive: true });
+fs.writeFileSync(fakeDashboardPath, '<html><script src="assets/dashboard-data.js"></script></html>\n');
+fs.writeFileSync(path.join(fakeDashboardDir, "assets/dashboard-data.js"), 'window.__HARNESS_DASHBOARD__ = {"status":{"schemaVersion":2,"project":{"name":"WrongProject"},"checkState":{}},"adoption":{"warnings":[]}};\n');
+fs.writeFileSync(path.join(fakeDashboardDir, "data/status.json"), "{}\n");
+fs.writeFileSync(path.join(fakeDashboardDir, "data/adoption.json"), "{}\n");
+const fakeDashboardSessionPath = path.join(tmpRoot, "fake-dashboard-session.json");
+const fakeDashboardSession = {
+  ...JSON.parse(fs.readFileSync(migrationRun.sessionPath, "utf8")),
+  dashboard: { dir: fakeDashboardDir, indexPath: fakeDashboardPath, kind: "html-folder" },
+};
+fs.writeFileSync(fakeDashboardSessionPath, `${JSON.stringify(fakeDashboardSession, null, 2)}\n`);
+const fakeDashboardVerify = run(["migrate-verify", "--json", fakeDashboardSessionPath]);
+assert(fakeDashboardVerify.status !== 0, "migrate-verify should reject arbitrary HTML as dashboard evidence");
+
+const missingGitSessionPath = path.join(tmpRoot, "missing-git-session.json");
+const missingGitSession = {
+  ...JSON.parse(fs.readFileSync(migrationRun.sessionPath, "utf8")),
+  git: undefined,
+};
+fs.writeFileSync(missingGitSessionPath, `${JSON.stringify(missingGitSession, null, 2)}\n`);
+const missingGitVerify = run(["migrate-verify", "--json", missingGitSessionPath]);
+assert(missingGitVerify.status !== 0, "migrate-verify should require git audit metadata");
+
 const legacyCheckerOnlyTarget = path.join(tmpRoot, "legacy-checker-only");
 fs.mkdirSync(legacyCheckerOnlyTarget);
 expectPass(["add-capability", "safe-adoption", "--locale", "en-US", legacyCheckerOnlyTarget]);
@@ -447,6 +1302,63 @@ if (fs.existsSync(mingjingDocs)) {
   assert(before === after, "mingjing docs changed during status/check/dashboard smoke");
 }
 
+// --- Date prefix auto-generation tests ---
+const datePrefixTarget = path.join(tmpRoot, "date-prefix-target");
+fs.mkdirSync(datePrefixTarget);
+expectJson(["init", "--locale", "en-US", "--capabilities", "core,dashboard", datePrefixTarget]);
+
+// 1. Bare slug gets auto-prefixed with local date
+const datePrefixCreate = expectJson(["new-task", "my-feature", "--title", "My Feature", datePrefixTarget]);
+assert(datePrefixCreate.task?.shortId === `${todayLocal}-my-feature`, "new-task bare slug should auto-prefix local date");
+assert(datePrefixCreate.task?.id === `TASKS/${todayLocal}-my-feature`, "new-task bare slug task id should include date prefix");
+assert(datePrefixCreate.task?.title === "My Feature", "new-task should use explicit title, not dated id");
+assert(
+  fs.existsSync(path.join(datePrefixTarget, `docs/09-PLANNING/TASKS/${todayLocal}-my-feature/task_plan.md`)),
+  "new-task bare slug should create dated directory",
+);
+
+// 2. Already-dated slug should NOT double-prefix
+const alreadyDated = expectJson(["new-task", `${todayLocal}-existing-date`, "--title", "Already Dated", datePrefixTarget]);
+assert(alreadyDated.task?.shortId === `${todayLocal}-existing-date`, "new-task already-dated slug should not double-prefix");
+assert(
+  fs.existsSync(path.join(datePrefixTarget, `docs/09-PLANNING/TASKS/${todayLocal}-existing-date/task_plan.md`)),
+  "new-task already-dated slug should create directory without double date",
+);
+assert(
+  !fs.existsSync(path.join(datePrefixTarget, `docs/09-PLANNING/TASKS/${todayLocal}-${todayLocal}-existing-date`)),
+  "new-task already-dated slug must not create double-dated directory",
+);
+
+// 3. Module task also gets date prefix
+const moduleWithDate = expectJson(["new-task", "module-feat", "--module", "payments", "--title", "Module Feature", datePrefixTarget]);
+assert(moduleWithDate.task?.shortId === `${todayLocal}-module-feat`, "new-task --module bare slug should auto-prefix local date");
+assert(moduleWithDate.task?.id === `MODULES/payments/${todayLocal}-module-feat`, "new-task --module task id should include date prefix");
+assert(
+  fs.existsSync(path.join(datePrefixTarget, `docs/09-PLANNING/MODULES/payments/${todayLocal}-module-feat/task_plan.md`)),
+  "new-task --module should create dated directory under module",
+);
+
+// 4. Bare slug lifecycle resolution: task-start resolves "my-feature" to dated directory
+const startByBareSlug = expectJson(["task-start", "my-feature", "--message", "start via bare slug", datePrefixTarget]);
+assert(startByBareSlug.task?.id === `TASKS/${todayLocal}-my-feature`, "task-start should resolve bare slug to dated directory");
+assert(startByBareSlug.task?.state === "in_progress", "task-start via bare slug should transition to in_progress");
+
+// 5. task-log also resolves bare slug
+expectJson(["task-log", "my-feature", "--message", "log via bare slug", "--evidence", "command:TARGET:test:passed", datePrefixTarget]);
+
+// 6. Ambiguous multi-match: create a second dated directory with same bare slug
+fs.mkdirSync(path.join(datePrefixTarget, "docs/09-PLANNING/TASKS/2025-01-01-my-feature"), { recursive: true });
+fs.writeFileSync(path.join(datePrefixTarget, "docs/09-PLANNING/TASKS/2025-01-01-my-feature/task_plan.md"), "# Old\n");
+const ambiguousBareSlug = run(["task-log", "my-feature", "--message", "ambiguous", datePrefixTarget]);
+assert(ambiguousBareSlug.status !== 0, "bare slug matching multiple dated directories should fail");
+assert(ambiguousBareSlug.stderr.includes("Ambiguous task reference"), "ambiguous bare slug should report ambiguity");
+assert(ambiguousBareSlug.stderr.includes(`${todayLocal}-my-feature`) && ambiguousBareSlug.stderr.includes("2025-01-01-my-feature"), "ambiguous error should list both dated candidates");
+
+// 7. Title preservation: title should be the semantic slug, not the date-id
+const noTitleCreate = expectJson(["new-task", "auto-title-check", datePrefixTarget]);
+assert(noTitleCreate.task?.title === "auto-title-check", "new-task without --title should use semantic slug as display title, not dated id");
+assert(noTitleCreate.task?.shortId === `${todayLocal}-auto-title-check`, "new-task without --title should still date-prefix the shortId");
+
 console.log("Harness v1 tests passed");
 
 function hasLocalAbsolutePath(content) {