coding-agent-harness 1.0.5 → 1.0.7

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

@@ -0,0 +1,239 @@
+// @ts-nocheck
+import fs from "node:fs";
+import path from "node:path";
+import { tableAfterHeading, firstColumn, } from "./markdown-utils.mjs";
+import { toPosix } from "./core-shared.mjs";
+export const allowedLessonCandidateTaskStatuses = new Set([
+    "missing",
+    "pending-review",
+    "no-candidate-accepted",
+    "needs-promotion",
+    "promoted",
+    "rejected",
+]);
+export const allowedLessonCandidateRowStatuses = new Set([
+    "ready-for-review",
+    "needs-promotion",
+    "promoted",
+    "rejected",
+]);
+export const reviewCompleteLessonCandidateStatuses = new Set([
+    "no-candidate-accepted",
+    "needs-promotion",
+    "promoted",
+    "rejected",
+]);
+export function parseLessonCandidateStatus(content) {
+    const text = String(content || "");
+    if (!text.trim()) {
+        return emptyLessonCandidateStatus("missing", ["missing-candidate-file"]);
+    }
+    const fields = lessonCandidateFields(text);
+    const declaredStatus = normalizeLessonCandidateStatus(fields.get("task-level status") || "pending-review");
+    const reviewDecision = normalizeCandidateField(fields.get("review decision") || "pending-human-review");
+    const promotionState = normalizeCandidateField(fields.get("promotion state") || "not-promoted");
+    const closeoutToken = String(fields.get("closeout token") || "pending").trim();
+    const candidateTable = lessonCandidateRows(text);
+    const rows = candidateTable.rows;
+    const issues = [];
+    if (!allowedLessonCandidateTaskStatuses.has(declaredStatus)) {
+        issues.push(`invalid-task-status:${declaredStatus}`);
+    }
+    for (const row of rows) {
+        if (!allowedLessonCandidateRowStatuses.has(row.status))
+            issues.push(`invalid-row-status:${row.id || "missing-id"}:${row.status}`);
+    }
+    const promotionRows = rows.filter((row) => row.status === "needs-promotion");
+    if (promotionRows.length > 0) {
+        for (const column of candidateTable.missingColumns)
+            issues.push(`missing-column:${column}`);
+        for (const row of promotionRows) {
+            for (const [field, label] of [
+                ["scope", "Scope"],
+                ["detailArtifact", "Detail Artifact"],
+                ["boundaryReason", "Boundary Reason"],
+                ["whyItMightMatter", "Why It Might Matter"],
+                ["promotionTarget", "Promotion Target"],
+                ["conflictCheck", "Conflict Check"],
+                ["requiredStandardUpdate", "Required Standard Update"],
+                ["followUpTask", "Follow-up Task"],
+            ]) {
+                if (!String(row[field] || "").trim())
+                    issues.push(`missing-row-field:${row.id || "missing-id"}:${label}`);
+            }
+        }
+    }
+    const aggregateStatus = aggregateLessonCandidateStatus(rows, declaredStatus);
+    if (declaredStatus !== aggregateStatus && declaredStatus !== "missing") {
+        issues.push(`status-aggregate-mismatch:${declaredStatus}->${aggregateStatus}`);
+    }
+    if (aggregateStatus === "no-candidate-accepted" && !noCandidateReason(text)) {
+        issues.push("missing-no-candidate-reason");
+    }
+    return {
+        status: aggregateStatus,
+        declaredStatus,
+        schemaVersion: fields.get("schema version") || "",
+        reviewDecision,
+        promotionState,
+        closeoutToken,
+        rows,
+        openCount: rows.filter((row) => ["ready-for-review", "needs-promotion"].includes(row.status)).length,
+        issues,
+    };
+}
+export function isLessonCandidateDecisionComplete(candidateStatus) {
+    if (!candidateStatus || candidateStatus.issues?.length)
+        return false;
+    return reviewCompleteLessonCandidateStatuses.has(candidateStatus.status);
+}
+export function validateLessonCandidateDetailArtifacts(target, taskDir, candidateStatus) {
+    const issues = [];
+    const rows = Array.isArray(candidateStatus?.rows) ? candidateStatus.rows : [];
+    for (const row of rows.filter((candidate) => candidate.status === "needs-promotion")) {
+        const rawPath = String(row.detailArtifact || "").trim();
+        if (!rawPath)
+            continue;
+        const resolved = resolveTaskLocalLessonArtifact(target, taskDir, rawPath);
+        if (!resolved || !isInsideDirectory(taskDir, resolved)) {
+            issues.push(`invalid-detail-artifact-path:${row.id || "missing-id"}:${rawPath}`);
+            continue;
+        }
+        if (!fs.existsSync(resolved) || !fs.statSync(resolved).isFile()) {
+            issues.push(`missing-detail-artifact:${row.id || "missing-id"}:${rawPath}`);
+        }
+    }
+    return issues;
+}
+function emptyLessonCandidateStatus(status, issues = []) {
+    return {
+        status,
+        declaredStatus: status,
+        schemaVersion: "",
+        reviewDecision: "",
+        promotionState: "",
+        closeoutToken: "",
+        rows: [],
+        openCount: 0,
+        issues,
+    };
+}
+function lessonCandidateFields(content) {
+    const { header, rows } = tableAfterHeading(content, /^Field$/i);
+    const fieldIndex = firstColumn(header, ["Field", "字段"]);
+    const valueIndex = firstColumn(header, ["Value", "值"]);
+    const fields = new Map();
+    if (fieldIndex < 0 || valueIndex < 0)
+        return fields;
+    for (const row of rows) {
+        const key = String(row[fieldIndex] || "").trim().toLowerCase();
+        if (key)
+            fields.set(key, String(row[valueIndex] || "").trim());
+    }
+    return fields;
+}
+function resolveTaskLocalLessonArtifact(target, taskDir, artifactPath) {
+    const raw = String(artifactPath || "").trim();
+    if (!raw)
+        return "";
+    if (/^(?:https?:|file:|[A-Za-z]:\\|\/)/.test(raw))
+        return "";
+    const relative = raw.startsWith("TARGET:")
+        ? raw.replace(/^TARGET:/, "").replace(/^\/+/, "")
+        : toPosix(path.join(toPosix(path.relative(target.projectRoot, taskDir)), raw));
+    return path.resolve(target.projectRoot, relative);
+}
+function isInsideDirectory(parent, child) {
+    const relative = path.relative(parent, child);
+    return Boolean(relative) && !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+function lessonCandidateRows(content) {
+    const { header, rows } = tableAfterHeading(content, /^ID$/i);
+    const idIndex = firstColumn(header, ["ID", "候选 ID"]);
+    const statusIndex = firstColumn(header, ["Row Status", "行状态", "Status", "状态"]);
+    const titleIndex = firstColumn(header, ["Title", "标题"]);
+    const decisionIndex = firstColumn(header, ["Review Decision", "审查决定"]);
+    const targetIndex = firstColumn(header, ["Promotion Target", "沉淀目标"]);
+    const scopeIndex = firstColumn(header, ["Scope", "范围"]);
+    const boundaryIndex = firstColumn(header, ["Boundary Reason", "边界原因"]);
+    const moduleKeyIndex = firstColumn(header, ["Module Key", "模块 Key", "模块"]);
+    const detailArtifactIndex = firstColumn(header, ["Detail Artifact", "Lesson Detail", "详情产物", "详情文件"]);
+    const whyIndex = firstColumn(header, ["Why It Might Matter", "价值说明", "为什么重要"]);
+    const conflictIndex = firstColumn(header, ["Conflict Check", "冲突检查"]);
+    const requiredUpdateIndex = firstColumn(header, ["Required Standard Update", "必需标准更新"]);
+    const followUpIndex = firstColumn(header, ["Follow-up Task", "Followup Task", "后续任务"]);
+    if (idIndex < 0 || statusIndex < 0)
+        return { rows: [], missingColumns: [] };
+    const requiredColumnSpecs = [
+        ["Scope", scopeIndex],
+        ["Detail Artifact", detailArtifactIndex],
+        ["Boundary Reason", boundaryIndex],
+        ["Why It Might Matter", whyIndex],
+        ["Promotion Target", targetIndex],
+        ["Conflict Check", conflictIndex],
+        ["Required Standard Update", requiredUpdateIndex],
+        ["Follow-up Task", followUpIndex],
+    ];
+    const missingColumns = requiredColumnSpecs.filter(([, index]) => index < 0).map(([label]) => label);
+    return {
+        missingColumns,
+        rows: rows
+            .filter((row) => /^LC-[A-Za-z0-9-]+$/i.test(row[idIndex] || ""))
+            .map((row) => ({
+            id: row[idIndex] || "",
+            status: normalizeLessonCandidateStatus(row[statusIndex] || ""),
+            title: row[titleIndex] || "",
+            scope: scopeIndex >= 0 ? row[scopeIndex] || "" : "",
+            moduleKey: moduleKeyIndex >= 0 ? row[moduleKeyIndex] || "" : "",
+            detailArtifact: detailArtifactIndex >= 0 ? row[detailArtifactIndex] || "" : "",
+            boundaryReason: boundaryIndex >= 0 ? row[boundaryIndex] || "" : "",
+            whyItMightMatter: whyIndex >= 0 ? row[whyIndex] || "" : "",
+            reviewDecision: row[decisionIndex] || "",
+            promotionTarget: row[targetIndex] || "",
+            conflictCheck: conflictIndex >= 0 ? row[conflictIndex] || "" : "",
+            requiredStandardUpdate: requiredUpdateIndex >= 0 ? row[requiredUpdateIndex] || "" : "",
+            followUpTask: followUpIndex >= 0 ? row[followUpIndex] || "" : "",
+            originalRow: row.map((cell) => String(cell || "").trim()).join(" | "),
+        })),
+    };
+}
+function normalizeLessonCandidateStatus(value) {
+    return String(value || "")
+        .replace(/`/g, "")
+        .trim()
+        .toLowerCase()
+        .replaceAll("_", "-")
+        .replace(/\s+/g, "-");
+}
+function normalizeCandidateField(value) {
+    return String(value || "").replace(/`/g, "").trim().toLowerCase().replaceAll("_", "-").replace(/\s+/g, "-");
+}
+function aggregateLessonCandidateStatus(rows, declaredStatus) {
+    if (rows.length === 0)
+        return declaredStatus === "no-candidate-accepted" ? "no-candidate-accepted" : declaredStatus;
+    const statuses = rows.map((row) => row.status);
+    if (statuses.includes("ready-for-review"))
+        return "pending-review";
+    if (statuses.includes("needs-promotion"))
+        return "needs-promotion";
+    if (statuses.every((status) => status === "promoted"))
+        return "promoted";
+    if (statuses.every((status) => status === "rejected"))
+        return "rejected";
+    if (statuses.every((status) => ["promoted", "rejected"].includes(status)))
+        return "promoted";
+    return declaredStatus;
+}
+function noCandidateReason(content) {
+    const lines = String(content || "").split(/\r?\n/);
+    const start = lines.findIndex((line) => /^##\s*No-Candidate Reason\s*$/i.test(line.trim()));
+    if (start < 0)
+        return "";
+    const body = [];
+    for (const line of lines.slice(start + 1)) {
+        if (/^##\s+/.test(line))
+            break;
+        body.push(line);
+    }
+    return body.join("\n").replace(/`/g, "").trim();
+}

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

@@ -0,0 +1,300 @@
+// @ts-nocheck
+import fs from "node:fs";
+import path from "node:path";
+import { lessonCandidatesFile, normalizeTarget, readFileSafe, toPosix, normalizeTaskId, localDate, } from "./core-shared.mjs";
+import { parseLessonCandidateStatus } from "./task-lesson-candidates.mjs";
+import { readCapabilityRegistry } from "./capability-registry.mjs";
+import { createTask, resolveTaskDirectory } from "./task-lifecycle.mjs";
+import { readPresetPackage, buildPresetAudit, renderPresetTemplate } from "./preset-registry.mjs";
+import { firstColumn, updateMarkdownTableRow } from "./markdown-utils.mjs";
+import { taskIdForDirectory } from "./task-scanner.mjs";
+import { beginGovernanceSync, commitGovernanceSync, governanceRelativePaths, releaseGovernanceSync, } from "./governance-sync.mjs";
+const presetId = "lesson-sedimentation";
+export class LessonSedimentationError extends Error {
+    constructor(message, { code = "lesson-sedimentation-failed", status = 400, details = {}, recovery = [] } = {}) {
+        super(message);
+        this.name = "LessonSedimentationError";
+        this.code = code;
+        this.status = status;
+        this.details = details;
+        this.recovery = recovery;
+    }
+}
+export function createLessonSedimentationTask(targetInput, taskRef, candidateId, { dryRun = false, title = "" } = {}) {
+    const target = normalizeTarget(targetInput);
+    const sourceTaskDir = resolveTaskDirectory(target, taskRef);
+    const sourceTaskId = taskIdForDirectory(target, sourceTaskDir);
+    const sourceShortId = path.basename(sourceTaskDir);
+    const candidatePath = path.join(sourceTaskDir, lessonCandidatesFile);
+    const content = readFileSafe(candidatePath);
+    const candidateStatus = parseLessonCandidateStatus(content);
+    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.",
+            ],
+        });
+    }
+    const preset = readPresetPackage(presetId);
+    const slug = normalizeTaskId(`lesson-${sourceShortId.replace(/^\d{4}-\d{2}-\d{2}-/, "")}-${candidate.id}`);
+    const taskTitle = title || `Lesson sedimentation for ${candidate.id}`;
+    const locale = readCapabilityRegistry(target).locale;
+    let taskResult;
+    try {
+        taskResult = createTask(target.projectRoot, slug, {
+            title: taskTitle,
+            locale,
+            budget: "standard",
+            longRunning: true,
+            dryRun,
+        });
+    }
+    catch (error) {
+        if (/Task already exists:/i.test(error.message)) {
+            const existingTask = `TASKS/${localDate()}-${slug}`;
+            throw new LessonSedimentationError(error.message, {
+                code: "lesson-follow-up-directory-exists",
+                status: 409,
+                details: { candidateId, existingTask, sourceTask: sourceTaskId },
+                recovery: [
+                    "Open the existing task directory and confirm whether it is the intended follow-up.",
+                    "If it is valid, update the source candidate Follow-up Task cell to that task id.",
+                ],
+            });
+        }
+        throw error;
+    }
+    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 = renderLessonSedimentationPrompt(preset, {
+        target,
+        sourceTaskDir,
+        sourceTaskId,
+        sourceShortId,
+        candidate,
+        followUpTaskId,
+    });
+    const contextPacket = renderContextPacket({
+        target,
+        sourceTaskDir,
+        sourceTaskId,
+        candidate,
+        followUpTaskId,
+        audit,
+    });
+    const changes = [...taskResult.changes];
+    if (!dryRun) {
+        const governanceContext = beginGovernanceSync(target, { operation: `lesson-sediment ${sourceTaskId} ${candidate.id}` });
+        try {
+            appendToFollowUpTask({ followUpDir, sourceTaskId, candidate, prompt, contextPacket, audit });
+            updateSourceFollowUpTask(candidatePath, candidate.id, followUpTaskId);
+            changes.push({
+                destination: toPosix(path.relative(target.projectRoot, path.join(followUpDir, "task_plan.md"))),
+                source: "lesson-sedimentation",
+                action: "append-preset-context",
+            }, {
+                destination: toPosix(path.relative(target.projectRoot, path.join(followUpDir, "progress.md"))),
+                source: "lesson-sedimentation",
+                action: "append-preset-progress",
+            }, {
+                destination: toPosix(path.relative(target.projectRoot, path.join(followUpDir, "artifacts/lesson-sedimentation-prompt.md"))),
+                source: "lesson-sedimentation",
+                action: "create-prompt-artifact",
+            }, {
+                destination: toPosix(path.relative(target.projectRoot, path.join(followUpDir, "artifacts/preset-audit.json"))),
+                source: "lesson-sedimentation",
+                action: "create-preset-audit",
+            }, {
+                destination: toPosix(path.relative(target.projectRoot, candidatePath)),
+                source: lessonCandidatesFile,
+                action: "update-follow-up-task",
+            });
+            taskResult.governance = {
+                ...(taskResult.governance || {}),
+                lessonSedimentationCommit: commitGovernanceSync(governanceContext, governanceRelativePaths(changes), {
+                    message: `chore(harness): record lesson sedimentation ${candidate.id}`,
+                }),
+            };
+        }
+        finally {
+            releaseGovernanceSync(governanceContext);
+        }
+    }
+    return {
+        dryRun,
+        event: "lesson-sedimentation-task",
+        preset: presetId,
+        sourceTask: sourceTaskId,
+        candidate,
+        followUpTask: {
+            id: followUpTaskId,
+            path: taskResult.task.path,
+            title: taskTitle,
+        },
+        prompt,
+        changes,
+        governance: taskResult.governance || null,
+    };
+}
+function renderLessonSedimentationPrompt(preset, values) {
+    const detailArtifact = resolveDetailArtifact(values.target, values.sourceTaskDir, values.candidate);
+    const prompt = renderPresetTemplate(preset, preset.entrypoints.newTask?.templates?.prompt, {
+        sourceTaskId: values.sourceTaskId,
+        sourceShortId: values.sourceShortId,
+        candidateId: values.candidate.id,
+        candidateTitle: values.candidate.title,
+        candidateScope: values.candidate.scope,
+        candidateModuleKey: values.candidate.moduleKey || "n/a",
+        detailArtifact: detailArtifact.prefixedPath || "not provided",
+        boundaryReason: values.candidate.boundaryReason,
+        whyItMightMatter: values.candidate.whyItMightMatter,
+        promotionTarget: values.candidate.promotionTarget,
+        conflictCheck: values.candidate.conflictCheck,
+        requiredStandardUpdate: values.candidate.requiredStandardUpdate,
+        followUpTaskId: values.followUpTaskId,
+    });
+    return prompt.trim();
+}
+function renderContextPacket({ target, sourceTaskDir, sourceTaskId, candidate, followUpTaskId, audit }) {
+    const sourceLessonPath = `TARGET:${toPosix(path.relative(target.projectRoot, path.join(sourceTaskDir, lessonCandidatesFile)))}`;
+    const detailArtifact = resolveDetailArtifact(target, sourceTaskDir, candidate);
+    const sourceReview = summarizeMarkdown(readFileSafe(path.join(sourceTaskDir, "review.md")));
+    const sourceFindings = summarizeMarkdown(readFileSafe(path.join(sourceTaskDir, "findings.md")));
+    const sourceProgress = summarizeMarkdown(readFileSafe(path.join(sourceTaskDir, "progress.md")));
+    const sourceLessonDetail = summarizeMarkdown(detailArtifact.path ? readFileSafe(detailArtifact.path) : "");
+    return [
+        "## Lesson Sedimentation Context Packet",
+        "",
+        "| Field | Value |",
+        "| --- | --- |",
+        `| Preset | ${presetId} |`,
+        `| Follow-up Task | ${followUpTaskId} |`,
+        `| Source Task | ${sourceTaskId} |`,
+        `| Source Lesson Candidates | ${sourceLessonPath} |`,
+        `| Source Lesson Detail | ${detailArtifact.prefixedPath || "not provided"} |`,
+        `| Candidate ID | ${candidate.id} |`,
+        `| Candidate Title | ${markdownCell(candidate.title)} |`,
+        `| Original Candidate Row | ${markdownCell(candidate.originalRow || "")} |`,
+        `| Scope | ${markdownCell(candidate.scope || "unspecified")} |`,
+        `| Module Key | ${markdownCell(candidate.moduleKey || "n/a")} |`,
+        `| Detail Summary | ${markdownCell(sourceLessonDetail || "not recorded")} |`,
+        `| Boundary Reason | ${markdownCell(candidate.boundaryReason || "unspecified")} |`,
+        `| Why It Might Matter | ${markdownCell(candidate.whyItMightMatter || "unspecified")} |`,
+        `| Promotion Target | ${markdownCell(candidate.promotionTarget || "unspecified")} |`,
+        `| Conflict Check | ${markdownCell(candidate.conflictCheck || "pending")} |`,
+        `| Required Standard Update | ${markdownCell(candidate.requiredStandardUpdate || "pending")} |`,
+        `| Review Summary | ${markdownCell(sourceReview)} |`,
+        `| Findings Summary | ${markdownCell(sourceFindings)} |`,
+        `| Evidence Summary | ${markdownCell(sourceProgress)} |`,
+        `| 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))
+        return { path: "", prefixedPath: "" };
+    const absolute = raw.startsWith("TARGET:")
+        ? path.resolve(target.projectRoot, raw.replace(/^TARGET:/, "").replace(/^\/+/, ""))
+        : path.resolve(sourceTaskDir, raw.replace(/^\.?\//, ""));
+    if (!absolute.startsWith(path.resolve(sourceTaskDir) + path.sep))
+        return { path: "", prefixedPath: "" };
+    return {
+        path: absolute,
+        prefixedPath: `TARGET:${toPosix(path.relative(target.projectRoot, absolute))}`,
+    };
+}
+function appendToFollowUpTask({ followUpDir, sourceTaskId, candidate, 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 taskPlanAppend = [
+        "",
+        "## Lesson Sedimentation Preset",
+        "",
+        "Task Preset: lesson-sedimentation",
+        "Preset Version: 1",
+        "Task Kind: lesson-sedimentation",
+        `Source Task: ${sourceTaskId}`,
+        `Source Candidate: ${candidate.id}`,
+        `Promotion Target: ${candidate.promotionTarget || "pending"}`,
+        "",
+        contextPacket.trimEnd(),
+        "",
+        "## Execution Prompt",
+        "",
+        "The copyable prompt for a new agent session is stored in `artifacts/lesson-sedimentation-prompt.md`.",
+        "",
+    ].join("\n");
+    fs.appendFileSync(taskPlanPath, taskPlanAppend);
+    fs.appendFileSync(progressPath, [
+        "",
+        "### Lesson sedimentation task created",
+        "",
+        `- Source task: ${sourceTaskId}`,
+        `- Source candidate: ${candidate.id}`,
+        "- Next: paste the execution prompt into a fresh agent session and require diff-first review before applying changes.",
+        "",
+    ].join("\n"));
+}
+function updateSourceFollowUpTask(candidatePath, candidateId, followUpTaskId) {
+    const content = readFileSafe(candidatePath);
+    const update = updateMarkdownTableRow(content, /^ID$/i, (header, row) => {
+        const idIndex = firstColumn(header, ["ID", "候选 ID"]);
+        const followUpIndex = firstColumn(header, ["Follow-up Task", "Followup Task", "后续任务"]);
+        if (idIndex < 0 || followUpIndex < 0 || row[idIndex] !== candidateId)
+            return null;
+        const next = [...row];
+        next[followUpIndex] = followUpTaskId;
+        return next;
+    });
+    if (!update.matched)
+        throw new Error(`Could not update Follow-up Task column for ${candidateId}`);
+    fs.writeFileSync(candidatePath, update.content.endsWith("\n") ? update.content : `${update.content}\n`);
+}
+function markdownCell(value) {
+    return String(value || "").replace(/\r?\n/g, " ").replaceAll("|", "\\|").trim();
+}
+function summarizeMarkdown(content) {
+    const lines = String(content || "")
+        .split(/\r?\n/)
+        .map((line) => line.replace(/^#+\s*/, "").trim())
+        .filter((line) => line && !/^\|?\s*-{3,}/.test(line));
+    return lines.slice(0, 4).join(" / ") || "not recorded";
+}

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

@@ -0,0 +1,84 @@
+// @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 }) {
+    const changes = [];
+    if (normalizedModuleKey) {
+        const moduleDirectory = path.dirname(directory);
+        for (const [destination, source] of moduleTemplateFiles({ locale: normalizedLocale })) {
+            const destinationPath = path.join(moduleDirectory, destination);
+            if (fs.existsSync(destinationPath))
+                continue;
+            changes.push({
+                destination: toPosix(path.relative(target.projectRoot, destinationPath)),
+                source,
+                action: "create",
+            });
+        }
+    }
+    for (const [destination, source] of appendLongRunningContractFile(taskFilesForBudget({ budget: normalizedBudget, locale: normalizedLocale }), {
+        locale: normalizedLocale,
+        longRunning,
+    })) {
+        changes.push({
+            destination: toPosix(path.relative(target.projectRoot, path.join(directory, destination))),
+            source,
+            action: "create",
+        });
+    }
+    if (presetContext) {
+        for (const evidence of presetContext.evidenceFiles || []) {
+            changes.push({ destination: toPosix(evidence.relativePath), source: evidence.source, action: "create" });
+        }
+        for (const resource of presetContext.resourceFiles || []) {
+            changes.push({ destination: toPosix(resource.relativePath), source: resource.source, action: "create" });
+        }
+        for (const [kind, rows] of Object.entries(presetContext.resourceIndexRows || {})) {
+            if (!rows.length)
+                continue;
+            const destination = kind === "references" ? "references/INDEX.md" : "artifacts/INDEX.md";
+            changes.push({
+                destination: toPosix(path.relative(target.projectRoot, path.join(directory, destination))),
+                source: `preset-${kind}-index`,
+                action: "update",
+            });
+        }
+    }
+    return changes;
+}
+export function refreshPresetCommandAudit(target, presetContext, { commandWriteScopes = [], dryRun = false } = {}) {
+    const scopes = [...new Set(commandWriteScopes.filter(Boolean))];
+    presetContext.audit = {
+        ...presetContext.audit,
+        presetWriteScopes: presetContext.audit.writeScopes || [],
+        commandWriteScopes: scopes,
+    };
+    for (const evidence of presetContext.evidenceFiles || []) {
+        if (evidence.source !== "preset-audit")
+            continue;
+        evidence.content = `${JSON.stringify(presetContext.audit, null, 2)}\n`;
+        if (dryRun)
+            continue;
+        fs.writeFileSync(path.join(target.projectRoot, evidence.relativePath), evidence.content);
+    }
+}
+export function targetInputFromSessionFile(fromSession) {
+    if (!fromSession)
+        return "";
+    try {
+        const parsed = JSON.parse(fs.readFileSync(path.resolve(fromSession), "utf8"));
+        return parsed.target || "";
+    }
+    catch {
+        return "";
+    }
+}
+export function resolveImplicitCreateTarget(targetInput, fromSession) {
+    const sessionTarget = targetInputFromSessionFile(fromSession);
+    if (targetInput && targetInput !== ".")
+        return targetInput;
+    return sessionTarget || discoverImplicitHarnessTarget(targetInput || ".") || targetInput || "";
+}