gsd-pi 2.59.0 → 2.60.0-dev.2580e65

package/src/resources/extensions/gsd/parallel-orchestrator.ts

@@ -41,6 +41,7 @@ import {
   type ParallelCandidates,
 } from "./parallel-eligibility.js";
 import { getErrorMessage } from "./error-utils.js";
+import { logWarning } from "./workflow-logger.js";
 
 // ─── Types ─────────────────────────────────────────────────────────────────
 
@@ -126,7 +127,7 @@ export function persistState(basePath: string): void {
     const tmp = dest + TMP_SUFFIX;
     writeFileSync(tmp, JSON.stringify(persisted, null, 2), "utf-8");
     renameSync(tmp, dest);
-  } catch { /* non-fatal */ }
+  } catch (e) { logWarning("parallel", `persist parallel state failed: ${(e as Error).message}`); }
 }
 
 /**
@@ -136,7 +137,7 @@ function removeStateFile(basePath: string): void {
   try {
     const p = stateFilePath(basePath);
     if (existsSync(p)) unlinkSync(p);
-  } catch { /* non-fatal */ }
+  } catch (e) { logWarning("parallel", `clear parallel state file failed: ${(e as Error).message}`); }
 }
 
 function isPidAlive(pid: number): boolean {
@@ -144,7 +145,8 @@ function isPidAlive(pid: number): boolean {
   try {
     process.kill(pid, 0);
     return true;
-  } catch {
+  } catch (e) {
+    logWarning("parallel", `pid alive check failed for pid ${pid}: ${(e as Error).message}`);
     return false;
   }
 }
@@ -176,7 +178,8 @@ export function restoreState(basePath: string): PersistedState | null {
     }
 
     return persisted;
-  } catch {
+  } catch (e) {
+    logWarning("parallel", `readParallelState JSON parse failed: ${(e as Error).message}`);
     return null;
   }
 }
@@ -190,8 +193,8 @@ function appendWorkerLog(basePath: string, milestoneId: string, chunk: string):
     const dir = join(gsdRoot(basePath), "parallel");
     if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
     appendFileSync(workerLogPath(basePath, milestoneId), chunk, "utf-8");
-  } catch {
-    // Non-fatal — diagnostics should never break orchestration.
+  } catch (e) {
+    logWarning("parallel", `appendFileSync worker log failed for ${milestoneId}: ${(e as Error).message}`);
   }
 }
 
@@ -430,9 +433,8 @@ export async function startParallel(
       let wtPath: string;
       try {
         wtPath = createMilestoneWorktree(basePath, mid);
-      } catch {
-        // Worktree creation may fail in test environments or when git
-        // is not available. Fall back to a placeholder path.
+      } catch (e) {
+        logWarning("parallel", `createMilestoneWorktree fallback for ${mid}: ${(e as Error).message}`);
         wtPath = worktreePath(basePath, mid);
       }
 
@@ -564,7 +566,8 @@ export function spawnWorker(
       stdio: ["ignore", "pipe", "pipe"],
       detached: false,
     });
-  } catch {
+  } catch (e) {
+    logWarning("parallel", `spawnSync worker failed for ${milestoneId}: ${(e as Error).message}`);
     return false;
   }
 
@@ -694,7 +697,8 @@ function resolveGsdBin(): string | null {
   let thisDir: string;
   try {
     thisDir = dirname(fileURLToPath(import.meta.url));
-  } catch {
+  } catch (e) {
+    logWarning("parallel", `dirname(fileURLToPath) failed: ${(e as Error).message}`);
     thisDir = process.cwd();
   }
   const candidates = [
@@ -722,7 +726,7 @@ function processWorkerLine(basePath: string, milestoneId: string, line: string):
   try {
     event = JSON.parse(line);
   } catch {
-    return; // Not valid JSON — skip (stderr leakage, debug output, etc.)
+    return; // Non-NDJSON lines (progress text, tool output) are expected — silent drop
   }
 
   const type = String(event.type ?? "");
@@ -817,7 +821,7 @@ export async function stopParallel(
         } else if (worker.pid !== process.pid) {
           process.kill(worker.pid, "SIGTERM");
         }
-      } catch { /* process may already be dead */ }
+      } catch (e) { logWarning("parallel", `process.kill SIGTERM failed for pid ${worker.pid}: ${(e as Error).message}`); }
     }
 
     // Wait for the headless process to cascade SIGTERM to its RPC child.
@@ -833,7 +837,7 @@ export async function stopParallel(
         } else if (worker.pid !== process.pid) {
           process.kill(worker.pid, "SIGKILL");
         }
-      } catch { /* process may already be dead */ }
+      } catch (e) { logWarning("parallel", `process.kill SIGKILL failed for pid ${worker.pid}: ${(e as Error).message}`); }
       await waitForWorkerExit(worker, 250);
     }
 

package/src/resources/extensions/gsd/phase-anchor.ts

@@ -0,0 +1,71 @@
+/**
+ * Phase handoff anchors — compact structured summaries written between
+ * GSD auto-mode phases so downstream agents inherit decisions, blockers,
+ * and intent without re-inferring from scratch.
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { gsdRoot } from "./paths.js";
+
+export interface PhaseAnchor {
+  phase: string;
+  milestoneId: string;
+  generatedAt: string;
+  intent: string;
+  decisions: string[];
+  blockers: string[];
+  nextSteps: string[];
+}
+
+function anchorsDir(basePath: string, milestoneId: string): string {
+  return join(gsdRoot(basePath), "milestones", milestoneId, "anchors");
+}
+
+function anchorPath(basePath: string, milestoneId: string, phase: string): string {
+  return join(anchorsDir(basePath, milestoneId), `${phase}.json`);
+}
+
+export function writePhaseAnchor(basePath: string, milestoneId: string, anchor: PhaseAnchor): void {
+  const dir = anchorsDir(basePath, milestoneId);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(anchorPath(basePath, milestoneId, anchor.phase), JSON.stringify(anchor, null, 2), "utf-8");
+}
+
+export function readPhaseAnchor(basePath: string, milestoneId: string, phase: string): PhaseAnchor | null {
+  const path = anchorPath(basePath, milestoneId, phase);
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf-8")) as PhaseAnchor;
+  } catch {
+    return null;
+  }
+}
+
+export function formatAnchorForPrompt(anchor: PhaseAnchor): string {
+  const lines: string[] = [
+    `## Handoff from ${anchor.phase}`,
+    "",
+    `**Intent:** ${anchor.intent}`,
+  ];
+
+  if (anchor.decisions.length > 0) {
+    lines.push("", "**Decisions:**");
+    for (const d of anchor.decisions) lines.push(`- ${d}`);
+  }
+
+  if (anchor.blockers.length > 0) {
+    lines.push("", "**Blockers:**");
+    for (const b of anchor.blockers) lines.push(`- ${b}`);
+  }
+
+  if (anchor.nextSteps.length > 0) {
+    lines.push("", "**Next steps:**");
+    for (const s of anchor.nextSteps) lines.push(`- ${s}`);
+  }
+
+  lines.push("", "---");
+  return lines.join("\n");
+}

package/src/resources/extensions/gsd/preferences-types.ts

@@ -21,6 +21,13 @@ import type {
   GateEvaluationConfig,
 } from "./types.js";
 import type { DynamicRoutingConfig } from "./model-router.js";
+
+export interface ContextManagementConfig {
+  observation_masking?: boolean;          // default: true
+  observation_mask_turns?: number;        // default: 8, range: 1-50
+  compaction_threshold_percent?: number;  // default: 0.70, range: 0.5-0.95
+  tool_result_max_chars?: number;         // default: 800, range: 200-10000
+}
 import type { GitHubSyncConfig } from "../github-sync/types.js";
 
 // ─── Workflow Modes ──────────────────────────────────────────────────────────
@@ -94,7 +101,9 @@ export const KNOWN_PREFERENCE_KEYS = new Set<string>([
   "forensics_dedup",
   "show_token_cost",
   "stale_commit_threshold_minutes",
+  "context_management",
   "experimental",
+  "codebase",
 ]);
 
 /** Canonical list of all dispatch unit types. */
@@ -203,6 +212,16 @@ export interface ExperimentalPreferences {
   rtk?: boolean;
 }
 
+/** Configuration for the codebase map generator (/gsd codebase). */
+export interface CodebaseMapPreferences {
+  /** Additional directory/file patterns to exclude (e.g. ["docs/", "fixtures/"]). Merged with built-in defaults. */
+  exclude_patterns?: string[];
+  /** Max files to include in the map. Default: 500. */
+  max_files?: number;
+  /** Files-per-directory threshold before collapsing to a summary line. Default: 20. */
+  collapse_threshold?: number;
+}
+
 export interface GSDPreferences {
   version?: number;
   mode?: WorkflowMode;
@@ -227,6 +246,7 @@ export interface GSDPreferences {
   post_unit_hooks?: PostUnitHookConfig[];
   pre_dispatch_hooks?: PreDispatchHookConfig[];
   dynamic_routing?: DynamicRoutingConfig;
+  context_management?: ContextManagementConfig;
   token_profile?: TokenProfile;
   phases?: PhaseSkipPreferences;
   auto_visualize?: boolean;
@@ -266,6 +286,8 @@ export interface GSDPreferences {
    * See the preferences reference for details on each feature.
    */
   experimental?: ExperimentalPreferences;
+  /** Configuration for the codebase map generator (/gsd codebase). */
+  codebase?: CodebaseMapPreferences;
 }
 
 export interface LoadedGSDPreferences {

package/src/resources/extensions/gsd/preferences-validation.ts

@@ -428,6 +428,10 @@ export function validatePreferences(preferences: GSDPreferences): {
         if (typeof dr.hooks === "boolean") validDr.hooks = dr.hooks;
         else errors.push("dynamic_routing.hooks must be a boolean");
       }
+      if (dr.capability_routing !== undefined) {
+        if (typeof dr.capability_routing === "boolean") validDr.capability_routing = dr.capability_routing;
+        else errors.push("dynamic_routing.capability_routing must be a boolean");
+      }
       if (dr.tier_models !== undefined) {
         if (typeof dr.tier_models === "object" && dr.tier_models !== null) {
           const tm = dr.tier_models as Record<string, unknown>;
@@ -452,6 +456,40 @@ export function validatePreferences(preferences: GSDPreferences): {
     }
   }
 
+  // ─── Context Management ──────────────────────────────────────────────
+  if (preferences.context_management !== undefined) {
+    if (typeof preferences.context_management === "object" && preferences.context_management !== null) {
+      const cm = preferences.context_management as unknown as Record<string, unknown>;
+      const validCm: Record<string, unknown> = {};
+
+      if (cm.observation_masking !== undefined) {
+        if (typeof cm.observation_masking === "boolean") validCm.observation_masking = cm.observation_masking;
+        else errors.push("context_management.observation_masking must be a boolean");
+      }
+      if (cm.observation_mask_turns !== undefined) {
+        const turns = cm.observation_mask_turns;
+        if (typeof turns === "number" && turns >= 1 && turns <= 50) validCm.observation_mask_turns = turns;
+        else errors.push("context_management.observation_mask_turns must be a number between 1 and 50");
+      }
+      if (cm.compaction_threshold_percent !== undefined) {
+        const pct = cm.compaction_threshold_percent;
+        if (typeof pct === "number" && pct >= 0.5 && pct <= 0.95) validCm.compaction_threshold_percent = pct;
+        else errors.push("context_management.compaction_threshold_percent must be a number between 0.5 and 0.95");
+      }
+      if (cm.tool_result_max_chars !== undefined) {
+        const chars = cm.tool_result_max_chars;
+        if (typeof chars === "number" && chars >= 200 && chars <= 10000) validCm.tool_result_max_chars = chars;
+        else errors.push("context_management.tool_result_max_chars must be a number between 200 and 10000");
+      }
+
+      if (Object.keys(validCm).length > 0) {
+        validated.context_management = validCm as any;
+      }
+    } else {
+      errors.push("context_management must be an object");
+    }
+  }
+
   // ─── Parallel Config ────────────────────────────────────────────────────
   if (preferences.parallel && typeof preferences.parallel === "object") {
     const p = preferences.parallel as unknown as Record<string, unknown>;
@@ -819,5 +857,50 @@ export function validatePreferences(preferences: GSDPreferences): {
     }
   }
 
+  // ─── Codebase Map ──────────────────────────────────────────────────
+  if (preferences.codebase !== undefined) {
+    if (typeof preferences.codebase === "object" && preferences.codebase !== null) {
+      const cb = preferences.codebase as Record<string, unknown>;
+      const validCb: import("./preferences-types.js").CodebaseMapPreferences = {};
+
+      if (cb.exclude_patterns !== undefined) {
+        if (Array.isArray(cb.exclude_patterns) && cb.exclude_patterns.every((p: unknown) => typeof p === "string")) {
+          validCb.exclude_patterns = cb.exclude_patterns as string[];
+        } else {
+          errors.push("codebase.exclude_patterns must be an array of strings");
+        }
+      }
+      if (cb.max_files !== undefined) {
+        const mf = typeof cb.max_files === "number" ? cb.max_files : Number(cb.max_files);
+        if (Number.isFinite(mf) && mf >= 1) {
+          validCb.max_files = Math.floor(mf);
+        } else {
+          errors.push("codebase.max_files must be a positive integer");
+        }
+      }
+      if (cb.collapse_threshold !== undefined) {
+        const ct = typeof cb.collapse_threshold === "number" ? cb.collapse_threshold : Number(cb.collapse_threshold);
+        if (Number.isFinite(ct) && ct >= 1) {
+          validCb.collapse_threshold = Math.floor(ct);
+        } else {
+          errors.push("codebase.collapse_threshold must be a positive integer");
+        }
+      }
+
+      const knownCbKeys = new Set(["exclude_patterns", "max_files", "collapse_threshold"]);
+      for (const key of Object.keys(cb)) {
+        if (!knownCbKeys.has(key)) {
+          warnings.push(`unknown codebase key "${key}" — ignored`);
+        }
+      }
+
+      if (Object.keys(validCb).length > 0) {
+        validated.codebase = validCb;
+      }
+    } else {
+      errors.push("codebase must be an object");
+    }
+  }
+
   return { preferences: validated, errors, warnings };
 }

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

@@ -19,6 +19,7 @@ import { parse as parseYaml } from "yaml";
 import type { PostUnitHookConfig, PreDispatchHookConfig, TokenProfile } from "./types.js";
 import type { DynamicRoutingConfig } from "./model-router.js";
 import { normalizeStringArray } from "../shared/format-utils.js";
+import { logWarning } from "./workflow-logger.js";
 import { resolveProfileDefaults as _resolveProfileDefaults } from "./preferences-models.js";
 
 import {
@@ -48,6 +49,7 @@ export type {
   AutoSupervisorConfig,
   RemoteQuestionsConfig,
   CmuxPreferences,
+  CodebaseMapPreferences,
   GSDPreferences,
   LoadedGSDPreferences,
   SkillResolution,
@@ -237,7 +239,7 @@ function parseFrontmatterBlock(frontmatter: string): GSDPreferences {
     }
     return parsed as GSDPreferences;
   } catch (e) {
-    console.error("[parseFrontmatterBlock] YAML parse error:", e);
+    logWarning("guided", `YAML parse error in frontmatter block: ${(e as Error).message}`);
     return {} as GSDPreferences;
   }
 }
@@ -296,8 +298,8 @@ function parseHeadingListFormat(content: string): GSDPreferences {
       }
 
       typed[targetSection] = value;
-    } catch {
-      /* malformed section — skip */
+    } catch (e) {
+      logWarning("guided", `preferences section parse failed: ${(e as Error).message}`);
     }
   }
 
@@ -371,6 +373,17 @@ function mergePreferences(base: GSDPreferences, override: GSDPreferences): GSDPr
     service_tier: override.service_tier ?? base.service_tier,
     forensics_dedup: override.forensics_dedup ?? base.forensics_dedup,
     show_token_cost: override.show_token_cost ?? base.show_token_cost,
+    codebase: (base.codebase || override.codebase)
+      ? {
+          ...(base.codebase ?? {}),
+          ...(override.codebase ?? {}),
+          // Merge exclude_patterns arrays rather than overriding
+          exclude_patterns: [
+            ...((base.codebase?.exclude_patterns) ?? []),
+            ...((override.codebase?.exclude_patterns) ?? []),
+          ].filter(Boolean),
+        }
+      : undefined,
   };
 }
 

package/src/resources/extensions/gsd/prompt-loader.ts

@@ -22,6 +22,7 @@ import { GSDError, GSD_PARSE_ERROR } from "./errors.js";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { homedir } from "node:os";
+import { logWarning } from "./workflow-logger.js";
 
 /**
  * Resolve the GSD extension directory.
@@ -72,7 +73,7 @@ function warmCache(): void {
     // prompts/ may not exist in test environments — lazy loading still works.
     // Emit a diagnostic when running outside tests so wrong-path bugs are visible.
     if (!process.env.VITEST && !process.env.NODE_TEST) {
-      process.stderr.write(`[gsd:prompt-loader] warmCache: prompts dir not found: ${promptsDir}\n`);
+      logWarning("prompt", `warmCache: prompts dir not found: ${promptsDir}`);
     }
   }
 
@@ -87,7 +88,7 @@ function warmCache(): void {
   } catch {
     // templates/ may not exist in test environments — lazy loading still works.
     if (!process.env.VITEST && !process.env.NODE_TEST) {
-      process.stderr.write(`[gsd:prompt-loader] warmCache: templates dir not found: ${templatesDir}\n`);
+      logWarning("prompt", `warmCache: templates dir not found: ${templatesDir}`);
     }
   }
 }

package/src/resources/extensions/gsd/prompts/execute-task.md

@@ -12,6 +12,8 @@ A researcher explored the codebase and a planner decomposed the work — you are
 
 {{runtimeContext}}
 
+{{phaseAnchorSection}}
+
 {{resumeSection}}
 
 {{carryForwardSection}}

package/src/resources/extensions/gsd/prompts/rethink.md

@@ -45,6 +45,13 @@ reason: "<reason>"
 ### Unpark a milestone
 Remove the `{ID}-PARKED.md` file from the milestone directory to reactivate it.
 
+### Skip a slice
+Mark a slice as skipped so auto-mode advances past it without executing. Use the `gsd_skip_slice` tool:
+```
+gsd_skip_slice({ milestoneId: "M003", sliceId: "S02", reason: "Descoped — feature moved to M005" })
+```
+Skipped slices are treated as closed by the state machine (like "complete" but distinct). Use when a slice is no longer needed or has been superseded. The slice data is preserved for reference.
+
 ### Discard a milestone
 **Permanently** delete a milestone directory and prune it from QUEUE-ORDER.json. **Always confirm with the user before discarding.** Warn explicitly if the milestone has completed work.
 

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

@@ -20,6 +20,8 @@ The user captured thoughts during execution using `/gsd capture`. Your job is to
 
 For each capture, classify it as one of:
 
+- **stop**: User directive to halt auto-mode immediately. Use when the user says "stop", "halt", "abort", "don't continue", "pause", or otherwise wants execution to cease. Auto-mode will pause after the current unit completes. Examples: "stop running", "halt execution", "don't continue".
+- **backtrack**: User directive to abandon the current milestone and return to a previous one. The user believes earlier milestones missed critical features or need rework. Include the target milestone ID (e.g., M003) in the Resolution field. Auto-mode will pause and write a regression marker. Examples: "restart from M003", "go back to milestone 3", "M004 and M005 failed, restart from M003".
 - **quick-task**: Small, self-contained, no downstream impact. Can be done in minutes without modifying the plan. Examples: fix a typo, add a missing import, tweak a config value.
 - **inject**: Belongs in the current slice but wasn't planned. Needs a new task added to the slice plan. Examples: add error handling to a module being built, add a missing test case for current work.
 - **defer**: Belongs in a future slice or milestone. Not urgent for current work. Examples: performance optimization, feature that depends on unbuilt infrastructure, nice-to-have enhancement.
@@ -28,10 +30,12 @@ For each capture, classify it as one of:
 
 ## Decision Guidelines
 
+- **ALWAYS classify as stop** when the user explicitly says "stop", "halt", "abort", or "don't continue". Never shoe-horn a stop directive into "replan" or "note".
+- **ALWAYS classify as backtrack** when the user references returning to a previous milestone, restarting from an earlier point, or abandoning current milestone work. Include the target milestone ID in the Resolution field (e.g., "Backtrack to M003").
 - Prefer **quick-task** when the work is clearly small and self-contained.
 - Prefer **inject** over **replan** when only a new task is needed, not rewriting existing ones.
 - Prefer **defer** over **inject** when the work doesn't belong in the current slice's scope.
-- Use **replan** only when remaining incomplete tasks need to change — not just for adding work.
+- Use **replan** only when remaining incomplete tasks in the *current slice* need to change — not for cross-milestone issues.
 - Use **note** for observations that don't require action.
 - When unsure between quick-task and inject, consider: will this take more than 10 minutes? If yes, inject.
 
@@ -46,6 +50,7 @@ For each capture, classify it as one of:
    - If applicable, which files would be affected
    
    For captures classified as **note** or **defer**, auto-confirm without asking — these are low-impact.
+   For captures classified as **stop** or **backtrack**, auto-confirm without asking — these are urgent user directives that must be honored immediately.
    For captures classified as **quick-task**, **inject**, or **replan**, ask the user to confirm or choose a different classification.
 
 3. **Update** `.gsd/CAPTURES.md` — for each capture, update its section with the confirmed classification:

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

@@ -112,8 +112,11 @@ function buildRethinkData(
     if (dbAvailable && status !== "complete") {
       const slices = getMilestoneSlices(mid);
       if (slices.length > 0) {
-        const done = slices.filter(s => s.status === "complete").length;
-        sliceInfo = `${done}/${slices.length} complete`;
+        const done = slices.filter(s => s.status === "complete" || s.status === "done").length;
+        const skipped = slices.filter(s => s.status === "skipped").length;
+        sliceInfo = skipped > 0
+          ? `${done}/${slices.length} complete, ${skipped} skipped`
+          : `${done}/${slices.length} complete`;
       }
     }
 

package/src/resources/extensions/gsd/rule-registry.ts

@@ -6,6 +6,7 @@
 //
 // A module-level singleton accessor allows existing code to migrate incrementally.
 
+import { logWarning } from "./workflow-logger.js";
 import type { UnifiedRule, RulePhase } from "./rule-types.js";
 import type { DispatchAction, DispatchContext, DispatchRule } from "./auto-dispatch.js";
 import type {
@@ -387,8 +388,8 @@ export class RuleRegistry {
       const dir = join(basePath, ".gsd");
       if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
       writeFileSync(this._hookStatePath(basePath), JSON.stringify(state, null, 2), "utf-8");
-    } catch {
-      // Non-fatal — state is recreatable from artifacts
+    } catch (e) {
+      logWarning("registry", `failed to persist hook state: ${(e as Error).message}`);
     }
   }
 
@@ -407,8 +408,8 @@ export class RuleRegistry {
           }
         }
       }
-    } catch {
-      // Non-fatal — fresh state is fine
+    } catch (e) {
+      logWarning("registry", `failed to restore hook state: ${(e as Error).message}`);
     }
   }
 
@@ -423,8 +424,8 @@ export class RuleRegistry {
           "utf-8",
         );
       }
-    } catch {
-      // Non-fatal
+    } catch (e) {
+      logWarning("registry", `failed to clear hook state: ${(e as Error).message}`);
     }
   }
 

package/src/resources/extensions/gsd/safe-fs.ts

@@ -1,23 +1,24 @@
 import { existsSync, mkdirSync, cpSync, type CopySyncOptions } from "node:fs"
 import { dirname } from "node:path"
+import { logWarning } from "./workflow-logger.js"
 
 /**
  * Safely creates a directory. Returns true if successful, false on error.
- * Logs to stderr when GSD_DEBUG is set.
+ * Logs warnings via workflow-logger on failure.
  */
 export function safeMkdir(dirPath: string): boolean {
   try {
     mkdirSync(dirPath, { recursive: true })
     return true
   } catch (err) {
-    if (process.env.GSD_DEBUG) console.error(`[gsd] mkdir failed: ${dirPath}`, err)
+    logWarning("fs", `mkdir failed: ${dirPath}: ${(err as Error).message}`)
     return false
   }
 }
 
 /**
  * Safely copies src to dst. Returns true if successful, false if src doesn't exist or copy fails.
- * Logs to stderr when GSD_DEBUG is set.
+ * Logs warnings via workflow-logger on failure.
  */
 export function safeCopy(src: string, dst: string, opts?: CopySyncOptions): boolean {
   if (!existsSync(src)) return false
@@ -25,7 +26,7 @@ export function safeCopy(src: string, dst: string, opts?: CopySyncOptions): bool
     cpSync(src, dst, opts)
     return true
   } catch (err) {
-    if (process.env.GSD_DEBUG) console.error(`[gsd] copy failed: ${src} → ${dst}`, err)
+    logWarning("fs", `copy failed: ${src} → ${dst}: ${(err as Error).message}`)
     return false
   }
 }
@@ -41,7 +42,7 @@ export function safeCopyRecursive(src: string, dst: string, opts?: Omit<CopySync
     cpSync(src, dst, { ...opts, recursive: true })
     return true
   } catch (err) {
-    if (process.env.GSD_DEBUG) console.error(`[gsd] recursive copy failed: ${src} → ${dst}`, err)
+    logWarning("fs", `recursive copy failed: ${src} → ${dst}: ${(err as Error).message}`)
     return false
   }
 }

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

@@ -295,7 +295,7 @@ function extractContextTitle(content: string | null, fallback: string): string {
  * Helper: check if a DB status counts as "done" (handles K002 ambiguity).
  */
 function isStatusDone(status: string): boolean {
-  return status === 'complete' || status === 'done';
+  return status === 'complete' || status === 'done' || status === 'skipped';
 }
 
 /**

package/src/resources/extensions/gsd/status-guards.ts

@@ -1,13 +1,14 @@
 /**
  * Status predicates for GSD state-machine guards.
  *
- * The DB stores status as free-form strings. Two values indicate
- * "closed": "complete" (canonical) and "done" (legacy / alias).
+ * The DB stores status as free-form strings. Three values indicate
+ * "closed": "complete" (canonical), "done" (legacy / alias), and
+ * "skipped" (user-directed skip via rethink or backtrack).
  * Every inline `status === "complete" || status === "done"` should
  * use isClosedStatus() instead.
  */
 
 /** Returns true when a milestone, slice, or task status indicates closure. */
 export function isClosedStatus(status: string): boolean {
-  return status === "complete" || status === "done";
+  return status === "complete" || status === "done" || status === "skipped";
 }