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

package/src/resources/extensions/gsd/repo-identity.ts

@@ -8,7 +8,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";
 
@@ -276,14 +276,9 @@ export function validateProjectId(id: string): boolean {
  * 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: string): string {
   const projectId = process.env.GSD_PROJECT_ID;
@@ -291,14 +286,8 @@ export function repoIdentity(basePath: string): string {
     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);
 }
 
@@ -362,148 +351,21 @@ export function cleanNumberedGsdVariants(projectPath: string): string[] {
   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: string, identity: string): void {
-  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: string): string | null {
-  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: string): boolean {
-  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: string): string {
-  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: string): string {
-  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: string): string {
-  const externalPath = resolveExternalPathWithRecovery(projectPath);
+  const externalPath = externalGsdRoot(projectPath);
   const localGsd = join(projectPath, ".gsd");
   const inWorktree = isInsideWorktree(projectPath);
 
@@ -556,28 +418,12 @@ function ensureGsdSymlinkCore(projectPath: string): string {
 
   const replaceWithSymlink = (): string => {
     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;
   }
@@ -596,27 +442,6 @@ function ensureGsdSymlinkCore(projectPath: string): string {
       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/src/resources/extensions/gsd/rethink.ts

@@ -19,7 +19,6 @@ import { isParked, 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 ──────────────────────────────────────────────────────────────
 
@@ -54,14 +53,9 @@ export async function handleRethink(
   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(

package/src/resources/extensions/gsd/roadmap-slices.ts

@@ -219,14 +219,13 @@ export function parseRoadmapSlices(content: string): RoadmapSliceEntry[] {
 function parseProseSliceHeaders(content: string): RoadmapSliceEntry[] {
   const slices: RoadmapSliceEntry[] = [];
   // 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: RegExpExecArray | null;
 
   // 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]!;
@@ -252,7 +251,7 @@ function parseProseSliceHeaders(content: string): RoadmapSliceEntry[] {
 
     // 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);

package/src/resources/extensions/gsd/state.ts

@@ -36,24 +36,22 @@ import {
 
 import { findMilestoneIds } from './milestone-ids.js';
 import { loadQueueOrder, sortByQueueOrder } from './queue-order.js';
+import { isClosedStatus } from './status-guards.js';
 import { nativeBatchParseGsdFiles, type BatchParsedFile } 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,
   type MilestoneRow,
@@ -66,29 +64,8 @@ import {
  * 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: string, mid: string): boolean {
-  // 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");
@@ -232,10 +209,10 @@ export async function deriveState(basePath: string): Promise<GSDState> {
   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;
@@ -254,7 +231,7 @@ export async function deriveState(basePath: string): Promise<GSDState> {
       stopDbTimer({ phase: result.phase, milestone: result.activeMilestone?.id });
       _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++;
     }
@@ -291,13 +268,6 @@ function extractContextTitle(content: string | null, fallback: string): string {
 
 // ─── DB-backed State Derivation ────────────────────────────────────────────
 
-/**
- * Helper: check if a DB status counts as "done" (handles K002 ambiguity).
- */
-function isStatusDone(status: string): boolean {
-  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)
@@ -328,36 +298,6 @@ export async function deriveStateFromDb(basePath: string): Promise<GSDState> {
   }
   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: string;
-    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
@@ -417,7 +357,7 @@ export async function deriveStateFromDb(basePath: string): Promise<GSDState> {
       continue;
     }
 
-    if (isStatusDone(m.status)) {
+    if (isClosedStatus(m.status)) {
       completeMilestoneIds.add(m.id);
       continue;
     }
@@ -431,7 +371,7 @@ export async function deriveStateFromDb(basePath: string): Promise<GSDState> {
 
     // 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
@@ -453,7 +393,7 @@ export async function deriveStateFromDb(basePath: string): Promise<GSDState> {
 
     // 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;
     }
@@ -476,7 +416,7 @@ export async function deriveStateFromDb(basePath: string): Promise<GSDState> {
     }
 
     // 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;
@@ -586,8 +526,7 @@ export async function deriveStateFromDb(basePath: string): Promise<GSDState> {
       ? `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: [],
@@ -629,7 +568,10 @@ export async function deriveStateFromDb(basePath: string): Promise<GSDState> {
   }
 
   // ── 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;
@@ -662,19 +604,19 @@ export async function deriveStateFromDb(basePath: string): Promise<GSDState> {
 
   // ── 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)
+    activeMilestoneSlices.filter(s => isClosedStatus(s.status)).map(s => s.id)
   );
 
   let activeSlice: ActiveRef | null = null;
   let activeSliceRow: SliceRow | null = null;
 
   for (const s of activeMilestoneSlices) {
-    if (isStatusDone(s.status)) continue;
+    if (isClosedStatus(s.status)) continue;
     if (s.depends.every(dep => doneSliceIds.has(dep))) {
       activeSlice = { id: s.id, title: s.title };
       activeSliceRow = s;
@@ -717,16 +659,20 @@ export async function deriveStateFromDb(basePath: string): Promise<GSDState> {
   // causing the dispatcher to re-dispatch the same completed task forever.
   let reconciled = false;
   for (const t of tasks) {
-    if (isStatusDone(t.status)) continue;
+    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 as Error).message });
+        process.stderr.write(
+          `gsd-reconcile: failed to update task ${t.id}: ${(e as Error).message}\n`,
+        );
       }
     }
   }
@@ -736,11 +682,11 @@ export async function deriveStateFromDb(basePath: string): Promise<GSDState> {
   }
 
   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
@@ -801,7 +747,7 @@ export async function deriveStateFromDb(basePath: string): Promise<GSDState> {
   }
 
   // ── 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: string | null = null;
   for (const ct of completedTasks) {
     if (ct.blocker_discovered) {
@@ -1381,7 +1327,9 @@ export async function _deriveStateImpl(basePath: string): Promise<GSDState> {
     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`,
+      );
     }
   }
 

package/src/resources/extensions/gsd/tests/auto-loop.test.ts

@@ -317,35 +317,6 @@ test("auto/resolve.ts one-shot pattern: _currentResolve is nulled before calling
   );
 });
 
-test("auto/phases.ts: selectAndApplyModel called exactly once and before updateProgressWidget (#2907)", () => {
-  const src = readFileSync(
-    resolve(import.meta.dirname, "..", "auto", "phases.ts"),
-    "utf-8",
-  );
-  // Extract the runUnitPhase function body
-  const fnStart = src.indexOf("export async function runUnitPhase");
-  assert.ok(fnStart > 0, "runUnitPhase should exist in phases.ts");
-  const fnBody = src.slice(fnStart, fnStart + 8000);
-
-  // selectAndApplyModel must appear exactly once
-  const allOccurrences = [...fnBody.matchAll(/selectAndApplyModel\(/g)];
-  assert.equal(
-    allOccurrences.length,
-    1,
-    `selectAndApplyModel should be called exactly once in runUnitPhase, found ${allOccurrences.length} calls`,
-  );
-
-  // selectAndApplyModel must appear BEFORE updateProgressWidget
-  const modelIdx = fnBody.indexOf("selectAndApplyModel(");
-  const widgetIdx = fnBody.indexOf("updateProgressWidget(");
-  assert.ok(modelIdx > 0, "selectAndApplyModel should exist in runUnitPhase");
-  assert.ok(widgetIdx > 0, "updateProgressWidget should exist in runUnitPhase");
-  assert.ok(
-    modelIdx < widgetIdx,
-    "selectAndApplyModel must be called BEFORE updateProgressWidget (#2899/#2907)",
-  );
-});
-
 // ─── autoLoop tests (T02) ─────────────────────────────────────────────────
 
 /**