@opengsd/gsd-pi 1.3.0 → 1.4.0-dev.c18009cd

package/dist/resources/extensions/gsd/exec-sandbox.js

@@ -11,7 +11,8 @@ import { spawn } from "node:child_process";
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { randomUUID } from "node:crypto";
 import { resolve } from "node:path";
-import { killProcessTree, SIGKILL_GRACE_MS, HARD_DEADLINE_MS } from "@gsd/pi-coding-agent";
+import { getShellConfig, killProcessTree, SIGKILL_GRACE_MS, HARD_DEADLINE_MS } from "@gsd/pi-coding-agent";
+import { redactSecrets } from "./redact-secrets.js";
 const ALWAYS_FORWARD_ENV = ["PATH", "HOME"];
 // SIGKILL_GRACE_MS / HARD_DEADLINE_MS are imported from @gsd/pi-coding-agent
 // (shell.ts) — the single source of truth for the graceful-kill timing ladder —
@@ -60,7 +61,13 @@ function clampTimeout(request, opts) {
 function resolveCommand(runtime) {
     switch (runtime) {
         case "bash":
-            return { cmd: "bash", args: ["-c"] };
+            try {
+                const { shell, args } = getShellConfig();
+                return { cmd: shell, args };
+            }
+            catch {
+                return { cmd: "bash", args: ["-c"] };
+            }
         case "node":
             return { cmd: process.execPath, args: ["-e"] };
         case "python":
@@ -180,10 +187,22 @@ export function runExecSandbox(request, opts) {
         const effectiveGraceMs = opts.kill_grace_ms ?? SIGKILL_GRACE_MS;
         const effectiveForceResolveDelay = opts.force_resolve_delay_ms ?? (effectiveGraceMs + HARD_DEADLINE_MS);
         let timedOut = false;
+        let aborted = false;
         let settled = false;
+        let killInitiated = false;
+        let timer;
         let forceResolveTimer;
-        const timer = setTimeout(() => {
-            timedOut = true;
+        let abortListener;
+        const removeAbortListener = () => {
+            if (opts.signal && abortListener) {
+                opts.signal.removeEventListener("abort", abortListener);
+                abortListener = undefined;
+            }
+        };
+        const initiateKill = () => {
+            if (killInitiated)
+                return;
+            killInitiated = true;
             // killProcessTree handles both platforms and kills the whole tree: on Unix
             // it signals the process group (SIGTERM -> grace -> SIGKILL); on Windows it
             // force-kills the tree via taskkill /F /T. Using child.kill("SIGTERM") here
@@ -201,35 +220,41 @@ export function runExecSandbox(request, opts) {
                 finalize(null, "SIGKILL", true);
             }, effectiveForceResolveDelay);
             forceResolveTimer.unref?.();
-        }, timeoutMs);
-        timer.unref?.();
+        };
         const finalize = (exitCode, signal, forceResolved = false) => {
             if (settled)
                 return;
             settled = true;
             clearTimeout(timer);
             clearTimeout(forceResolveTimer);
+            removeAbortListener();
             const duration = Date.now() - started;
             const stdoutBuf = Buffer.concat(stdoutChunks);
             const stderrBuf = Buffer.concat(stderrChunks);
             const stdoutSuffix = stdoutTruncated ? "\n[truncated: stdout cap reached]\n" : "";
             const stderrSuffix = stderrTruncated ? "\n[truncated: stderr cap reached]\n" : "";
-            writeFileSync(stdoutPath, Buffer.concat([stdoutBuf, Buffer.from(stdoutSuffix, "utf-8")]));
-            writeFileSync(stderrPath, Buffer.concat([stderrBuf, Buffer.from(stderrSuffix, "utf-8")]));
+            // Redact secret-shaped substrings before persisting to .gsd/exec/ (skipped by
+            // the secret scanner). The returned digest is derived from the raw buffer
+            // below and is redacted downstream when the session is written to activity/.
+            writeFileSync(stdoutPath, redactSecrets(Buffer.concat([stdoutBuf, Buffer.from(stdoutSuffix, "utf-8")]).toString("utf-8")));
+            writeFileSync(stderrPath, redactSecrets(Buffer.concat([stderrBuf, Buffer.from(stderrSuffix, "utf-8")]).toString("utf-8")));
             const digestBody = tail(stdoutBuf, opts.digest_chars);
             const digest = digestBody.length > 0
                 ? digestBody
-                : timedOut
-                    ? "[no stdout — timed out]"
-                    : stderrBuf.length > 0
-                        ? `[no stdout — tail of stderr]\n${tail(stderrBuf, opts.digest_chars)}`
-                        : "[no output]";
+                : aborted
+                    ? "[no stdout — aborted]"
+                    : timedOut
+                        ? "[no stdout — timed out]"
+                        : stderrBuf.length > 0
+                            ? `[no stdout — tail of stderr]\n${tail(stderrBuf, opts.digest_chars)}`
+                            : "[no output]";
             const result = {
                 id,
                 runtime: request.runtime,
                 exit_code: exitCode,
                 signal,
                 timed_out: timedOut,
+                aborted,
                 force_resolved: forceResolved,
                 duration_ms: duration,
                 stdout_bytes: stdoutBytes,
@@ -244,6 +269,26 @@ export function runExecSandbox(request, opts) {
             writeMeta(metaPath, result, request, now);
             resolveP(result);
         };
+        timer = setTimeout(() => {
+            timedOut = true;
+            initiateKill();
+        }, timeoutMs);
+        timer.unref?.();
+        if (opts.signal) {
+            abortListener = () => {
+                if (settled || timedOut)
+                    return;
+                aborted = true;
+                clearTimeout(timer);
+                initiateKill();
+            };
+            if (opts.signal.aborted) {
+                abortListener();
+            }
+            else {
+                opts.signal.addEventListener("abort", abortListener, { once: true });
+            }
+        }
         child.on("error", (err) => {
             const message = err instanceof Error ? err.message : String(err);
             const line = `child error: ${message}\n`;
@@ -274,6 +319,7 @@ function writeMeta(path, result, request, now) {
         exit_code: result.exit_code,
         signal: result.signal,
         timed_out: result.timed_out,
+        aborted: result.aborted === true,
         force_resolved: result.force_resolved,
         duration_ms: result.duration_ms,
         stdout_bytes: result.stdout_bytes,

package/dist/resources/extensions/gsd/export-html.js

@@ -760,10 +760,11 @@ function buildChangelogSection(data) {
 // ─── Section: Knowledge ───────────────────────────────────────────────────────
 function buildKnowledgeSection(data) {
     const k = data.knowledge;
-    if (!k.exists)
+    const memories = data.memories;
+    if (!k.exists && memories.entries.length === 0)
         return section('knowledge', 'Knowledge', '<p class="empty">No KNOWLEDGE.md found.</p>');
     const total = k.rules.length + k.patterns.length + k.lessons.length;
-    if (total === 0)
+    if (total === 0 && memories.entries.length === 0)
         return section('knowledge', 'Knowledge', '<p class="empty">KNOWLEDGE.md exists but no entries parsed.</p>');
     const rulesHtml = k.rules.length > 0 ? `
     <h3>Rules <span class="count">${k.rules.length}</span></h3>
@@ -783,7 +784,13 @@ function buildKnowledgeSection(data) {
       <thead><tr><th>ID</th><th>Lesson</th></tr></thead>
       <tbody>${k.lessons.map(l => `<tr><td class="mono">${esc(l.id)}</td><td>${esc(l.content)}</td></tr>`).join('')}</tbody>
     </table>` : '';
-    return section('knowledge', `Knowledge <span class="count">${total}</span>`, `${rulesHtml}${patternsHtml}${lessonsHtml}`);
+    const memoriesHtml = memories.entries.length > 0 ? `
+    <h3>Memories <span class="count">${memories.entries.length}/${memories.totalCount}</span></h3>
+    <table class="tbl">
+      <thead><tr><th>ID</th><th>Category</th><th>Scope</th><th>Memory</th></tr></thead>
+      <tbody>${memories.entries.map(m => `<tr><td class="mono">${esc(m.id)}</td><td>${esc(m.category)}</td><td>${esc(m.scope)}</td><td>${esc(m.content)}</td></tr>`).join('')}</tbody>
+    </table>` : '';
+    return section('knowledge', `Knowledge <span class="count">${total + memories.totalCount}</span>`, `${rulesHtml}${patternsHtml}${lessonsHtml}${memoriesHtml}`);
 }
 // ─── Section: Captures ────────────────────────────────────────────────────────
 function buildCapturesSection(data) {

package/dist/resources/extensions/gsd/export.js

@@ -7,6 +7,71 @@ import { getLedger, getProjectTotals, aggregateByPhase, aggregateBySlice, aggreg
 import { gsdRoot } from "./paths.js";
 import { formatDuration, fileLink } from "../shared/format-utils.js";
 import { getErrorMessage } from "./error-utils.js";
+import { isDbAvailable } from "./gsd-db.js";
+import { openExistingWorkflowDatabase } from "./db-workspace.js";
+import { getActiveMemories, getActiveMemoriesRanked } from "./memory-store.js";
+const EXPORT_MEMORY_LIMIT = 20;
+const EXPORT_MEMORY_CONTENT_LIMIT = 2000;
+function ensureExportDb(basePath) {
+    if (isDbAvailable())
+        return;
+    openExistingWorkflowDatabase(basePath);
+}
+function loadExportMemories(basePath, visualizerData) {
+    if (visualizerData?.memories)
+        return limitMemoryInfo(visualizerData.memories);
+    ensureExportDb(basePath);
+    try {
+        const allActive = getActiveMemories();
+        const ranked = getActiveMemoriesRanked(EXPORT_MEMORY_LIMIT);
+        return {
+            totalCount: allActive.length,
+            entries: ranked.map((memory) => ({
+                id: memory.id,
+                category: memory.category,
+                content: limitMemoryContent(memory.content),
+                confidence: memory.confidence,
+                hitCount: memory.hit_count,
+                scope: memory.scope,
+                tags: memory.tags,
+                updatedAt: memory.updated_at,
+            })),
+        };
+    }
+    catch {
+        return { entries: [], totalCount: 0 };
+    }
+}
+function limitMemoryInfo(memories) {
+    return {
+        totalCount: memories.totalCount,
+        entries: memories.entries.map((memory) => ({
+            ...memory,
+            content: limitMemoryContent(memory.content),
+        })),
+    };
+}
+function limitMemoryContent(content) {
+    if (content.length <= EXPORT_MEMORY_CONTENT_LIMIT)
+        return content;
+    return `${content.slice(0, EXPORT_MEMORY_CONTENT_LIMIT).trimEnd()}...`;
+}
+function formatMemoryLines(memories) {
+    if (memories.entries.length === 0)
+        return [];
+    return [
+        `## Memories`,
+        ``,
+        `Active memories: ${memories.totalCount}`,
+        ``,
+        ...memories.entries.map((memory) => {
+            const scope = memory.scope ? `, scope ${memory.scope}` : "";
+            const tags = memory.tags.length > 0 ? `, tags ${memory.tags.join(", ")}` : "";
+            return `- **${memory.id}** (${memory.category}, confidence ${Math.round(memory.confidence * 100)}%, hits ${memory.hitCount}${scope}${tags}): ${memory.content}`;
+        }),
+        ``,
+    ];
+}
 /**
  * Open a file in the user's default browser.
  * Uses platform-specific commands: `open` (macOS), `xdg-open` (Linux), `start` (Windows).
@@ -47,6 +112,7 @@ export function writeExportFile(basePath, format, visualizerData) {
     mkdirSync(exportDir, { recursive: true });
     const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
     if (format === "json") {
+        const memories = loadExportMemories(basePath, visualizerData);
         const report = {
             exportedAt: new Date().toISOString(),
             project: projectName,
@@ -54,6 +120,7 @@ export function writeExportFile(basePath, format, visualizerData) {
             byPhase: visualizerData?.byPhase ?? aggregateByPhase(units),
             bySlice: visualizerData?.bySlice ?? aggregateBySlice(units),
             byModel: visualizerData?.byModel ?? aggregateByModel(units),
+            memories,
             units,
         };
         const outPath = join(exportDir, `export-${timestamp}.json`);
@@ -64,6 +131,7 @@ export function writeExportFile(basePath, format, visualizerData) {
         const totals = visualizerData?.totals ?? getProjectTotals(units);
         const phases = visualizerData?.byPhase ?? aggregateByPhase(units);
         const slices = visualizerData?.bySlice ?? aggregateBySlice(units);
+        const memories = loadExportMemories(basePath, visualizerData);
         const md = [
             `# GSD Session Report — ${projectName}`,
             ``,
@@ -86,6 +154,7 @@ export function writeExportFile(basePath, format, visualizerData) {
             `|-------|-------|------|--------|----------|`,
             ...slices.map((s) => `| ${s.sliceId} | ${s.units} | ${formatCost(s.cost)} | ${formatTokenCount(s.tokens.total)} | ${formatDuration(s.duration)} |`),
             ``,
+            ...formatMemoryLines(memories),
         ].join("\n");
         const outPath = join(exportDir, `export-${timestamp}.md`);
         writeFileSync(outPath, md, "utf-8");
@@ -216,6 +285,7 @@ export async function handleExport(args, ctx, basePath) {
     mkdirSync(exportDir, { recursive: true });
     const timestamp = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
     if (format === "json") {
+        const memories = loadExportMemories(basePath);
         const report = {
             exportedAt: new Date().toISOString(),
             project: projectName,
@@ -223,6 +293,7 @@ export async function handleExport(args, ctx, basePath) {
             byPhase: aggregateByPhase(units),
             bySlice: aggregateBySlice(units),
             byModel: aggregateByModel(units),
+            memories,
             units,
         };
         const outPath = join(exportDir, `export-${timestamp}.json`);
@@ -233,6 +304,7 @@ export async function handleExport(args, ctx, basePath) {
         const totals = getProjectTotals(units);
         const phases = aggregateByPhase(units);
         const slices = aggregateBySlice(units);
+        const memories = loadExportMemories(basePath);
         const md = [
             `# GSD Session Report — ${projectName}`,
             ``,
@@ -255,6 +327,7 @@ export async function handleExport(args, ctx, basePath) {
             `|-------|-------|------|--------|----------|`,
             ...slices.map(s => `| ${s.sliceId} | ${s.units} | ${formatCost(s.cost)} | ${formatTokenCount(s.tokens.total)} | ${formatDuration(s.duration)} |`),
             ``,
+            ...formatMemoryLines(memories),
             `## Unit History`,
             ``,
             `| Type | ID | Model | Cost | Tokens | Duration |`,

package/dist/resources/extensions/gsd/file-lock.js

@@ -30,9 +30,9 @@ function acquireLockSyncWithRetry(filePath, retries, stale) {
 export function withFileLockSync(filePath, fn, opts = {}) {
     if (!existsSync(filePath))
         return fn();
-    const retries = opts.retries ?? DEFAULT_RETRIES;
     const stale = opts.stale ?? DEFAULT_STALE_MS;
     const onLocked = opts.onLocked ?? "fail";
+    const retries = onLocked === "skip" ? 0 : (opts.retries ?? DEFAULT_RETRIES);
     try {
         const release = acquireLockSyncWithRetry(filePath, retries, stale);
         try {

package/dist/resources/extensions/gsd/flat-phase-migration.js

@@ -0,0 +1,272 @@
+// Project/App: gsd-pi
+// File Purpose: One-time migration from legacy nested .gsd/milestones/ to
+// flat-phase .gsd/phases/. Runs on startup when the legacy structure is detected.
+import { cpSync, existsSync, mkdirSync, readdirSync, renameSync, rmSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { renderAllFromDb, renderRoadmapFromDb } from "./markdown-renderer.js";
+import { getAllMilestones, getMilestoneSlices } from "./gsd-db.js";
+import { migrateFromMarkdown } from "./md-importer.js";
+import { countDbHierarchy } from "./migration-auto-check.js";
+import { logWarning } from "./workflow-logger.js";
+import { LAYOUT_SEGMENTS } from "./layout-policy.js";
+import { canonicalPhaseDirName, dirIsContentBearingLegacyMilestone, milestonesDir, resolveMilestonePath, } from "./paths.js";
+const LEGACY_MIGRATING_SEGMENT = "milestones.migrating";
+const RETRYABLE_FS_ERROR_CODES = new Set(["EPERM", "EBUSY", "ENOTEMPTY"]);
+const RM_RETRY_OPTIONS = { recursive: true, force: true, maxRetries: 5, retryDelay: 100 };
+let fsOps = { cpSync, renameSync, rmSync };
+export function _setFlatPhaseMigrationFsOpsForTest(overrides) {
+    const previous = fsOps;
+    fsOps = { ...fsOps, ...overrides };
+    return () => {
+        fsOps = previous;
+    };
+}
+function legacyMigratingPath(basePath) {
+    return join(basePath, ".gsd", LEGACY_MIGRATING_SEGMENT);
+}
+function removePathWithRetries(path) {
+    fsOps.rmSync(path, { recursive: true, force: true, maxRetries: RM_RETRY_OPTIONS.maxRetries, retryDelay: RM_RETRY_OPTIONS.retryDelay });
+}
+function isRetryableFsError(err) {
+    const code = err?.code;
+    return typeof code === "string" && RETRYABLE_FS_ERROR_CODES.has(code);
+}
+function movePathWithCopyDeleteFallback(src, dst) {
+    try {
+        fsOps.renameSync(src, dst);
+        return;
+    }
+    catch (err) {
+        if (!isRetryableFsError(err))
+            throw err;
+    }
+    try {
+        fsOps.cpSync(src, dst, { recursive: true, force: true });
+        removePathWithRetries(src);
+    }
+    catch (fallbackErr) {
+        if (existsSync(src) && existsSync(dst)) {
+            try {
+                removePathWithRetries(dst);
+            }
+            catch {
+                // Leave the original error intact; the next run can pre-clean dst.
+            }
+        }
+        throw fallbackErr;
+    }
+}
+function expectedPhaseDirs(basePath) {
+    return getAllMilestones().map((milestone) => resolveMilestonePath(basePath, milestone.id) ??
+        join(milestonesDir(basePath), canonicalPhaseDirName(milestone.id, milestone.title)));
+}
+function hasLegacyMilestoneSubdirs(dirPath) {
+    if (!existsSync(dirPath))
+        return false;
+    try {
+        return readdirSync(dirPath).some((e) => statSync(join(dirPath, e)).isDirectory() && dirIsContentBearingLegacyMilestone(join(dirPath, e)));
+    }
+    catch {
+        return false;
+    }
+}
+function rollbackPartialMigration(basePath, backupDir, migratingPath) {
+    // Remove the partially-written phases/ dir.
+    try {
+        removePathWithRetries(join(basePath, ".gsd", LAYOUT_SEGMENTS.level1));
+    }
+    catch (removeErr) {
+        logWarning("migration", `rollback: could not remove partial ${LAYOUT_SEGMENTS.level1}/: ${removeErr.message}`);
+    }
+    // Restore milestones/ — prefer renaming the preserved migrating copy back.
+    const milestonesPath = join(basePath, ".gsd", "milestones");
+    try {
+        if (migratingPath && existsSync(migratingPath) && !existsSync(milestonesPath)) {
+            movePathWithCopyDeleteFallback(migratingPath, milestonesPath);
+            return;
+        }
+        if (existsSync(backupDir)) {
+            cpSync(backupDir, milestonesPath, { recursive: true });
+        }
+        if (migratingPath && existsSync(migratingPath)) {
+            removePathWithRetries(migratingPath);
+        }
+    }
+    catch (restoreErr) {
+        logWarning("migration", `rollback: could not restore milestones/: ${restoreErr.message}`);
+        // Non-fatal: backup still exists at backupDir for manual recovery.
+    }
+}
+/**
+ * Detect whether the project uses the legacy nested layout.
+ * True when .gsd/milestones/ exists AND contains at least one milestone
+ * subdirectory. An empty milestones/ dir (created by old bootstrap code
+ * before it was fixed) is not a real legacy layout and must not trigger
+ * a migration that would thrash the reconciler.
+ */
+export function needsFlatPhaseMigration(basePath) {
+    if (hasLegacyMilestoneSubdirs(join(basePath, ".gsd", "milestones")))
+        return true;
+    // Resume an interrupted migration where the legacy tree was renamed aside.
+    return hasLegacyMilestoneSubdirs(legacyMigratingPath(basePath));
+}
+/** Retention window before flat-phase migration backups are auto-pruned. */
+export const FLAT_PHASE_BACKUP_RETENTION_MS = 30 * 24 * 60 * 60 * 1000;
+/**
+ * Remove stale flat-phase migration backups after the retention window.
+ * Only runs when migration is complete (.gsd/phases/ exists, legacy layout gone).
+ * Returns the number of migrate-* directories removed.
+ */
+export function pruneStaleFlatPhaseBackups(basePath) {
+    if (needsFlatPhaseMigration(basePath))
+        return 0;
+    const phasesPath = join(basePath, ".gsd", LAYOUT_SEGMENTS.level1);
+    if (!existsSync(phasesPath))
+        return 0;
+    const backupRoot = join(basePath, ".gsd-backups");
+    if (!existsSync(backupRoot))
+        return 0;
+    const now = Date.now();
+    let removed = 0;
+    for (const entry of readdirSync(backupRoot)) {
+        if (!entry.startsWith("migrate-"))
+            continue;
+        const dirPath = join(backupRoot, entry);
+        try {
+            const st = statSync(dirPath);
+            if (!st.isDirectory())
+                continue;
+            if (now - st.mtimeMs < FLAT_PHASE_BACKUP_RETENTION_MS)
+                continue;
+            rmSync(dirPath, { recursive: true, force: true });
+            removed++;
+        }
+        catch {
+            // Non-fatal: leave backup for manual recovery.
+        }
+    }
+    try {
+        if (readdirSync(backupRoot).length === 0) {
+            rmSync(backupRoot, { recursive: true, force: true });
+        }
+    }
+    catch {
+        // Non-fatal.
+    }
+    return removed;
+}
+/**
+ * Migrate from legacy nested .gsd/milestones/ to flat-phase .gsd/phases/.
+ *
+ * Steps:
+ * 1. Backup .gsd/milestones/ to .gsd-backups/migrate-<ts>/
+ * 2. Rename .gsd/milestones/ aside so path resolvers target phases/
+ * 3. Render flat-phase from the DB (which already has the data)
+ * 4. Verify counts match
+ * 5. Remove the renamed legacy tree
+ *
+ * Idempotent: if .gsd/milestones/ doesn't exist, returns immediately.
+ */
+export async function migrateToFlatPhase(basePath) {
+    if (!needsFlatPhaseMigration(basePath))
+        return;
+    const milestonesPath = join(basePath, ".gsd", "milestones");
+    const migratingPath = legacyMigratingPath(basePath);
+    const phasesPath = join(basePath, ".gsd", LAYOUT_SEGMENTS.level1);
+    const resumingInterrupted = !hasLegacyMilestoneSubdirs(milestonesPath) && hasLegacyMilestoneSubdirs(migratingPath);
+    // 1. Reconcile DB from legacy markdown before backup/removal so on-disk-only
+    // content is imported even when milestone rows already exist in SQLite.
+    // Check BEFORE creating the backup — avoids accumulating .gsd-backups/ entries
+    // on every session start when milestones/ exists but the DB has no rows.
+    migrateFromMarkdown(basePath);
+    const milestonesBefore = getAllMilestones().length;
+    if (milestonesBefore === 0) {
+        logWarning("migration", "flat-phase migration skipped: legacy milestones/ exists but DB has no milestone rows — will retry when DB is populated");
+        return;
+    }
+    let backupDir = migratingPath;
+    if (!resumingInterrupted) {
+        // 2. Backup (only reached when the DB has rows and migration will proceed)
+        const ts = Date.now();
+        backupDir = join(basePath, ".gsd-backups", `migrate-${ts}`);
+        try {
+            mkdirSync(join(basePath, ".gsd-backups"), { recursive: true });
+            cpSync(milestonesPath, backupDir, { recursive: true });
+        }
+        catch (err) {
+            logWarning("migration", `flat-phase migration backup failed: ${err.message}`);
+            throw err;
+        }
+        if (existsSync(migratingPath)) {
+            removePathWithRetries(migratingPath);
+        }
+        // 3. Rename legacy tree aside before rendering so path resolvers target
+        // phases/ instead of writing back into the nested milestones/ layout.
+        // Keep the full tree on disk until render+verify succeed (unlike rmSync).
+        try {
+            movePathWithCopyDeleteFallback(milestonesPath, migratingPath);
+        }
+        catch (err) {
+            logWarning("migration", `failed to rename legacy milestones/ before render: ${err.message}`);
+            throw err;
+        }
+    }
+    // Clear any stale or partially-rendered flat projection before this run
+    // writes. Verification below checks the current DB render, not leftovers.
+    try {
+        removePathWithRetries(phasesPath);
+    }
+    catch (err) {
+        logWarning("migration", `failed to clear stale phases/ before render: ${err.message}`);
+        rollbackPartialMigration(basePath, backupDir, migratingPath);
+        throw err;
+    }
+    // 4. Render flat-phase from DB
+    let renderResult;
+    try {
+        renderResult = await renderAllFromDb(basePath);
+        // Slice-less milestones still need a phase directory for flat-phase layout.
+        for (const milestone of getAllMilestones()) {
+            if (getMilestoneSlices(milestone.id).length > 0)
+                continue;
+            const roadmapResult = await renderRoadmapFromDb(basePath, milestone.id);
+            if ("skipped" in roadmapResult) {
+                const phaseDir = resolveMilestonePath(basePath, milestone.id) ??
+                    join(milestonesDir(basePath), canonicalPhaseDirName(milestone.id, milestone.title));
+                mkdirSync(phaseDir, { recursive: true });
+                continue;
+            }
+            renderResult.rendered++;
+        }
+    }
+    catch (err) {
+        logWarning("migration", `flat-phase render failed: ${err.message}`);
+        rollbackPartialMigration(basePath, backupDir, migratingPath);
+        throw err;
+    }
+    // 5. Verify render succeeded and flat-phase projection was written
+    if (renderResult.errors.length > 0) {
+        logWarning("migration", `flat-phase render had ${renderResult.errors.length} error(s): ${renderResult.errors.join("; ")}`);
+        rollbackPartialMigration(basePath, backupDir, migratingPath);
+        throw new Error(`flat-phase migration render failed: ${renderResult.errors.slice(0, 3).join("; ")}`);
+    }
+    const db = countDbHierarchy();
+    const missingPhaseDirs = expectedPhaseDirs(basePath).filter((phaseDir) => !existsSync(phaseDir));
+    if (db.milestones > 0 && missingPhaseDirs.length > 0) {
+        logWarning("migration", `flat-phase migration missing ${missingPhaseDirs.length} expected phase dir(s): ${missingPhaseDirs.join(", ")}`);
+        rollbackPartialMigration(basePath, backupDir, migratingPath);
+        throw new Error("flat-phase migration verification failed: missing rendered phase directories");
+    }
+    if (db.slices > 0 && renderResult.rendered === 0) {
+        logWarning("migration", "flat-phase migration verification failed: render produced no artifacts for populated DB");
+        rollbackPartialMigration(basePath, backupDir, migratingPath);
+        throw new Error("flat-phase migration verification failed: no artifacts rendered");
+    }
+    // 6. Verified — remove the renamed legacy tree (backup already on disk).
+    try {
+        removePathWithRetries(migratingPath);
+    }
+    catch (err) {
+        logWarning("migration", `flat-phase migration succeeded but could not remove ${LEGACY_MIGRATING_SEGMENT}: ${err.message}`);
+    }
+}

package/dist/resources/extensions/gsd/forensics.js

@@ -22,11 +22,10 @@ import { deriveState } from "./state.js";
 import { isAutoActive } from "./auto.js";
 import { loadPrompt } from "./prompt-loader.js";
 import { gsdRoot } from "./paths.js";
-import { isDbAvailable, getAllMilestones, getMilestoneSlices, getSliceTasks } from "./gsd-db.js";
-import { isClosedStatus } from "./status-guards.js";
+import { isDbAvailable, getHierarchyCompletionCounts } from "./gsd-db.js";
 import { formatDuration } from "../shared/format-utils.js";
 import { getAutoWorktreePath } from "./auto-worktree.js";
-import { loadEffectiveGSDPreferences, loadGlobalGSDPreferences, getGlobalGSDPreferencesPath } from "./preferences.js";
+import { clearGSDPreferencesCache, loadEffectiveGSDPreferences, loadGlobalGSDPreferences, getGlobalGSDPreferencesPath } from "./preferences.js";
 import { showNextAction } from "../shared/tui.js";
 import { isInteractiveCommandContext, notifyForensicsNeedsInteractiveMenu, } from "./command-feedback.js";
 import { ensurePreferencesFile, serializePreferencesToFrontmatter } from "./commands-prefs-wizard.js";
@@ -154,6 +153,7 @@ async function writeForensicsDedupPref(ctx, enabled) {
         }
     }
     writeFileSync(prefsPath, `---\n${frontmatter}---${body}`, "utf-8");
+    clearGSDPreferencesCache();
 }
 // ─── Entry Point ──────────────────────────────────────────────────────────────
 export async function handleForensics(args, ctx, pi) {
@@ -592,36 +592,7 @@ function loadCompletedKeys(basePath) {
 function getDbCompletionCounts() {
     if (!isDbAvailable())
         return null;
-    const milestones = getAllMilestones();
-    let completedMilestones = 0;
-    let totalSlices = 0;
-    let completedSlices = 0;
-    let totalTasks = 0;
-    let completedTasks = 0;
-    for (const m of milestones) {
-        if (isClosedStatus(m.status))
-            completedMilestones++;
-        const slices = getMilestoneSlices(m.id);
-        for (const s of slices) {
-            totalSlices++;
-            if (isClosedStatus(s.status))
-                completedSlices++;
-            const tasks = getSliceTasks(m.id, s.id);
-            for (const t of tasks) {
-                totalTasks++;
-                if (isClosedStatus(t.status))
-                    completedTasks++;
-            }
-        }
-    }
-    return {
-        milestones: completedMilestones,
-        milestonesTotal: milestones.length,
-        slices: completedSlices,
-        slicesTotal: totalSlices,
-        tasks: completedTasks,
-        tasksTotal: totalTasks,
-    };
+    return getHierarchyCompletionCounts();
 }
 // ─── Anomaly Detectors ───────────────────────────────────────────────────────
 /**