gsd-pi 2.57.0-dev.f22a903 → 2.58.0-dev.778d6ac

package/dist/resources/extensions/gsd/prompts/triage-captures.md

@@ -54,6 +54,7 @@ For each capture, classify it as one of:
    - Add `**Resolution:** <brief description of what will happen>`
    - Add `**Rationale:** <why this classification>`
    - Add `**Resolved:** <current ISO timestamp>`
+   - Add `**Milestone:** <current milestone ID>` (e.g., `**Milestone:** M003`)
 
 4. **Summarize** what was triaged: how many captures, what classifications were assigned, and what actions are pending (e.g., "2 quick-tasks ready for execution, 1 deferred to S03").
 

package/dist/resources/extensions/gsd/repo-identity.js

@@ -7,7 +7,7 @@
  */
 import { createHash } from "node:crypto";
 import { execFileSync } from "node:child_process";
-import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, realpathSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { cpSync, existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, realpathSync, renameSync, rmSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, dirname, join, resolve } from "node:path";
 const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
@@ -255,9 +255,14 @@ export function validateProjectId(id) {
  * If `GSD_PROJECT_ID` is set, returns it directly (validation is expected
  * to have already happened at startup via `validateProjectId`).
  *
- * Otherwise returns SHA-256 of `${remoteUrl}\n${resolvedRoot}`, truncated
- * to 12 hex chars. Deterministic: same repo always produces the same hash
- * regardless of which worktree the caller is inside.
+ * For repos with a remote URL, returns SHA-256 of the remote URL only —
+ * this makes the identity stable across directory moves/renames (#2750).
+ *
+ * For local-only repos (no remote), includes the git root in the hash.
+ * Local repos use a `.gsd-id` marker file for recovery after moves.
+ *
+ * Deterministic: same repo always produces the same hash regardless of
+ * which worktree the caller is inside.
  */
 export function repoIdentity(basePath) {
     const projectId = process.env.GSD_PROJECT_ID;
@@ -265,8 +270,14 @@ export function repoIdentity(basePath) {
         return projectId;
     }
     const remoteUrl = getRemoteUrl(basePath);
+    if (remoteUrl) {
+        // Remote URL alone uniquely identifies the repo — path is redundant.
+        // This makes moves transparent for repos with remotes (#2750).
+        return createHash("sha256").update(remoteUrl).digest("hex").slice(0, 12);
+    }
+    // Local-only repo: include git root since there's no remote to anchor identity.
     const root = resolveGitRoot(basePath);
-    const input = `${remoteUrl}\n${root}`;
+    const input = `\n${root}`;
     return createHash("sha256").update(input).digest("hex").slice(0, 12);
 }
 // ─── External State Directory ───────────────────────────────────────────────
@@ -325,20 +336,149 @@ export function cleanNumberedGsdVariants(projectPath) {
     }
     return removed;
 }
+// ─── .gsd-id Marker ─────────────────────────────────────────────────────────
+/**
+ * Write a `.gsd-id` marker file in the project root.
+ *
+ * This file records the identity hash used for the external state directory.
+ * For local-only repos (no remote), this marker survives directory moves and
+ * enables automatic recovery of orphaned state (#2750).
+ *
+ * The marker is gitignored by ensureGitignore(). Non-fatal: failure to write
+ * the marker must never block project setup.
+ */
+function writeGsdIdMarker(projectPath, identity) {
+    try {
+        const markerPath = join(projectPath, ".gsd-id");
+        // Only write if content differs to avoid unnecessary disk writes.
+        if (existsSync(markerPath)) {
+            try {
+                if (readFileSync(markerPath, "utf-8").trim() === identity)
+                    return;
+            }
+            catch { /* fall through and overwrite */ }
+        }
+        writeFileSync(markerPath, identity + "\n", "utf-8");
+    }
+    catch {
+        // Non-fatal — marker write failure should not block project setup
+    }
+}
+/**
+ * Read the `.gsd-id` marker from the project root.
+ * Returns the identity hash, or null if the marker doesn't exist or is unreadable.
+ */
+function readGsdIdMarker(projectPath) {
+    try {
+        const markerPath = join(projectPath, ".gsd-id");
+        if (!existsSync(markerPath))
+            return null;
+        const content = readFileSync(markerPath, "utf-8").trim();
+        return /^[a-zA-Z0-9_-]+$/.test(content) ? content : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Check whether an external state directory has meaningful content.
+ * Returns true if the directory contains any files or subdirectories
+ * beyond just repo-meta.json.
+ */
+function hasProjectState(externalPath) {
+    try {
+        if (!existsSync(externalPath))
+            return false;
+        const entries = readdirSync(externalPath);
+        return entries.some(e => e !== "repo-meta.json");
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Resolve the external state directory, with recovery for relocated projects.
+ *
+ * For local-only repos where the computed identity produces an empty state dir,
+ * checks the `.gsd-id` marker for the original identity hash and recovers
+ * the old state directory if it still exists and contains data (#2750).
+ *
+ * Returns the resolved external path (may differ from the computed identity).
+ */
+function resolveExternalPathWithRecovery(projectPath) {
+    const computedPath = externalGsdRoot(projectPath);
+    const computedId = repoIdentity(projectPath);
+    // Check if computed path already has state — fast path, no recovery needed.
+    if (hasProjectState(computedPath)) {
+        return computedPath;
+    }
+    // Check for .gsd-id marker from a previous location.
+    const markerId = readGsdIdMarker(projectPath);
+    if (markerId && markerId !== computedId) {
+        // The marker points to a different identity — the repo was likely moved.
+        const base = process.env.GSD_STATE_DIR || gsdHome;
+        const markerPath = join(base, "projects", markerId);
+        if (hasProjectState(markerPath)) {
+            // Recover: use the old state directory and update the marker to the new identity.
+            // Move the state from the old hash dir to the new one so future lookups work
+            // without the marker.
+            try {
+                mkdirSync(computedPath, { recursive: true });
+                const entries = readdirSync(markerPath);
+                for (const entry of entries) {
+                    try {
+                        const src = join(markerPath, entry);
+                        const dst = join(computedPath, entry);
+                        // Use rename for same-filesystem (fast) or fall back to copy.
+                        try {
+                            renameSync(src, dst);
+                        }
+                        catch {
+                            cpSync(src, dst, { recursive: true, force: true });
+                        }
+                    }
+                    catch { /* continue with remaining entries */ }
+                }
+                // Clean up old directory after successful migration.
+                try {
+                    rmSync(markerPath, { recursive: true, force: true });
+                }
+                catch { /* non-fatal */ }
+            }
+            catch {
+                // If migration fails, just point at the old directory.
+                return markerPath;
+            }
+        }
+    }
+    return computedPath;
+}
 // ─── Symlink Management ─────────────────────────────────────────────────────
 /**
  * Ensure the `<project>/.gsd` symlink points to the external state directory.
  *
  * 1. Clean up any macOS numbered collision variants (`.gsd 2`, `.gsd 3`, etc.)
- * 2. mkdir -p the external dir
- * 3. If `<project>/.gsd` doesn't exist → create symlink
- * 4. If `<project>/.gsd` is already the correct symlink → no-op
- * 5. If `<project>/.gsd` is a real directory → return as-is (migration handles later)
+ * 2. Resolve external dir (with relocation recovery via `.gsd-id` marker)
+ * 3. mkdir -p the external dir
+ * 4. If `<project>/.gsd` doesn't exist → create symlink
+ * 5. If `<project>/.gsd` is already the correct symlink → no-op
+ * 6. If `<project>/.gsd` is a real directory → return as-is (migration handles later)
+ * 7. Write `.gsd-id` marker for future relocation recovery
  *
  * Returns the resolved external path.
  */
 export function ensureGsdSymlink(projectPath) {
-    const externalPath = externalGsdRoot(projectPath);
+    const result = ensureGsdSymlinkCore(projectPath);
+    // Write .gsd-id marker so future relocations can recover this state (#2750).
+    // Only write for the project root (not subdirectories or worktrees that
+    // delegate to a parent .gsd).
+    if (!isInsideWorktree(projectPath)) {
+        writeGsdIdMarker(projectPath, repoIdentity(projectPath));
+    }
+    return result;
+}
+function ensureGsdSymlinkCore(projectPath) {
+    const externalPath = resolveExternalPathWithRecovery(projectPath);
     const localGsd = join(projectPath, ".gsd");
     const inWorktree = isInsideWorktree(projectPath);
     // Guard: Never create a symlink at ~/.gsd — that's the user-level GSD home,
@@ -387,11 +527,34 @@ export function ensureGsdSymlink(projectPath) {
     writeRepoMeta(externalPath, getRemoteUrl(projectPath), resolveGitRoot(projectPath));
     const replaceWithSymlink = () => {
         rmSync(localGsd, { recursive: true, force: true });
+        // Defensive: remove any residual entry (e.g. dangling symlink) before creating.
+        try {
+            unlinkSync(localGsd);
+        }
+        catch { /* already gone */ }
         symlinkSync(externalPath, localGsd, "junction");
         return externalPath;
     };
+    // Check for dangling symlinks (e.g. after relocation recovery removed the old
+    // state dir). existsSync follows symlinks, so it returns false for dangling ones.
+    // lstatSync does NOT follow, so we can detect the dangling symlink and replace it.
     if (!existsSync(localGsd)) {
-        // Nothing exists yet — create symlink
+        try {
+            const stat = lstatSync(localGsd);
+            if (stat.isSymbolicLink()) {
+                // Dangling symlink — replace with correct one (#2750).
+                return replaceWithSymlink();
+            }
+        }
+        catch {
+            // lstat also failed — nothing exists at this path
+        }
+        // Nothing exists yet — create symlink.
+        // Defensive: remove any residual entry to avoid EEXIST race (#2750).
+        try {
+            unlinkSync(localGsd);
+        }
+        catch { /* nothing to remove */ }
         symlinkSync(externalPath, localGsd, "junction");
         return externalPath;
     }
@@ -408,6 +571,37 @@ export function ensureGsdSymlink(projectPath) {
             if (inWorktree) {
                 return replaceWithSymlink();
             }
+            // After identity hash change (e.g. upgrade from path-based to remote-only
+            // hash, or relocation recovery), migrate data from old target to new path
+            // and update the symlink (#2750).
+            if (!hasProjectState(externalPath) && hasProjectState(target)) {
+                try {
+                    mkdirSync(externalPath, { recursive: true });
+                    const oldEntries = readdirSync(target);
+                    for (const entry of oldEntries) {
+                        try {
+                            const src = join(target, entry);
+                            const dst = join(externalPath, entry);
+                            try {
+                                renameSync(src, dst);
+                            }
+                            catch {
+                                cpSync(src, dst, { recursive: true, force: true });
+                            }
+                        }
+                        catch { /* continue */ }
+                    }
+                    try {
+                        rmSync(target, { recursive: true, force: true });
+                    }
+                    catch { /* non-fatal */ }
+                    return replaceWithSymlink();
+                }
+                catch {
+                    // Migration failed — preserve old symlink
+                    return target;
+                }
+            }
             // Outside worktrees, preserve custom overrides or legacy symlinks.
             return target;
         }

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

@@ -16,6 +16,7 @@ import { getParkedReason } from "./milestone-actions.js";
 import { getMilestoneSlices, isDbAvailable } from "./gsd-db.js";
 import { buildExistingMilestonesContext } from "./guided-flow-queue.js";
 import { loadPrompt } from "./prompt-loader.js";
+import { isGsdGitignored } from "./gitignore.js";
 // ─── Entry Point ──────────────────────────────────────────────────────────────
 export async function handleRethink(_args, ctx, pi) {
     if (isAutoActive()) {
@@ -38,9 +39,13 @@ export async function handleRethink(_args, ctx, pi) {
     const queueOrder = loadQueueOrder(basePath);
     const rethinkData = buildRethinkData(basePath, milestoneIds, state, queueOrder);
     const existingMilestonesContext = await buildExistingMilestonesContext(basePath, milestoneIds, state);
+    const commitInstruction = isGsdGitignored(basePath)
+        ? "Do not commit planning artifacts — .gsd/ is gitignored in this project."
+        : 'After changes, run `git add .gsd/ && git commit -m "docs(gsd): rethink milestone plan"` to persist (rethink runs interactively outside auto-mode, so no system auto-commit)';
     const content = loadPrompt("rethink", {
         rethinkData,
         existingMilestonesContext,
+        commitInstruction,
     });
     pi.sendMessage({ customType: "gsd-rethink", content, display: false }, { triggerTurn: true });
 }

package/dist/resources/extensions/gsd/roadmap-slices.js

@@ -211,12 +211,13 @@ export function parseRoadmapSlices(content) {
 function parseProseSliceHeaders(content) {
     const slices = [];
     // Match H1-H4 headers containing S<digits> with optional "Slice" prefix, bold markers,
-    // and optional checkmark completion marker before the slice ID.
+    // numeric prefixes (e.g., "1.", "(1)"), bracketed IDs (e.g., "[S01]"),
+    // optional checkmark completion marker, and optional leading indentation.
     // Separator after the ID is flexible: colon, dash, em/en dash, dot, or just whitespace.
-    const headerPattern = /^#{1,4}\s+\*{0,2}(?:\u2713\s+)?(?:Slice\s+)?(S\d+)\*{0,2}[:\s.\u2014\u2013-]*\s*(.+)/gm;
+    const headerPattern = /^\s*#{1,4}\s+\*{0,2}(?:\u2713\s+)?(?:\d+[.)]\s+)?(?:\(\d+\)\s+)?(?:Slice\s+)?\[?(S\d+)\]?\*{0,2}[:\s.\u2014\u2013-]*\s*(.+)/gm;
     let match;
     // Check for checkmark before the slice ID (e.g., "## checkmark S01: Title")
-    const prefixCheckPattern = /^#{1,4}\s+\*{0,2}\u2713\s+/;
+    const prefixCheckPattern = /^\s*#{1,4}\s+\*{0,2}\u2713\s+/;
     while ((match = headerPattern.exec(content)) !== null) {
         const id = match[1];
         let title = match[2].trim().replace(/\*{1,2}$/g, "").trim(); // strip trailing bold markers
@@ -238,7 +239,7 @@ function parseProseSliceHeaders(content) {
         }
         // Try to extract depends from prose: "Depends on: S01" or "**Depends on:** S01, S02"
         const afterHeader = content.slice(match.index + match[0].length);
-        const nextHeader = afterHeader.search(/^#{1,4}\s/m);
+        const nextHeader = afterHeader.search(/^\s*#{1,4}\s/m);
         const section = nextHeader !== -1 ? afterHeader.slice(0, nextHeader) : afterHeader.slice(0, 500);
         const depsMatch = section.match(/\*{0,2}Depends\s+on:?\*{0,2}\s*(.+)/i);
         let depends = [];

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

@@ -6,20 +6,41 @@ import { parseSummary, loadFile, parseRequirementCounts, parseContextDependsOn,
 import { resolveMilestoneFile, resolveSlicePath, resolveSliceFile, resolveTaskFile, resolveTasksDir, resolveGsdRootFile, gsdRoot, } from './paths.js';
 import { findMilestoneIds } from './milestone-ids.js';
 import { loadQueueOrder, sortByQueueOrder } from './queue-order.js';
-import { isClosedStatus } from './status-guards.js';
 import { nativeBatchParseGsdFiles } from './native-parser-bridge.js';
 import { join, resolve } from 'path';
-import { existsSync, readdirSync } from 'node:fs';
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import { debugCount, debugTime } from './debug-logger.js';
 import { extractVerdict } from './verdict-parser.js';
-import { isDbAvailable, getAllMilestones, getMilestoneSlices, getSliceTasks, getReplanHistory, getSlice, insertMilestone, updateTaskStatus, getPendingSliceGateCount, } from './gsd-db.js';
+import { logWarning, logError } from './workflow-logger.js';
+import { isDbAvailable, getAllMilestones, getMilestone, getMilestoneSlices, getSliceTasks, getReplanHistory, getSlice, insertMilestone, insertSlice, updateTaskStatus, getPendingSliceGateCount, } from './gsd-db.js';
 /**
  * A "ghost" milestone directory contains only META.json (and no substantive
  * files like CONTEXT, CONTEXT-DRAFT, ROADMAP, or SUMMARY).  These appear when
  * a milestone is created but never initialised.  Treating them as active causes
  * auto-mode to stall or falsely declare completion.
+ *
+ * However, a milestone is NOT a ghost if:
+ * - It has a DB row with a meaningful status (queued, active, etc.) — the DB
+ *   knows about it even if content files haven't been created yet.
+ * - It has a worktree directory — a worktree proves the milestone was
+ *   legitimately created and is expected to be populated.
+ *
+ * Fixes #2921: queued milestones with worktrees were incorrectly classified
+ * as ghosts, causing auto-mode to skip them entirely.
  */
 export function isGhostMilestone(basePath, mid) {
+    // If the milestone has a DB row, it's a known milestone — not a ghost.
+    if (isDbAvailable()) {
+        const dbRow = getMilestone(mid);
+        if (dbRow)
+            return false;
+    }
+    // If a worktree exists for this milestone, it was legitimately created.
+    const root = gsdRoot(basePath);
+    const wtPath = join(root, 'worktrees', mid);
+    if (existsSync(wtPath))
+        return false;
+    // Fall back to content-file check: no substantive files means ghost.
     const context = resolveMilestoneFile(basePath, mid, "CONTEXT");
     const draft = resolveMilestoneFile(basePath, mid, "CONTEXT-DRAFT");
     const roadmap = resolveMilestoneFile(basePath, mid, "ROADMAP");
@@ -140,10 +161,10 @@ export async function deriveState(basePath) {
     // Dual-path: try DB-backed derivation first when hierarchy tables are populated
     if (isDbAvailable()) {
         let dbMilestones = getAllMilestones();
-        // Disk→DB reconciliation (#2631): when the milestones table is empty
-        // (e.g. failed initial migration per #2529), the reconciliation code
-        // inside deriveStateFromDb is unreachable. Populate from disk here so
-        // the DB path activates correctly.
+        // Disk→DB reconciliation when DB is empty but disk has milestones (#2631).
+        // deriveStateFromDb() does its own reconciliation, but deriveState() skips
+        // it entirely when the DB is empty. Sync here so the DB path is used when
+        // disk milestones exist but haven't been migrated yet.
         if (dbMilestones.length === 0) {
             const diskIds = findMilestoneIds(basePath);
             let synced = false;
@@ -163,7 +184,7 @@ export async function deriveState(basePath) {
             _telemetry.dbDeriveCount++;
         }
         else {
-            // DB open but empty hierarchy tables — pre-migration project, use filesystem
+            // DB open but no milestones on disk either — use filesystem path
             result = await _deriveStateImpl(basePath);
             _telemetry.markdownDeriveCount++;
         }
@@ -198,6 +219,12 @@ function extractContextTitle(content, fallback) {
     return stripMilestonePrefix(h1.slice(2).trim()) || fallback;
 }
 // ─── DB-backed State Derivation ────────────────────────────────────────────
+/**
+ * Helper: check if a DB status counts as "done" (handles K002 ambiguity).
+ */
+function isStatusDone(status) {
+    return status === 'complete' || status === 'done';
+}
 /**
  * Derive GSD state from the milestones/slices/tasks DB tables.
  * Flag files (PARKED, VALIDATION, CONTINUE, REPLAN, REPLAN-TRIGGER, CONTEXT-DRAFT)
@@ -226,6 +253,39 @@ export async function deriveStateFromDb(basePath) {
     }
     if (synced)
         allMilestones = getAllMilestones();
+    // Disk→DB slice reconciliation (#2533): slices defined in ROADMAP.md but
+    // missing from the DB cause permanent "No slice eligible" blocks because
+    // the dependency resolver only sees DB rows. Parse each milestone's roadmap
+    // and insert any missing slices, checking SUMMARY files to set correct status.
+    // insertSlice uses INSERT OR IGNORE, so existing rows are never overwritten.
+    for (const mid of diskIds) {
+        if (isGhostMilestone(basePath, mid))
+            continue;
+        const roadmapPath = resolveMilestoneFile(basePath, mid, "ROADMAP");
+        if (!roadmapPath)
+            continue;
+        const dbSlices = getMilestoneSlices(mid);
+        const dbSliceIds = new Set(dbSlices.map(s => s.id));
+        let roadmapContent;
+        try {
+            roadmapContent = readFileSync(roadmapPath, "utf-8");
+        }
+        catch {
+            continue;
+        }
+        const parsed = parseRoadmap(roadmapContent);
+        for (const s of parsed.slices) {
+            if (dbSliceIds.has(s.id))
+                continue;
+            const summaryPath = resolveSliceFile(basePath, mid, s.id, "SUMMARY");
+            const sliceStatus = (s.done || summaryPath) ? "complete" : "pending";
+            insertSlice({
+                id: s.id, milestoneId: mid, title: s.title,
+                status: sliceStatus, risk: s.risk,
+                depends: s.depends, demo: s.demo,
+            });
+        }
+    }
     // Reconcile: discover milestones that exist on disk but are missing from
     // the DB. This happens when milestones were created before the DB migration
     // or were manually added to the filesystem. Without this, disk-only
@@ -281,7 +341,7 @@ export async function deriveStateFromDb(basePath) {
             parkedMilestoneIds.add(m.id);
             continue;
         }
-        if (isClosedStatus(m.status)) {
+        if (isStatusDone(m.status)) {
             completeMilestoneIds.add(m.id);
             continue;
         }
@@ -293,7 +353,7 @@ export async function deriveStateFromDb(basePath) {
         }
         // Check roadmap: all slices done means milestone is complete
         const slices = getMilestoneSlices(m.id);
-        if (slices.length > 0 && slices.every(s => isClosedStatus(s.status))) {
+        if (slices.length > 0 && slices.every(s => isStatusDone(s.status))) {
             // All slices done but no summary — still counts as complete for dep resolution
             // if a summary file exists
             // Note: without summary file, the milestone is in validating/completing state, not complete
@@ -312,7 +372,7 @@ export async function deriveStateFromDb(basePath) {
         }
         // Ghost milestone check: no slices in DB AND no substantive files on disk
         const slices = getMilestoneSlices(m.id);
-        if (slices.length === 0 && !isClosedStatus(m.status)) {
+        if (slices.length === 0 && !isStatusDone(m.status)) {
             // Check disk for ghost detection
             if (isGhostMilestone(basePath, m.id))
                 continue;
@@ -333,7 +393,7 @@ export async function deriveStateFromDb(basePath) {
             continue;
         }
         // Not complete — determine if it should be active
-        const allSlicesDone = slices.length > 0 && slices.every(s => isClosedStatus(s.status));
+        const allSlicesDone = slices.length > 0 && slices.every(s => isStatusDone(s.status));
         // Get title — prefer DB, fall back to context file extraction
         let title = stripMilestonePrefix(m.title) || m.id;
         if (title === m.id) {
@@ -432,7 +492,8 @@ export async function deriveStateFromDb(basePath) {
             ? `All milestones complete. ${activeReqs} active requirement${activeReqs === 1 ? '' : 's'} in REQUIREMENTS.md ${activeReqs === 1 ? 'has' : 'have'} not been mapped to a milestone.`
             : 'All milestones complete.';
         return {
-            activeMilestone: lastEntry ? { id: lastEntry.id, title: lastEntry.title } : null,
+            activeMilestone: null,
+            lastCompletedMilestone: lastEntry ? { id: lastEntry.id, title: lastEntry.title } : null,
             activeSlice: null, activeTask: null,
             phase: 'complete',
             recentDecisions: [], blockers: [],
@@ -470,10 +531,7 @@ export async function deriveStateFromDb(basePath) {
         };
     }
     // ── All slices done → validating/completing ─────────────────────────
-    // Guard: [].every() === true (vacuous truth). Without the length check,
-    // an empty slice array causes a premature phase transition to
-    // validating-milestone. See: https://github.com/gsd-build/gsd-2/issues/2667
-    const allSlicesDone = activeMilestoneSlices.length > 0 && activeMilestoneSlices.every(s => isClosedStatus(s.status));
+    const allSlicesDone = activeMilestoneSlices.every(s => isStatusDone(s.status));
     if (allSlicesDone) {
         const validationFile = resolveMilestoneFile(basePath, activeMilestone.id, "VALIDATION");
         const validationContent = validationFile ? await loadFile(validationFile) : null;
@@ -503,14 +561,14 @@ export async function deriveStateFromDb(basePath) {
     }
     // ── Find active slice (first incomplete with deps satisfied) ─────────
     const sliceProgress = {
-        done: activeMilestoneSlices.filter(s => isClosedStatus(s.status)).length,
+        done: activeMilestoneSlices.filter(s => isStatusDone(s.status)).length,
         total: activeMilestoneSlices.length,
     };
-    const doneSliceIds = new Set(activeMilestoneSlices.filter(s => isClosedStatus(s.status)).map(s => s.id));
+    const doneSliceIds = new Set(activeMilestoneSlices.filter(s => isStatusDone(s.status)).map(s => s.id));
     let activeSlice = null;
     let activeSliceRow = null;
     for (const s of activeMilestoneSlices) {
-        if (isClosedStatus(s.status))
+        if (isStatusDone(s.status))
             continue;
         if (s.depends.every(dep => doneSliceIds.has(dep))) {
             activeSlice = { id: s.id, title: s.title };
@@ -550,18 +608,18 @@ export async function deriveStateFromDb(basePath) {
     // causing the dispatcher to re-dispatch the same completed task forever.
     let reconciled = false;
     for (const t of tasks) {
-        if (isClosedStatus(t.status))
+        if (isStatusDone(t.status))
             continue;
         const summaryPath = resolveTaskFile(basePath, activeMilestone.id, activeSlice.id, t.id, "SUMMARY");
         if (summaryPath && existsSync(summaryPath)) {
             try {
                 updateTaskStatus(activeMilestone.id, activeSlice.id, t.id, "complete");
-                process.stderr.write(`gsd-reconcile: task ${activeMilestone.id}/${activeSlice.id}/${t.id} had SUMMARY on disk but DB status was "${t.status}" — updated to "complete" (#2514)\n`);
+                logWarning("reconcile", `task ${activeMilestone.id}/${activeSlice.id}/${t.id} status reconciled from "${t.status}" to "complete" (#2514)`, { mid: activeMilestone.id, sid: activeSlice.id, tid: t.id });
                 reconciled = true;
             }
             catch (e) {
                 // DB write failed — continue with stale status rather than crash
-                process.stderr.write(`gsd-reconcile: failed to update task ${t.id}: ${e.message}\n`);
+                logError("reconcile", `failed to update task ${t.id}`, { tid: t.id, error: e.message });
             }
         }
     }
@@ -570,10 +628,10 @@ export async function deriveStateFromDb(basePath) {
         tasks = getSliceTasks(activeMilestone.id, activeSlice.id);
     }
     const taskProgress = {
-        done: tasks.filter(t => isClosedStatus(t.status)).length,
+        done: tasks.filter(t => isStatusDone(t.status)).length,
         total: tasks.length,
     };
-    const activeTaskRow = tasks.find(t => !isClosedStatus(t.status));
+    const activeTaskRow = tasks.find(t => !isStatusDone(t.status));
     if (!activeTaskRow && tasks.length > 0) {
         // All tasks done but slice not marked complete → summarizing
         return {
@@ -628,7 +686,7 @@ export async function deriveStateFromDb(basePath) {
         };
     }
     // ── Blocker detection: check completed tasks for blocker_discovered ──
-    const completedTasks = tasks.filter(t => isClosedStatus(t.status));
+    const completedTasks = tasks.filter(t => isStatusDone(t.status));
     let blockerTaskId = null;
     for (const ct of completedTasks) {
         if (ct.blocker_discovered) {
@@ -1187,7 +1245,7 @@ export async function _deriveStateImpl(basePath) {
         const summaryPath = resolveTaskFile(basePath, activeMilestone.id, activeSlice.id, t.id, "SUMMARY");
         if (summaryPath && existsSync(summaryPath)) {
             t.done = true;
-            process.stderr.write(`gsd-reconcile: task ${activeMilestone.id}/${activeSlice.id}/${t.id} has SUMMARY on disk but plan shows incomplete — marking done (#2514)\n`);
+            logWarning("reconcile", `task ${activeMilestone.id}/${activeSlice.id}/${t.id} reconciled via SUMMARY on disk (#2514)`, { mid: activeMilestone.id, sid: activeSlice.id, tid: t.id });
         }
     }
     const taskProgress = {

package/dist/resources/extensions/gsd/tests/dist-redirect.mjs

@@ -87,7 +87,26 @@ export function load(url, context, nextLoad) {
         emitDecoratorMetadata: true,
       },
     });
-    return { format: 'module', source: outputText, shortCircuit: true };
+    // Inject CJS-compatible globals (__dirname, __filename, require) so that
+    // workspace packages compiled as ESM can still use them.  This avoids the
+    // need for import.meta.url behind indirect invocation patterns that fail in
+    // CJS and in dynamically-created scopes.
+    // Only inject globals that the source file doesn't already declare itself.
+    const preambleLines = [
+      'import { fileURLToPath as __preamble_fUTP } from "node:url";',
+      'import { dirname as __preamble_dn } from "node:path";',
+      'import { createRequire as __preamble_cR } from "node:module";',
+    ];
+    if (!outputText.includes('const __filename') && !outputText.includes('let __filename')) {
+      preambleLines.push('const __filename = __preamble_fUTP(import.meta.url);');
+    }
+    if (!outputText.includes('const __dirname') && !outputText.includes('let __dirname')) {
+      preambleLines.push('const __dirname = __preamble_dn(__preamble_fUTP(import.meta.url));');
+    }
+    if (!outputText.includes('const require') && !outputText.includes('let require')) {
+      preambleLines.push('const require = __preamble_cR(import.meta.url);');
+    }
+    return { format: 'module', source: preambleLines.join('\n') + '\n' + outputText, shortCircuit: true };
   }
   return nextLoad(url, context);
 }