gsd-pi 2.58.0-dev.778d6ac → 2.58.0-dev.d63175c

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

@@ -54,7 +54,6 @@ 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 { cpSync, existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, realpathSync, renameSync, rmSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs";
+import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, realpathSync, rmSync, symlinkSync, 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,14 +255,9 @@ export function validateProjectId(id) {
  * If `GSD_PROJECT_ID` is set, returns it directly (validation is expected
  * to have already happened at startup via `validateProjectId`).
  *
- * 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.
+ * 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.
  */
 export function repoIdentity(basePath) {
     const projectId = process.env.GSD_PROJECT_ID;
@@ -270,14 +265,8 @@ 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 = `\n${root}`;
+    const input = `${remoteUrl}\n${root}`;
     return createHash("sha256").update(input).digest("hex").slice(0, 12);
 }
 // ─── External State Directory ───────────────────────────────────────────────
@@ -336,149 +325,20 @@ 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. 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
+ * 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)
  *
  * Returns the resolved external path.
  */
 export function ensureGsdSymlink(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 externalPath = externalGsdRoot(projectPath);
     const localGsd = join(projectPath, ".gsd");
     const inWorktree = isInsideWorktree(projectPath);
     // Guard: Never create a symlink at ~/.gsd — that's the user-level GSD home,
@@ -527,34 +387,11 @@ function ensureGsdSymlinkCore(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)) {
-        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 */ }
+        // Nothing exists yet — create symlink
         symlinkSync(externalPath, localGsd, "junction");
         return externalPath;
     }
@@ -571,37 +408,6 @@ function ensureGsdSymlinkCore(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,7 +16,6 @@ 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()) {
@@ -39,13 +38,9 @@ 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,13 +211,12 @@ export function parseRoadmapSlices(content) {
 function parseProseSliceHeaders(content) {
     const slices = [];
     // Match H1-H4 headers containing S<digits> with optional "Slice" prefix, bold markers,
-    // numeric prefixes (e.g., "1.", "(1)"), bracketed IDs (e.g., "[S01]"),
-    // optional checkmark completion marker, and optional leading indentation.
+    // and optional checkmark completion marker before the slice ID.
     // Separator after the ID is flexible: colon, dash, em/en dash, dot, or just whitespace.
-    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;
+    const headerPattern = /^#{1,4}\s+\*{0,2}(?:\u2713\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 = /^\s*#{1,4}\s+\*{0,2}\u2713\s+/;
+    const prefixCheckPattern = /^#{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
@@ -239,7 +238,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(/^\s*#{1,4}\s/m);
+        const nextHeader = afterHeader.search(/^#{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,41 +6,20 @@ 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, readFileSync } from 'node:fs';
+import { existsSync, readdirSync } from 'node:fs';
 import { debugCount, debugTime } from './debug-logger.js';
 import { extractVerdict } from './verdict-parser.js';
-import { logWarning, logError } from './workflow-logger.js';
-import { isDbAvailable, getAllMilestones, getMilestone, getMilestoneSlices, getSliceTasks, getReplanHistory, getSlice, insertMilestone, insertSlice, updateTaskStatus, getPendingSliceGateCount, } from './gsd-db.js';
+import { isDbAvailable, getAllMilestones, getMilestoneSlices, getSliceTasks, getReplanHistory, getSlice, insertMilestone, 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");
@@ -161,10 +140,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 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.
+        // 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.
         if (dbMilestones.length === 0) {
             const diskIds = findMilestoneIds(basePath);
             let synced = false;
@@ -184,7 +163,7 @@ export async function deriveState(basePath) {
             _telemetry.dbDeriveCount++;
         }
         else {
-            // DB open but no milestones on disk either — use filesystem path
+            // DB open but empty hierarchy tables — pre-migration project, use filesystem
             result = await _deriveStateImpl(basePath);
             _telemetry.markdownDeriveCount++;
         }
@@ -219,12 +198,6 @@ 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)
@@ -253,39 +226,6 @@ 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
@@ -341,7 +281,7 @@ export async function deriveStateFromDb(basePath) {
             parkedMilestoneIds.add(m.id);
             continue;
         }
-        if (isStatusDone(m.status)) {
+        if (isClosedStatus(m.status)) {
             completeMilestoneIds.add(m.id);
             continue;
         }
@@ -353,7 +293,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 => isStatusDone(s.status))) {
+        if (slices.length > 0 && slices.every(s => isClosedStatus(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
@@ -372,7 +312,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 && !isStatusDone(m.status)) {
+        if (slices.length === 0 && !isClosedStatus(m.status)) {
             // Check disk for ghost detection
             if (isGhostMilestone(basePath, m.id))
                 continue;
@@ -393,7 +333,7 @@ export async function deriveStateFromDb(basePath) {
             continue;
         }
         // Not complete — determine if it should be active
-        const allSlicesDone = slices.length > 0 && slices.every(s => isStatusDone(s.status));
+        const allSlicesDone = slices.length > 0 && slices.every(s => isClosedStatus(s.status));
         // Get title — prefer DB, fall back to context file extraction
         let title = stripMilestonePrefix(m.title) || m.id;
         if (title === m.id) {
@@ -492,8 +432,7 @@ 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: null,
-            lastCompletedMilestone: lastEntry ? { id: lastEntry.id, title: lastEntry.title } : null,
+            activeMilestone: lastEntry ? { id: lastEntry.id, title: lastEntry.title } : null,
             activeSlice: null, activeTask: null,
             phase: 'complete',
             recentDecisions: [], blockers: [],
@@ -531,7 +470,10 @@ export async function deriveStateFromDb(basePath) {
         };
     }
     // ── All slices done → validating/completing ─────────────────────────
-    const allSlicesDone = activeMilestoneSlices.every(s => isStatusDone(s.status));
+    // 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));
     if (allSlicesDone) {
         const validationFile = resolveMilestoneFile(basePath, activeMilestone.id, "VALIDATION");
         const validationContent = validationFile ? await loadFile(validationFile) : null;
@@ -561,14 +503,14 @@ export async function deriveStateFromDb(basePath) {
     }
     // ── Find active slice (first incomplete with deps satisfied) ─────────
     const sliceProgress = {
-        done: activeMilestoneSlices.filter(s => isStatusDone(s.status)).length,
+        done: activeMilestoneSlices.filter(s => isClosedStatus(s.status)).length,
         total: activeMilestoneSlices.length,
     };
-    const doneSliceIds = new Set(activeMilestoneSlices.filter(s => isStatusDone(s.status)).map(s => s.id));
+    const doneSliceIds = new Set(activeMilestoneSlices.filter(s => isClosedStatus(s.status)).map(s => s.id));
     let activeSlice = null;
     let activeSliceRow = null;
     for (const s of activeMilestoneSlices) {
-        if (isStatusDone(s.status))
+        if (isClosedStatus(s.status))
             continue;
         if (s.depends.every(dep => doneSliceIds.has(dep))) {
             activeSlice = { id: s.id, title: s.title };
@@ -608,18 +550,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 (isStatusDone(t.status))
+        if (isClosedStatus(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");
-                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 });
+                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`);
                 reconciled = true;
             }
             catch (e) {
                 // DB write failed — continue with stale status rather than crash
-                logError("reconcile", `failed to update task ${t.id}`, { tid: t.id, error: e.message });
+                process.stderr.write(`gsd-reconcile: failed to update task ${t.id}: ${e.message}\n`);
             }
         }
     }
@@ -628,10 +570,10 @@ export async function deriveStateFromDb(basePath) {
         tasks = getSliceTasks(activeMilestone.id, activeSlice.id);
     }
     const taskProgress = {
-        done: tasks.filter(t => isStatusDone(t.status)).length,
+        done: tasks.filter(t => isClosedStatus(t.status)).length,
         total: tasks.length,
     };
-    const activeTaskRow = tasks.find(t => !isStatusDone(t.status));
+    const activeTaskRow = tasks.find(t => !isClosedStatus(t.status));
     if (!activeTaskRow && tasks.length > 0) {
         // All tasks done but slice not marked complete → summarizing
         return {
@@ -686,7 +628,7 @@ export async function deriveStateFromDb(basePath) {
         };
     }
     // ── Blocker detection: check completed tasks for blocker_discovered ──
-    const completedTasks = tasks.filter(t => isStatusDone(t.status));
+    const completedTasks = tasks.filter(t => isClosedStatus(t.status));
     let blockerTaskId = null;
     for (const ct of completedTasks) {
         if (ct.blocker_discovered) {
@@ -1245,7 +1187,7 @@ export async function _deriveStateImpl(basePath) {
         const summaryPath = resolveTaskFile(basePath, activeMilestone.id, activeSlice.id, t.id, "SUMMARY");
         if (summaryPath && existsSync(summaryPath)) {
             t.done = true;
-            logWarning("reconcile", `task ${activeMilestone.id}/${activeSlice.id}/${t.id} reconciled via SUMMARY on disk (#2514)`, { mid: activeMilestone.id, sid: activeSlice.id, tid: t.id });
+            process.stderr.write(`gsd-reconcile: task ${activeMilestone.id}/${activeSlice.id}/${t.id} has SUMMARY on disk but plan shows incomplete — marking done (#2514)\n`);
         }
     }
     const taskProgress = {

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

@@ -87,26 +87,7 @@ export function load(url, context, nextLoad) {
         emitDecoratorMetadata: 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 { format: 'module', source: outputText, shortCircuit: true };
   }
   return nextLoad(url, context);
 }