@opengsd/gsd-pi 1.8.1 → 1.9.0-dev.5c1a3ff2

package/dist/resources/extensions/gsd/gsd-db.js

@@ -19,7 +19,8 @@ import { createHash } from "node:crypto";
 import { GSDError, GSD_STALE_STATE } from "./errors.js";
 import { getGateIdsForTurn } from "./gate-registry.js";
 import { logWarning } from "./workflow-logger.js";
-import { isClosedStatus } from "./status-guards.js";
+import { rowToArtifact } from "./db-milestone-artifact-rows.js";
+import { isClosedStatus, toStatus } from "./status-guards.js";
 // Connection ownership, lifecycle, schema/migrations and transaction
 // primitives now live in the engine; re-export the full public surface so
 // existing `from "./gsd-db.js"` imports keep working.
@@ -336,6 +337,11 @@ export function upsertSlicePlanning(milestoneId, sliceId, planning) {
 export function insertTask(t) {
     if (!getDbOrNull())
         throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+    // Stamp completed_at for every terminal-complete alias (complete/done/closed),
+    // not just two literals — a task imported as "closed" is completed and must
+    // carry a timestamp. NOT for "skipped": a skipped task was never completed
+    // (cascade writers set its completed_at = NULL).
+    const isCompleteAlias = t.status != null && toStatus(t.status) === "complete";
     getDbOrNull().prepare(`INSERT INTO tasks (
       milestone_id, slice_id, id, title, status, one_liner, narrative,
       verification_result, duration, completed_at, blocker_discovered,
@@ -385,7 +391,7 @@ export function insertTask(t) {
         ":narrative": t.narrative ?? "",
         ":verification_result": t.verificationResult ?? "",
         ":duration": t.duration ?? "",
-        ":completed_at": t.status === "done" || t.status === "complete" ? new Date().toISOString() : null,
+        ":completed_at": isCompleteAlias ? new Date().toISOString() : null,
         ":blocker_discovered": t.blockerDiscovered ? 1 : 0,
         ":deviations": t.deviations ?? "",
         ":known_issues": t.knownIssues ?? "",
@@ -401,7 +407,7 @@ export function insertTask(t) {
         ":observability_impact": t.planning?.observabilityImpact ?? "",
         ":full_plan_md": t.planning?.fullPlanMd ?? "",
         ":sequence": t.sequence ?? 0,
-        ":preserve_completion": t.preserveCompletionMetadata && (t.status === "complete" || t.status === "done") ? 1 : 0,
+        ":preserve_completion": t.preserveCompletionMetadata && isCompleteAlias ? 1 : 0,
         ":target_repositories": JSON.stringify(t.planning?.targetRepositories ?? []),
         ":raw_target_repositories": t.planning && "targetRepositories" in t.planning
             ? JSON.stringify(t.planning.targetRepositories ?? [])
@@ -498,8 +504,8 @@ export function upsertTaskPlanning(milestoneId, sliceId, taskId, planning) {
         ":target_repositories": planning.targetRepositories ? JSON.stringify(planning.targetRepositories) : null,
     });
 }
-export function updateSliceStatus(milestoneId, sliceId, status, completedAt) {
-    applyStatusTransition({ entity: "slice", milestoneId, sliceId, status, completedAt });
+export function updateSliceStatus(milestoneId, sliceId, status, completedAt, preserveCompletion) {
+    applyStatusTransition({ entity: "slice", milestoneId, sliceId, status, completedAt, preserveCompletion });
 }
 export function setTaskSummaryMd(milestoneId, sliceId, taskId, md) {
     if (!getDbOrNull())
@@ -611,8 +617,8 @@ function writeMilestoneStatus(milestoneId, status, completedAt) {
  * advance planned milestones. They may not reopen a closed milestone; callers
  * must use reopenMilestoneStatus(), which is reserved for gsd_milestone_reopen.
  */
-export function updateMilestoneStatus(milestoneId, status, completedAt) {
-    applyStatusTransition({ entity: "milestone", milestoneId, status, completedAt });
+export function updateMilestoneStatus(milestoneId, status, completedAt, preserveCompletion) {
+    applyStatusTransition({ entity: "milestone", milestoneId, status, completedAt, preserveCompletion });
 }
 /**
  * Explicit closed -> active transition for gsd_milestone_reopen only.
@@ -657,6 +663,128 @@ export function insertReplanHistory(entry) {
         ":created_at": new Date().toISOString(),
     });
 }
+function reworkBriefIdFromTask(milestoneId, sliceId, taskId) {
+    return `RB-${milestoneId}-${sliceId}-${taskId}`;
+}
+function normalizeReworkStatus(status) {
+    const normalized = String(status ?? "pending");
+    if (normalized === "resolved" || normalized === "deferred-with-override") {
+        return normalized;
+    }
+    return "pending";
+}
+function rowToReworkFinding(row) {
+    let verificationCommands = [];
+    try {
+        const parsed = JSON.parse(String(row["verification_commands"] ?? "[]"));
+        verificationCommands = Array.isArray(parsed) ? parsed.map(String) : [];
+    }
+    catch {
+        verificationCommands = [];
+    }
+    return {
+        brief_id: String(row["brief_id"] ?? ""),
+        finding_id: String(row["finding_id"] ?? ""),
+        severity: String(row["severity"] ?? "blocking") === "advisory" ? "advisory" : "blocking",
+        description: String(row["description"] ?? ""),
+        required_fix: String(row["required_fix"] ?? ""),
+        verification_commands: verificationCommands,
+        status: normalizeReworkStatus(row["status"]),
+        evidence: String(row["evidence"] ?? ""),
+        decision_ref: String(row["decision_ref"] ?? ""),
+    };
+}
+export function saveReworkBrief(entry) {
+    if (!getDbOrNull())
+        throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+    const briefId = entry.briefId?.trim() || reworkBriefIdFromTask(entry.milestoneId, entry.sliceId, entry.taskId);
+    const now = new Date().toISOString();
+    transaction(() => {
+        getDbOrNull().prepare(`INSERT INTO rework_briefs (id, milestone_id, slice_id, task_id, created_at, updated_at)
+       VALUES (:id, :mid, :sid, :tid, :created_at, :updated_at)
+       ON CONFLICT(id) DO UPDATE SET
+         milestone_id = :mid,
+         slice_id = :sid,
+         task_id = :tid,
+         updated_at = :updated_at`).run({
+            ":id": briefId,
+            ":mid": entry.milestoneId,
+            ":sid": entry.sliceId,
+            ":tid": entry.taskId,
+            ":created_at": now,
+            ":updated_at": now,
+        });
+        getDbOrNull().prepare("DELETE FROM rework_brief_findings WHERE brief_id = :id").run({ ":id": briefId });
+        const stmt = getDbOrNull().prepare(`INSERT INTO rework_brief_findings (
+         brief_id, finding_id, severity, description, required_fix, verification_commands,
+         status, evidence, decision_ref, updated_at
+       ) VALUES (
+         :brief_id, :finding_id, :severity, :description, :required_fix, :verification_commands,
+         :status, :evidence, :decision_ref, :updated_at
+       )`);
+        for (const finding of entry.findings) {
+            stmt.run({
+                ":brief_id": briefId,
+                ":finding_id": finding.findingId,
+                ":severity": finding.severity,
+                ":description": finding.description,
+                ":required_fix": finding.requiredFix,
+                ":verification_commands": JSON.stringify(finding.verificationCommands),
+                ":status": finding.status ?? "pending",
+                ":evidence": finding.evidence ?? "",
+                ":decision_ref": finding.decisionRef ?? "",
+                ":updated_at": now,
+            });
+        }
+    });
+    return { briefId };
+}
+export function getBlockingReworkFindingsForTask(milestoneId, sliceId, taskId) {
+    if (!getDbOrNull())
+        return [];
+    const rows = getDbOrNull().prepare(`SELECT f.*
+     FROM rework_brief_findings f
+     JOIN rework_briefs b ON b.id = f.brief_id
+     WHERE b.milestone_id = :mid
+       AND b.slice_id = :sid
+       AND b.task_id = :tid
+       AND f.severity = 'blocking'
+     ORDER BY b.created_at, f.finding_id`).all({ ":mid": milestoneId, ":sid": sliceId, ":tid": taskId });
+    return rows.map(rowToReworkFinding);
+}
+export function getUnresolvedBlockingReworkFindingsForTask(milestoneId, sliceId, taskId) {
+    return getBlockingReworkFindingsForTask(milestoneId, sliceId, taskId)
+        .filter((finding) => finding.status === "pending");
+}
+export function applyReworkResolutions(resolutions) {
+    if (!getDbOrNull())
+        throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+    const now = new Date().toISOString();
+    const stmt = getDbOrNull().prepare(`UPDATE rework_brief_findings
+     SET status = :status,
+         evidence = :evidence,
+         decision_ref = :decision_ref,
+         updated_at = :updated_at
+     WHERE finding_id = :finding_id
+       AND brief_id IN (
+         SELECT id FROM rework_briefs
+         WHERE milestone_id = :mid AND slice_id = :sid AND task_id = :tid
+       )`);
+    transaction(() => {
+        for (const resolution of resolutions) {
+            stmt.run({
+                ":status": resolution.status,
+                ":evidence": resolution.evidence,
+                ":decision_ref": resolution.decisionRef ?? "",
+                ":updated_at": now,
+                ":finding_id": resolution.findingId,
+                ":mid": resolution.milestoneId,
+                ":sid": resolution.sliceId,
+                ":tid": resolution.taskId,
+            });
+        }
+    });
+}
 export function insertAssessment(entry) {
     if (!getDbOrNull())
         throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
@@ -767,44 +895,51 @@ export function saveGateResult(g) {
     if (!getDbOrNull())
         throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
     const evaluatedAt = new Date().toISOString();
-    const result = getDbOrNull().prepare(`UPDATE quality_gates
-     SET status = 'complete', verdict = :verdict, rationale = :rationale,
-         findings = :findings, evaluated_at = :evaluated_at
-     WHERE milestone_id = :mid AND slice_id = :sid AND gate_id = :gid
-       AND (task_id = :tid OR (:tid = '' AND task_id IS NULL))`).run({
-        ":mid": g.milestoneId,
-        ":sid": g.sliceId,
-        ":gid": g.gateId,
-        ":tid": g.taskId ?? "",
-        ":verdict": g.verdict,
-        ":rationale": g.rationale,
-        ":findings": g.findings,
-        ":evaluated_at": evaluatedAt,
-    });
-    if ((result.changes ?? 0) === 0) {
-        throw new GSDError(GSD_STALE_STATE, `quality gate row not found for ${g.milestoneId}/${g.sliceId}/${g.gateId}${g.taskId ? `/${g.taskId}` : ""}`);
-    }
-    const outcome = g.verdict === "pass"
-        ? "pass"
-        : g.verdict === "omitted"
-            ? "manual-attention"
-            : "fail";
-    insertGateRun({
-        traceId: `quality-gate:${g.milestoneId}:${g.sliceId}`,
-        turnId: `gate:${g.gateId}:${g.taskId ?? "slice"}`,
-        gateId: g.gateId,
-        gateType: "quality-gate",
-        milestoneId: g.milestoneId,
-        sliceId: g.sliceId,
-        taskId: g.taskId ?? undefined,
-        outcome,
-        failureClass: outcome === "fail" ? "verification" : outcome === "manual-attention" ? "manual-attention" : "none",
-        rationale: g.rationale,
-        findings: g.findings,
-        attempt: 1,
-        maxAttempts: 1,
-        retryable: false,
-        evaluatedAt,
+    // Atomic: the gate verdict UPDATE and the gate_runs ledger INSERT must commit
+    // together. As two autocommits, a crash between them records a completed gate
+    // with no ledger row (the row Recovery Classification reads). transaction()
+    // is re-entrant, so callers already inside a transaction are safe. The
+    // throw-on-zero-changes stays inside so a missing gate row rolls back cleanly.
+    transaction(() => {
+        const result = getDbOrNull().prepare(`UPDATE quality_gates
+       SET status = 'complete', verdict = :verdict, rationale = :rationale,
+           findings = :findings, evaluated_at = :evaluated_at
+       WHERE milestone_id = :mid AND slice_id = :sid AND gate_id = :gid
+         AND (task_id = :tid OR (:tid = '' AND task_id IS NULL))`).run({
+            ":mid": g.milestoneId,
+            ":sid": g.sliceId,
+            ":gid": g.gateId,
+            ":tid": g.taskId ?? "",
+            ":verdict": g.verdict,
+            ":rationale": g.rationale,
+            ":findings": g.findings,
+            ":evaluated_at": evaluatedAt,
+        });
+        if ((result.changes ?? 0) === 0) {
+            throw new GSDError(GSD_STALE_STATE, `quality gate row not found for ${g.milestoneId}/${g.sliceId}/${g.gateId}${g.taskId ? `/${g.taskId}` : ""}`);
+        }
+        const outcome = g.verdict === "pass"
+            ? "pass"
+            : g.verdict === "omitted"
+                ? "manual-attention"
+                : "fail";
+        insertGateRun({
+            traceId: `quality-gate:${g.milestoneId}:${g.sliceId}`,
+            turnId: `gate:${g.gateId}:${g.taskId ?? "slice"}`,
+            gateId: g.gateId,
+            gateType: "quality-gate",
+            milestoneId: g.milestoneId,
+            sliceId: g.sliceId,
+            taskId: g.taskId ?? undefined,
+            outcome,
+            failureClass: outcome === "fail" ? "verification" : outcome === "manual-attention" ? "manual-attention" : "none",
+            rationale: g.rationale,
+            findings: g.findings,
+            attempt: 1,
+            maxAttempts: 1,
+            retryable: false,
+            evaluatedAt,
+        });
     });
 }
 export function markAllGatesOmitted(milestoneId, sliceId) {
@@ -1012,6 +1147,13 @@ export function deleteArtifactsByPathPrefix(prefix) {
         return Number(countRow?.["count"] ?? 0);
     });
 }
+/** List artifact rows whose paths share a DB-relative prefix. */
+export function getArtifactsByPathPrefix(prefix) {
+    if (!getDbOrNull())
+        return [];
+    const rows = getDbOrNull().prepare("SELECT * FROM artifacts WHERE path LIKE :prefix ORDER BY path").all({ ":prefix": `${prefix}%` });
+    return rows.map(rowToArtifact);
+}
 /**
  * Drop hierarchy rows in dependency order inside a transaction. Used by
  * `gsd recover --confirm` to rebuild engine state from markdown.

package/dist/resources/extensions/gsd/guided-flow.js

@@ -11,7 +11,7 @@ import { loadFile, saveFile } from "./files.js";
 import { isDbAvailable, getMilestone, getMilestoneSlices } from "./gsd-db.js";
 import { parseRoadmapSlices } from "./roadmap-slices.js";
 import { loadPrompt, inlineTemplate } from "./prompt-loader.js";
-import { buildCompleteSlicePrompt, buildDiscussMilestonePrompt, buildExecuteTaskPrompt, buildPlanMilestonePrompt, buildPlanSlicePrompt, buildSkillActivationBlock, } from "./auto-prompts.js";
+import { buildCompleteSlicePrompt, buildDiscussMilestonePrompt, buildExecuteTaskPrompt, buildPlanMilestonePrompt, buildPlanSlicePrompt, buildSkillActivationBlock, capPreamble, } from "./auto-prompts.js";
 import { deriveState, isGhostMilestone } from "./state.js";
 import { invalidateAllCaches } from "./cache.js";
 import { startAutoDetached } from "./auto.js";
@@ -603,6 +603,9 @@ export const _dispatchWorkflowForTest = dispatchWorkflow;
 export function getDiscussableFutureMilestones(registry, activeMilestoneId) {
     return registry.filter((m) => m.id !== activeMilestoneId && m.status !== "complete" && m.status !== "parked");
 }
+function findDiscussTargetMilestone(registry, milestoneId) {
+    return registry.find((m) => m.id === milestoneId || m.id.startsWith(`${milestoneId}-`));
+}
 function getStructuredQuestionsAvailability(pi, ctx) {
     if (!ctx)
         return "false";
@@ -852,7 +855,9 @@ function resolveDiscussSliceBasePath(basePath, milestoneId) {
  * slice summaries so the agent can ask grounded UX/behaviour questions
  * without wasting a turn reading files.
  */
-async function buildDiscussSlicePrompt(mid, sid, sTitle, base, options) {
+// Exported for tests (`prompt-budget-enforcement.test.ts`) — verifies the
+// inlined-context cap. Not part of the public flow surface otherwise.
+export async function buildDiscussSlicePrompt(mid, sid, sTitle, base, options) {
     const inlined = [];
     // Roadmap — always included so the agent sees surrounding slices
     const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
@@ -903,8 +908,12 @@ async function buildDiscussSlicePrompt(mid, sid, sTitle, base, options) {
             }
         }
     }
+    // Cap the inlined block: it grows unbounded with each completed slice's full
+    // SUMMARY. `capPreamble` truncates at `### ` section boundaries — roadmap and
+    // milestone context come first (survive), completed-slice summaries come last
+    // (dropped first) when the executor's window can't hold everything.
     const inlinedContext = inlined.length > 0
-        ? `## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`
+        ? capPreamble(`## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`)
         : `## Inlined Context\n\n_(no context files found yet — go in blind and ask broad questions)_`;
     const sliceDirPath = `.gsd/milestones/${mid}/slices/${sid}`;
     const sliceContextPath = `${sliceDirPath}/${sid}-CONTEXT.md`;
@@ -964,12 +973,20 @@ export async function showDiscuss(ctx, pi, basePath, options) {
         if (slash > 0) {
             const mid = target.slice(0, slash);
             const sid = target.slice(slash + 1);
-            const targetMilestone = state.registry.find((m) => m.id === mid);
-            if (!targetMilestone || targetMilestone.status === "complete" || targetMilestone.status === "parked") {
-                ctx.ui.notify(`Milestone ${mid} is not discussable.`, "warning");
+            const targetMilestone = findDiscussTargetMilestone(state.registry, mid);
+            if (!targetMilestone) {
+                ctx.ui.notify(`Milestone ${mid} was not found in the roadmap. Use /gsd new-milestone to add it, or /gsd status to see available milestones.`, "warning");
+                return;
+            }
+            if (targetMilestone.status === "complete") {
+                ctx.ui.notify(`Milestone ${targetMilestone.id} is already complete.`, "info");
+                return;
+            }
+            if (targetMilestone.status === "parked") {
+                ctx.ui.notify(`Milestone ${targetMilestone.id} is parked. Run /gsd unpark ${targetMilestone.id} to reactivate.`, "warning");
                 return;
             }
-            const slices = await loadDiscussNormSlices(basePath, mid);
+            const slices = await loadDiscussNormSlices(basePath, targetMilestone.id);
             const chosen = slices.find((s) => s.id.toUpperCase() === sid.toUpperCase());
             if (!chosen) {
                 ctx.ui.notify(`Slice ${target} was not found in discussable slices.`, "warning");
@@ -979,19 +996,27 @@ export async function showDiscuss(ctx, pi, basePath, options) {
                 ctx.ui.notify(`Slice ${target} is already complete; nothing to discuss.`, "info");
                 return;
             }
-            const discussBasePath = resolveDiscussSliceBasePath(basePath, mid);
-            const contextFile = resolveSliceFile(discussBasePath, mid, sid, "CONTEXT");
+            const discussBasePath = resolveDiscussSliceBasePath(basePath, targetMilestone.id);
+            const contextFile = resolveSliceFile(discussBasePath, targetMilestone.id, sid, "CONTEXT");
             const sqAvail = getStructuredQuestionsAvailability(pi, ctx);
-            const prompt = await buildDiscussSlicePrompt(mid, sid, chosen.title, discussBasePath, {
+            const prompt = await buildDiscussSlicePrompt(targetMilestone.id, sid, chosen.title, discussBasePath, {
                 rediscuss: !!contextFile,
                 structuredQuestionsAvailable: sqAvail,
             });
             await dispatchWorkflow(pi, prompt, "gsd-discuss", ctx, "discuss-slice", { basePath: discussBasePath });
             return;
         }
-        const targetMilestone = state.registry.find((m) => m.id === target);
-        if (!targetMilestone || targetMilestone.status === "complete" || targetMilestone.status === "parked") {
-            ctx.ui.notify(`Milestone ${target} is not discussable.`, "warning");
+        const targetMilestone = findDiscussTargetMilestone(state.registry, target);
+        if (!targetMilestone) {
+            ctx.ui.notify(`Milestone ${target} was not found in the roadmap. Use /gsd new-milestone to add it, or /gsd status to see available milestones.`, "warning");
+            return;
+        }
+        if (targetMilestone.status === "complete") {
+            ctx.ui.notify(`Milestone ${targetMilestone.id} is already complete.`, "info");
+            return;
+        }
+        if (targetMilestone.status === "parked") {
+            ctx.ui.notify(`Milestone ${targetMilestone.id} is parked. Run /gsd unpark ${targetMilestone.id} to reactivate.`, "warning");
             return;
         }
         await dispatchDiscussForMilestone(ctx, pi, basePath, targetMilestone.id, targetMilestone.title, {});

package/dist/resources/extensions/gsd/markdown-renderer.js

@@ -13,7 +13,7 @@ import { logWarning } from "./workflow-logger.js";
 import { isClosedStatus } from "./status-guards.js";
 import { dirname, join, relative } from "node:path";
 import { getAllMilestones, getMilestone, getMilestoneScopedArtifacts, getSliceScopedArtifacts, getMilestoneSlices, getSliceTasks, getTasksBySliceIds, getTask, getSlice, insertArtifact, deleteArtifactByPath, getGateResults, isDbAvailable, } from "./gsd-db.js";
-import { resolveSliceFile, resolveSlicePath, resolveTaskFile, resolveTasksDir, targetMilestoneFile, targetSliceFile, gsdProjectionRoot, gsdRoot, buildTaskFileName, } from "./paths.js";
+import { resolveDir, resolveSliceFile, resolveSlicePath, resolveTaskFile, resolveTasksDir, targetMilestoneFile, targetSliceFile, targetTaskFile, gsdProjectionRoot, gsdRoot, buildTaskFileName, } from "./paths.js";
 import { saveFile, clearParseCache, registerCacheClearCallback } from "./files.js";
 import { parseRoadmap, parsePlan } from "./parsers-legacy.js";
 import { invalidateStateCache } from "./state.js";
@@ -612,17 +612,7 @@ export async function renderTaskSummary(basePath, milestoneId, sliceId, taskId)
     if (!task || !task.full_summary_md) {
         return false; // No summary to render — skip silently
     }
-    // Resolve the tasks directory, creating path if needed
-    const slicePath = resolveSlicePath(basePath, milestoneId, sliceId);
-    if (!slicePath) {
-        process.stderr.write(`markdown-renderer: cannot resolve slice path for ${milestoneId}/${sliceId}\n`);
-        return false;
-    }
-    // Use the tasks/ subdir when it exists (legacy layout), otherwise use the
-    // slice path directly (flat-phase: task summaries live alongside plan files).
-    const tasksDir = resolveTasksDir(basePath, milestoneId, sliceId) ?? slicePath;
-    const fileName = buildTaskFileName(taskId, "SUMMARY");
-    const absPath = join(tasksDir, fileName);
+    const absPath = targetTaskFile(basePath, milestoneId, sliceId, taskId, "SUMMARY", getMilestone(milestoneId)?.title);
     const artifactPath = toArtifactPath(absPath, basePath);
     await writeAndStore(absPath, artifactPath, task.full_summary_md, {
         artifact_type: "SUMMARY",
@@ -975,6 +965,19 @@ function detectStaleRendersImpl(basePath) {
 export function roadmapRenderMarksSliceDone(roadmapContent, sliceId) {
     return parseRoadmap(roadmapContent).slices.some((slice) => slice.id === sliceId && slice.done);
 }
+function existingLegacySliceAssessmentPath(basePath, milestoneId, sliceId) {
+    if (!isLegacyMilestonesLayout(basePath))
+        return null;
+    const legacyBase = legacyMilestonesDir(basePath);
+    const milestoneDirName = resolveDir(legacyBase, milestoneId);
+    if (!milestoneDirName)
+        return null;
+    const slicesDir = join(legacyBase, milestoneDirName, "slices");
+    const sliceDirName = resolveDir(slicesDir, sliceId);
+    if (!sliceDirName)
+        return null;
+    return join(slicesDir, sliceDirName, `${sliceId}-ASSESSMENT.md`);
+}
 export async function renderReplanFromDb(basePath, milestoneId, sliceId, replanData) {
     const absPath = targetSliceFile(basePath, milestoneId, sliceId, "REPLAN", getMilestone(milestoneId)?.title);
     mkdirSync(dirname(absPath), { recursive: true });
@@ -1004,7 +1007,8 @@ export async function renderReplanFromDb(basePath, milestoneId, sliceId, replanD
     return { replanPath: absPath, content };
 }
 export async function renderAssessmentFromDb(basePath, milestoneId, sliceId, assessmentData) {
-    const absPath = targetSliceFile(basePath, milestoneId, sliceId, "ASSESSMENT", getMilestone(milestoneId)?.title);
+    const absPath = existingLegacySliceAssessmentPath(basePath, milestoneId, sliceId)
+        ?? targetSliceFile(basePath, milestoneId, sliceId, "ASSESSMENT", getMilestone(milestoneId)?.title);
     mkdirSync(dirname(absPath), { recursive: true });
     const artifactPath = toArtifactPath(absPath, basePath);
     const lines = [];