gsd-pi 2.60.0-dev.d9052f5 → 2.61.0-dev.7aed0bf

package/src/resources/extensions/gsd/tests/silent-catch-diagnostics.test.ts

@@ -0,0 +1,284 @@
+/**
+ * Verify that catch blocks across GSD source files use the centralized
+ * workflow-logger (logWarning/logError) instead of raw process.stderr.write,
+ * console.error, or being completely empty (#3348, #3345).
+ *
+ * Two tests:
+ * 1. Auto-mode files must have zero empty catch blocks (fully migrated).
+ * 2. All GSD files must not use raw stderr/console in catch blocks.
+ */
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { join, dirname, relative } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const gsdDir = join(__dirname, "..");
+
+/** Files exempt from the raw-stderr/console check */
+const EXEMPT_FILES = new Set([
+  "workflow-logger.ts",       // The logger itself
+  "debug-logger.ts",          // Separate opt-in debug system
+]);
+
+/**
+ * Files that have been fully migrated to workflow-logger and must not
+ * regress to empty catch blocks. Covers auto-mode, tools, bootstrap,
+ * and core infrastructure files.
+ */
+const MIGRATED_FILES = new Set([
+  // auto-mode (detected dynamically below)
+  // tools/
+  "tools/complete-task.ts",
+  "tools/complete-slice.ts",
+  "tools/complete-milestone.ts",
+  "tools/plan-milestone.ts",
+  "tools/plan-slice.ts",
+  "tools/plan-task.ts",
+  "tools/reassess-roadmap.ts",
+  "tools/reopen-task.ts",
+  "tools/reopen-slice.ts",
+  "tools/replan-slice.ts",
+  "tools/validate-milestone.ts",
+  // bootstrap/
+  "bootstrap/agent-end-recovery.ts",
+  "bootstrap/system-context.ts",
+  "bootstrap/db-tools.ts",
+  "bootstrap/dynamic-tools.ts",
+  "bootstrap/journal-tools.ts",
+  // core infrastructure
+  "gsd-db.ts",
+  "workflow-logger.ts",
+  "workflow-reconcile.ts",
+  "workflow-migration.ts",
+  "workflow-projections.ts",
+  "workflow-events.ts",
+  "worktree-manager.ts",
+  "parallel-orchestrator.ts",
+  "parallel-merge.ts",
+  "guided-flow.ts",
+  "preferences.ts",
+  "commands-maintenance.ts",
+  "commands-inspect.ts",
+  "safe-fs.ts",
+  "markdown-renderer.ts",
+  "md-importer.ts",
+  "milestone-actions.ts",
+  "milestone-ids.ts",
+  "rule-registry.ts",
+  "custom-verification.ts",
+  "prompt-loader.ts",
+  "auto-verification.ts",
+]);
+
+/** Patterns that indicate a catch block already uses workflow-logger */
+const LOGGER_PATTERNS = [
+  /logWarning\s*\(/,
+  /logError\s*\(/,
+];
+
+function getAutoModeFiles(): string[] {
+  const files: string[] = [];
+
+  // Top-level auto*.ts files
+  for (const f of readdirSync(gsdDir)) {
+    if (f.startsWith("auto") && f.endsWith(".ts") && !f.endsWith(".test.ts")) {
+      files.push(join(gsdDir, f));
+    }
+  }
+
+  // auto/ subdirectory
+  const autoSubDir = join(gsdDir, "auto");
+  for (const f of readdirSync(autoSubDir)) {
+    if (f.endsWith(".ts") && !f.endsWith(".test.ts")) {
+      files.push(join(autoSubDir, f));
+    }
+  }
+
+  return files;
+}
+
+function getGsdSourceFiles(): string[] {
+  const files: string[] = [];
+
+  function walk(dir: string): void {
+    for (const entry of readdirSync(dir)) {
+      const full = join(dir, entry);
+      if (entry === "tests" || entry === "node_modules") continue;
+      try {
+        const st = statSync(full);
+        if (st.isDirectory()) {
+          walk(full);
+        } else if (entry.endsWith(".ts") && !entry.endsWith(".test.ts") && !entry.endsWith(".d.ts")) {
+          files.push(full);
+        }
+      } catch {
+        continue;
+      }
+    }
+  }
+
+  walk(gsdDir);
+  return files;
+}
+
+/**
+ * Scan a file for empty catch blocks — catches whose body contains
+ * only whitespace and/or comments but no executable statements.
+ */
+function findEmptyCatches(filePath: string): Array<{ line: number; text: string }> {
+  const content = readFileSync(filePath, "utf-8");
+  const lines = content.split("\n");
+  const results: Array<{ line: number; text: string }> = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+
+    // Match catch block opening
+    if (!/\}\s*catch\s*(\([^)]*\))?\s*\{/.test(line)) continue;
+
+    // Inline single-line catch: } catch { ... }
+    const inlineMatch = line.match(/\}\s*catch\s*(\([^)]*\))?\s*\{(.*)\}\s*;?\s*$/);
+    if (inlineMatch) {
+      const body = inlineMatch[2].trim();
+      const stripped = body.replace(/\/\*.*?\*\//g, "").replace(/\/\/.*/g, "").trim();
+      if (!stripped) {
+        results.push({ line: i + 1, text: line.trim() });
+      }
+      continue;
+    }
+
+    // Multi-line catch — scan until matching }
+    let j = i + 1;
+    let depth = 1;
+    const bodyLines: string[] = [];
+    while (j < lines.length && depth > 0) {
+      for (const ch of lines[j]) {
+        if (ch === "{") depth++;
+        else if (ch === "}") depth--;
+      }
+      bodyLines.push(lines[j].trim());
+      j++;
+    }
+
+    const meaningful = bodyLines.slice(0, -1).filter(
+      (l) => l && !l.startsWith("//") && !l.startsWith("/*") && !l.startsWith("*") && l !== "}",
+    );
+
+    if (meaningful.length === 0) {
+      results.push({ line: i + 1, text: line.trim() });
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Scan a file for catch blocks that use raw process.stderr.write or
+ * console.error/warn instead of workflow-logger.
+ */
+function findRawStderrCatches(filePath: string): Array<{ line: number; text: string }> {
+  const content = readFileSync(filePath, "utf-8");
+  const lines = content.split("\n");
+  const results: Array<{ line: number; text: string }> = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (!/\}\s*catch\s*(\([^)]*\))?\s*\{/.test(line)) continue;
+
+    // Inline single-line catch
+    const inlineMatch = line.match(/\}\s*catch\s*(\([^)]*\))?\s*\{(.*)\}\s*;?\s*$/);
+    if (inlineMatch) {
+      const body = inlineMatch[2];
+      if (!LOGGER_PATTERNS.some((p) => p.test(body))) {
+        if (/process\.stderr\.write/.test(body) || /console\.(error|warn)/.test(body)) {
+          results.push({ line: i + 1, text: line.trim() });
+        }
+      }
+      continue;
+    }
+
+    // Multi-line catch
+    let j = i + 1;
+    let depth = 1;
+    const bodyLines: string[] = [];
+    while (j < lines.length && depth > 0) {
+      for (const ch of lines[j]) {
+        if (ch === "{") depth++;
+        else if (ch === "}") depth--;
+      }
+      bodyLines.push(lines[j]);
+      j++;
+    }
+
+    const bodyText = bodyLines.slice(0, -1).join("\n");
+    if (!LOGGER_PATTERNS.some((p) => p.test(bodyText))) {
+      if (/process\.stderr\.write/.test(bodyText) || /console\.(error|warn)/.test(bodyText)) {
+        results.push({ line: i + 1, text: line.trim() });
+      }
+    }
+  }
+
+  return results;
+}
+
+describe("workflow-logger coverage (#3348)", () => {
+  test("no empty catch blocks remain in migrated files", () => {
+    // Combine auto-mode files + explicitly migrated files
+    const autoFiles = getAutoModeFiles();
+    const allFiles = getGsdSourceFiles();
+    const migratedPaths = new Set(autoFiles);
+    for (const file of allFiles) {
+      const rel = relative(gsdDir, file);
+      if (MIGRATED_FILES.has(rel)) {
+        migratedPaths.add(file);
+      }
+    }
+
+    assert.ok(migratedPaths.size > 0, "should find migrated source files");
+
+    const violations: string[] = [];
+    for (const file of migratedPaths) {
+      const rel = relative(gsdDir, file);
+      const basename = rel.split("/").pop()!;
+      // gsd-db.ts has intentionally silent provider probes
+      if (basename === "gsd-db.ts" || basename === "session-lock.ts") continue;
+
+      const empties = findEmptyCatches(file);
+      for (const empty of empties) {
+        violations.push(`${rel}:${empty.line} — ${empty.text}`);
+      }
+    }
+
+    assert.equal(
+      violations.length,
+      0,
+      `Found ${violations.length} empty catch block(s) in migrated files:\n${violations.join("\n")}`,
+    );
+  });
+
+  test("catch blocks use workflow-logger instead of raw stderr/console", () => {
+    const files = getGsdSourceFiles();
+    assert.ok(files.length > 0, "should find GSD source files");
+
+    const violations: string[] = [];
+    for (const file of files) {
+      const rel = relative(gsdDir, file);
+      const basename = rel.split("/").pop()!;
+      if (EXEMPT_FILES.has(basename)) continue;
+
+      const issues = findRawStderrCatches(file);
+      for (const issue of issues) {
+        violations.push(`${rel}:${issue.line} — ${issue.text}`);
+      }
+    }
+
+    assert.equal(
+      violations.length,
+      0,
+      `Found ${violations.length} catch block(s) using raw stderr/console instead of workflow-logger:\n${violations.join("\n")}`,
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/workflow-logger-audit.test.ts

@@ -0,0 +1,120 @@
+// GSD Extension — Workflow Logger Audit Persistence Tests
+// Validates error-only persistence, sanitization, and warning ephemeral behavior.
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, readFileSync, existsSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  logWarning,
+  logError,
+  setLogBasePath,
+  _resetLogs,
+  peekLogs,
+  drainLogs,
+} from "../workflow-logger.ts";
+
+function createTempProject(): string {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-wflog-test-"));
+  mkdirSync(join(tmp, ".gsd"), { recursive: true });
+  return tmp;
+}
+
+function readAuditLines(basePath: string): Record<string, unknown>[] {
+  const auditPath = join(basePath, ".gsd", "audit-log.jsonl");
+  if (!existsSync(auditPath)) return [];
+  const content = readFileSync(auditPath, "utf-8").trim();
+  if (!content) return [];
+  return content.split("\n").map((line) => JSON.parse(line));
+}
+
+describe("workflow-logger audit persistence", () => {
+  let tmp: string;
+
+  beforeEach(() => {
+    tmp = createTempProject();
+    _resetLogs();
+    setLogBasePath(tmp);
+  });
+
+  afterEach(() => {
+    _resetLogs();
+    setLogBasePath(null as unknown as string);
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  test("logError persists to audit-log.jsonl", () => {
+    logError("engine", "something broke");
+    const lines = readAuditLines(tmp);
+    assert.equal(lines.length, 1);
+    assert.equal(lines[0].severity, "error");
+    assert.equal(lines[0].component, "engine");
+  });
+
+  test("logWarning does NOT persist to audit-log.jsonl", () => {
+    logWarning("engine", "something fishy");
+    const lines = readAuditLines(tmp);
+    assert.equal(lines.length, 0, "warnings must not be persisted to audit log");
+  });
+
+  test("logWarning still appears in in-memory buffer", () => {
+    logWarning("recovery", "probe miss");
+    const entries = peekLogs();
+    assert.equal(entries.length, 1);
+    assert.equal(entries[0].severity, "warn");
+    assert.equal(entries[0].component, "recovery");
+  });
+
+  test("persisted error messages are truncated at 200 chars", () => {
+    const longMessage = "x".repeat(300);
+    logError("engine", longMessage);
+    const lines = readAuditLines(tmp);
+    assert.equal(lines.length, 1);
+    const msg = lines[0].message as string;
+    assert.ok(msg.length <= 215, `message should be truncated, got ${msg.length} chars`);
+    assert.ok(msg.endsWith("…[truncated]"));
+  });
+
+  test("persisted errors have context filtered to safe allowlist", () => {
+    logError("tool", "tool failed", {
+      fn: "saveDecisionToDb",
+      tool: "gsd_decision_save",
+      error: "SQLITE_BUSY: database is locked",
+      file: "/home/user/project/gsd.db",
+    });
+    const lines = readAuditLines(tmp);
+    assert.equal(lines.length, 1);
+    const ctx = lines[0].context as Record<string, string>;
+    assert.ok(ctx, "context should exist");
+    assert.equal(ctx.fn, "saveDecisionToDb");
+    assert.equal(ctx.tool, "gsd_decision_save");
+    assert.equal(ctx.error, undefined, "error key must be stripped from persisted context");
+    assert.equal(ctx.file, undefined, "file key must be stripped from persisted context");
+  });
+
+  test("persisted errors omit context when no safe keys present", () => {
+    logError("bootstrap", "ensureDbOpen failed", {
+      error: "ENOENT",
+      cwd: "/home/user/project",
+    });
+    const lines = readAuditLines(tmp);
+    assert.equal(lines.length, 1);
+    assert.equal(lines[0].context, undefined, "context should be omitted when no safe keys match");
+  });
+
+  test("mixed warnings and errors only persist errors", () => {
+    logWarning("recovery", "main not found");
+    logWarning("recovery", "master not found");
+    logError("engine", "fatal failure");
+    logWarning("prompt", "cache miss");
+
+    const lines = readAuditLines(tmp);
+    assert.equal(lines.length, 1, "only the error should be persisted");
+    assert.equal(lines[0].severity, "error");
+
+    const buffered = drainLogs();
+    assert.equal(buffered.length, 4, "all entries should be in the in-memory buffer");
+  });
+});

package/src/resources/extensions/gsd/tests/workflow-logger.test.ts

@@ -240,13 +240,13 @@ describe("workflow-logger", () => {
 
     test("writes entry to .gsd/audit-log.jsonl after setLogBasePath", () => {
       setLogBasePath(dir);
-      logWarning("engine", "audit test entry");
+      logError("engine", "audit test entry");
 
       const auditPath = join(dir, ".gsd", "audit-log.jsonl");
       assert.ok(existsSync(auditPath), "audit-log.jsonl should exist");
       const content = readFileSync(auditPath, "utf-8");
       const entry = JSON.parse(content.trim());
-      assert.equal(entry.severity, "warn");
+      assert.equal(entry.severity, "error");
       assert.equal(entry.component, "engine");
       assert.equal(entry.message, "audit test entry");
     });
@@ -254,7 +254,7 @@ describe("workflow-logger", () => {
     test("_resetLogs does not clear the audit base path", () => {
       setLogBasePath(dir);
       _resetLogs();
-      logWarning("engine", "post-reset entry");
+      logError("engine", "post-reset entry");
 
       const auditPath = join(dir, ".gsd", "audit-log.jsonl");
       assert.ok(existsSync(auditPath), "audit-log.jsonl should exist after _resetLogs");
@@ -293,13 +293,13 @@ describe("workflow-logger", () => {
 
     test("writes entry to .gsd/audit-log.jsonl after setLogBasePath", () => {
       setLogBasePath(dir);
-      logWarning("engine", "audit test entry");
+      logError("engine", "audit test entry");
 
       const auditPath = join(dir, ".gsd", "audit-log.jsonl");
       assert.ok(existsSync(auditPath), "audit-log.jsonl should exist");
       const content = readFileSync(auditPath, "utf-8");
       const entry = JSON.parse(content.trim());
-      assert.equal(entry.severity, "warn");
+      assert.equal(entry.severity, "error");
       assert.equal(entry.component, "engine");
       assert.equal(entry.message, "audit test entry");
     });
@@ -307,7 +307,7 @@ describe("workflow-logger", () => {
     test("_resetLogs does not clear the audit base path", () => {
       setLogBasePath(dir);
       _resetLogs();
-      logWarning("engine", "post-reset entry");
+      logError("engine", "post-reset entry");
 
       const auditPath = join(dir, ".gsd", "audit-log.jsonl");
       assert.ok(existsSync(auditPath), "audit-log.jsonl should exist after _resetLogs");

package/src/resources/extensions/gsd/tools/complete-milestone.ts

@@ -23,6 +23,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";
 
 export interface CompleteMilestoneParams {
   milestoneId: string;
@@ -191,9 +192,7 @@ export async function handleCompleteMilestone(
     await saveFile(summaryPath, summaryMd);
   } 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 as Error).message}\n`,
-    );
+    logWarning("tool", `complete_milestone — disk render failed, rolling back DB status: ${(renderErr as Error).message}`);
     updateMilestoneStatus(params.milestoneId, 'active', null);
     invalidateStateCache();
     return { error: `disk render failed: ${(renderErr as Error).message}` };
@@ -217,9 +216,7 @@ export async function handleCompleteMilestone(
       trigger_reason: params.triggerReason,
     });
   } catch (hookErr) {
-    process.stderr.write(
-      `gsd: complete-milestone post-mutation hook warning: ${(hookErr as Error).message}\n`,
-    );
+    logWarning("tool", `complete-milestone post-mutation hook warning: ${(hookErr as Error).message}`);
   }
 
   return {

package/src/resources/extensions/gsd/tools/complete-slice.ts

@@ -30,6 +30,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";
 
 export interface CompleteSliceResult {
   sliceId: string;
@@ -297,9 +298,7 @@ export async function handleCompleteSlice(
     }
   } 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 as Error).message}\n`,
-    );
+    logWarning("tool", `complete_slice — disk render failed, rolling back DB status: ${(renderErr as Error).message}`);
     updateSliceStatus(params.milestoneId, params.sliceId, 'pending');
     invalidateStateCache();
     return { error: `disk render failed: ${(renderErr as Error).message}` };
@@ -326,9 +325,7 @@ export async function handleCompleteSlice(
       trigger_reason: params.triggerReason,
     });
   } catch (hookErr) {
-    process.stderr.write(
-      `gsd: complete-slice post-mutation hook warning: ${(hookErr as Error).message}\n`,
-    );
+    logWarning("tool", `complete-slice post-mutation hook warning: ${(hookErr as Error).message}`);
   }
 
   return {

package/src/resources/extensions/gsd/tools/complete-task.ts

@@ -33,6 +33,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";
 
 export interface CompleteTaskResult {
   taskId: string;
@@ -210,9 +211,7 @@ export async function handleCompleteTask(
     }
   } 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 as Error).message}\n`,
-    );
+    logWarning("tool", `complete_task — disk render failed, rolling back DB status: ${(renderErr as Error).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).
@@ -243,9 +242,7 @@ export async function handleCompleteTask(
       trigger_reason: params.triggerReason,
     });
   } catch (hookErr) {
-    process.stderr.write(
-      `gsd: complete-task post-mutation hook warning: ${(hookErr as Error).message}\n`,
-    );
+    logWarning("tool", `complete-task post-mutation hook warning: ${(hookErr as Error).message}`);
   }
 
   return {

package/src/resources/extensions/gsd/tools/plan-milestone.ts

@@ -15,6 +15,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";
 
 export interface PlanMilestoneSliceInput {
   sliceId: string;
@@ -269,9 +270,7 @@ export async function handlePlanMilestone(
     const renderResult = await renderRoadmapFromDb(basePath, params.milestoneId);
     roadmapPath = renderResult.roadmapPath;
   } catch (renderErr) {
-    process.stderr.write(
-      `gsd-db: plan_milestone — render failed (DB rows preserved for debugging): ${(renderErr as Error).message}\n`,
-    );
+    logWarning("tool", `plan_milestone — render failed (DB rows preserved for debugging): ${(renderErr as Error).message}`);
     invalidateStateCache();
     return { error: `render failed: ${(renderErr as Error).message}` };
   }
@@ -292,9 +291,7 @@ export async function handlePlanMilestone(
       trigger_reason: params.triggerReason,
     });
   } catch (hookErr) {
-    process.stderr.write(
-      `gsd: plan-milestone post-mutation hook warning: ${(hookErr as Error).message}\n`,
-    );
+    logWarning("tool", `plan-milestone post-mutation hook warning: ${(hookErr as Error).message}`);
   }
 
   return {

package/src/resources/extensions/gsd/tools/plan-slice.ts

@@ -16,6 +16,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";
 
 export interface PlanSliceTaskInput {
   taskId: string;
@@ -229,9 +230,7 @@ export async function handlePlanSlice(
         trigger_reason: params.triggerReason,
       });
     } catch (hookErr) {
-      process.stderr.write(
-        `gsd: plan-slice post-mutation hook warning: ${(hookErr as Error).message}\n`,
-      );
+      logWarning("tool", `plan-slice post-mutation hook warning: ${(hookErr as Error).message}`);
     }
 
     return {
@@ -241,9 +240,7 @@ export async function handlePlanSlice(
       taskPlanPaths: renderResult.taskPlanPaths,
     };
   } catch (renderErr) {
-    process.stderr.write(
-      `gsd-db: plan_slice — render failed (DB rows preserved for debugging): ${(renderErr as Error).message}\n`,
-    );
+    logWarning("tool", `plan_slice — render failed (DB rows preserved for debugging): ${(renderErr as Error).message}`);
     invalidateStateCache();
     return { error: `render failed: ${(renderErr as Error).message}` };
   }

package/src/resources/extensions/gsd/tools/plan-task.ts

@@ -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";
 
 export interface PlanTaskParams {
   milestoneId: string;
@@ -135,9 +136,7 @@ export async function handlePlanTask(
         trigger_reason: params.triggerReason,
       });
     } catch (hookErr) {
-      process.stderr.write(
-        `gsd: plan-task post-mutation hook warning: ${(hookErr as Error).message}\n`,
-      );
+      logWarning("tool", `plan-task post-mutation hook warning: ${(hookErr as Error).message}`);
     }
 
     return {

package/src/resources/extensions/gsd/tools/reassess-roadmap.ts

@@ -19,6 +19,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";
 
 export interface SliceChangeInput {
   sliceId: string;
@@ -248,9 +249,8 @@ export async function handleReassessRoadmap(
       );
       try {
         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 as Error).message}`);
       }
     }
 
@@ -271,9 +271,7 @@ export async function handleReassessRoadmap(
         trigger_reason: params.triggerReason,
       });
     } catch (hookErr) {
-      process.stderr.write(
-        `gsd: reassess-roadmap post-mutation hook warning: ${(hookErr as Error).message}\n`,
-      );
+      logWarning("tool", `reassess-roadmap post-mutation hook warning: ${(hookErr as Error).message}`);
     }
 
     return {

package/src/resources/extensions/gsd/tools/reopen-slice.ts

@@ -24,6 +24,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 interface ReopenSliceParams {
   milestoneId: string;
@@ -113,9 +114,7 @@ export async function handleReopenSlice(
       trigger_reason: params.triggerReason,
     });
   } catch (hookErr) {
-    process.stderr.write(
-      `gsd: reopen-slice post-mutation hook warning: ${(hookErr as Error).message}\n`,
-    );
+    logWarning("tool", `reopen-slice post-mutation hook warning: ${(hookErr as Error).message}`);
   }
 
   return {