coding-agent-harness 1.0.7 → 1.1.0

package/dist/lib/task-lifecycle.mjs

@@ -1,24 +1,38 @@
-// @ts-nocheck
 import fs from "node:fs";
 import path from "node:path";
 import crypto from "node:crypto";
-import { visualMapFile, legacyVisualRoadmapFile, lessonCandidatesFile, allowedTaskStates, allowedTaskBudgets, allowedPhaseStates, allowedEvidenceStatus, normalizeTarget, normalizeLocale, toPosix, readFileSafe, readBundledTemplate, todayDate, localDate, datePrefix, normalizeTaskId, renderTaskTemplate, } from "./core-shared.mjs";
+import { visualMapFile, legacyVisualRoadmapFile, allowedTaskStates, allowedTaskBudgets, allowedPhaseStates, allowedEvidenceStatus, normalizeTarget, normalizeLocale, toPosix, readFileSafe, readBundledTemplate, todayDate, localDate, datePrefix, normalizeTaskId, renderTaskTemplate } from "./core-shared.mjs";
 import { readCapabilityRegistry } from "./capability-registry.mjs";
 import { readPresetPackage } from "./preset-registry.mjs";
-import { assertPresetWriteScope, buildPresetContext, evaluateTemplateValues, resolvePresetInputs, renderPresetResourceIndex, renderPresetTaskTemplate, } from "./preset-engine.mjs";
-import { collectTasks, listTaskPlanPaths, parseTaskBudget, taskIdForDirectory, } from "./task-scanner.mjs";
+import { renderPresetResourceIndex } from "./preset-engine.mjs";
+import { parseTaskBudget } from "./task-metadata.mjs";
+import { createScannerTaskRepository } from "./task-repository.mjs";
 import { getColumn, firstColumn, updateMarkdownTableRow } from "./markdown-utils.mjs";
 import { validateLifecycleTransition, validateReviewEntryGate } from "./task-lifecycle/review-gates.mjs";
 import { advanceLifecyclePhase, autoRecordNoLessonCandidateDecision } from "./task-lifecycle/phase-sync.mjs";
-import { confirmTaskReview as confirmTaskReviewWithContext } from "./task-lifecycle/review-confirm.mjs";
+import { confirmTaskReview as confirmTaskReviewWithContext, finalizeDeferredTaskReviewConfirmation as finalizeDeferredTaskReviewConfirmationWithContext } from "./task-lifecycle/review-confirm.mjs";
 import { appendProgressLog, markWalkthroughClosed } from "./task-lifecycle/text-utils.mjs";
 import { buildScaffoldProvenance } from "./task-lifecycle/scaffold-provenance.mjs";
 import { buildCreationTaskAudit } from "./task-audit-metadata.mjs";
-import { renderAgentReviewSubmission, replaceAgentReviewSubmission, } from "./task-lifecycle/review-submission.mjs";
-import { appendLongRunningContractFile, moduleTemplateFiles, taskFilesForBudget, } from "./task-lifecycle/template-files.mjs";
-import { planCreateTaskChanges, refreshPresetCommandAudit, resolveImplicitCreateTarget, } from "./task-lifecycle/create-task-helpers.mjs";
-import { beginGovernanceSync, commitGovernanceSync, governanceRelativePaths, releaseGovernanceSync, syncModuleStepGovernance, syncTaskGovernance, } from "./governance-sync.mjs";
-import { taskRefPath } from "./harness-paths.mjs";
+import { renderAgentReviewSubmission, replaceAgentReviewSubmission } from "./task-lifecycle/review-submission.mjs";
+import { appendLongRunningContractFile, moduleTemplateFiles, taskFilesForBudget } from "./task-lifecycle/template-files.mjs";
+import { planCreateTaskChanges, refreshPresetCommandAudit, resolveImplicitCreateTarget } from "./task-lifecycle/create-task-helpers.mjs";
+import { beginGovernanceSync, commitGovernanceSync, governanceRelativePaths, releaseGovernanceSync, syncModuleStepGovernance, syncTaskGovernance } from "./governance-sync.mjs";
+import { normalizeHarnessModuleKey, prepareModuleRegistration, prepareModuleStepRegistrationUpdate, readHarnessModules, registeredHarnessModule } from "./module-registry.mjs";
+import { assertLifecyclePresetWriteScope, buildLifecyclePresetContext, evaluatePresetValues, renderLifecyclePresetTaskTemplate, resolveLifecyclePresetInputs } from "./task-lifecycle/preset-interop.mjs";
+import { taskIdFromDirectory } from "./harness-paths.mjs";
+function asLifecycleTarget(target) {
+    return target;
+}
+function changeDestinations(changes) {
+    return changes.map((change) => change.destination).filter(Boolean);
+}
+function lifecycleGateEvent(event) {
+    return String(event || "task-log");
+}
+function findReviewTaskByDirectory(target, taskDir) {
+    return findTaskByDirectory(asLifecycleTarget(normalizeTarget(target.projectRoot)), taskDir);
+}
 function taskRoot(target, taskId, { moduleKey = "" } = {}) {
     const normalizedTaskId = normalizeTaskId(taskId);
     if (moduleKey) {
@@ -30,59 +44,18 @@ function taskRoot(target, taskId, { moduleKey = "" } = {}) {
     return path.join(target.harness.tasksRoot, normalizedTaskId);
 }
 export function resolveTaskDirectory(target, taskRef) {
-    const raw = String(taskRef || "")
-        .replace(/^coding-agent-harness\/planning\//, "")
-        .replace(/^planning\//, "")
-        .replace(new RegExp(`^${legacyPlanningPrefix()}\\/`), "")
-        .replace(/^\/+/, "");
-    if (!raw)
-        throw new Error("Missing task id");
-    const direct = directTaskRefPath(target, raw);
-    if (direct && fs.existsSync(path.join(direct, "task_plan.md")))
-        return direct;
-    const normalized = normalizeTaskId(raw);
-    const candidates = listTaskPlanPaths(target)
-        .map((taskPlanPath) => path.dirname(taskPlanPath))
-        .filter((taskDir) => {
-        const id = taskIdForDirectory(target, taskDir);
-        const dirName = path.basename(taskDir);
-        return id === raw || id.endsWith(`/${raw}`) || dirName === normalized;
-    });
-    if (candidates.length === 1)
-        return candidates[0];
-    if (candidates.length > 1) {
-        const options = candidates.map((taskDir) => `- ${taskIdForDirectory(target, taskDir)}`).join("\n");
-        throw new Error(`Ambiguous task reference: ${taskRef}\n${options}`);
-    }
-    // Try bare slug resolution: match normalized slug against dated directories
-    if (!datePrefix.test(normalized)) {
-        const datedCandidates = listTaskPlanPaths(target)
-            .map((taskPlanPath) => path.dirname(taskPlanPath))
-            .filter((taskDir) => {
-            const dirName = path.basename(taskDir);
-            return datePrefix.test(dirName) && dirName.replace(datePrefix, "") === normalized;
-        });
-        if (datedCandidates.length === 1)
-            return datedCandidates[0];
-        if (datedCandidates.length > 1) {
-            const options = datedCandidates.map((taskDir) => `- ${taskIdForDirectory(target, taskDir)}`).join("\n");
-            throw new Error(`Ambiguous task reference: ${taskRef}\n${options}`);
-        }
-    }
-    const legacy = taskRoot(target, normalized);
-    if (fs.existsSync(path.join(legacy, "task_plan.md")))
-        return legacy;
-    throw new Error(`Task not found: ${taskRef}`);
-}
-function directTaskRefPath(target, raw) {
-    return taskRefPath(target.harness, raw);
+    return createScannerTaskRepository(target).resolve({ id: taskRef }).directory;
 }
-function legacyPlanningPrefix() {
-    return "docs\\/09-PLANNING";
+function taskIdForDirectory(target, taskDir) {
+    return taskIdFromDirectory(target.harness, taskDir);
 }
 function findTaskByDirectory(target, taskDir) {
-    const id = taskIdForDirectory(target, taskDir);
-    return collectTasks(target).find((task) => task.id === id) || null;
+    try {
+        return createScannerTaskRepository(target).get({ path: taskDir });
+    }
+    catch {
+        return undefined;
+    }
 }
 function stateLabel(state, locale) {
     if (normalizeLocale(locale) !== "zh-CN")
@@ -150,13 +123,13 @@ function resolveTaskIdentity({ target, taskId, title, presetPackage, moduleKey,
     }
     throw new Error(`Unable to allocate automatic task id for: ${semanticSlug}`);
 }
-export function createTask(targetInput, taskId, { title = "", locale = "en-US", dryRun = false, moduleKey = "", budget = "standard", longRunning = false, preset = "", fromSession = "", presetArgs = [], automaticTaskId = false } = {}) {
+export function createTask(targetInput, taskId, { title = "", locale = "en-US", dryRun = false, moduleKey = "", budget = "standard", longRunning = false, preset = "", fromSession = "", presetArgs = [], automaticTaskId = false, deferCommit = false, allowDirtyRelativePaths = [], registerModule = false, moduleRegistration = {} } = {}) {
     const requestedPreset = preset || (moduleKey ? "module" : "");
     const presetTargetInput = resolveImplicitCreateTarget(targetInput, fromSession);
     const normalizedPreset = normalizeTaskPresetInput(requestedPreset, { targetInput: presetTargetInput });
     const presetPackage = normalizedPreset === "none" ? null : readPresetPackage(normalizedPreset, { targetInput: presetTargetInput });
-    const presetInputs = presetPackage ? resolvePresetInputs(presetPackage, { cliArgs: presetArgs, fromSession, targetInput: presetTargetInput }) : null;
-    const target = normalizeTarget(presetInputs?.targetInput || presetTargetInput || targetInput);
+    const presetInputs = presetPackage ? resolveLifecyclePresetInputs(presetPackage, { cliArgs: presetArgs, fromSession, targetInput: presetTargetInput }) : null;
+    const target = asLifecycleTarget(normalizeTarget(presetInputs?.targetInput || presetTargetInput || targetInput));
     if (presetInputs?.targetInput && targetInput && targetInput !== "." && path.resolve(targetInput) !== path.resolve(presetInputs.targetInput)) {
         throw new Error(`--from-session target mismatch: session target is ${presetInputs.targetInput}`);
     }
@@ -167,7 +140,15 @@ export function createTask(targetInput, taskId, { title = "", locale = "en-US",
         throw new Error(`${normalizedPreset} preset is project-level and cannot be combined with --module`);
     if (presetPackage?.task?.requiresFromSession === true && !fromSession)
         throw new Error(`${normalizedPreset} preset requires --from-session`);
-    const normalizedModuleKey = moduleKey ? normalizeTaskId(moduleKey) : "";
+    const normalizedModuleKey = moduleKey ? normalizeHarnessModuleKey(moduleKey) : "";
+    const plannedModuleRegistration = normalizedModuleKey && !registeredHarnessModule(target, normalizedModuleKey)
+        ? registerModule
+            ? prepareModuleRegistration(target, normalizedModuleKey, moduleRegistration, { dryRun: true })
+            : null
+        : null;
+    if (normalizedModuleKey && !registeredHarnessModule(target, normalizedModuleKey) && !plannedModuleRegistration) {
+        throw new Error(`Unknown module: ${normalizedModuleKey}. Register it first with: harness module register ${normalizedModuleKey} --title <title> --prefix <PREFIX> --scope <path> ${target.projectRoot}`);
+    }
     const identity = resolveTaskIdentity({ target, taskId, title, presetPackage, moduleKey: normalizedModuleKey, automaticTaskId });
     const normalizedTaskId = identity.normalizedTaskId;
     const semanticSlug = identity.semanticSlug;
@@ -190,9 +171,9 @@ export function createTask(targetInput, taskId, { title = "", locale = "en-US",
         automaticTaskId,
     });
     const baseTaskAudit = buildCreationTaskAudit(scaffoldProvenance, { projectRoot: target.projectRoot });
-    const evaluatedPresetValues = presetPackage ? evaluateTemplateValues(presetPackage, presetInputs.inputs, { taskId: normalizedTaskId, taskTitle, moduleKey: normalizedModuleKey }) : null;
-    const presetContext = presetPackage
-        ? buildPresetContext({ ...presetPackage, task: { ...(presetPackage.task || {}), kind: presetPackage.task?.kind || "general" } }, {
+    const evaluatedPresetValues = presetPackage && presetInputs ? evaluatePresetValues(presetPackage, presetInputs.inputs, { taskId: normalizedTaskId, taskTitle, moduleKey: normalizedModuleKey, target }) : null;
+    const presetContext = presetPackage && presetInputs && evaluatedPresetValues
+        ? buildLifecyclePresetContext({ ...presetPackage, task: { ...(presetPackage.task || {}), kind: presetPackage.task?.kind || "general" } }, {
             target,
             taskDir: directory,
             taskId: normalizedTaskId,
@@ -225,14 +206,17 @@ export function createTask(targetInput, taskId, { title = "", locale = "en-US",
         normalizedLocale,
         normalizedBudget,
         longRunning,
-        presetContext,
-        task,
+        presetContext: presetContext || undefined,
     });
     const plannedGovernance = syncTaskGovernance(target, task, { event: "new-task", state: "planned", message: "task registered by CLI", dryRun: true });
-    const plannedWriteScopes = governanceRelativePaths([...plannedChanges, ...plannedGovernance.changes]);
+    const plannedWriteScopes = [...governanceRelativePaths(plannedModuleRegistration?.changes || []), ...changeDestinations(plannedChanges), ...governanceRelativePaths(plannedGovernance.changes)];
     const changes = [];
-    const governanceContext = beginGovernanceSync(target, { operation: `new-task ${normalizedTaskId}`, dryRun, allowDirtyWorktree: true, allowedRelativePaths: plannedWriteScopes });
+    const governanceContext = beginGovernanceSync(target, { operation: `new-task ${normalizedTaskId}`, dryRun, allowDirtyWorktree: true, allowedRelativePaths: [...plannedWriteScopes, ...(allowDirtyRelativePaths || [])], allowDirtyWriteScope: deferCommit });
     try {
+        if (plannedModuleRegistration) {
+            const moduleRegistrationResult = prepareModuleRegistration(target, normalizedModuleKey, moduleRegistration, { dryRun });
+            changes.push(...moduleRegistrationResult.changes);
+        }
         if (normalizedModuleKey) {
             const moduleDirectory = target.harness.version === 2
                 ? path.join(target.harness.modulesRoot, normalizedModuleKey)
@@ -247,7 +231,7 @@ export function createTask(targetInput, taskId, { title = "", locale = "en-US",
                     action: dryRun ? "would-create" : "create",
                 });
                 if (presetPackage)
-                    assertPresetWriteScope(presetPackage, toPosix(path.relative(target.projectRoot, destinationPath)));
+                    assertLifecyclePresetWriteScope(presetPackage, toPosix(path.relative(target.projectRoot, destinationPath)), target);
                 if (dryRun)
                     continue;
                 fs.mkdirSync(path.dirname(destinationPath), { recursive: true });
@@ -263,6 +247,7 @@ export function createTask(targetInput, taskId, { title = "", locale = "en-US",
                     longRunning,
                     scaffoldProvenance,
                     taskAudit: buildCreationTaskAudit({ ...scaffoldProvenance, templateSource: source }, { projectRoot: target.projectRoot }),
+                    target,
                 }));
             }
         }
@@ -278,11 +263,11 @@ export function createTask(targetInput, taskId, { title = "", locale = "en-US",
                 action: dryRun ? "would-create" : "create",
             });
             if (presetPackage)
-                assertPresetWriteScope(presetPackage, toPosix(path.relative(target.projectRoot, destinationPath)));
+                assertLifecyclePresetWriteScope(presetPackage, toPosix(path.relative(target.projectRoot, destinationPath)), target);
             if (dryRun)
                 continue;
             fs.mkdirSync(path.dirname(destinationPath), { recursive: true });
-            fs.writeFileSync(destinationPath, renderPresetTaskTemplate(destination, renderTaskTemplate(readBundledTemplate(source), {
+            fs.writeFileSync(destinationPath, renderLifecyclePresetTaskTemplate(destination, renderTaskTemplate(readBundledTemplate(source), {
                 taskId: normalizedTaskId,
                 title: taskTitle,
                 locale: normalizedLocale,
@@ -299,17 +284,19 @@ export function createTask(targetInput, taskId, { title = "", locale = "en-US",
                 taskAudit: destination === "INDEX.md"
                     ? buildCreationTaskAudit({ ...scaffoldProvenance, templateSource: source }, { projectRoot: target.projectRoot })
                     : baseTaskAudit,
+                target,
             }), presetContext));
         }
         if (presetContext) {
-            for (const evidence of presetContext.evidenceFiles) {
+            for (const evidence of presetContext.evidenceFiles || []) {
                 const destinationPath = path.join(target.projectRoot, evidence.relativePath);
                 changes.push({
                     destination: toPosix(evidence.relativePath),
                     source: evidence.source,
                     action: dryRun ? "would-create" : "create",
                 });
-                assertPresetWriteScope(presetPackage, toPosix(evidence.relativePath));
+                if (presetPackage)
+                    assertLifecyclePresetWriteScope(presetPackage, toPosix(evidence.relativePath), target);
                 if (dryRun)
                     continue;
                 fs.mkdirSync(path.dirname(destinationPath), { recursive: true });
@@ -322,7 +309,8 @@ export function createTask(targetInput, taskId, { title = "", locale = "en-US",
                     source: resource.source,
                     action: dryRun ? "would-create" : "create",
                 });
-                assertPresetWriteScope(presetPackage, toPosix(resource.relativePath));
+                if (presetPackage)
+                    assertLifecyclePresetWriteScope(presetPackage, toPosix(resource.relativePath), target);
                 if (dryRun)
                     continue;
                 fs.mkdirSync(path.dirname(destinationPath), { recursive: true });
@@ -339,7 +327,8 @@ export function createTask(targetInput, taskId, { title = "", locale = "en-US",
                     source: `preset-${kind}-index`,
                     action: dryRun ? "would-update" : "update",
                 });
-                assertPresetWriteScope(presetPackage, relativePath);
+                if (presetPackage)
+                    assertLifecyclePresetWriteScope(presetPackage, relativePath, target);
                 if (dryRun)
                     continue;
                 fs.mkdirSync(path.dirname(destinationPath), { recursive: true });
@@ -349,14 +338,12 @@ export function createTask(targetInput, taskId, { title = "", locale = "en-US",
         }
         const governance = syncTaskGovernance(target, task, { event: "new-task", state: "planned", message: "task registered by CLI", dryRun });
         changes.push(...governance.changes);
-        const commandWriteScopes = governanceRelativePaths(changes);
+        const commandWriteScopes = [...changeDestinations(changes), ...governanceRelativePaths(governance.changes)];
         if (presetContext) {
             refreshPresetCommandAudit(target, presetContext, { commandWriteScopes, dryRun });
             task.presetAudit = presetContext.audit;
         }
-        const commit = commitGovernanceSync(governanceContext, commandWriteScopes, {
-            message: `chore(harness): register task ${task.id}`,
-        });
+        const commit = deferCommit ? { committed: false, reason: "deferred", allowedPaths: commandWriteScopes } : commitGovernanceSync(governanceContext, commandWriteScopes, { message: `chore(harness): register task ${task.id}` });
         return {
             dryRun,
             task,
@@ -369,18 +356,20 @@ export function createTask(targetInput, taskId, { title = "", locale = "en-US",
     }
 }
 export function updateTaskLifecycle(targetInput, taskId, { event = "task-log", state = "", message = "", evidence = "" } = {}) {
-    const target = normalizeTarget(targetInput);
+    const target = asLifecycleTarget(normalizeTarget(targetInput));
+    const normalizedEvent = lifecycleGateEvent(event);
     const taskDir = resolveTaskDirectory(target, taskId);
     const progressPath = path.join(taskDir, "progress.md");
     const registry = readCapabilityRegistry(target);
     const normalizedState = state ? String(state).toLowerCase().replaceAll("-", "_") : "";
     if (normalizedState && !allowedTaskStates.has(normalizedState))
         throw new Error(`Invalid task state: ${state}`);
+    assertLifecycleEventStateConsistency(normalizedEvent, normalizedState);
     const currentTask = findTaskByDirectory(target, taskDir);
     const canonicalTaskId = taskIdForDirectory(target, taskDir);
     const budget = parseTaskBudget(readFileSafe(path.join(taskDir, "task_plan.md")));
     validateLifecycleTransition({
-        event,
+        event: normalizedEvent,
         currentState: currentTask?.state || "unknown",
         budget,
         reviewContent: readFileSafe(path.join(taskDir, "review.md")),
@@ -395,11 +384,11 @@ export function updateTaskLifecycle(targetInput, taskId, { event = "task-log", s
     try {
         let content = readFileSafe(progressPath);
         if (normalizedState)
-            content = updateProgressState(content, normalizedState, registry.locale);
+            content = updateProgressState(content, normalizedState, registry.locale || "en-US");
         content = appendProgressLog(content, { event, message, evidence });
         fs.writeFileSync(progressPath, content.endsWith("\n") ? content : `${content}\n`);
         const allowedPaths = [toPosix(path.relative(target.projectRoot, progressPath))];
-        const advancedPhasePath = advanceLifecyclePhase(target, taskDir, event);
+        const advancedPhasePath = advanceLifecyclePhase(target, taskDir, normalizedEvent);
         if (advancedPhasePath)
             allowedPaths.push(advancedPhasePath);
         if (event === "task-review") {
@@ -446,13 +435,26 @@ export function updateTaskLifecycle(targetInput, taskId, { event = "task-log", s
         releaseGovernanceSync(governanceContext);
     }
 }
-export function confirmTaskReview(targetInput, taskId, { reviewer = "Human Reviewer", message = "", confirmText = "", evidence = "" } = {}) {
-    const target = normalizeTarget(targetInput);
-    const taskDir = resolveTaskDirectory(target, taskId);
-    return confirmTaskReviewWithContext({ target, taskDir, findTaskByDirectory }, { reviewer, message, confirmText, evidence });
+function assertLifecycleEventStateConsistency(event, state) {
+    if (!state)
+        return;
+    if (state === "done" && event !== "task-complete") {
+        throw new Error(`State done must be written through task-complete, not ${event}.`);
+    }
+    if (state === "review" && event !== "task-review") {
+        throw new Error(`State review must be written through task-review, not ${event}.`);
+    }
+}
+export function confirmTaskReview(targetInput, taskId, { reviewer = "Human Reviewer", message = "", confirmText = "", evidence = "", deferCommit = false } = {}) {
+    const target = asLifecycleTarget(normalizeTarget(targetInput));
+    return confirmTaskReviewWithContext({ target, taskDir: resolveTaskDirectory(target, taskId), findTaskByDirectory: findReviewTaskByDirectory }, { reviewer, message, confirmText, evidence, deferCommit });
+}
+export function finalizeDeferredTaskReviewConfirmation(targetInput, taskId, { commitSha = "" } = {}) {
+    const target = asLifecycleTarget(normalizeTarget(targetInput));
+    return finalizeDeferredTaskReviewConfirmationWithContext({ target, taskDir: resolveTaskDirectory(target, taskId), findTaskByDirectory: findReviewTaskByDirectory }, { commitSha });
 }
 export function updateTaskPhase(targetInput, taskId, phaseId, { state = "", completion = "", evidenceStatus = "" } = {}) {
-    const target = normalizeTarget(targetInput);
+    const target = asLifecycleTarget(normalizeTarget(targetInput));
     const taskDir = resolveTaskDirectory(target, taskId);
     const visualMapPath = path.join(taskDir, visualMapFile);
     const legacyPath = path.join(taskDir, legacyVisualRoadmapFile);
@@ -504,8 +506,8 @@ export function updateTaskPhase(targetInput, taskId, phaseId, { state = "", comp
     }
 }
 export function updateModuleStep(targetInput, moduleKey, stepId, { state = "" } = {}) {
-    const target = normalizeTarget(targetInput);
-    const normalizedModuleKey = normalizeTaskId(moduleKey);
+    const target = asLifecycleTarget(normalizeTarget(targetInput));
+    const normalizedModuleKey = normalizeHarnessModuleKey(moduleKey);
     const normalizedState = String(state || "done").toLowerCase().replaceAll("_", "-");
     if (!["planned", "in-progress", "done", "blocked", "superseded"].includes(normalizedState))
         throw new Error(`Invalid module step state: ${state}`);
@@ -529,39 +531,11 @@ export function updateModuleStep(targetInput, moduleKey, stepId, { state = "" }
     try {
         content = stepUpdate.content;
         fs.writeFileSync(modulePlanPath, content);
-        const registryPath = path.join(target.harness.modulesRoot, "Module-Registry.md");
-        if (fs.existsSync(registryPath)) {
-            let registry = readFileSafe(registryPath);
-            const registryUpdate = updateMarkdownTableRow(registry, /^(ID|模块 Key)$/i, (header, row) => {
-                const moduleIndex = firstColumn(header, ["Module", "模块", "模块 Key"]);
-                const taskPlanIndex = getColumn(header, "Task Plan");
-                const matchesModule = normalizeTaskId(row[moduleIndex] || "") === normalizedModuleKey;
-                const matchesPlan = taskPlanIndex >= 0 && String(row[taskPlanIndex] || "").includes(`/MODULES/${normalizedModuleKey}/`);
-                if (!matchesModule && !matchesPlan)
-                    return null;
-                const next = [...row];
-                const statusIndex = firstColumn(header, ["Status", "状态"]);
-                const updatedIndex = firstColumn(header, ["Updated", "更新时间"]);
-                const currentStepIndex = firstColumn(header, ["Current Step", "当前步骤"]);
-                const chineseRegistry = header.some((cell) => /模块 Key|模块名称|状态|更新时间/.test(cell));
-                if (statusIndex >= 0) {
-                    next[statusIndex] = normalizedState === "done"
-                        ? chineseRegistry ? "completed" : "merged"
-                        : normalizedState === "in-progress" ? chineseRegistry ? "in-progress" : "active" : normalizedState;
-                }
-                if (currentStepIndex >= 0)
-                    next[currentStepIndex] = stepId;
-                if (updatedIndex >= 0)
-                    next[updatedIndex] = todayDate();
-                return next;
-            });
-            registry = registryUpdate.content;
-            fs.writeFileSync(registryPath, registry);
-        }
+        const moduleRegistration = prepareModuleStepRegistrationUpdate(target, normalizedModuleKey, { stepId, state: normalizedState });
         const governance = syncModuleStepGovernance(target, { moduleKey: normalizedModuleKey, stepId, state: normalizedState });
         const commit = commitGovernanceSync(governanceContext, [
             toPosix(path.relative(target.projectRoot, modulePlanPath)),
-            toPosix(path.relative(target.projectRoot, registryPath)),
+            ...governanceRelativePaths(moduleRegistration.changes),
             ...governanceRelativePaths(governance.changes),
         ], { message: `chore(harness): update module ${normalizedModuleKey} step ${stepId}` });
         return { event: "module-step", moduleKey: normalizedModuleKey, stepId, state: normalizedState, governance: { ...governance, commit } };
@@ -570,42 +544,26 @@ export function updateModuleStep(targetInput, moduleKey, stepId, { state = "" }
         releaseGovernanceSync(governanceContext);
     }
 }
-export function listLifecycleTasks(targetInput, { state = "", moduleKey = "", queue = "", preset = "", review = "", lesson = "", search = "", missingMaterials = false } = {}) {
-    const target = normalizeTarget(targetInput);
-    let tasks = collectTasks(target);
-    if (state)
-        tasks = tasks.filter((task) => task.state === String(state).toLowerCase().replaceAll("-", "_"));
-    if (moduleKey)
-        tasks = tasks.filter((task) => task.module === normalizeTaskId(moduleKey));
-    if (queue) {
-        const normalizedQueue = queryToken(queue);
-        tasks = tasks.filter((task) => (task.taskQueues || []).map(queryToken).includes(normalizedQueue));
-    }
-    if (preset)
-        tasks = tasks.filter((task) => queryToken(task.taskPreset || "none") === queryToken(preset));
-    if (review)
-        tasks = tasks.filter((task) => queryToken(task.reviewStatus || "") === queryToken(review));
-    if (lesson) {
-        const needle = queryToken(lesson);
-        tasks = tasks.filter((task) => [task.lessonCandidateStatus, task.lessonCandidateReviewDecision, task.lessonCandidatePromotionState].some((value) => queryToken(value) === needle));
+export function listLifecycleTasks(targetInput, { state = "", moduleKey = "", queue = "", preset = "", review = "", lesson = "", search = "", missingMaterials = false, includeArchived = false } = {}) {
+    const target = asLifecycleTarget(normalizeTarget(targetInput));
+    const tasks = createScannerTaskRepository(target).list({
+        includeArchived,
+        state,
+        module: moduleKey ? normalizeHarnessModuleKey(moduleKey) : "",
+        queue,
+        preset,
+        review,
+        lesson,
+        missingMaterials,
+        search,
+    });
+    let modules = [];
+    try {
+        const registry = readHarnessModules(target);
+        modules = Object.entries(registry.items || {}).map(([key, module]) => ({ key, ...module }));
     }
-    if (missingMaterials)
-        tasks = tasks.filter((task) => !task.materialsReady);
-    if (search) {
-        const needle = String(search).toLowerCase();
-        tasks = tasks.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)));
+    catch {
+        modules = [];
     }
-    return { tasks };
-}
-function queryToken(value) {
-    return String(value || "").trim().toLowerCase().replaceAll("_", "-");
+    return { tasks, modules };
 }

package/dist/lib/task-metadata.mjs

@@ -1,6 +1,5 @@
-// @ts-nocheck
 // Dynamic metadata parsing stays behavior-first until the metadata domain model PR.
-import { allowedTaskStates, allowedTaskBudgets, taskContractMarker, } from "./core-shared.mjs";
+import { allowedTaskStates, taskContractMarker, } from "./core-shared.mjs";
 import { tableAfterHeading, firstColumn } from "./markdown-utils.mjs";
 export function parseTaskState(progressContent) {
     return parseTaskStateInfo(progressContent).state;
@@ -12,7 +11,7 @@ export function parseTaskBudget(taskPlanContent) {
         return "standard";
     const raw = match[1].replace(/`/g, "").trim().toLowerCase();
     const normalized = raw.replaceAll("_", "-").replace(/\s+/g, "-");
-    if (allowedTaskBudgets.has(normalized))
+    if (isTaskBudget(normalized))
         return normalized;
     if (["long-running", "longrunning", "module-parallel"].includes(normalized))
         return "complex";
@@ -76,7 +75,7 @@ export function parseTaskStateInfo(progressContent) {
         ["pending", "planned"],
     ]);
     const normalized = aliases.get(raw) || raw.toLowerCase().replaceAll("-", "_").replaceAll(" ", "_");
-    return allowedTaskStates.has(normalized)
+    return isKnownTaskState(normalized)
         ? { state: normalized, source: "explicit", raw }
         : { state: "unknown", source: "invalid", raw };
 }
@@ -85,7 +84,7 @@ function inferLegacyTaskState(progressContent) {
     const statusIndex = firstColumn(header, ["Status", "状态"]);
     if (statusIndex < 0 || rows.length === 0)
         return { state: "unknown", source: "missing", raw: "" };
-    const states = rows.map((row) => normalizeLegacyState(row[statusIndex])).filter(Boolean);
+    const states = rows.map((row) => normalizeLegacyState(row[statusIndex])).filter(isKnownTaskState);
     if (states.includes("blocked"))
         return { state: "blocked", source: "legacy-table", raw: "blocked" };
     if (states.includes("in_progress"))
@@ -114,3 +113,9 @@ function normalizeLegacyState(value) {
         return "planned";
     return "";
 }
+function isKnownTaskState(value) {
+    return typeof value === "string" && allowedTaskStates.has(value);
+}
+function isTaskBudget(value) {
+    return value === "simple" || value === "standard" || value === "complex";
+}

package/dist/lib/task-preset-contract-drift.mjs

@@ -0,0 +1,45 @@
+import fs from "node:fs";
+import path from "node:path";
+import { validateTaskPresetAuditSnapshot } from "./preset-audit-contracts.mjs";
+import { validatePresetResourcesForTask } from "./preset-resource-contracts.mjs";
+export function validateRegularTaskPresetContract(target, task, presetPackage) {
+    const failures = [];
+    const warnings = [];
+    const driftWarnings = [];
+    if (presetPackage.task?.kind && task.taskKind !== presetPackage.task.kind) {
+        driftWarnings.push(`${task.path} ${task.taskPreset} preset Task Kind mismatch: expected ${presetPackage.task.kind}, got ${task.taskKind || "(missing)"}`);
+    }
+    if (String(task.presetVersion || "") !== String(presetPackage.version)) {
+        driftWarnings.push(`${task.path} ${task.taskPreset} preset version drift: task ${task.presetVersion || "(missing)"}, current ${presetPackage.version}`);
+    }
+    if (presetNeedsEvidenceBundle(presetPackage)) {
+        if (!task.evidenceBundle)
+            failures.push(`${task.path} ${task.taskPreset} preset missing Evidence Bundle`);
+        else if (!fs.existsSync(path.join(target.projectRoot, String(task.evidenceBundle).replace(/^TARGET:/, "").replace(/^\/+/, "")))) {
+            failures.push(`${task.path} ${task.taskPreset} preset Evidence Bundle missing: ${task.evidenceBundle}`);
+        }
+    }
+    for (const issue of validateTaskPresetAuditSnapshot(target, task, presetPackage)) {
+        if (issue.includes("preset manifest hash mismatch"))
+            driftWarnings.push(issue);
+        else
+            failures.push(issue);
+    }
+    const resourceIssues = validatePresetResourcesForTask(target, task, presetPackage);
+    if (driftWarnings.length) {
+        warnings.push(...driftWarnings.map(toPresetDriftWarning));
+        warnings.push(...resourceIssues.map(toPresetDriftWarning));
+    }
+    else {
+        failures.push(...resourceIssues);
+    }
+    return { failures, warnings };
+}
+function presetNeedsEvidenceBundle(presetPackage) {
+    return Boolean(presetPackage.evidence?.bundleDir ||
+        presetPackage.audit?.evidenceFiles?.length ||
+        Object.keys(presetPackage.evidence?.files || {}).length);
+}
+function toPresetDriftWarning(issue) {
+    return `preset-drift-warning: creation-time preset provenance drift; ${issue}`;
+}