coding-agent-harness 1.0.8 → 1.1.0

package/dist/lib/task-lesson-sedimentation.mjs

@@ -1,4 +1,3 @@
-// @ts-nocheck
 import fs from "node:fs";
 import path from "node:path";
 import { lessonCandidatesFile, normalizeTarget, readFileSafe, toPosix, normalizeTaskId, localDate, } from "./core-shared.mjs";
@@ -11,6 +10,10 @@ import { taskIdForDirectory } from "./task-scanner.mjs";
 import { beginGovernanceSync, commitGovernanceSync, governanceRelativePaths, releaseGovernanceSync, } from "./governance-sync.mjs";
 const presetId = "lesson-sedimentation";
 export class LessonSedimentationError extends Error {
+    code;
+    status;
+    details;
+    recovery;
     constructor(message, { code = "lesson-sedimentation-failed", status = 400, details = {}, recovery = [] } = {}) {
         super(message);
         this.name = "LessonSedimentationError";
@@ -20,7 +23,7 @@ export class LessonSedimentationError extends Error {
         this.recovery = recovery;
     }
 }
-export function createLessonSedimentationTask(targetInput, taskRef, candidateId, { dryRun = false, title = "" } = {}) {
+export function createLessonSedimentationTask(targetInput, taskRef, candidateId, { dryRun = false, title = "", deferCommit = false, allowDirtyRelativePaths = [] } = {}) {
     const target = normalizeTarget(targetInput);
     const sourceTaskDir = resolveTaskDirectory(target, taskRef);
     const sourceTaskId = taskIdForDirectory(target, sourceTaskDir);
@@ -74,12 +77,14 @@ export function createLessonSedimentationTask(targetInput, taskRef, candidateId,
             budget: "standard",
             longRunning: true,
             dryRun,
+            deferCommit,
+            allowDirtyRelativePaths,
         });
     }
     catch (error) {
-        if (/Task already exists:/i.test(error.message)) {
+        if (/Task already exists:/i.test(errorMessage(error))) {
             const existingTask = `TASKS/${localDate()}-${slug}`;
-            throw new LessonSedimentationError(error.message, {
+            throw new LessonSedimentationError(errorMessage(error), {
                 code: "lesson-follow-up-directory-exists",
                 status: 409,
                 details: { candidateId, existingTask, sourceTask: sourceTaskId },
@@ -117,7 +122,19 @@ export function createLessonSedimentationTask(targetInput, taskRef, candidateId,
     });
     const changes = [...taskResult.changes];
     if (!dryRun) {
-        const governanceContext = beginGovernanceSync(target, { operation: `lesson-sediment ${sourceTaskId} ${candidate.id}` });
+        const deferredDirtyPaths = deferCommit
+            ? [
+                ...governanceRelativePaths(asGovernanceChanges(taskResult.changes)),
+                toPosix(path.relative(target.projectRoot, candidatePath)),
+                ...(allowDirtyRelativePaths || []),
+            ]
+            : [];
+        const governanceContext = beginGovernanceSync(target, {
+            operation: `lesson-sediment ${sourceTaskId} ${candidate.id}`,
+            allowDirtyWorktree: deferCommit,
+            allowedRelativePaths: deferredDirtyPaths,
+            allowDirtyWriteScope: deferCommit,
+        });
         try {
             appendToFollowUpTask({ followUpDir, sourceTaskId, candidate, prompt, contextPacket, audit });
             updateSourceFollowUpTask(candidatePath, candidate.id, followUpTaskId);
@@ -142,11 +159,14 @@ export function createLessonSedimentationTask(targetInput, taskRef, candidateId,
                 source: lessonCandidatesFile,
                 action: "update-follow-up-task",
             });
+            const commit = deferCommit
+                ? { committed: false, reason: "deferred", allowedPaths: governanceRelativePaths(asGovernanceChanges(changes)) }
+                : commitGovernanceSync(governanceContext, governanceRelativePaths(asGovernanceChanges(changes)), {
+                    message: `chore(harness): record lesson sedimentation ${candidate.id}`,
+                });
             taskResult.governance = {
                 ...(taskResult.governance || {}),
-                lessonSedimentationCommit: commitGovernanceSync(governanceContext, governanceRelativePaths(changes), {
-                    message: `chore(harness): record lesson sedimentation ${candidate.id}`,
-                }),
+                lessonSedimentationCommit: commit,
             };
         }
         finally {
@@ -169,9 +189,173 @@ export function createLessonSedimentationTask(targetInput, taskRef, candidateId,
         governance: taskResult.governance || null,
     };
 }
+export function createAggregateLessonSedimentationTask(targetInput, selections, { dryRun = false, title = "" } = {}) {
+    const target = normalizeTarget(targetInput);
+    const normalizedSelections = normalizeAggregateSelections(selections);
+    if (normalizedSelections.length === 0) {
+        throw new LessonSedimentationError("No lesson candidates selected", {
+            code: "lesson-aggregate-empty",
+            status: 400,
+            recovery: ["Select at least one actionable lesson candidate."],
+        });
+    }
+    const entries = normalizedSelections.map((selection) => resolveLessonCandidate(target, selection.taskId, selection.candidateId));
+    const sourceShort = entries.length === 1
+        ? entries[0].sourceShortId.replace(/^\d{4}-\d{2}-\d{2}-/, "")
+        : commonSourceShort(entries) || "selected-lessons";
+    const slug = normalizeTaskId(`lesson-${sourceShort}-aggregate-${Date.now().toString(36).slice(-6)}`);
+    const taskTitle = title || `Aggregate lesson sedimentation for ${entries.length} candidates`;
+    const locale = readCapabilityRegistry(target).locale;
+    const preset = readPresetPackage(presetId);
+    const taskResult = createTask(target.projectRoot, slug, {
+        title: taskTitle,
+        locale,
+        budget: "standard",
+        longRunning: true,
+        dryRun,
+        deferCommit: true,
+    });
+    const followUpTaskId = taskResult.task.id;
+    const followUpDir = path.join(target.projectRoot, taskResult.task.path.replace(/^TARGET:/, ""));
+    const audit = buildPresetAudit(preset, {
+        taskId: followUpTaskId,
+        targetRoot: target.projectRoot,
+        entrypoint: "newTask",
+        writeScopes: [`${toPosix(path.relative(target.projectRoot, target.harness.tasksRoot))}/**`],
+    });
+    const prompt = renderAggregateLessonSedimentationPrompt({ target, entries, followUpTaskId });
+    const contextPacket = renderAggregateContextPacket({ target, entries, followUpTaskId, audit });
+    const changes = [...taskResult.changes];
+    if (!dryRun) {
+        const candidatePaths = [...new Set(entries.map((entry) => toPosix(path.relative(target.projectRoot, entry.candidatePath))))];
+        const governanceContext = beginGovernanceSync(target, {
+            operation: `lesson-sediment-aggregate ${followUpTaskId}`,
+            allowDirtyWorktree: true,
+            allowedRelativePaths: [...governanceRelativePaths(asGovernanceChanges(taskResult.changes)), ...candidatePaths],
+            allowDirtyWriteScope: true,
+        });
+        try {
+            appendToAggregateFollowUpTask({ followUpDir, entries, prompt, contextPacket, audit });
+            for (const entry of entries)
+                updateSourceFollowUpTask(entry.candidatePath, entry.candidate.id, followUpTaskId);
+            changes.push({
+                destination: toPosix(path.relative(target.projectRoot, path.join(followUpDir, "task_plan.md"))),
+                source: "lesson-sedimentation-aggregate",
+                action: "append-aggregate-context",
+            }, {
+                destination: toPosix(path.relative(target.projectRoot, path.join(followUpDir, "progress.md"))),
+                source: "lesson-sedimentation-aggregate",
+                action: "append-aggregate-progress",
+            }, {
+                destination: toPosix(path.relative(target.projectRoot, path.join(followUpDir, "artifacts/lesson-sedimentation-prompt.md"))),
+                source: "lesson-sedimentation-aggregate",
+                action: "create-aggregate-prompt-artifact",
+            }, {
+                destination: toPosix(path.relative(target.projectRoot, path.join(followUpDir, "artifacts/preset-audit.json"))),
+                source: "lesson-sedimentation-aggregate",
+                action: "create-aggregate-preset-audit",
+            }, ...candidatePaths.map((destination) => ({
+                destination,
+                source: lessonCandidatesFile,
+                action: "update-follow-up-task",
+            })));
+            taskResult.governance = {
+                ...(taskResult.governance || {}),
+                commit: commitGovernanceSync(governanceContext, governanceRelativePaths(asGovernanceChanges(changes)), {
+                    message: `chore(harness): record aggregate lesson sedimentation ${followUpTaskId}`,
+                }),
+            };
+        }
+        finally {
+            releaseGovernanceSync(governanceContext);
+        }
+    }
+    return {
+        dryRun,
+        event: "lesson-sedimentation-aggregate",
+        preset: presetId,
+        candidates: entries.map((entry) => ({
+            taskId: entry.sourceTaskId,
+            candidateId: entry.candidate.id,
+            title: entry.candidate.title,
+            detailArtifact: resolveDetailArtifact(target, entry.sourceTaskDir, entry.candidate).prefixedPath || "",
+        })),
+        followUpTask: {
+            id: followUpTaskId,
+            path: taskResult.task.path,
+            title: taskTitle,
+        },
+        prompt,
+        changes,
+        governance: taskResult.governance || null,
+    };
+}
+function normalizeAggregateSelections(selections) {
+    const seen = new Set();
+    const normalized = [];
+    for (const selection of Array.isArray(selections) ? selections : []) {
+        const record = asRecord(selection);
+        const taskId = String(record.taskId || "").trim();
+        const candidateId = String(record.candidateId || "").trim();
+        if (!taskId || !candidateId)
+            continue;
+        const key = `${taskId}\n${candidateId}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        normalized.push({ taskId, candidateId });
+    }
+    return normalized;
+}
+function resolveLessonCandidate(target, taskRef, candidateId) {
+    const sourceTaskDir = resolveTaskDirectory(target, taskRef);
+    const sourceTaskId = taskIdForDirectory(target, sourceTaskDir);
+    const sourceShortId = path.basename(sourceTaskDir);
+    const candidatePath = path.join(sourceTaskDir, lessonCandidatesFile);
+    const candidateStatus = parseLessonCandidateStatus(readFileSafe(candidatePath));
+    const candidate = candidateStatus.rows.find((row) => row.id === candidateId);
+    if (!candidate) {
+        throw new LessonSedimentationError(`Lesson candidate not found: ${candidateId}`, {
+            code: "lesson-candidate-not-found",
+            status: 404,
+            details: { candidateId, sourceTask: sourceTaskId },
+            recovery: [
+                "Open the source task lesson_candidates.md and confirm the candidate ID.",
+                "Refresh the Dashboard snapshot if the candidate was just added.",
+            ],
+        });
+    }
+    if (!["needs-promotion", "ready-for-review"].includes(candidate.status)) {
+        throw new LessonSedimentationError(`Lesson candidate must be ready-for-review or needs-promotion; current status is ${candidate.status}`, {
+            code: "lesson-candidate-not-actionable",
+            status: 409,
+            details: { candidateId, status: candidate.status, sourceTask: sourceTaskId },
+            recovery: [
+                "Set the candidate status to ready-for-review or needs-promotion after human review.",
+                "Use Copy lesson prompt if you only need the prompt without creating a task.",
+            ],
+        });
+    }
+    if (candidate.followUpTask && !/^pending$/i.test(candidate.followUpTask)) {
+        throw new LessonSedimentationError(`Lesson candidate already has follow-up task: ${candidate.followUpTask}`, {
+            code: "lesson-follow-up-exists",
+            status: 409,
+            details: { candidateId, followUpTask: candidate.followUpTask, sourceTask: sourceTaskId },
+            recovery: [
+                "Open the existing follow-up task instead of creating a duplicate.",
+                "If the existing task is wrong, edit the Follow-up Task cell back to pending after review.",
+            ],
+        });
+    }
+    return { sourceTaskDir, sourceTaskId, sourceShortId, candidatePath, candidate };
+}
+function commonSourceShort(entries) {
+    const unique = [...new Set(entries.map((entry) => entry.sourceShortId.replace(/^\d{4}-\d{2}-\d{2}-/, "")))];
+    return unique.length === 1 ? unique[0] : "";
+}
 function renderLessonSedimentationPrompt(preset, values) {
     const detailArtifact = resolveDetailArtifact(values.target, values.sourceTaskDir, values.candidate);
-    const prompt = renderPresetTemplate(preset, preset.entrypoints.newTask?.templates?.prompt, {
+    const prompt = renderPresetTemplate(preset, preset.entrypoints.newTask?.templates?.prompt || "", {
         sourceTaskId: values.sourceTaskId,
         sourceShortId: values.sourceShortId,
         candidateId: values.candidate.id,
@@ -223,6 +407,76 @@ function renderContextPacket({ target, sourceTaskDir, sourceTaskId, candidate, f
         "",
     ].join("\n");
 }
+function renderAggregateLessonSedimentationPrompt({ target, entries, followUpTaskId }) {
+    const candidateBlocks = entries.map((entry, index) => {
+        const detailArtifact = resolveDetailArtifact(target, entry.sourceTaskDir, entry.candidate);
+        return [
+            `### ${index + 1}. ${entry.candidate.id} - ${entry.candidate.title || "Untitled lesson candidate"}`,
+            "",
+            `- Source task: ${entry.sourceTaskId}`,
+            `- Candidate status: ${entry.candidate.status}`,
+            `- Scope: ${entry.candidate.scope || "unspecified"}`,
+            `- Module key: ${entry.candidate.moduleKey || "n/a"}`,
+            `- Detail artifact: ${detailArtifact.prefixedPath || "not provided"}`,
+            `- Boundary reason: ${entry.candidate.boundaryReason || "unspecified"}`,
+            `- Why it might matter: ${entry.candidate.whyItMightMatter || "unspecified"}`,
+            `- Promotion target: ${entry.candidate.promotionTarget || "unspecified"}`,
+            `- Conflict check: ${entry.candidate.conflictCheck || "pending"}`,
+            `- Required standard update: ${entry.candidate.requiredStandardUpdate || "pending"}`,
+            "",
+        ].join("\n");
+    }).join("\n");
+    return [
+        "You are executing an aggregate lesson sedimentation follow-up task.",
+        "",
+        `Follow-up task: ${followUpTaskId}`,
+        `Candidate count: ${entries.length}`,
+        "",
+        "Instructions:",
+        "1. Read each source task, review, findings, progress, lesson_candidates.md, and task-local detail artifact.",
+        "2. Preserve candidate boundaries; do not merge unrelated lessons into one vague generalization.",
+        "3. Promote the smallest coherent set of reusable lessons, grouping only when candidates describe the same rule.",
+        "4. Check conflicts against existing lessons and standards before proposing changes.",
+        "5. Propose the smallest diff first.",
+        "6. Do not write a shared Lessons table; use promoted detail docs or focused follow-up edits.",
+        "",
+        "Selected candidates:",
+        "",
+        candidateBlocks.trimEnd(),
+        "",
+    ].join("\n");
+}
+function renderAggregateContextPacket({ target, entries, followUpTaskId, audit }) {
+    const rows = entries.map((entry) => {
+        const detailArtifact = resolveDetailArtifact(target, entry.sourceTaskDir, entry.candidate);
+        const sourceLessonPath = `TARGET:${toPosix(path.relative(target.projectRoot, path.join(entry.sourceTaskDir, lessonCandidatesFile)))}`;
+        return [
+            entry.candidate.id,
+            entry.sourceTaskId,
+            entry.candidate.title || "",
+            entry.candidate.scope || "unspecified",
+            entry.candidate.moduleKey || "n/a",
+            detailArtifact.prefixedPath || "not provided",
+            sourceLessonPath,
+            entry.candidate.promotionTarget || "unspecified",
+        ];
+    });
+    return [
+        "## Aggregate Lesson Sedimentation Context Packet",
+        "",
+        "| Candidate | Source Task | Title | Scope | Module | Detail Artifact | Candidate Table | Promotion Target |",
+        "| --- | --- | --- | --- | --- | --- | --- | --- |",
+        ...rows.map((row) => `| ${row.map(markdownCell).join(" | ")} |`),
+        "",
+        "| Field | Value |",
+        "| --- | --- |",
+        `| Preset | ${presetId} |`,
+        `| Follow-up Task | ${followUpTaskId} |`,
+        `| Candidate Count | ${entries.length} |`,
+        `| Preset Manifest | ${audit.manifestPath} |`,
+        "",
+    ].join("\n");
+}
 function resolveDetailArtifact(target, sourceTaskDir, candidate) {
     const raw = String(candidate.detailArtifact || "").trim();
     if (!raw || /^(?:n\/a|none|pending)$/i.test(raw))
@@ -273,6 +527,44 @@ function appendToFollowUpTask({ followUpDir, sourceTaskId, candidate, prompt, co
         "",
     ].join("\n"));
 }
+function appendToAggregateFollowUpTask({ followUpDir, entries, prompt, contextPacket, audit }) {
+    const taskPlanPath = path.join(followUpDir, "task_plan.md");
+    const progressPath = path.join(followUpDir, "progress.md");
+    const artifactsDir = path.join(followUpDir, "artifacts");
+    fs.mkdirSync(artifactsDir, { recursive: true });
+    fs.writeFileSync(path.join(artifactsDir, "lesson-sedimentation-prompt.md"), `${prompt}\n`);
+    fs.writeFileSync(path.join(artifactsDir, "preset-audit.json"), `${JSON.stringify(audit, null, 2)}\n`);
+    const candidateList = entries.map((entry) => `- ${entry.candidate.id}: ${entry.sourceTaskId} - ${entry.candidate.title || "Untitled lesson candidate"}`).join("\n");
+    fs.appendFileSync(taskPlanPath, [
+        "",
+        "## Aggregate Lesson Sedimentation Preset",
+        "",
+        "Task Preset: lesson-sedimentation",
+        "Preset Version: 1",
+        "Task Kind: lesson-sedimentation",
+        `Candidate Count: ${entries.length}`,
+        "",
+        "### Selected Candidates",
+        "",
+        candidateList,
+        "",
+        contextPacket.trimEnd(),
+        "",
+        "## Execution Prompt",
+        "",
+        "The copyable aggregate prompt for a new agent session is stored in `artifacts/lesson-sedimentation-prompt.md`.",
+        "",
+    ].join("\n"));
+    fs.appendFileSync(progressPath, [
+        "",
+        "### Aggregate lesson sedimentation task created",
+        "",
+        `- Candidate count: ${entries.length}`,
+        `- Source tasks: ${[...new Set(entries.map((entry) => entry.sourceTaskId))].join(", ")}`,
+        "- Next: use the aggregate execution prompt, preserve candidate boundaries, and propose focused reusable lesson diffs.",
+        "",
+    ].join("\n"));
+}
 function updateSourceFollowUpTask(candidatePath, candidateId, followUpTaskId) {
     const content = readFileSafe(candidatePath);
     const update = updateMarkdownTableRow(content, /^ID$/i, (header, row) => {
@@ -298,3 +590,12 @@ function summarizeMarkdown(content) {
         .filter((line) => line && !/^\|?\s*-{3,}/.test(line));
     return lines.slice(0, 4).join(" / ") || "not recorded";
 }
+function asGovernanceChanges(changes) {
+    return changes.map((change) => ({ surface: "task", ...change }));
+}
+function asRecord(value) {
+    return value && typeof value === "object" ? value : {};
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/lib/task-lifecycle/create-task-helpers.mjs

@@ -1,13 +1,16 @@
-// @ts-nocheck
 import fs from "node:fs";
 import path from "node:path";
 import { toPosix } from "../core-shared.mjs";
 import { appendLongRunningContractFile, moduleTemplateFiles, taskFilesForBudget, } from "./template-files.mjs";
 import { discoverImplicitHarnessTarget } from "../harness-paths.mjs";
-export function planCreateTaskChanges({ target, directory, normalizedModuleKey, normalizedLocale, normalizedBudget, longRunning, presetContext }) {
+export function planCreateTaskChanges({ target, directory, normalizedModuleKey, normalizedLocale, normalizedBudget, longRunning, presetContext, }) {
     const changes = [];
     if (normalizedModuleKey) {
-        const moduleDirectory = path.dirname(directory);
+        const harness = target.harness;
+        const modulesRoot = String(harness?.modulesRoot || target.modulesRoot || "");
+        const moduleDirectory = modulesRoot
+            ? path.join(modulesRoot, normalizedModuleKey)
+            : path.dirname(directory);
         for (const [destination, source] of moduleTemplateFiles({ locale: normalizedLocale })) {
             const destinationPath = path.join(moduleDirectory, destination);
             if (fs.existsSync(destinationPath))

package/dist/lib/task-lifecycle/phase-sync.mjs

@@ -1,4 +1,3 @@
-// @ts-nocheck
 import fs from "node:fs";
 import path from "node:path";
 import { lessonCandidatesFile, readFileSafe, todayDate, toPosix, visualMapFile, } from "../core-shared.mjs";

package/dist/lib/task-lifecycle/preset-interop.mjs

@@ -0,0 +1,16 @@
+import { assertPresetWriteScope, buildPresetContext, evaluateTemplateValues, resolvePresetInputs, renderPresetTaskTemplate, } from "../preset-engine.mjs";
+export function resolveLifecyclePresetInputs(presetPackage, { cliArgs, fromSession, targetInput }) {
+    return Reflect.apply(resolvePresetInputs, undefined, [presetPackage, { cliArgs, fromSession, targetInput }]);
+}
+export function evaluatePresetValues(presetPackage, resolvedInputs, { taskId, taskTitle, moduleKey, target }) {
+    return Reflect.apply(evaluateTemplateValues, undefined, [presetPackage, resolvedInputs, { taskId, taskTitle, moduleKey, target }]);
+}
+export function buildLifecyclePresetContext(presetPackage, options) {
+    return Reflect.apply(buildPresetContext, undefined, [presetPackage, options]);
+}
+export function renderLifecyclePresetTaskTemplate(destination, content, presetContext) {
+    return Reflect.apply(renderPresetTaskTemplate, undefined, [destination, content, presetContext]);
+}
+export function assertLifecyclePresetWriteScope(presetPackage, relativePath, target) {
+    Reflect.apply(assertPresetWriteScope, undefined, [presetPackage, relativePath, target]);
+}

package/dist/lib/task-lifecycle/review-confirm.mjs

@@ -1,4 +1,3 @@
-// @ts-nocheck
 // Dynamic review confirmation flow stays behavior-first until the metadata domain model PR.
 import fs from "node:fs";
 import path from "node:path";
@@ -8,7 +7,7 @@ import { collectReviewRisks, isBlockingReviewRisk, isLessonCandidateDecisionComp
 import { commitReviewConfirmationGate, prepareReviewConfirmGitGate } from "../review-confirm-git-gate.mjs";
 import { validateHumanReviewConfirmation } from "./review-gates.mjs";
 import { markdownCell } from "./text-utils.mjs";
-export function confirmTaskReview({ target, taskDir, findTaskByDirectory }, { reviewer = "Human Reviewer", message = "", confirmText = "", evidence = "" } = {}) {
+export function confirmTaskReview({ target, taskDir, findTaskByDirectory }, { reviewer = "Human Reviewer", message = "", confirmText = "", evidence = "", deferCommit = false } = {}) {
     assertTaskDirectoryInsidePlanning(target, taskDir);
     const canonicalTaskId = taskIdForDirectory(target, taskDir);
     const shortId = path.basename(taskDir);
@@ -56,6 +55,19 @@ export function confirmTaskReview({ target, taskDir, findTaskByDirectory }, { re
         "Migration Status": baseAuditFields["Migration Status"] || "native",
     });
     fs.writeFileSync(indexPath, ensureTrailingNewline(replaceTaskAuditMetadata(indexContent, buildAuditFields(), { locale: target.locale })));
+    if (deferCommit) {
+        return {
+            event: "review-confirm",
+            task: findTaskByDirectory(target, taskDir) || { id: canonicalTaskId, reviewStatus: "confirmed" },
+            audit: {
+                commitSha: "pending",
+                auditCommitSha: "",
+                auditStatus: "deferred",
+                allowedPaths: gitGate.allowedPaths,
+                message: message || `Human review confirmed by ${reviewer}`,
+            },
+        };
+    }
     const audit = commitReviewConfirmationGate(gitGate, {
         taskId: canonicalTaskId,
         reviewPath: indexPath,
@@ -72,6 +84,26 @@ export function confirmTaskReview({ target, taskDir, findTaskByDirectory }, { re
         audit,
     };
 }
+export function finalizeDeferredTaskReviewConfirmation({ target, taskDir, findTaskByDirectory }, { commitSha = "" } = {}) {
+    assertTaskDirectoryInsidePlanning(target, taskDir);
+    if (!commitSha)
+        throw new Error("Missing deferred review confirmation commit SHA");
+    const canonicalTaskId = taskIdForDirectory(target, taskDir);
+    const indexPath = path.join(taskDir, "INDEX.md");
+    const indexContent = readFileSafe(indexPath);
+    const existingAudit = taskAuditFieldsFromIndex(indexContent);
+    const finalIndex = replaceTaskAuditMetadata(indexContent, {
+        ...existingAudit,
+        "Review Commit SHA": commitSha,
+        "Audit Status": "committed",
+    }, { locale: target.locale });
+    fs.writeFileSync(indexPath, ensureTrailingNewline(finalIndex));
+    return {
+        event: "review-confirm-audit",
+        task: findTaskByDirectory(target, taskDir) || { id: canonicalTaskId, reviewStatus: "confirmed" },
+        indexPath,
+    };
+}
 function assertTaskDirectoryInsidePlanning(target, taskDir) {
     const realTaskDir = fs.realpathSync(taskDir);
     const allowedRoots = (target.harness?.taskRoots || [])

package/dist/lib/task-lifecycle/review-gates.mjs

@@ -1,11 +1,10 @@
-// @ts-nocheck
 // Dynamic review gate modeling stays behavior-first until the metadata domain model PR.
 import fs from "node:fs";
 import path from "node:path";
 import { lessonCandidatesFile, } from "../core-shared.mjs";
-import { collectReviewRisks, isBlockingReviewRisk, parseTaskAuditMetadata, parsePhases, parseReviewConfirmation, readVisualMapContractFile, } from "../task-scanner.mjs";
+import { collectReviewRisks, isLessonCandidateDecisionComplete, isBlockingReviewRisk, parseLessonCandidateStatus, parseTaskAuditMetadata, parsePhases, parseReviewConfirmation, readVisualMapContractFile, } from "../task-scanner.mjs";
 import { implementationPhases, phaseHasRecordedProgress, } from "../phase-kind.mjs";
-export function validateLifecycleTransition({ event, currentState, budget, reviewContent = "", indexContent = "", reviewTaskKey = "", projectRoot = "", taskDir = "" }) {
+export function validateLifecycleTransition({ event, currentState, budget, reviewContent = "", indexContent = "", reviewTaskKey = "", projectRoot = "", taskDir = "", }) {
     if (event === "task-review" && currentState !== "in_progress") {
         throw new Error(`task-review requires current state in_progress; current state is ${currentState || "unknown"}`);
     }
@@ -19,7 +18,15 @@ export function validateLifecycleTransition({ event, currentState, budget, revie
             throw new Error(`Open blocking review findings must be closed before task-complete: ${ids}`);
         }
         if (!parseReviewConfirmation(reviewContent, { taskKey: reviewTaskKey, taskAudit: parseTaskAuditMetadata(indexContent), projectRoot, taskDir, indexPath: path.join(taskDir, "INDEX.md") })?.confirmed) {
-            throw new Error("Human review must be confirmed before task-complete. Run review-confirm first.");
+            throw new Error("Human review must be confirmed before task-complete. Confirm it from the local Dashboard workbench first.");
+        }
+        const lessonCandidateStatus = parseLessonCandidateStatus(fs.existsSync(path.join(taskDir, lessonCandidatesFile)) ? fs.readFileSync(path.join(taskDir, lessonCandidatesFile), "utf8") : "");
+        if (!isLessonCandidateDecisionComplete(lessonCandidateStatus)) {
+            throw new Error(`Lesson candidate decision must be complete before task-complete; current status is ${lessonCandidateStatus.status}.`);
+        }
+        const hasLessonWork = lessonCandidateStatus.status === "needs-promotion" || lessonCandidateStatus.promotionState === "queued" || lessonCandidateStatus.openCount > 0;
+        if (hasLessonWork) {
+            throw new Error("Lesson candidate promotion or sedimentation work must be resolved before task-complete.");
         }
     }
 }
@@ -44,7 +51,7 @@ export function validateHumanReviewConfirmation({ task, budget }) {
     if (budget === "simple")
         return;
     if (!task?.walkthroughPath) {
-        throw new Error("Human review confirmation requires task-local walkthrough.md before review-confirm.");
+        throw new Error("Human review confirmation requires task-local walkthrough.md before Dashboard confirmation.");
     }
     const queueState = task?.reviewQueueState || "not-in-queue";
     if (queueState !== "ready-to-confirm") {

package/dist/lib/task-lifecycle/review-submission.mjs

@@ -1,4 +1,3 @@
-// @ts-nocheck
 // Dynamic review submission rendering stays behavior-first until the metadata domain model PR.
 import crypto from "node:crypto";
 import fs from "node:fs";
@@ -6,7 +5,7 @@ import path from "node:path";
 import { lessonCandidatesFile, longRunningTaskContractFile, nowTimestamp, readFileSafe, toPosix, visualMapFile, } from "../core-shared.mjs";
 import { collectReviewRisks, isBlockingReviewRisk, taskScannerVersion, } from "../task-review-model.mjs";
 import { markdownCell } from "./text-utils.mjs";
-export function renderAgentReviewSubmission({ target, taskDir, canonicalTaskId, message, evidence }) {
+export function renderAgentReviewSubmission({ target, taskDir, canonicalTaskId, message, evidence, }) {
     const timestamp = nowTimestamp();
     const submissionId = `ARS-${timestamp.replace(/[^0-9]/g, "").slice(0, 14)}`;
     const materialsHash = hashTaskMaterials(taskDir);

package/dist/lib/task-lifecycle/scaffold-provenance.mjs

@@ -1,4 +1,3 @@
-// @ts-nocheck
 import path from "node:path";
 import { localizedTemplateSource, todayDate } from "../core-shared.mjs";
 import { markdownCell } from "./text-utils.mjs";

package/dist/lib/task-lifecycle/template-files.mjs

@@ -30,11 +30,8 @@ export function optionalTaskTemplateFiles({ locale = "en-US" } = {}) {
 }
 export function moduleTemplateFiles({ locale = "en-US" } = {}) {
     return [
-        ["brief.md", "templates/planning/module_brief.md"],
-        ["module_plan.md", "templates/planning/module_plan.md"],
-        ["execution_strategy.md", "templates/planning/execution_strategy.md"],
-        [visualMapFile, "templates/planning/visual_map.md"],
-        ["session_prompt.md", "templates/planning/module_session_prompt.md"],
+        ["brief.md", "templates/modules/module_brief.md"],
+        ["module_plan.md", "templates/modules/module_plan.md"],
     ].map(([destination, source]) => [destination, localizedTemplateSource(source, locale)]);
 }
 export function taskFilesForBudget({ budget, locale }) {