gsd-pi 2.59.0 → 2.60.0-dev.2580e65

package/dist/resources/extensions/gsd/phase-anchor.js

@@ -0,0 +1,56 @@
+/**
+ * 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";
+function anchorsDir(basePath, milestoneId) {
+    return join(gsdRoot(basePath), "milestones", milestoneId, "anchors");
+}
+function anchorPath(basePath, milestoneId, phase) {
+    return join(anchorsDir(basePath, milestoneId), `${phase}.json`);
+}
+export function writePhaseAnchor(basePath, milestoneId, anchor) {
+    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, milestoneId, phase) {
+    const path = anchorPath(basePath, milestoneId, phase);
+    if (!existsSync(path))
+        return null;
+    try {
+        return JSON.parse(readFileSync(path, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function formatAnchorForPrompt(anchor) {
+    const lines = [
+        `## 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/dist/resources/extensions/gsd/preferences-types.js

@@ -71,7 +71,9 @@ export const KNOWN_PREFERENCE_KEYS = new Set([
     "forensics_dedup",
     "show_token_cost",
     "stale_commit_threshold_minutes",
+    "context_management",
     "experimental",
+    "codebase",
 ]);
 /** Canonical list of all dispatch unit types. */
 export const KNOWN_UNIT_TYPES = [

package/dist/resources/extensions/gsd/preferences-validation.js

@@ -425,6 +425,12 @@ export function validatePreferences(preferences) {
                 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;
@@ -452,6 +458,46 @@ export function validatePreferences(preferences) {
             errors.push("dynamic_routing must be an object");
         }
     }
+    // ─── Context Management ──────────────────────────────────────────────
+    if (preferences.context_management !== undefined) {
+        if (typeof preferences.context_management === "object" && preferences.context_management !== null) {
+            const cm = preferences.context_management;
+            const validCm = {};
+            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;
+            }
+        }
+        else {
+            errors.push("context_management must be an object");
+        }
+    }
     // ─── Parallel Config ────────────────────────────────────────────────────
     if (preferences.parallel && typeof preferences.parallel === "object") {
         const p = preferences.parallel;
@@ -848,5 +894,50 @@ export function validatePreferences(preferences) {
             errors.push("experimental must be an object");
         }
     }
+    // ─── Codebase Map ──────────────────────────────────────────────────
+    if (preferences.codebase !== undefined) {
+        if (typeof preferences.codebase === "object" && preferences.codebase !== null) {
+            const cb = preferences.codebase;
+            const validCb = {};
+            if (cb.exclude_patterns !== undefined) {
+                if (Array.isArray(cb.exclude_patterns) && cb.exclude_patterns.every((p) => typeof p === "string")) {
+                    validCb.exclude_patterns = cb.exclude_patterns;
+                }
+                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/dist/resources/extensions/gsd/preferences.js

@@ -15,6 +15,7 @@ import { join } from "node:path";
 import { gsdRoot } from "./paths.js";
 import { parse as parseYaml } from "yaml";
 import { normalizeStringArray } from "../shared/format-utils.js";
+import { logWarning } from "./workflow-logger.js";
 import { resolveProfileDefaults as _resolveProfileDefaults } from "./preferences-models.js";
 import { KNOWN_PREFERENCE_KEYS, MODE_DEFAULTS, } from "./preferences-types.js";
 import { validatePreferences } from "./preferences-validation.js";
@@ -162,7 +163,7 @@ function parseFrontmatterBlock(frontmatter) {
         return parsed;
     }
     catch (e) {
-        console.error("[parseFrontmatterBlock] YAML parse error:", e);
+        logWarning("guided", `YAML parse error in frontmatter block: ${e.message}`);
         return {};
     }
 }
@@ -217,8 +218,8 @@ function parseHeadingListFormat(content) {
             }
             typed[targetSection] = value;
         }
-        catch {
-            /* malformed section — skip */
+        catch (e) {
+            logWarning("guided", `preferences section parse failed: ${e.message}`);
         }
     }
     return typed;
@@ -289,6 +290,17 @@ function mergePreferences(base, override) {
         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,
     };
 }
 function mergeStringLists(base, override) {

package/dist/resources/extensions/gsd/prompt-loader.js

@@ -21,6 +21,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.
  *
@@ -69,7 +70,7 @@ function warmCache() {
         // 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}`);
         }
     }
     try {
@@ -85,7 +86,7 @@ function warmCache() {
     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/dist/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/dist/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/dist/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/dist/resources/extensions/gsd/rethink.js

@@ -81,8 +81,11 @@ function buildRethinkData(basePath, milestoneIds, state, queueOrder) {
         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`;
             }
         }
         // Add parked reason if applicable

package/dist/resources/extensions/gsd/rule-registry.js

@@ -5,6 +5,7 @@
 // and encapsulates mutable hook state as instance fields.
 //
 // A module-level singleton accessor allows existing code to migrate incrementally.
+import { logWarning } from "./workflow-logger.js";
 import { resolvePostUnitHooks, resolvePreDispatchHooks } from "./preferences.js";
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
@@ -310,8 +311,8 @@ export class RuleRegistry {
                 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.message}`);
         }
     }
     /** Restore hook cycle counts from disk after a crash/restart. */
@@ -331,8 +332,8 @@ export class RuleRegistry {
                 }
             }
         }
-        catch {
-            // Non-fatal — fresh state is fine
+        catch (e) {
+            logWarning("registry", `failed to restore hook state: ${e.message}`);
         }
     }
     /** Clear persisted hook state file from disk. */
@@ -343,8 +344,8 @@ export class RuleRegistry {
                 writeFileSync(filePath, JSON.stringify({ cycleCounts: {}, savedAt: new Date().toISOString() }, null, 2), "utf-8");
             }
         }
-        catch {
-            // Non-fatal
+        catch (e) {
+            logWarning("registry", `failed to clear hook state: ${e.message}`);
         }
     }
     // ── Hook status reporting ───────────────────────────────────────────

package/dist/resources/extensions/gsd/safe-fs.js

@@ -1,8 +1,9 @@
 import { existsSync, mkdirSync, cpSync } 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) {
     try {
@@ -10,14 +11,13 @@ export function safeMkdir(dirPath) {
         return true;
     }
     catch (err) {
-        if (process.env.GSD_DEBUG)
-            console.error(`[gsd] mkdir failed: ${dirPath}`, err);
+        logWarning("fs", `mkdir failed: ${dirPath}: ${err.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, dst, opts) {
     if (!existsSync(src))
@@ -27,8 +27,7 @@ export function safeCopy(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.message}`);
         return false;
     }
 }
@@ -45,8 +44,7 @@ export function safeCopyRecursive(src, dst, opts) {
         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.message}`);
         return false;
     }
 }

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

@@ -223,7 +223,7 @@ function extractContextTitle(content, fallback) {
  * Helper: check if a DB status counts as "done" (handles K002 ambiguity).
  */
 function isStatusDone(status) {
-    return status === 'complete' || status === 'done';
+    return status === 'complete' || status === 'done' || status === 'skipped';
 }
 /**
  * Derive GSD state from the milestones/slices/tasks DB tables.

package/dist/resources/extensions/gsd/status-guards.js

@@ -1,12 +1,13 @@
 /**
  * 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) {
-    return status === "complete" || status === "done";
+    return status === "complete" || status === "done" || status === "skipped";
 }

package/dist/resources/extensions/gsd/tools/complete-milestone.js

@@ -15,6 +15,7 @@ import { invalidateStateCache } from "../state.js";
 import { renderAllProjections } from "../workflow-projections.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
+import { logWarning } from "../workflow-logger.js";
 function renderMilestoneSummaryMarkdown(params) {
     const now = new Date().toISOString();
     const keyDecisionsYaml = params.keyDecisions.length > 0
@@ -140,7 +141,7 @@ export async function handleCompleteMilestone(params, basePath) {
     }
     catch (renderErr) {
         // Disk render failed — roll back DB status so state stays consistent
-        process.stderr.write(`gsd-db: complete_milestone — disk render failed, rolling back DB status: ${renderErr.message}\n`);
+        logWarning("tool", `complete_milestone — disk render failed, rolling back DB status: ${renderErr.message}`);
         updateMilestoneStatus(params.milestoneId, 'active', null);
         invalidateStateCache();
         return { error: `disk render failed: ${renderErr.message}` };
@@ -163,7 +164,7 @@ export async function handleCompleteMilestone(params, basePath) {
         });
     }
     catch (hookErr) {
-        process.stderr.write(`gsd: complete-milestone post-mutation hook warning: ${hookErr.message}\n`);
+        logWarning("tool", `complete-milestone post-mutation hook warning: ${hookErr.message}`);
     }
     return {
         milestoneId: params.milestoneId,

package/dist/resources/extensions/gsd/tools/complete-slice.js

@@ -18,6 +18,7 @@ import { renderRoadmapCheckboxes } from "../markdown-renderer.js";
 import { renderAllProjections } from "../workflow-projections.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
+import { logWarning } from "../workflow-logger.js";
 /**
  * Render slice summary markdown matching the template format.
  * YAML frontmatter uses snake_case keys for parseSummary() compatibility.
@@ -240,7 +241,7 @@ export async function handleCompleteSlice(params, basePath) {
     }
     catch (renderErr) {
         // Disk render failed — roll back DB status so state stays consistent
-        process.stderr.write(`gsd-db: complete_slice — disk render failed, rolling back DB status: ${renderErr.message}\n`);
+        logWarning("tool", `complete_slice — disk render failed, rolling back DB status: ${renderErr.message}`);
         updateSliceStatus(params.milestoneId, params.sliceId, 'pending');
         invalidateStateCache();
         return { error: `disk render failed: ${renderErr.message}` };
@@ -265,7 +266,7 @@ export async function handleCompleteSlice(params, basePath) {
         });
     }
     catch (hookErr) {
-        process.stderr.write(`gsd: complete-slice post-mutation hook warning: ${hookErr.message}\n`);
+        logWarning("tool", `complete-slice post-mutation hook warning: ${hookErr.message}`);
     }
     return {
         sliceId: params.sliceId,

package/dist/resources/extensions/gsd/tools/complete-task.js

@@ -18,6 +18,7 @@ import { renderPlanCheckboxes } from "../markdown-renderer.js";
 import { renderAllProjections, renderSummaryContent } from "../workflow-projections.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
+import { logWarning } from "../workflow-logger.js";
 /**
  * Build a TaskRow-shaped object from CompleteTaskParams so the unified
  * renderSummaryContent() can be used at completion time (#2720).
@@ -165,7 +166,7 @@ export async function handleCompleteTask(params, basePath) {
     }
     catch (renderErr) {
         // Disk render failed — roll back DB status so state stays consistent
-        process.stderr.write(`gsd-db: complete_task — disk render failed, rolling back DB status: ${renderErr.message}\n`);
+        logWarning("tool", `complete_task — disk render failed, rolling back DB status: ${renderErr.message}`);
         // Delete orphaned verification_evidence rows first (FK constraint
         // references tasks, so evidence must go before status change).
         // Without this, retries accumulate duplicate evidence rows (#2724).
@@ -194,7 +195,7 @@ export async function handleCompleteTask(params, basePath) {
         });
     }
     catch (hookErr) {
-        process.stderr.write(`gsd: complete-task post-mutation hook warning: ${hookErr.message}\n`);
+        logWarning("tool", `complete-task post-mutation hook warning: ${hookErr.message}`);
     }
     return {
         taskId: params.taskId,

package/dist/resources/extensions/gsd/tools/plan-milestone.js

@@ -7,6 +7,7 @@ import { renderRoadmapFromDb } from "../markdown-renderer.js";
 import { renderAllProjections } from "../workflow-projections.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
+import { logWarning } from "../workflow-logger.js";
 function validateRiskEntries(value) {
     if (!Array.isArray(value)) {
         throw new Error("keyRisks must be an array");
@@ -221,7 +222,7 @@ export async function handlePlanMilestone(rawParams, basePath) {
         roadmapPath = renderResult.roadmapPath;
     }
     catch (renderErr) {
-        process.stderr.write(`gsd-db: plan_milestone — render failed (DB rows preserved for debugging): ${renderErr.message}\n`);
+        logWarning("tool", `plan_milestone — render failed (DB rows preserved for debugging): ${renderErr.message}`);
         invalidateStateCache();
         return { error: `render failed: ${renderErr.message}` };
     }
@@ -241,7 +242,7 @@ export async function handlePlanMilestone(rawParams, basePath) {
         });
     }
     catch (hookErr) {
-        process.stderr.write(`gsd: plan-milestone post-mutation hook warning: ${hookErr.message}\n`);
+        logWarning("tool", `plan-milestone post-mutation hook warning: ${hookErr.message}`);
     }
     return {
         milestoneId: params.milestoneId,

package/dist/resources/extensions/gsd/tools/plan-slice.js

@@ -7,6 +7,7 @@ import { renderPlanFromDb } from "../markdown-renderer.js";
 import { renderAllProjections } from "../workflow-projections.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
+import { logWarning } from "../workflow-logger.js";
 function validateTasks(value) {
     if (!Array.isArray(value) || value.length === 0) {
         throw new Error("tasks must be a non-empty array");
@@ -182,7 +183,7 @@ export async function handlePlanSlice(rawParams, basePath) {
             });
         }
         catch (hookErr) {
-            process.stderr.write(`gsd: plan-slice post-mutation hook warning: ${hookErr.message}\n`);
+            logWarning("tool", `plan-slice post-mutation hook warning: ${hookErr.message}`);
         }
         return {
             milestoneId: params.milestoneId,
@@ -192,7 +193,7 @@ export async function handlePlanSlice(rawParams, basePath) {
         };
     }
     catch (renderErr) {
-        process.stderr.write(`gsd-db: plan_slice — render failed (DB rows preserved for debugging): ${renderErr.message}\n`);
+        logWarning("tool", `plan_slice — render failed (DB rows preserved for debugging): ${renderErr.message}`);
         invalidateStateCache();
         return { error: `render failed: ${renderErr.message}` };
     }

package/dist/resources/extensions/gsd/tools/plan-task.js

@@ -7,6 +7,7 @@ import { renderTaskPlanFromDb } from "../markdown-renderer.js";
 import { renderAllProjections } from "../workflow-projections.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
+import { logWarning } from "../workflow-logger.js";
 function validateParams(params) {
     if (!isNonEmptyString(params?.milestoneId))
         throw new Error("milestoneId is required");
@@ -106,7 +107,7 @@ export async function handlePlanTask(rawParams, basePath) {
             });
         }
         catch (hookErr) {
-            process.stderr.write(`gsd: plan-task post-mutation hook warning: ${hookErr.message}\n`);
+            logWarning("tool", `plan-task post-mutation hook warning: ${hookErr.message}`);
         }
         return {
             milestoneId: params.milestoneId,

package/dist/resources/extensions/gsd/tools/reassess-roadmap.js

@@ -9,6 +9,7 @@ import { renderRoadmapFromDb, renderAssessmentFromDb } from "../markdown-rendere
 import { renderAllProjections } from "../workflow-projections.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
+import { logWarning } from "../workflow-logger.js";
 function validateParams(params) {
     if (!isNonEmptyString(params?.milestoneId))
         throw new Error("milestoneId is required");
@@ -182,9 +183,8 @@ export async function handleReassessRoadmap(rawParams, basePath) {
                 if (existsSync(validationFile))
                     unlinkSync(validationFile);
             }
-            catch {
-                // Best-effort: DB row is already deleted, so state derivation
-                // will not see the file-based verdict as authoritative.
+            catch (e) {
+                logWarning("tool", `validation file cleanup failed: ${e.message}`);
             }
         }
         // ── Invalidate caches ─────────────────────────────────────────
@@ -204,7 +204,7 @@ export async function handleReassessRoadmap(rawParams, basePath) {
             });
         }
         catch (hookErr) {
-            process.stderr.write(`gsd: reassess-roadmap post-mutation hook warning: ${hookErr.message}\n`);
+            logWarning("tool", `reassess-roadmap post-mutation hook warning: ${hookErr.message}`);
         }
         return {
             milestoneId: params.milestoneId,

package/dist/resources/extensions/gsd/tools/reopen-slice.js

@@ -15,6 +15,7 @@ import { isClosedStatus } from "../status-guards.js";
 import { renderAllProjections } from "../workflow-projections.js";
 import { writeManifest } from "../workflow-manifest.js";
 import { appendEvent } from "../workflow-events.js";
+import { logWarning } from "../workflow-logger.js";
 export async function handleReopenSlice(params, basePath) {
     // ── Validate required fields ────────────────────────────────────────────
     if (!params.sliceId || typeof params.sliceId !== "string" || params.sliceId.trim() === "") {
@@ -77,7 +78,7 @@ export async function handleReopenSlice(params, basePath) {
         });
     }
     catch (hookErr) {
-        process.stderr.write(`gsd: reopen-slice post-mutation hook warning: ${hookErr.message}\n`);
+        logWarning("tool", `reopen-slice post-mutation hook warning: ${hookErr.message}`);
     }
     return {
         milestoneId: params.milestoneId,