gsd-pi 2.59.0 → 2.60.0-dev.2580e65

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 {

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

@@ -22,6 +22,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 ReopenTaskParams {
   milestoneId: string;
@@ -117,9 +118,7 @@ export async function handleReopenTask(
       trigger_reason: params.triggerReason,
     });
   } catch (hookErr) {
-    process.stderr.write(
-      `gsd: reopen-task post-mutation hook warning: ${(hookErr as Error).message}\n`,
-    );
+    logWarning("tool", `reopen-task post-mutation hook warning: ${(hookErr as Error).message}`);
   }
 
   return {

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

@@ -16,6 +16,7 @@ import { renderPlanFromDb, renderReplanFromDb } 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 ReplanSliceTaskInput {
   taskId: string;
@@ -226,9 +227,7 @@ export async function handleReplanSlice(
         trigger_reason: params.triggerReason,
       });
     } catch (hookErr) {
-      process.stderr.write(
-        `gsd: replan-slice post-mutation hook warning: ${(hookErr as Error).message}\n`,
-      );
+      logWarning("tool", `replan-slice post-mutation hook warning: ${(hookErr as Error).message}`);
     }
 
     return {

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

@@ -22,6 +22,7 @@ import { saveFile, clearParseCache } from "../files.js";
 import { invalidateStateCache } from "../state.js";
 import { VALIDATION_VERDICTS, isValidMilestoneVerdict } from "../verdict-parser.js";
 import { insertMilestoneValidationGates } from "../milestone-validation-gates.js";
+import { logWarning } from "../workflow-logger.js";
 
 export interface ValidateMilestoneParams {
   milestoneId: string;
@@ -137,9 +138,7 @@ export async function handleValidateMilestone(
   try {
     await saveFile(validationPath, validationMd);
   } catch (renderErr) {
-    process.stderr.write(
-      `gsd-db: validate_milestone — disk render failed, rolling back DB row: ${(renderErr as Error).message}\n`,
-    );
+    logWarning("tool", `validate_milestone — disk render failed, rolling back DB row: ${(renderErr as Error).message}`);
     deleteAssessmentByScope(params.milestoneId, 'milestone-validation');
     return { error: `disk render failed: ${(renderErr as Error).message}` };
   }

package/src/resources/extensions/gsd/triage-resolution.ts

@@ -10,7 +10,7 @@
  * Also provides detectFileOverlap() for surfacing downstream impact on quick tasks.
  */
 
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
 import { createRequire } from "node:module";
 import { gsdRoot, milestonesDir } from "./paths.js";
@@ -129,6 +129,136 @@ export function executeReplan(
   }
 }
 
+// ─── Backtrack (Milestone Regression) ────────────────────────────────────────
+
+/**
+ * Execute a backtrack directive — user wants to abandon current milestone
+ * and return to a previous one (milestone regression).
+ *
+ * Writes a BACKTRACK-TRIGGER.md marker at `.gsd/BACKTRACK-TRIGGER.md` with
+ * the target milestone, reason, and timestamp. The state machine (deriveState)
+ * detects this and transitions the project to the target milestone, resetting
+ * its slices to allow re-planning.
+ *
+ * Returns the extracted target milestone ID, or null if extraction failed.
+ */
+export function executeBacktrack(
+  basePath: string,
+  currentMilestoneId: string,
+  capture: CaptureEntry,
+): string | null {
+  try {
+    // Extract target milestone from capture text or resolution.
+    // Filter out the current milestone ID to avoid picking it as the backtrack target
+    // when the text mentions both current and target milestones (e.g. "backtrack from M004 to M003").
+    const sourceText = capture.resolution ?? capture.text;
+    const allMatches = [...sourceText.matchAll(/\b(M\d{3}(?:-[a-z0-9]{6})?)\b/g)]
+      .map(m => m[1])
+      .filter(id => id !== currentMilestoneId);
+    // Reject ambiguous multi-target strings — if more than one distinct target remains,
+    // don't guess; let the user clarify.
+    const uniqueTargets = [...new Set(allMatches)];
+    const targetMilestoneId = uniqueTargets.length === 1 ? uniqueTargets[0] : null;
+
+    const ts = new Date().toISOString();
+    const triggerPath = join(gsdRoot(basePath), "BACKTRACK-TRIGGER.md");
+    const content = [
+      `# Backtrack Trigger`,
+      ``,
+      `**Source:** Capture ${capture.id}`,
+      `**Capture:** ${capture.text}`,
+      `**Rationale:** ${capture.rationale ?? "User-initiated milestone backtrack"}`,
+      `**From:** ${currentMilestoneId}`,
+      `**Target:** ${targetMilestoneId ?? "(user to specify)"}`,
+      `**Triggered:** ${ts}`,
+      ``,
+      `Auto-mode was paused by this backtrack directive. The user directed`,
+      `that the current milestone (${currentMilestoneId}) be abandoned and work`,
+      `should return to ${targetMilestoneId ?? "a previous milestone"}.`,
+      ``,
+      `## Recovery Steps`,
+      ``,
+      `1. Review what went wrong in ${currentMilestoneId}`,
+      `2. Identify missing features/requirements from the target milestone`,
+      `3. Resume auto-mode — the state machine will re-enter discussion for the target`,
+    ].join("\n");
+
+    writeFileSync(triggerPath, content, "utf-8");
+
+    // If we have a valid target, also reset that milestone's completion status
+    // so deriveState() will re-enter it as the active milestone.
+    if (targetMilestoneId) {
+      try {
+        const targetDir = join(milestonesDir(basePath), targetMilestoneId);
+        if (existsSync(targetDir)) {
+          // Write a regression marker so the state machine knows this milestone
+          // needs re-discussion, not just re-execution
+          const regressionPath = join(targetDir, `${targetMilestoneId}-REGRESSION.md`);
+          writeFileSync(regressionPath, [
+            `# Milestone Regression`,
+            ``,
+            `**From:** ${currentMilestoneId}`,
+            `**Reason:** ${capture.text}`,
+            `**Triggered:** ${ts}`,
+            ``,
+            `This milestone is being revisited because downstream milestone`,
+            `${currentMilestoneId} failed or missed critical features that should`,
+            `have been part of this milestone's scope.`,
+            ``,
+            `The discuss phase should re-evaluate requirements and identify gaps.`,
+          ].join("\n"), "utf-8");
+        }
+      } catch { /* best-effort */ }
+    }
+
+    return targetMilestoneId;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Read the backtrack trigger file if it exists.
+ * Returns the parsed target milestone and metadata, or null.
+ */
+export function readBacktrackTrigger(basePath: string): {
+  target: string | null;
+  from: string | null;
+  capture: string;
+  triggeredAt: string;
+} | null {
+  const triggerPath = join(gsdRoot(basePath), "BACKTRACK-TRIGGER.md");
+  if (!existsSync(triggerPath)) return null;
+
+  try {
+    const content = readFileSync(triggerPath, "utf-8");
+    const target = content.match(/\*\*Target:\*\*\s*(.+)/)?.[1]?.trim() ?? null;
+    const from = content.match(/\*\*From:\*\*\s*(.+)/)?.[1]?.trim() ?? null;
+    const capture = content.match(/\*\*Capture:\*\*\s*(.+)/)?.[1]?.trim() ?? "";
+    const triggeredAt = content.match(/\*\*Triggered:\*\*\s*(.+)/)?.[1]?.trim() ?? "";
+    return {
+      target: target === "(user to specify)" ? null : target,
+      from,
+      capture,
+      triggeredAt,
+    };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Remove the backtrack trigger after it has been processed.
+ */
+export function clearBacktrackTrigger(basePath: string): void {
+  const triggerPath = join(gsdRoot(basePath), "BACKTRACK-TRIGGER.md");
+  try {
+    if (existsSync(triggerPath)) {
+      unlinkSync(triggerPath);
+    }
+  } catch { /* best-effort */ }
+}
+
 // ─── File Overlap Detection ───────────────────────────────────────────────────
 
 /**
@@ -298,6 +428,10 @@ export interface TriageExecutionResult {
   deferredMilestones: number;
   /** Captures classified as quick-task that need dispatch */
   quickTasks: CaptureEntry[];
+  /** Number of stop directives (will pause auto-mode via guard) */
+  stopped: number;
+  /** Backtrack captures (will trigger milestone regression via guard) */
+  backtracks: CaptureEntry[];
   /** Details of each action taken, for logging */
   actions: string[];
 }
@@ -326,6 +460,8 @@ export function executeTriageResolutions(
     replanned: 0,
     deferredMilestones: 0,
     quickTasks: [],
+    stopped: 0,
+    backtracks: [],
     actions: [],
   };
 
@@ -409,5 +545,19 @@ export function executeTriageResolutions(
     }
   }
 
+  // Count stop/backtrack captures — these are handled by the pre-dispatch guard
+  // in runGuards(), not here. We just report them for logging purposes.
+  const allCaptures = loadAllCaptures(basePath);
+  for (const cap of allCaptures) {
+    if (cap.status !== "resolved" || cap.executed) continue;
+    if (cap.classification === "stop") {
+      result.stopped++;
+      result.actions.push(`Stop directive from ${cap.id}: "${cap.text}" — will pause on next dispatch`);
+    } else if (cap.classification === "backtrack") {
+      result.backtracks.push(cap);
+      result.actions.push(`Backtrack directive from ${cap.id}: "${cap.text}" — will trigger milestone regression on next dispatch`);
+    }
+  }
+
   return result;
 }

package/src/resources/extensions/gsd/triage-ui.ts

@@ -49,10 +49,18 @@ const CLASSIFICATION_LABELS: Record<Classification, { label: string; description
     label: "Note",
     description: "Informational only — no action needed.",
   },
+  "stop": {
+    label: "Stop",
+    description: "Halt auto-mode immediately — user directive to cease execution.",
+  },
+  "backtrack": {
+    label: "Backtrack",
+    description: "Abandon current milestone and return to a previous one.",
+  },
 };
 
 const ALL_CLASSIFICATIONS: Classification[] = [
-  "quick-task", "inject", "defer", "replan", "note",
+  "quick-task", "inject", "defer", "replan", "note", "stop", "backtrack",
 ];
 
 // ─── Public API ───────────────────────────────────────────────────────────────
@@ -83,8 +91,9 @@ export async function showTriageConfirmation(
     const capture = captureMap.get(result.captureId);
     if (!capture) continue;
 
-    // Auto-confirm note and defer — low-impact, no plan modification
-    if (result.classification === "note" || result.classification === "defer") {
+    // Auto-confirm note, defer, stop, and backtrack — low-impact or urgent directives
+    if (result.classification === "note" || result.classification === "defer"
+      || result.classification === "stop" || result.classification === "backtrack") {
       const resolution = result.classification === "note"
         ? "acknowledged as note"
         : `deferred${result.targetSlice ? ` to ${result.targetSlice}` : ""}`;

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

@@ -316,6 +316,7 @@ export interface ClassificationResult {
   tier: ComplexityTier;
   reason: string;
   downgraded: boolean;
+  taskMetadata?: TaskMetadata;
 }
 
 export interface TaskMetadata {

package/src/resources/extensions/gsd/workflow-events.ts

@@ -2,6 +2,7 @@ import { createHash, randomUUID } from "node:crypto";
 import { appendFileSync, readFileSync, existsSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { atomicWriteSync } from "./atomic-write.js";
+import { logWarning } from "./workflow-logger.js";
 
 // ─── Session ID ───────────────────────────────────────────────────────────
 
@@ -74,7 +75,7 @@ export function readEvents(logPath: string): WorkflowEvent[] {
     try {
       events.push(JSON.parse(line) as WorkflowEvent);
     } catch {
-      process.stderr.write(`workflow-events: skipping corrupted event line: ${line.slice(0, 80)}\n`);
+      logWarning("event-log", `skipping corrupted event line (${line.length} bytes)`);
     }
   }
 

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

@@ -2,7 +2,9 @@
 // Centralized warning/error accumulator for the workflow engine pipeline.
 // Captures structured entries that the auto-loop can drain after each unit
 // to surface root causes for stuck loops, silent degradation, and blocked writes.
-// All entries are also persisted to .gsd/audit-log.jsonl for post-mortem analysis.
+// Error-severity entries are persisted to .gsd/audit-log.jsonl (sanitized) for
+// post-mortem analysis. Warnings are ephemeral (stderr + buffer only) to avoid
+// log amplification from expected-control-flow catch paths.
 //
 // Stderr policy: every logWarning/logError call writes immediately to stderr
 // for terminal visibility. This is intentional — unlike debug-logger (which is
@@ -33,7 +35,20 @@ export type LogComponent =
   | "compaction"    // Event compaction
   | "reconcile"     // Worktree reconciliation
   | "db"            // Database operations (gsd-db)
-  | "dispatch";     // Auto-dispatch rule evaluation
+  | "dispatch"      // Auto-dispatch rule evaluation
+  | "recovery"      // Auto-recovery and timeout recovery
+  | "session"       // Session lock and session state I/O
+  | "prompt"        // Prompt construction and context injection
+  | "dashboard"     // Auto-dashboard rendering
+  | "timer"         // Auto-timers (idle watchdog, hard timeout)
+  | "worktree"      // Worktree lifecycle (create, sync, merge)
+  | "command"       // Slash command execution and maintenance
+  | "parallel"      // Parallel orchestrator and merge
+  | "fs"            // Safe filesystem operations
+  | "bootstrap"     // Extension bootstrap (system-context, agent-end)
+  | "guided"        // Guided flow (discuss, plan wizards)
+  | "registry"      // Rule registry hook state
+  | "renderer";     // Markdown renderer and projections
 
 export interface LogEntry {
   ts: string;
@@ -230,15 +245,47 @@ function _push(
     _buffer.shift();
   }
 
-  // Persist to .gsd/audit-log.jsonl so entries survive context resets
-  if (_auditBasePath) {
+  // Persist errors to .gsd/audit-log.jsonl so they survive context resets.
+  // Only error-severity entries are persisted — warnings are ephemeral (stderr + buffer)
+  // to avoid log amplification from expected-control-flow catch paths.
+  if (_auditBasePath && severity === "error") {
     try {
       const auditDir = join(_auditBasePath, ".gsd");
       mkdirSync(auditDir, { recursive: true });
-      appendFileSync(join(auditDir, "audit-log.jsonl"), JSON.stringify(entry) + "\n", "utf-8");
+      const sanitized = _sanitizeForAudit(entry);
+      appendFileSync(join(auditDir, "audit-log.jsonl"), JSON.stringify(sanitized) + "\n", "utf-8");
     } catch (auditErr) {
       // Best-effort — never let audit write failures bubble up
       process.stderr.write(`[gsd:audit] failed to persist log entry: ${(auditErr as Error).message}\n`);
     }
   }
 }
+
+/**
+ * Sanitize a log entry before persisting to the audit JSONL file.
+ * Strips potentially sensitive context (raw paths, cwd, full error text)
+ * to avoid leaking local environment details into durable telemetry.
+ */
+function _sanitizeForAudit(entry: LogEntry): LogEntry {
+  const sanitized: LogEntry = {
+    ts: entry.ts,
+    severity: entry.severity,
+    component: entry.component,
+    // Truncate message to avoid persisting oversized raw error dumps
+    message: entry.message.length > 200 ? entry.message.slice(0, 200) + "…[truncated]" : entry.message,
+  };
+  if (entry.context) {
+    // Allowlist: only persist known-safe structured keys
+    const SAFE_KEYS = new Set(["fn", "tool", "mid", "sid", "tid", "worktree"]);
+    const filtered: Record<string, string> = {};
+    for (const [k, v] of Object.entries(entry.context)) {
+      if (SAFE_KEYS.has(k)) {
+        filtered[k] = v;
+      }
+    }
+    if (Object.keys(filtered).length > 0) {
+      sanitized.context = filtered;
+    }
+  }
+  return sanitized;
+}