coding-agent-harness 1.0.7 → 1.1.0

package/dist/lib/task-repository.mjs

@@ -0,0 +1,192 @@
+import fs from "node:fs";
+import path from "node:path";
+import { datePrefix, lessonCandidatesFile, longRunningTaskContractFile, normalizeTarget, normalizeTaskId, readFileSafe, visualMapFile, } from "./core-shared.mjs";
+import { resolveHarnessPaths, taskIdFromDirectory, taskRefPath, } from "./harness-paths.mjs";
+import { collectTasks, listTaskPlanPaths, readTaskContractFile, readVisualMapContractFile, } from "./task-scanner.mjs";
+export { isActiveTaskState, parsePhases, taskCutoverCounters, } from "./task-scanner.mjs";
+export { parseTaskBudget, parseTaskContractInfo, parseTaskState, } from "./task-metadata.mjs";
+export { readVisualMapContractFile } from "./task-scanner.mjs";
+export function createScannerTaskRepository(targetInput = ".", defaults = {}) {
+    const target = normalizeRepositoryTarget(targetInput);
+    return {
+        list(query = {}) {
+            const tasks = collectTasks(target, {
+                requireGeneratedScaffoldProvenance: query.requireGeneratedScaffoldProvenance ?? defaults.requireGeneratedScaffoldProvenance,
+                closeoutContent: query.closeoutContent ?? defaults.closeoutContent,
+            });
+            return applyTaskQuery(tasks, query);
+        },
+        get(ref) {
+            const location = resolveRepositoryTaskLocation(target, ref);
+            const task = collectTasks(target, {
+                requireGeneratedScaffoldProvenance: defaults.requireGeneratedScaffoldProvenance,
+                closeoutContent: defaults.closeoutContent,
+            }).find((candidate) => candidate.id === location.id);
+            if (!task)
+                throw new Error(`Task not found: ${ref.id || ref.path || ""}`);
+            return task;
+        },
+        resolve(ref) {
+            return resolveRepositoryTaskLocation(target, ref);
+        },
+        readMaterials(ref) {
+            const location = resolveRepositoryTaskLocation(target, ref);
+            const taskDir = location.directory;
+            const taskPlanContent = readFileSafe(location.taskPlanPath);
+            return {
+                location,
+                index: readMaterialFile(path.join(taskDir, "INDEX.md")),
+                brief: readTaskContractFile(taskDir, "brief.md", ""),
+                taskPlan: materialFromContent(location.taskPlanPath, taskPlanContent),
+                executionStrategy: readMaterialFile(path.join(taskDir, "execution_strategy.md")),
+                visualMap: readVisualMapContractFile(taskDir, taskPlanContent),
+                progress: readMaterialFile(path.join(taskDir, "progress.md")),
+                findings: readMaterialFile(path.join(taskDir, "findings.md")),
+                review: readMaterialFile(path.join(taskDir, "review.md")),
+                lessonCandidates: readMaterialFile(path.join(taskDir, lessonCandidatesFile)),
+                longRunningContract: readMaterialFile(path.join(taskDir, longRunningTaskContractFile)),
+                walkthrough: readMaterialFile(path.join(taskDir, "walkthrough.md")),
+            };
+        },
+    };
+}
+export function taskPlanPathFromRecord(target, task) {
+    const raw = String(task.taskPlanPath || "");
+    if (raw)
+        return absoluteTargetPath(target, raw);
+    const taskDir = absoluteTargetPath(target, String(task.path || ""));
+    return path.join(taskDir, "task_plan.md");
+}
+function normalizeRepositoryTarget(targetInput) {
+    if (targetInput && typeof targetInput === "object" && "projectRoot" in targetInput)
+        return targetInput;
+    return normalizeTarget(typeof targetInput === "string" ? targetInput : ".");
+}
+function applyTaskQuery(tasks, query) {
+    let result = [...tasks];
+    if (query.includeArchived === false) {
+        result = result.filter((task) => task.deletionState === "active" && task.hiddenByDefault !== true);
+    }
+    if (query.state)
+        result = result.filter((task) => task.state === String(query.state).toLowerCase().replaceAll("-", "_"));
+    if (query.module)
+        result = result.filter((task) => task.module === query.module);
+    if (query.queue) {
+        const normalizedQueue = queryToken(query.queue);
+        result = result.filter((task) => (task.taskQueues || []).map(queryToken).includes(normalizedQueue));
+    }
+    if (query.preset)
+        result = result.filter((task) => queryToken(task.taskPreset || "none") === queryToken(query.preset));
+    if (query.review)
+        result = result.filter((task) => queryToken(task.reviewStatus || "") === queryToken(query.review));
+    if (query.lesson) {
+        const needle = queryToken(query.lesson);
+        result = result.filter((task) => [task.lessonCandidateStatus, task.lessonCandidateReviewDecision, task.lessonCandidatePromotionState].some((value) => queryToken(value) === needle));
+    }
+    if (query.missingMaterials)
+        result = result.filter((task) => !task.materialsReady);
+    if (query.search) {
+        const needle = String(query.search).toLowerCase();
+        result = result.filter((task) => [
+            task.id,
+            task.taskKey,
+            task.shortId,
+            task.title,
+            task.currentPath,
+            task.taskPlanPath,
+            task.module,
+            task.inferredModule,
+        ].some((value) => String(value || "").toLowerCase().includes(needle)));
+    }
+    return result;
+}
+function resolveRepositoryTaskLocation(target, ref) {
+    const harnessPaths = (target.harness || resolveHarnessPaths(target));
+    const pathLocation = ref.path ? resolvePathRef(target, harnessPaths, ref.path) : null;
+    if (pathLocation)
+        return pathLocation;
+    const raw = normalizeRawTaskRef(ref.id || ref.path || "");
+    if (!raw)
+        throw new Error("Missing task id");
+    const direct = taskRefPath(harnessPaths, raw);
+    if (direct && fs.existsSync(path.join(direct, "task_plan.md")))
+        return taskLocationFromDirectory(harnessPaths, direct);
+    const normalized = normalizeTaskId(raw);
+    const candidates = taskDirectories(target).filter((taskDir) => {
+        const id = taskIdFromDirectory(harnessPaths, taskDir);
+        const dirName = path.basename(taskDir);
+        return id === raw || id.endsWith(`/${raw}`) || dirName === normalized;
+    });
+    if (candidates.length === 1)
+        return taskLocationFromDirectory(harnessPaths, candidates[0]);
+    if (candidates.length > 1) {
+        const options = candidates.map((taskDir) => `- ${taskIdFromDirectory(harnessPaths, taskDir)}`).join("\n");
+        throw new Error(`Ambiguous task reference: ${ref.id || ref.path}\n${options}`);
+    }
+    if (!datePrefix.test(normalized)) {
+        const datedCandidates = taskDirectories(target).filter((taskDir) => {
+            const dirName = path.basename(taskDir);
+            return datePrefix.test(dirName) && dirName.replace(datePrefix, "") === normalized;
+        });
+        if (datedCandidates.length === 1)
+            return taskLocationFromDirectory(harnessPaths, datedCandidates[0]);
+        if (datedCandidates.length > 1) {
+            const options = datedCandidates.map((taskDir) => `- ${taskIdFromDirectory(harnessPaths, taskDir)}`).join("\n");
+            throw new Error(`Ambiguous task reference: ${ref.id || ref.path}\n${options}`);
+        }
+    }
+    const legacy = path.join(harnessPaths.tasksRoot, normalized);
+    if (fs.existsSync(path.join(legacy, "task_plan.md")))
+        return taskLocationFromDirectory(harnessPaths, legacy);
+    throw new Error(`Task not found: ${ref.id || ref.path}`);
+}
+function resolvePathRef(target, harnessPaths, rawPath) {
+    const absolute = absoluteTargetPath(target, rawPath);
+    const taskPlanPath = path.basename(absolute) === "task_plan.md" ? absolute : path.join(absolute, "task_plan.md");
+    if (!fs.existsSync(taskPlanPath))
+        return null;
+    return taskLocationFromDirectory(harnessPaths, path.dirname(taskPlanPath));
+}
+function absoluteTargetPath(target, rawPath) {
+    const withoutPrefix = String(rawPath || "").replace(/^TARGET:/, "");
+    if (path.isAbsolute(withoutPrefix))
+        return withoutPrefix;
+    const normalized = withoutPrefix.replace(/^\/+/, "");
+    if (!normalized)
+        return "";
+    return path.join(target.projectRoot, normalized);
+}
+function normalizeRawTaskRef(rawRef) {
+    return String(rawRef || "")
+        .replace(/^TARGET:/, "")
+        .replace(/^coding-agent-harness\/planning\//, "")
+        .replace(/^planning\//, "")
+        .replace(new RegExp(`^${legacyPlanningPrefix()}\\/`), "")
+        .replace(/^\/+/, "");
+}
+function legacyPlanningPrefix() {
+    return "docs\\/09-PLANNING";
+}
+function taskDirectories(target) {
+    return listTaskPlanPaths(target).map((taskPlanPath) => path.dirname(taskPlanPath));
+}
+function taskLocationFromDirectory(harnessPaths, directory) {
+    return {
+        id: taskIdFromDirectory(harnessPaths, directory),
+        directory,
+        taskPlanPath: path.join(directory, "task_plan.md"),
+    };
+}
+function readMaterialFile(filePath) {
+    return materialFromContent(filePath, readFileSafe(filePath));
+}
+function materialFromContent(filePath, content) {
+    return {
+        path: filePath,
+        content,
+        source: content.trim() ? "standalone" : "missing",
+    };
+}
+function queryToken(value) {
+    return String(value || "").trim().toLowerCase().replaceAll("_", "-");
+}

package/dist/lib/task-review-model.mjs

@@ -1,9 +1,8 @@
-// @ts-nocheck
 // Dynamic review queue modeling stays behavior-first until the metadata domain model PR.
 import fs from "node:fs";
 import path from "node:path";
 import { lessonCandidatesFile, longRunningTaskContractFile, toPosix, visualMapFile, } from "./core-shared.mjs";
-import { firstColumn, splitList, splitMarkdownRow, tableAfterHeading, } from "./markdown-utils.mjs";
+import { firstColumn, splitList, splitMarkdownRow, stripFencedCodeBlocks, tableAfterHeading, } from "./markdown-utils.mjs";
 import { implementationPhases, phaseHasRecordedProgress, } from "./phase-kind.mjs";
 import { validateReviewConfirmationGitAudit } from "./review-confirm-git-gate.mjs";
 import { isLessonCandidateDecisionComplete } from "./task-lesson-candidates.mjs";
@@ -18,6 +17,10 @@ export const reviewFindingColumns = {
     waiverBy: ["Waiver By", "豁免人"],
 };
 export function normalizeReviewBoolean(value) {
+    if (value === true)
+        return "yes";
+    if (value === false)
+        return "no";
     const raw = String(value || "").trim().toLowerCase();
     if (/^(yes|true|open|是|开放)$/.test(raw))
         return "yes";
@@ -49,8 +52,9 @@ export function parseTaskIdentity(taskPlanContent, fallbackTaskId) {
     };
 }
 export function parseTaskTombstone(taskPlanContent) {
-    const topLevelSupersedes = splitList(parseMetadataLine(taskPlanContent, ["Supersedes", "合并自"]));
-    const match = String(taskPlanContent || "").match(/^##\s*(?:Task Tombstone|任务墓碑)\s*$([\s\S]*?)(?=^##\s+|(?![\s\S]))/im);
+    const scanContent = stripFencedCodeBlocks(String(taskPlanContent || ""));
+    const topLevelSupersedes = splitList(parseMetadataLine(scanContent, ["Supersedes", "合并自"]));
+    const match = String(scanContent || "").match(/^##\s*(?:Task Tombstone|任务墓碑)\s*$([\s\S]*?)(?=^##\s+|(?![\s\S]))/im);
     const fields = match ? fieldsFromMarkdownBlock(match[1] || "") : new Map();
     if (fields.size === 0) {
         return {
@@ -58,6 +62,7 @@ export function parseTaskTombstone(taskPlanContent) {
             supersededBy: "",
             supersedes: topLevelSupersedes,
             deleteReason: "",
+            archiveMetadata: {},
             hiddenByDefault: false,
             reopenEligible: false,
             archiveEligible: false,
@@ -65,12 +70,16 @@ export function parseTaskTombstone(taskPlanContent) {
         };
     }
     const state = normalizeMetadataValue(fields.get("state") || fields.get("状态") || "soft-deleted", "soft-deleted");
-    const deletionState = ["soft-deleted", "superseded", "archived"].includes(state) ? state : "soft-deleted";
+    if (!["soft-deleted", "superseded", "archived"].includes(state)) {
+        throw new Error(`Invalid tombstone state: ${state}`);
+    }
+    const deletionState = state;
     return {
         deletionState,
         supersededBy: fields.get("superseded by") || fields.get("替代任务") || "",
         supersedes: [...new Set([...topLevelSupersedes, ...splitList(fields.get("supersedes") || fields.get("合并自") || "")])],
         deleteReason: fields.get("reason") || fields.get("原因") || "",
+        archiveMetadata: Object.fromEntries([...fields.entries()].filter(([key]) => !["state", "状态", "superseded by", "替代任务", "supersedes", "合并自", "reason", "原因", "reopen eligible", "可重新打开", "archive eligible", "可归档"].includes(key))),
         hiddenByDefault: true,
         reopenEligible: parseTombstoneBooleanLike(fields.get("reopen eligible") || fields.get("可重新打开")),
         archiveEligible: parseTombstoneBooleanLike(fields.get("archive eligible") || fields.get("可归档")),
@@ -108,7 +117,7 @@ export function parseAgentReviewSubmission(reviewContent, { taskKey = "" } = {})
         scannerVersion: fields.get("scanner version") || "",
     };
 }
-export function assessMaterialsReadiness({ budget, taskDir, brief, visualMap, reviewSubmission, lessonCandidates, phases, longRunningContractPath, reviewSurfaceRequired = true }) {
+export function assessMaterialsReadiness({ budget, taskDir, brief, visualMap, reviewSubmission, lessonCandidates, phases, longRunningContractPath, reviewSurfaceRequired = true, }) {
     const issues = [];
     const addIssue = (code, message, sourcePath, extra = {}) => {
         issues.push({
@@ -165,10 +174,13 @@ export function assessMaterialsReadiness({ budget, taskDir, brief, visualMap, re
 export function requiresReviewMaterials({ state = "unknown", lifecycleState = "unknown", closeoutStatus = "missing" } = {}) {
     return (state === "review" ||
         state === "done" ||
-        ["in_review", "review-blocked", "closing", "closed-review-pending"].includes(lifecycleState) ||
+        ["in_review", "review-blocked", "closing", "closed-review-pending", "confirmed-finalization-pending", "lesson-finalization-pending"].includes(lifecycleState) ||
         closeoutStatus === "closed");
 }
-export function deriveTaskQueues({ id, title, state, budget, reviewStatus, reviewSubmission, reviewConfirmation, reviewQueueState, materialIssues, risks, stateConflicts, lessonCandidates, closeoutStatus, tombstone, taskDir, target }) {
+export function hasPendingLessonWork(lessonCandidates) {
+    return lessonCandidates?.status === "needs-promotion" || lessonCandidates?.promotionState === "queued" || (lessonCandidates?.openCount ?? 0) > 0;
+}
+export function deriveTaskQueues({ id, title, state, budget, reviewStatus, reviewSubmission, reviewConfirmation, reviewQueueState, materialIssues, risks, stateConflicts, lessonCandidates, closeoutStatus, tombstone, taskDir, target, }) {
     const queueReasons = [];
     const pushReason = (reason) => {
         queueReasons.push({
@@ -224,7 +236,7 @@ export function deriveTaskQueues({ id, title, state, budget, reviewStatus, revie
             message: "Agent review was submitted, but closeout materials are not ready for human confirmation.",
         });
     }
-    const hasLessonWork = lessonCandidates?.status === "needs-promotion" || lessonCandidates?.promotionState === "queued" || lessonCandidates?.openCount > 0;
+    const hasLessonWork = hasPendingLessonWork(lessonCandidates);
     const taskQueues = [];
     if (tombstone.deletionState !== "active") {
         taskQueues.push("soft-deleted-superseded");
@@ -241,13 +253,21 @@ export function deriveTaskQueues({ id, title, state, budget, reviewStatus, revie
             taskQueues.push("lessons");
         if (budget === "simple" && state === "done" && closeoutStatus === "closed")
             taskQueues.push("finalized");
-        if (reviewStatus === "confirmed")
-            taskQueues.push(closeoutStatus === "closed" ? "finalized" : "confirmed");
+        if (reviewStatus === "confirmed") {
+            if (closeoutStatus === "closed")
+                taskQueues.push("finalized");
+            else {
+                taskQueues.push("confirmed");
+                if (!hasLessonWork)
+                    taskQueues.push("confirmed-finalization-pending");
+            }
+        }
     }
-    if (taskQueues.length === 0)
-        taskQueues.push("active");
+    const normalizedTaskQueues = [...new Set(taskQueues)];
+    if (normalizedTaskQueues.length === 0)
+        normalizedTaskQueues.push("active");
     return {
-        taskQueues,
+        taskQueues: normalizedTaskQueues,
         queueReasons,
         repairPrompt: renderRepairPrompt({ id, title, taskDir, target, reasons: queueReasons }),
     };
@@ -265,7 +285,6 @@ export function parseReviewConfirmation(reviewContent, { taskKey = "", taskAudit
     if (taskAudit) {
         const confirmation = reviewConfirmationFromTaskAudit(taskAudit, { taskKey });
         if (confirmation?.confirmed &&
-            confirmation.auditSource !== "migrated-legacy-review" &&
             projectRoot &&
             (indexPath || taskDir) &&
             confirmation.commitSha) {
@@ -312,9 +331,9 @@ function hasAgentReviewSignal(reviewContent) {
     return /本轮已检查|未发现阻塞目标的重要发现/.test(content);
 }
 export function isBlockingReviewRisk(risk) {
-    return /^P[0-2]$/i.test(risk?.severity || "") && (risk.open || risk.blocksRelease);
+    return /^P[0-2]$/i.test(risk?.severity || "") && Boolean(risk?.open || risk?.blocksRelease);
 }
-export function deriveLifecycleState({ state = "unknown", reviewStatus = "missing", closeoutStatus = "missing", budget = "standard" } = {}) {
+export function deriveLifecycleState({ state = "unknown", reviewStatus = "missing", closeoutStatus = "missing", budget = "standard", lessonCandidates = null } = {}) {
     if (reviewStatus === "blocked-open-findings")
         return "review-blocked";
     if (budget === "simple" && closeoutStatus === "closed")
@@ -323,6 +342,8 @@ export function deriveLifecycleState({ state = "unknown", reviewStatus = "missin
         return "closed-review-pending";
     if (closeoutStatus === "closed")
         return "closed";
+    if (reviewStatus === "confirmed")
+        return hasPendingLessonWork(lessonCandidates) ? "lesson-finalization-pending" : "confirmed-finalization-pending";
     if (state === "blocked")
         return "blocked";
     if (state === "done")

package/dist/lib/task-scanner.mjs

@@ -1,4 +1,3 @@
-// @ts-nocheck
 import fs from "node:fs";
 import path from "node:path";
 import { visualMapFile, legacyVisualRoadmapFile, lessonCandidatesFile, longRunningTaskContractFile, toPosix, readFileSafe, readJsonSafe, walkFiles, isArchivedHarnessPath, titleFromMarkdown, } from "./core-shared.mjs";
@@ -7,8 +6,35 @@ import { normalizePhaseActor, normalizePhaseKind, phaseCompletionAverage, } from
 import { legacyAuditIssues, parseTaskAuditMetadata, scaffoldProvenanceSummaryFromTaskAudit, taskAuditMaterialIssues, } from "./task-audit-metadata.mjs";
 import { parseTaskBudget, parseTaskContractInfo, parseTaskMetadata, parseTaskStateInfo, } from "./task-metadata.mjs";
 import { isLessonCandidateDecisionComplete, parseLessonCandidateStatus, validateLessonCandidateDetailArtifacts, } from "./task-lesson-candidates.mjs";
+import { collectUneditedTemplateMaterialIssues } from "./task-template-materials.mjs";
 import { assessMaterialsReadiness, collectReviewRisks, collectStateConflicts, deriveLifecycleState, deriveReviewQueueState, deriveTaskQueues, isBlockingReviewRisk, parseAgentReviewSubmission, parseReviewConfirmation, parseTaskIdentity, parseTaskTombstone, requiresReviewMaterials, taskReviewStatus, taskScannerVersion, } from "./task-review-model.mjs";
 import { resolveHarnessPaths, safeAdoptionCapability, taskIdFromDirectory, taskLocalWalkthrough, } from "./harness-paths.mjs";
+import { isExcludedTaskPlanPath } from "./task-discovery-contract.mjs";
+function asLessonCandidateStatus(value) {
+    const candidate = isRecord(value) ? value : {};
+    const rows = Array.isArray(candidate.rows) ? candidate.rows.filter(isRecord).map((row) => Object.fromEntries(Object.entries(row).map(([key, item]) => [key, String(item || "")]))) : [];
+    const issues = Array.isArray(candidate.issues) ? candidate.issues.map((item) => String(item)) : [];
+    return {
+        status: String(candidate.status || ""),
+        declaredStatus: candidate.declaredStatus === undefined ? undefined : String(candidate.declaredStatus || ""),
+        schemaVersion: candidate.schemaVersion === undefined ? undefined : String(candidate.schemaVersion || ""),
+        reviewDecision: String(candidate.reviewDecision || ""),
+        promotionState: String(candidate.promotionState || ""),
+        closeoutToken: String(candidate.closeoutToken || ""),
+        rows,
+        openCount: Number(candidate.openCount || 0),
+        issues,
+    };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function nestedRecord(value, key) {
+    if (!isRecord(value))
+        return {};
+    const nested = value[key];
+    return isRecord(nested) ? nested : {};
+}
 export { parseTaskBudget, parseTaskContractInfo, parseTaskMetadata, parseTaskState, parseTaskStateInfo, } from "./task-metadata.mjs";
 export { collectReviewRisks, deriveLifecycleState, deriveReviewQueueState, isBlockingReviewRisk, parseAgentReviewSubmission, parseReviewConfirmation, parseTaskIdentity, parseTaskTombstone, requiresReviewMaterials, taskReviewStatus, taskScannerVersion, } from "./task-review-model.mjs";
 export { parseTaskAuditMetadata, } from "./task-audit-metadata.mjs";
@@ -73,17 +99,16 @@ export function isActiveTaskState(state) {
     return ["active", "planned", "not_started", "in_progress", "review", "blocked", "reopened", "current-evidence"].includes(state);
 }
 export function listTaskPlanPaths(target) {
-    const harnessPaths = target.harness || resolveHarnessPaths(target);
+    const harnessPaths = (target.harness || resolveHarnessPaths(target));
     const taskRoots = harnessPaths.taskRoots;
     return taskRoots
-        .flatMap(walkFiles)
+        .flatMap((root) => walkFiles(root))
         .filter((file) => file.endsWith("task_plan.md"))
-        .filter((file) => !file.includes(`${path.sep}_task-template${path.sep}`))
-        .filter((file) => !file.includes(`${path.sep}_optional-structures${path.sep}`))
+        .filter((file) => !isExcludedTaskPlanPath(file, harnessPaths))
         .filter((file) => !isArchivedHarnessPath(file));
 }
 export function taskIdForDirectory(target, taskDir) {
-    return taskIdFromDirectory(target.harness || resolveHarnessPaths(target), taskDir);
+    return taskIdFromDirectory((target.harness || resolveHarnessPaths(target)), taskDir);
 }
 export function inferTaskClassification({ id, title, relative, explicitModule, legacyCandidate = false }) {
     if (explicitModule) {
@@ -93,6 +118,13 @@ export function inferTaskClassification({ id, title, relative, explicitModule, l
             bucket: "module",
         };
     }
+    if (id.startsWith("TASKS/")) {
+        return {
+            module: "base",
+            source: "structure",
+            bucket: legacyCandidate ? "legacy" : "current",
+        };
+    }
     const text = `${id} ${title} ${relative}`.toLowerCase();
     const rules = [
         ["dashboard", /dashboard|visibility|cockpit|console|ui|frontend|view|页面|看板|驾驶舱/],
@@ -157,7 +189,7 @@ export function taskCutoverCounters(tasks) {
     };
 }
 export function collectTasks(target, { requireGeneratedScaffoldProvenance = false, taskPlanPaths, closeoutContent } = {}) {
-    const harnessPaths = target.harness || resolveHarnessPaths(target);
+    const harnessPaths = (target.harness || resolveHarnessPaths(target));
     const paths = taskPlanPaths || listTaskPlanPaths(target);
     const closeout = closeoutContent ?? (harnessPaths.version === 2 ? "" : readFileSafe(harnessPaths.legacy.closeoutPath));
     return paths.map((taskPlanPath) => {
@@ -175,7 +207,7 @@ export function collectTasks(target, { requireGeneratedScaffoldProvenance = fals
         const progress = readFileSafe(progressPath);
         const review = readFileSafe(reviewPath);
         const indexContent = readFileSafe(indexPath);
-        const parsedLessonCandidates = parseLessonCandidateStatus(readFileSafe(lessonCandidatesPath));
+        const parsedLessonCandidates = asLessonCandidateStatus(parseLessonCandidateStatus(readFileSafe(lessonCandidatesPath)));
         const lessonDetailIssues = validateLessonCandidateDetailArtifacts(target, taskDir, parsedLessonCandidates);
         const lessonCandidates = lessonDetailIssues.length
             ? { ...parsedLessonCandidates, issues: [...parsedLessonCandidates.issues, ...lessonDetailIssues] }
@@ -195,7 +227,7 @@ export function collectTasks(target, { requireGeneratedScaffoldProvenance = fals
             required: requireGeneratedScaffoldProvenance && taskContract.generated,
         });
         const scaffoldProvenance = { summary: scaffoldProvenanceSummaryFromTaskAudit(taskAudit) };
-        const explicitModule = id.startsWith("MODULES/") ? id.split("/")[1] : null;
+        const explicitModule = id.startsWith("MODULES/") ? id.split("/")[1] ?? null : null;
         const legacyCandidate = brief.source !== "standalone" || visualMap.status === "legacy-only" || !fs.existsSync(executionStrategyPath);
         const classification = inferTaskClassification({ id, title, relative, explicitModule, legacyCandidate });
         const briefVisualStatus = explicitVisualMapStatus(brief.content);
@@ -216,25 +248,40 @@ export function collectTasks(target, { requireGeneratedScaffoldProvenance = fals
         const effectiveCloseoutStatus = budget === "simple" && stateInfo.state === "done" && completion === 100
             ? "closed"
             : closeoutInfo.status;
-        const lifecycleState = deriveLifecycleState({ state: stateInfo.state, reviewStatus, closeoutStatus: effectiveCloseoutStatus, budget });
+        const lifecycleState = deriveLifecycleState({ state: stateInfo.state, reviewStatus, closeoutStatus: effectiveCloseoutStatus, budget, lessonCandidates });
+        const reviewSurfaceRequired = requiresReviewMaterials({
+            state: stateInfo.state,
+            lifecycleState,
+            closeoutStatus: effectiveCloseoutStatus,
+        });
         const materialReadiness = assessMaterialsReadiness({
             budget,
             taskDir,
-            taskPlan,
             brief,
             visualMap,
             reviewSubmission,
             lessonCandidates,
             phases,
             longRunningContractPath,
-            reviewSurfaceRequired: requiresReviewMaterials({
-                state: stateInfo.state,
-                lifecycleState,
-                closeoutStatus: effectiveCloseoutStatus,
-            }),
+            reviewSurfaceRequired,
         });
+        const templateMaterialIssues = reviewSurfaceRequired
+            ? collectUneditedTemplateMaterialIssues(target, taskDir, {
+                briefContent: brief.content,
+                taskPlanContent: taskPlan,
+                executionStrategyContent: readFileSafe(executionStrategyPath),
+                visualMapContent: visualMap.content,
+                progressContent: progress,
+                findingsContent: readFileSafe(findingsPath),
+                reviewContent: review,
+                lessonCandidatesContent: readFileSafe(lessonCandidatesPath),
+                walkthroughPath: closeoutInfo.walkthroughPath,
+                humanReviewConfirmed: taskAudit.summary.humanReviewStatus === "confirmed",
+            })
+            : [];
         const materialIssues = [
             ...materialReadiness.issues,
+            ...templateMaterialIssues,
             ...taskAuditMaterialIssues(target, taskDir, taskAudit),
             ...legacyAuditIssues(target, taskDir, { briefContent: brief.content, reviewContent: review }),
         ];
@@ -344,6 +391,7 @@ export function collectTasks(target, { requireGeneratedScaffoldProvenance = fals
             supersededBy: tombstone.supersededBy,
             supersedes: tombstone.supersedes,
             deleteReason: tombstone.deleteReason,
+            archiveMetadata: tombstone.archiveMetadata || {},
             hiddenByDefault: tombstone.hiddenByDefault,
             reopenEligible: tombstone.reopenEligible,
             archiveEligible: tombstone.archiveEligible,
@@ -367,17 +415,21 @@ function collectMigrationSnapshot(target, metadata) {
     const bundlePath = evidenceBundle ? path.join(target.projectRoot, evidenceBundle) : "";
     const sessionPath = bundlePath ? path.join(bundlePath, "session.json") : "";
     const session = sessionPath && fs.existsSync(sessionPath) ? readJsonSafe(sessionPath, null) : null;
-    const summary = session?.plan?.summary || {};
+    const plan = nestedRecord(session, "plan");
+    const checks = nestedRecord(session, "checks");
+    const normal = nestedRecord(checks, "normal");
+    const strict = nestedRecord(checks, "strict");
+    const summary = nestedRecord(plan, "summary");
     return {
         targetLevel: metadata.migrationTargetLevel || "",
         achievedLevel: metadata.migrationAchievedLevel || "",
         evidenceBundle: evidenceBundle ? `TARGET:${evidenceBundle}` : "",
         evidencePresent: Boolean(bundlePath && fs.existsSync(bundlePath)),
         sessionPresent: Boolean(session),
-        sessionResult: session?.result || "",
-        normalStatus: session?.checks?.normal?.status || "",
-        strictStatus: session?.checks?.strict?.status || "",
-        strictDeferred: Boolean(session?.strictDeferred),
+        sessionResult: isRecord(session) ? String(session.result || "") : "",
+        normalStatus: String(normal.status || ""),
+        strictStatus: String(strict.status || ""),
+        strictDeferred: isRecord(session) ? Boolean(session.strictDeferred) : false,
         warnings: Number(summary.warnings || 0),
         taskActions: Number(summary.taskActions || 0),
         reviewSchemaGaps: Number(summary.reviewSchemaGaps || 0),
@@ -391,7 +443,7 @@ function formatEvidenceBundle(value) {
     return normalized ? `TARGET:${normalized}` : "";
 }
 function taskCloseoutInfo(target, taskPlanPath, closeout) {
-    const localWalkthrough = taskLocalWalkthrough(target.harness || resolveHarnessPaths(target), path.dirname(taskPlanPath));
+    const localWalkthrough = taskLocalWalkthrough((target.harness || resolveHarnessPaths(target)), path.dirname(taskPlanPath));
     if (localWalkthrough) {
         const content = readFileSafe(path.join(target.projectRoot, localWalkthrough));
         const status = /^Closeout Status\s*:\s*(closed|complete|completed|done|已关闭|已完成)\s*$/im.test(content)
@@ -401,7 +453,7 @@ function taskCloseoutInfo(target, taskPlanPath, closeout) {
     }
     if (!closeout.trim())
         return { status: "missing", walkthroughPath: "" };
-    const docsRelative = `docs/${toPosix(path.relative(target.docsRoot, taskPlanPath))}`;
+    const docsRelative = `docs/${toPosix(path.relative(target.docsRoot || path.join(target.projectRoot, "docs"), taskPlanPath))}`;
     const projectRelative = toPosix(path.relative(target.projectRoot, taskPlanPath));
     const line = closeout
         .split(/\r?\n/)