gsd-pi 2.41.0 → 2.42.0-dev.eedc83f

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

@@ -167,7 +167,9 @@ import {
   buildLoopRemediationSteps,
   reconcileMergeState,
 } from "./auto-recovery.js";
-import { resolveDispatch } from "./auto-dispatch.js";
+import { resolveDispatch, DISPATCH_RULES } from "./auto-dispatch.js";
+import { initRegistry, convertDispatchRules } from "./rule-registry.js";
+import { emitJournalEvent as _emitJournalEvent, type JournalEntry } from "./journal.js";
 import {
   type AutoDashboardData,
   updateProgressWidget as _updateProgressWidget,
@@ -356,6 +358,22 @@ export function isAutoPaused(): boolean {
   return s.paused;
 }
 
+export function setActiveEngineId(id: string | null): void {
+  s.activeEngineId = id;
+}
+
+export function getActiveEngineId(): string | null {
+  return s.activeEngineId;
+}
+
+export function setActiveRunDir(runDir: string | null): void {
+  s.activeRunDir = runDir;
+}
+
+export function getActiveRunDir(): string | null {
+  return s.activeRunDir;
+}
+
 /**
  * Return the model captured at auto-mode start for this session.
  * Used by error-recovery to fall back to the session's own model
@@ -535,6 +553,33 @@ function handleLostSessionLock(
   ctx?.ui.setFooter(undefined);
 }
 
+/**
+ * Lightweight cleanup after autoLoop exits via step-wizard break.
+ *
+ * Unlike stopAuto (which tears down the entire session), this only clears
+ * the stale unit state, progress widget, status badge, and restores CWD so
+ * the dashboard does not show an orphaned timer and the shell is usable.
+ */
+function cleanupAfterLoopExit(ctx: ExtensionContext): void {
+  s.currentUnit = null;
+  s.active = false;
+  clearUnitTimeout();
+
+  ctx.ui.setStatus("gsd-auto", undefined);
+  ctx.ui.setWidget("gsd-progress", undefined);
+  ctx.ui.setFooter(undefined);
+
+  // Restore CWD out of worktree back to original project root
+  if (s.originalBasePath) {
+    s.basePath = s.originalBasePath;
+    try {
+      process.chdir(s.basePath);
+    } catch {
+      /* best-effort */
+    }
+  }
+}
+
 export async function stopAuto(
   ctx?: ExtensionContext,
   pi?: ExtensionAPI,
@@ -753,6 +798,8 @@ export async function pauseAuto(
       stepMode: s.stepMode,
       pausedAt: new Date().toISOString(),
       sessionFile: s.pausedSessionFile,
+      activeEngineId: s.activeEngineId,
+      activeRunDir: s.activeRunDir,
     };
     const runtimeDir = join(gsdRoot(s.originalBasePath || s.basePath), "runtime");
     mkdirSync(runtimeDir, { recursive: true });
@@ -849,6 +896,11 @@ function buildResolver(): WorktreeResolver {
  * This bundles all private functions that autoLoop needs without exporting them.
  */
 function buildLoopDeps(): LoopDeps {
+  // Initialize the unified rule registry with converted dispatch rules.
+  // Must happen before LoopDeps is assembled so facade functions
+  // (resolveDispatch, runPreDispatchHooks, etc.) delegate to the registry.
+  initRegistry(convertDispatchRules(DISPATCH_RULES));
+
   return {
     lockBase,
     buildSnapshotOpts,
@@ -959,6 +1011,9 @@ function buildLoopDeps(): LoopDeps {
         return "";
       }
     },
+
+    // Journal
+    emitJournalEvent: (entry: JournalEntry) => _emitJournalEvent(s.basePath, entry),
   } as unknown as LoopDeps;
 }
 
@@ -981,7 +1036,19 @@ export async function startAuto(
       const pausedPath = join(gsdRoot(base), "runtime", "paused-session.json");
       if (existsSync(pausedPath)) {
         const meta = JSON.parse(readFileSync(pausedPath, "utf-8"));
-        if (meta.milestoneId) {
+        if (meta.activeEngineId && meta.activeEngineId !== "dev") {
+          // Custom workflow resume — restore engine state
+          s.activeEngineId = meta.activeEngineId;
+          s.activeRunDir = meta.activeRunDir ?? null;
+          s.originalBasePath = meta.originalBasePath || base;
+          s.stepMode = meta.stepMode ?? requestedStepMode;
+          s.paused = true;
+          try { unlinkSync(pausedPath); } catch { /* non-fatal */ }
+          ctx.ui.notify(
+            `Resuming paused custom workflow${meta.activeRunDir ? ` (${meta.activeRunDir})` : ""}.`,
+            "info",
+          );
+        } else if (meta.milestoneId) {
           // Validate the milestone still exists and isn't already complete (#1664).
           const mDir = resolveMilestonePath(base, meta.milestoneId);
           const summaryFile = resolveMilestoneFile(base, meta.milestoneId, "SUMMARY");
@@ -1121,6 +1188,7 @@ export async function startAuto(
     await selfHealRuntimeRecords(s.basePath, ctx);
 
     await autoLoop(ctx, pi, s, buildLoopDeps());
+    cleanupAfterLoopExit(ctx);
     return;
   }
 
@@ -1155,6 +1223,7 @@ export async function startAuto(
 
   // Dispatch the first unit
   await autoLoop(ctx, pi, s, buildLoopDeps());
+  cleanupAfterLoopExit(ctx);
 }
 
 // ─── Agent End Handler ────────────────────────────────────────────────────────

package/src/resources/extensions/gsd/bootstrap/db-tools.ts

@@ -5,19 +5,71 @@ import { findMilestoneIds, nextMilestoneId, claimReservedId, getReservedMileston
 import { loadEffectiveGSDPreferences } from "../preferences.js";
 import { ensureDbOpen } from "./dynamic-tools.js";
 
-export function registerDbTools(pi: ExtensionAPI): void {
+/**
+ * Register an alias tool that shares the same execute function as its canonical counterpart.
+ * The alias description and promptGuidelines direct the LLM to prefer the canonical name.
+ */
+function registerAlias(pi: ExtensionAPI, toolDef: any, aliasName: string, canonicalName: string): void {
   pi.registerTool({
-    name: "gsd_save_decision",
+    ...toolDef,
+    name: aliasName,
+    description: toolDef.description + ` (alias for ${canonicalName} — prefer the canonical name)`,
+    promptGuidelines: [`Alias for ${canonicalName} — prefer the canonical name.`],
+  });
+}
+
+export function registerDbTools(pi: ExtensionAPI): void {
+  // ─── gsd_decision_save (formerly gsd_save_decision) ─────────────────────
+
+  const decisionSaveExecute = async (_toolCallId: any, params: any, _signal: any, _onUpdate: any, _ctx: any) => {
+    const dbAvailable = await ensureDbOpen();
+    if (!dbAvailable) {
+      return {
+        content: [{ type: "text" as const, text: "Error: GSD database is not available. Cannot save decision." }],
+        details: { operation: "save_decision", error: "db_unavailable" } as any,
+      };
+    }
+    try {
+      const { saveDecisionToDb } = await import("../db-writer.js");
+      const { id } = await saveDecisionToDb(
+        {
+          scope: params.scope,
+          decision: params.decision,
+          choice: params.choice,
+          rationale: params.rationale,
+          revisable: params.revisable,
+          when_context: params.when_context,
+          made_by: params.made_by,
+        },
+        process.cwd(),
+      );
+      return {
+        content: [{ type: "text" as const, text: `Saved decision ${id}` }],
+        details: { operation: "save_decision", id } as any,
+      };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`gsd-db: gsd_decision_save tool failed: ${msg}\n`);
+      return {
+        content: [{ type: "text" as const, text: `Error saving decision: ${msg}` }],
+        details: { operation: "save_decision", error: msg } as any,
+      };
+    }
+  };
+
+  const decisionSaveTool = {
+    name: "gsd_decision_save",
     label: "Save Decision",
     description:
       "Record a project decision to the GSD database and regenerate DECISIONS.md. " +
       "Decision IDs are auto-assigned — never provide an ID manually.",
     promptSnippet: "Record a project decision to the GSD database (auto-assigns ID, regenerates DECISIONS.md)",
     promptGuidelines: [
-      "Use gsd_save_decision when recording an architectural, pattern, library, or observability decision.",
+      "Use gsd_decision_save when recording an architectural, pattern, library, or observability decision.",
       "Decision IDs are auto-assigned (D001, D002, ...) — never guess or provide an ID.",
-      "All fields except revisable and when_context are required.",
+      "All fields except revisable, when_context, and made_by are required.",
       "The tool writes to the DB and regenerates .gsd/DECISIONS.md automatically.",
+      "Set made_by to 'human' when the user explicitly directed the decision, 'agent' when the LLM chose autonomously (default), or 'collaborative' when it was discussed and agreed together.",
     ],
     parameters: Type.Object({
       scope: Type.String({ description: "Scope of the decision (e.g. 'architecture', 'library', 'observability')" }),
@@ -26,52 +78,69 @@ export function registerDbTools(pi: ExtensionAPI): void {
       rationale: Type.String({ description: "Why this choice was made" }),
       revisable: Type.Optional(Type.String({ description: "Whether this can be revisited (default: 'Yes')" })),
       when_context: Type.Optional(Type.String({ description: "When/context for the decision (e.g. milestone ID)" })),
+      made_by: Type.Optional(Type.Union([
+        Type.Literal("human"),
+        Type.Literal("agent"),
+        Type.Literal("collaborative"),
+      ], { description: "Who made this decision: 'human' (user directed), 'agent' (LLM decided autonomously), or 'collaborative' (discussed and agreed). Default: 'agent'" })),
     }),
-    async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-      const dbAvailable = await ensureDbOpen();
-      if (!dbAvailable) {
-        return {
-          content: [{ type: "text" as const, text: "Error: GSD database is not available. Cannot save decision." }],
-          details: { operation: "save_decision", error: "db_unavailable" } as any,
-        };
-      }
-      try {
-        const { saveDecisionToDb } = await import("../db-writer.js");
-        const { id } = await saveDecisionToDb(
-          {
-            scope: params.scope,
-            decision: params.decision,
-            choice: params.choice,
-            rationale: params.rationale,
-            revisable: params.revisable,
-            when_context: params.when_context,
-          },
-          process.cwd(),
-        );
-        return {
-          content: [{ type: "text" as const, text: `Saved decision ${id}` }],
-          details: { operation: "save_decision", id } as any,
-        };
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        process.stderr.write(`gsd-db: gsd_save_decision tool failed: ${msg}\n`);
+    execute: decisionSaveExecute,
+  };
+
+  pi.registerTool(decisionSaveTool);
+  registerAlias(pi, decisionSaveTool, "gsd_save_decision", "gsd_decision_save");
+
+  // ─── gsd_requirement_update (formerly gsd_update_requirement) ───────────
+
+  const requirementUpdateExecute = async (_toolCallId: any, params: any, _signal: any, _onUpdate: any, _ctx: any) => {
+    const dbAvailable = await ensureDbOpen();
+    if (!dbAvailable) {
+      return {
+        content: [{ type: "text" as const, text: "Error: GSD database is not available. Cannot update requirement." }],
+        details: { operation: "update_requirement", id: params.id, error: "db_unavailable" } as any,
+      };
+    }
+    try {
+      const db = await import("../gsd-db.js");
+      const existing = db.getRequirementById(params.id);
+      if (!existing) {
         return {
-          content: [{ type: "text" as const, text: `Error saving decision: ${msg}` }],
-          details: { operation: "save_decision", error: msg } as any,
+          content: [{ type: "text" as const, text: `Error: Requirement ${params.id} not found.` }],
+          details: { operation: "update_requirement", id: params.id, error: "not_found" } as any,
         };
       }
-    },
-  });
+      const { updateRequirementInDb } = await import("../db-writer.js");
+      const updates: Record<string, string | undefined> = {};
+      if (params.status !== undefined) updates.status = params.status;
+      if (params.validation !== undefined) updates.validation = params.validation;
+      if (params.notes !== undefined) updates.notes = params.notes;
+      if (params.description !== undefined) updates.description = params.description;
+      if (params.primary_owner !== undefined) updates.primary_owner = params.primary_owner;
+      if (params.supporting_slices !== undefined) updates.supporting_slices = params.supporting_slices;
+      await updateRequirementInDb(params.id, updates, process.cwd());
+      return {
+        content: [{ type: "text" as const, text: `Updated requirement ${params.id}` }],
+        details: { operation: "update_requirement", id: params.id } as any,
+      };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`gsd-db: gsd_requirement_update tool failed: ${msg}\n`);
+      return {
+        content: [{ type: "text" as const, text: `Error updating requirement: ${msg}` }],
+        details: { operation: "update_requirement", id: params.id, error: msg } as any,
+      };
+    }
+  };
 
-  pi.registerTool({
-    name: "gsd_update_requirement",
+  const requirementUpdateTool = {
+    name: "gsd_requirement_update",
     label: "Update Requirement",
     description:
       "Update an existing requirement in the GSD database and regenerate REQUIREMENTS.md. " +
       "Provide the requirement ID (e.g. R001) and any fields to update.",
     promptSnippet: "Update an existing GSD requirement by ID (regenerates REQUIREMENTS.md)",
     promptGuidelines: [
-      "Use gsd_update_requirement to change status, validation, notes, or other fields on an existing requirement.",
+      "Use gsd_requirement_update to change status, validation, notes, or other fields on an existing requirement.",
       "The id parameter is required — it must be an existing RXXX identifier.",
       "All other fields are optional — only provided fields are updated.",
       "The tool verifies the requirement exists before updating.",
@@ -85,56 +154,73 @@ export function registerDbTools(pi: ExtensionAPI): void {
       primary_owner: Type.Optional(Type.String({ description: "Primary owning slice" })),
       supporting_slices: Type.Optional(Type.String({ description: "Supporting slices" })),
     }),
-    async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-      const dbAvailable = await ensureDbOpen();
-      if (!dbAvailable) {
-        return {
-          content: [{ type: "text" as const, text: "Error: GSD database is not available. Cannot update requirement." }],
-          details: { operation: "update_requirement", id: params.id, error: "db_unavailable" } as any,
-        };
-      }
-      try {
-        const db = await import("../gsd-db.js");
-        const existing = db.getRequirementById(params.id);
-        if (!existing) {
-          return {
-            content: [{ type: "text" as const, text: `Error: Requirement ${params.id} not found.` }],
-            details: { operation: "update_requirement", id: params.id, error: "not_found" } as any,
-          };
-        }
-        const { updateRequirementInDb } = await import("../db-writer.js");
-        const updates: Record<string, string | undefined> = {};
-        if (params.status !== undefined) updates.status = params.status;
-        if (params.validation !== undefined) updates.validation = params.validation;
-        if (params.notes !== undefined) updates.notes = params.notes;
-        if (params.description !== undefined) updates.description = params.description;
-        if (params.primary_owner !== undefined) updates.primary_owner = params.primary_owner;
-        if (params.supporting_slices !== undefined) updates.supporting_slices = params.supporting_slices;
-        await updateRequirementInDb(params.id, updates, process.cwd());
-        return {
-          content: [{ type: "text" as const, text: `Updated requirement ${params.id}` }],
-          details: { operation: "update_requirement", id: params.id } as any,
-        };
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        process.stderr.write(`gsd-db: gsd_update_requirement tool failed: ${msg}\n`);
-        return {
-          content: [{ type: "text" as const, text: `Error updating requirement: ${msg}` }],
-          details: { operation: "update_requirement", id: params.id, error: msg } as any,
-        };
+    execute: requirementUpdateExecute,
+  };
+
+  pi.registerTool(requirementUpdateTool);
+  registerAlias(pi, requirementUpdateTool, "gsd_update_requirement", "gsd_requirement_update");
+
+  // ─── gsd_summary_save (formerly gsd_save_summary) ──────────────────────
+
+  const summarySaveExecute = async (_toolCallId: any, params: any, _signal: any, _onUpdate: any, _ctx: any) => {
+    const dbAvailable = await ensureDbOpen();
+    if (!dbAvailable) {
+      return {
+        content: [{ type: "text" as const, text: "Error: GSD database is not available. Cannot save artifact." }],
+        details: { operation: "save_summary", error: "db_unavailable" } as any,
+      };
+    }
+    const validTypes = ["SUMMARY", "RESEARCH", "CONTEXT", "ASSESSMENT"];
+    if (!validTypes.includes(params.artifact_type)) {
+      return {
+        content: [{ type: "text" as const, text: `Error: Invalid artifact_type "${params.artifact_type}". Must be one of: ${validTypes.join(", ")}` }],
+        details: { operation: "save_summary", error: "invalid_artifact_type" } as any,
+      };
+    }
+    try {
+      let relativePath: string;
+      if (params.task_id && params.slice_id) {
+        relativePath = `milestones/${params.milestone_id}/slices/${params.slice_id}/tasks/${params.task_id}-${params.artifact_type}.md`;
+      } else if (params.slice_id) {
+        relativePath = `milestones/${params.milestone_id}/slices/${params.slice_id}/${params.slice_id}-${params.artifact_type}.md`;
+      } else {
+        relativePath = `milestones/${params.milestone_id}/${params.milestone_id}-${params.artifact_type}.md`;
       }
-    },
-  });
+      const { saveArtifactToDb } = await import("../db-writer.js");
+      await saveArtifactToDb(
+        {
+          path: relativePath,
+          artifact_type: params.artifact_type,
+          content: params.content,
+          milestone_id: params.milestone_id,
+          slice_id: params.slice_id,
+          task_id: params.task_id,
+        },
+        process.cwd(),
+      );
+      return {
+        content: [{ type: "text" as const, text: `Saved ${params.artifact_type} artifact to ${relativePath}` }],
+        details: { operation: "save_summary", path: relativePath, artifact_type: params.artifact_type } as any,
+      };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`gsd-db: gsd_summary_save tool failed: ${msg}\n`);
+      return {
+        content: [{ type: "text" as const, text: `Error saving artifact: ${msg}` }],
+        details: { operation: "save_summary", error: msg } as any,
+      };
+    }
+  };
 
-  pi.registerTool({
-    name: "gsd_save_summary",
+  const summarySaveTool = {
+    name: "gsd_summary_save",
     label: "Save Summary",
     description:
       "Save a summary, research, context, or assessment artifact to the GSD database and write it to disk. " +
       "Computes the file path from milestone/slice/task IDs automatically.",
     promptSnippet: "Save a GSD artifact (summary/research/context/assessment) to DB and disk",
     promptGuidelines: [
-      "Use gsd_save_summary to persist structured artifacts (SUMMARY, RESEARCH, CONTEXT, ASSESSMENT).",
+      "Use gsd_summary_save to persist structured artifacts (SUMMARY, RESEARCH, CONTEXT, ASSESSMENT).",
       "milestone_id is required. slice_id and task_id are optional — they determine the file path.",
       "The tool computes the relative path automatically: milestones/M001/M001-SUMMARY.md, milestones/M001/slices/S01/S01-SUMMARY.md, etc.",
       "artifact_type must be one of: SUMMARY, RESEARCH, CONTEXT, ASSESSMENT.",
@@ -146,59 +232,46 @@ export function registerDbTools(pi: ExtensionAPI): void {
       artifact_type: Type.String({ description: "One of: SUMMARY, RESEARCH, CONTEXT, ASSESSMENT" }),
       content: Type.String({ description: "The full markdown content of the artifact" }),
     }),
-    async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-      const dbAvailable = await ensureDbOpen();
-      if (!dbAvailable) {
-        return {
-          content: [{ type: "text" as const, text: "Error: GSD database is not available. Cannot save artifact." }],
-          details: { operation: "save_summary", error: "db_unavailable" } as any,
-        };
-      }
-      const validTypes = ["SUMMARY", "RESEARCH", "CONTEXT", "ASSESSMENT"];
-      if (!validTypes.includes(params.artifact_type)) {
-        return {
-          content: [{ type: "text" as const, text: `Error: Invalid artifact_type "${params.artifact_type}". Must be one of: ${validTypes.join(", ")}` }],
-          details: { operation: "save_summary", error: "invalid_artifact_type" } as any,
-        };
-      }
-      try {
-        let relativePath: string;
-        if (params.task_id && params.slice_id) {
-          relativePath = `milestones/${params.milestone_id}/slices/${params.slice_id}/tasks/${params.task_id}-${params.artifact_type}.md`;
-        } else if (params.slice_id) {
-          relativePath = `milestones/${params.milestone_id}/slices/${params.slice_id}/${params.slice_id}-${params.artifact_type}.md`;
-        } else {
-          relativePath = `milestones/${params.milestone_id}/${params.milestone_id}-${params.artifact_type}.md`;
-        }
-        const { saveArtifactToDb } = await import("../db-writer.js");
-        await saveArtifactToDb(
-          {
-            path: relativePath,
-            artifact_type: params.artifact_type,
-            content: params.content,
-            milestone_id: params.milestone_id,
-            slice_id: params.slice_id,
-            task_id: params.task_id,
-          },
-          process.cwd(),
-        );
-        return {
-          content: [{ type: "text" as const, text: `Saved ${params.artifact_type} artifact to ${relativePath}` }],
-          details: { operation: "save_summary", path: relativePath, artifact_type: params.artifact_type } as any,
-        };
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        process.stderr.write(`gsd-db: gsd_save_summary tool failed: ${msg}\n`);
+    execute: summarySaveExecute,
+  };
+
+  pi.registerTool(summarySaveTool);
+  registerAlias(pi, summarySaveTool, "gsd_save_summary", "gsd_summary_save");
+
+  // ─── gsd_milestone_generate_id (formerly gsd_generate_milestone_id) ────
+
+  const milestoneGenerateIdExecute = async (_toolCallId: any, _params: any, _signal: any, _onUpdate: any, _ctx: any) => {
+    try {
+      // Claim a reserved ID if the guided-flow already previewed one to the user.
+      // This guarantees the ID shown in the UI matches the one materialised on disk.
+      const reserved = claimReservedId();
+      if (reserved) {
         return {
-          content: [{ type: "text" as const, text: `Error saving artifact: ${msg}` }],
-          details: { operation: "save_summary", error: msg } as any,
+          content: [{ type: "text" as const, text: reserved }],
+          details: { operation: "generate_milestone_id", id: reserved, source: "reserved" } as any,
         };
       }
-    },
-  });
 
-  pi.registerTool({
-    name: "gsd_generate_milestone_id",
+      const basePath = process.cwd();
+      const existingIds = findMilestoneIds(basePath);
+      const uniqueEnabled = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
+      const allIds = [...new Set([...existingIds, ...getReservedMilestoneIds()])];
+      const newId = nextMilestoneId(allIds, uniqueEnabled);
+      return {
+        content: [{ type: "text" as const, text: newId }],
+        details: { operation: "generate_milestone_id", id: newId, existingCount: existingIds.length, uniqueEnabled } as any,
+      };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return {
+        content: [{ type: "text" as const, text: `Error generating milestone ID: ${msg}` }],
+        details: { operation: "generate_milestone_id", error: msg } as any,
+      };
+    }
+  };
+
+  const milestoneGenerateIdTool = {
+    name: "gsd_milestone_generate_id",
     label: "Generate Milestone ID",
     description:
       "Generate the next milestone ID for a new GSD milestone. " +
@@ -206,41 +279,15 @@ export function registerDbTools(pi: ExtensionAPI): void {
       "Always use this tool when creating a new milestone — never invent milestone IDs manually.",
     promptSnippet: "Generate a valid milestone ID (respects unique_milestone_ids preference)",
     promptGuidelines: [
-      "ALWAYS call gsd_generate_milestone_id before creating a new milestone directory or writing milestone files.",
+      "ALWAYS call gsd_milestone_generate_id before creating a new milestone directory or writing milestone files.",
       "Never invent or hardcode milestone IDs like M001, M002 — always use this tool.",
       "Call it once per milestone you need to create. For multi-milestone projects, call it once for each milestone in sequence.",
       "The tool returns the correct format based on project preferences (e.g. M001 or M001-r5jzab).",
     ],
     parameters: Type.Object({}),
-    async execute(_toolCallId, _params, _signal, _onUpdate, _ctx) {
-      try {
-        // Claim a reserved ID if the guided-flow already previewed one to the user.
-        // This guarantees the ID shown in the UI matches the one materialised on disk.
-        const reserved = claimReservedId();
-        if (reserved) {
-          return {
-            content: [{ type: "text" as const, text: reserved }],
-            details: { operation: "generate_milestone_id", id: reserved, source: "reserved" } as any,
-          };
-        }
-
-        const basePath = process.cwd();
-        const existingIds = findMilestoneIds(basePath);
-        const uniqueEnabled = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
-        const allIds = [...new Set([...existingIds, ...getReservedMilestoneIds()])];
-        const newId = nextMilestoneId(allIds, uniqueEnabled);
-        return {
-          content: [{ type: "text" as const, text: newId }],
-          details: { operation: "generate_milestone_id", id: newId, existingCount: existingIds.length, uniqueEnabled } as any,
-        };
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        return {
-          content: [{ type: "text" as const, text: `Error generating milestone ID: ${msg}` }],
-          details: { operation: "generate_milestone_id", error: msg } as any,
-        };
-      }
-    },
-  });
-}
+    execute: milestoneGenerateIdExecute,
+  };
 
+  pi.registerTool(milestoneGenerateIdTool);
+  registerAlias(pi, milestoneGenerateIdTool, "gsd_generate_milestone_id", "gsd_milestone_generate_id");
+}

package/src/resources/extensions/gsd/bootstrap/journal-tools.ts

@@ -0,0 +1,62 @@
+import { Type } from "@sinclair/typebox";
+import type { ExtensionAPI } from "@gsd/pi-coding-agent";
+
+import { queryJournal } from "../journal.js";
+
+export function registerJournalTools(pi: ExtensionAPI): void {
+  pi.registerTool({
+    name: "gsd_journal_query",
+    label: "Query Journal",
+    description:
+      "Query the structured event journal for auto-mode iterations. " +
+      "Returns matching journal entries filtered by flow ID, unit ID, rule name, event type, or time range.",
+    promptSnippet: "Query the GSD event journal with filters (flowId, unitId, rule, eventType, time range, limit)",
+    promptGuidelines: [
+      "Filter by flowId to trace all events from a single auto-mode iteration.",
+      "Filter by unitId to reconstruct the causal chain for a specific milestone/slice/task.",
+      "Use limit to control context size — default is 100 entries.",
+    ],
+    parameters: Type.Object({
+      flowId: Type.Optional(Type.String({ description: "Filter by flow ID (UUID grouping one iteration)" })),
+      unitId: Type.Optional(Type.String({ description: "Filter by unit ID (e.g. M001/S01/T01) from event data" })),
+      rule: Type.Optional(Type.String({ description: "Filter by rule name from the unified registry" })),
+      eventType: Type.Optional(Type.String({ description: "Filter by event type (e.g. dispatch-match, unit-start)" })),
+      after: Type.Optional(Type.String({ description: "ISO-8601 lower bound (inclusive)" })),
+      before: Type.Optional(Type.String({ description: "ISO-8601 upper bound (inclusive)" })),
+      limit: Type.Optional(Type.Number({ description: "Maximum entries to return (default: 100)", default: 100 })),
+    }),
+    async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+      try {
+        const filters: Record<string, string | undefined> = {};
+        if (params.flowId !== undefined) filters.flowId = params.flowId;
+        if (params.unitId !== undefined) filters.unitId = params.unitId;
+        if (params.rule !== undefined) filters.rule = params.rule;
+        if (params.eventType !== undefined) filters.eventType = params.eventType;
+        if (params.after !== undefined) filters.after = params.after;
+        if (params.before !== undefined) filters.before = params.before;
+
+        const entries = queryJournal(process.cwd(), filters);
+        const limited = entries.slice(0, params.limit ?? 100);
+
+        if (limited.length === 0) {
+          return {
+            content: [{ type: "text" as const, text: "No matching journal entries found." }],
+            details: { operation: "journal_query", count: 0 } as any,
+          };
+        }
+
+        return {
+          content: [{ type: "text" as const, text: JSON.stringify(limited, null, 2) }],
+          details: { operation: "journal_query", count: limited.length } as any,
+        };
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`gsd-journal: gsd_journal_query tool failed: ${msg}\n`);
+        return {
+          content: [{ type: "text" as const, text: `Error querying journal: ${msg}` }],
+          details: { operation: "journal_query", error: msg } as any,
+        };
+      }
+    },
+  });
+}

package/src/resources/extensions/gsd/bootstrap/register-extension.ts

@@ -5,6 +5,7 @@ import { registerExitCommand } from "../exit-command.js";
 import { registerWorktreeCommand } from "../worktree-command.js";
 import { registerDbTools } from "./db-tools.js";
 import { registerDynamicTools } from "./dynamic-tools.js";
+import { registerJournalTools } from "./journal-tools.js";
 import { registerHooks } from "./register-hooks.js";
 import { registerShortcuts } from "./register-shortcuts.js";
 
@@ -40,6 +41,7 @@ export function registerGsdExtension(pi: ExtensionAPI): void {
 
   registerDynamicTools(pi);
   registerDbTools(pi);
+  registerJournalTools(pi);
   registerShortcuts(pi);
   registerHooks(pi);
 }