@opengsd/gsd-pi 1.0.1 → 1.0.2-dev.0ee79e5

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

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Verifies auto-mode artifacts and manages recovery placeholders.
 /**
  * Auto-mode Recovery — artifact resolution, verification, blocker placeholders,
@@ -15,7 +15,7 @@ import { appendEvent } from "./workflow-events.js";
 import { atomicWriteSync } from "./atomic-write.js";
 import { clearParseCache } from "./files.js";
 import { parseRoadmap as parseLegacyRoadmap, parsePlan as parseLegacyPlan } from "./parsers-legacy.js";
-import { isDbAvailable, getTask, getSlice, getSliceTasks, getPendingGates, updateTaskStatus, updateSliceStatus, insertSlice, getMilestone, getMilestoneSlices, getLatestAssessmentByScope, updateMilestoneStatus, refreshOpenDatabaseFromDisk, getCompletedMilestoneTaskFileHints, getMilestoneCommitAttributionShas, recordMilestoneCommitAttribution } from "./gsd-db.js";
+import { isDbAvailable, getTask, getSlice, getSliceTasks, getPendingGates, updateTaskStatus, updateSliceStatus, insertSlice, getMilestone, getMilestoneSlices, getLatestAssessmentByScope, updateMilestoneStatus, refreshOpenDatabaseFromDisk, getCompletedMilestoneTaskFileHints, getMilestoneCommitAttributionShas, recordMilestoneCommitAttribution, transaction } from "./gsd-db.js";
 import { isValidationTerminal } from "./state.js";
 import { getErrorMessage } from "./error-utils.js";
 import { logWarning, logError } from "./workflow-logger.js";
@@ -40,6 +40,9 @@ import {
   writeFileSync,
 } from "node:fs";
 import { execFileSync } from "node:child_process";
+
+/** Large enough for unbounded milestone-history git log scans in big repos. */
+const GIT_LOG_MAX_BUFFER = 16 * 1024 * 1024;
 import { dirname, join } from "node:path";
 import {
   resolveExpectedArtifactPath,
@@ -409,7 +412,7 @@ function getChangedFilesSinceBranch(basePath: string, targetBranch: string): { o
     if (mergeBase) {
       const result = execFileSync(
         "git", ["diff", "--name-only", mergeBase, "HEAD"],
-        { cwd: basePath, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" },
+        { cwd: basePath, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8", maxBuffer: GIT_LOG_MAX_BUFFER },
       ).trim();
       return { ok: true, files: result ? result.split("\n").filter(Boolean) : [] };
     }
@@ -568,6 +571,7 @@ function getCommitRecords(basePath: string): Array<{ hash: string; parents: stri
     cwd: basePath,
     stdio: ["ignore", "pipe", "pipe"],
     encoding: "utf-8",
+    maxBuffer: GIT_LOG_MAX_BUFFER,
   });
   return logOutput
     .split("\x1e")
@@ -595,6 +599,7 @@ function scanGsdTaggedCommits(
       cwd: basePath,
       stdio: ["ignore", "pipe", "pipe"],
       encoding: "utf-8",
+      maxBuffer: GIT_LOG_MAX_BUFFER,
     });
     const records = logOutput
       .split("\x1e")
@@ -781,6 +786,10 @@ export function verifyExpectedArtifact(
   if (unitType === "reactive-execute") {
     const { milestone: mid, slice: sid, task: batchPart } = parseUnitId(unitId);
     if (!mid || !sid || !batchPart) return false;
+    const blockerPath = resolveExpectedArtifactPath(unitType, unitId, base);
+    if (blockerPath && existsSync(blockerPath)) {
+      return true;
+    }
     const plusIdx = batchPart.indexOf("+");
     if (plusIdx === -1) {
       // Legacy format "reactive" without batch IDs — fall back to "any summary"
@@ -1066,6 +1075,126 @@ export function verifyExpectedArtifact(
   return true;
 }
 
+export interface ReactiveExecuteBlockerRecovery {
+  blockerPath: string;
+  completedTaskIds: string[];
+  skippedTaskIds: string[];
+  unchangedTaskIds: string[];
+}
+
+/**
+ * Terminal recovery for a failed reactive-execute batch.
+ *
+ * Summary-present tasks are reconciled closed as complete; missing-summary
+ * tasks are closed as skipped. The slice-level blocker sentinel makes the
+ * failed batch terminal without fabricating per-task summaries.
+ */
+export function writeReactiveExecuteBlocker(
+  unitId: string,
+  base: string,
+  reason: string,
+): ReactiveExecuteBlockerRecovery | null {
+  if (!isDbAvailable()) return null;
+
+  const { milestone: mid, slice: sid, task: batchPart } = parseUnitId(unitId);
+  if (!mid || !sid || !batchPart) return null;
+
+  const plusIdx = batchPart.indexOf("+");
+  if (plusIdx === -1) return null;
+  const batchIds = batchPart.slice(plusIdx + 1).split(",").map((id) => id.trim()).filter(Boolean);
+  if (batchIds.length === 0) return null;
+
+  const blockerPath = resolveExpectedArtifactPath("reactive-execute", unitId, base);
+  if (!blockerPath) return null;
+
+  const tasksDir = resolveTasksDir(base, mid, sid);
+  const existingSummaries = new Set(
+    tasksDir
+      ? resolveTaskFiles(tasksDir, "SUMMARY").map((f) => f.replace(/-SUMMARY\.md$/i, "").toUpperCase())
+      : [],
+  );
+
+  const summaryPresent = batchIds.filter((tid) => existingSummaries.has(tid.toUpperCase()));
+  const summaryMissing = batchIds.filter((tid) => !existingSummaries.has(tid.toUpperCase()));
+  const completedTaskIds: string[] = [];
+  const skippedTaskIds: string[] = [];
+  const unchangedTaskIds: string[] = [];
+  const ts = new Date().toISOString();
+
+  transaction(() => {
+    for (const tid of summaryPresent) {
+      const task = getTask(mid, sid, tid);
+      if (!task || isClosedStatus(task.status)) {
+        unchangedTaskIds.push(tid);
+        continue;
+      }
+      updateTaskStatus(mid, sid, tid, "complete", ts);
+      completedTaskIds.push(tid);
+    }
+    for (const tid of summaryMissing) {
+      const task = getTask(mid, sid, tid);
+      if (!task || isClosedStatus(task.status)) {
+        unchangedTaskIds.push(tid);
+        continue;
+      }
+      updateTaskStatus(mid, sid, tid, "skipped", ts);
+      skippedTaskIds.push(tid);
+    }
+  });
+
+  const dir = dirname(blockerPath);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  const content = [
+    "# BLOCKER — reactive-execute batch recovery",
+    "",
+    `Unit \`reactive-execute\` for \`${unitId}\` failed to produce all task summaries after verification retries were exhausted.`,
+    "",
+    `**Reason**: ${reason}`,
+    "",
+    `**Batch tasks**: ${batchIds.join(", ")}`,
+    `**Summary present**: ${summaryPresent.length > 0 ? summaryPresent.join(", ") : "none"}`,
+    `**Summary missing**: ${summaryMissing.length > 0 ? summaryMissing.join(", ") : "none"}`,
+    `**Marked complete**: ${completedTaskIds.length > 0 ? completedTaskIds.join(", ") : "none"}`,
+    `**Marked skipped**: ${skippedTaskIds.length > 0 ? skippedTaskIds.join(", ") : "none"}`,
+    "",
+    "This placeholder was written by auto-mode so the pipeline can advance without re-dispatching the same reactive batch.",
+    "Review skipped tasks before relying on downstream artifacts.",
+  ].join("\n");
+  writeFileSync(blockerPath, content, "utf-8");
+
+  for (const tid of completedTaskIds) {
+    try {
+      appendEvent(base, {
+        cmd: "complete-task",
+        params: { milestoneId: mid, sliceId: sid, taskId: tid },
+        ts,
+        actor: "system",
+        trigger_reason: "reactive-execute-blocker-recovery",
+      });
+    } catch (e) {
+      logWarning("recovery", `appendEvent failed for reactive complete recovery: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
+  for (const tid of skippedTaskIds) {
+    try {
+      appendEvent(base, {
+        cmd: "skip-task",
+        params: { milestoneId: mid, sliceId: sid, taskId: tid },
+        ts,
+        actor: "system",
+        trigger_reason: "reactive-execute-blocker-recovery",
+      });
+    } catch (e) {
+      logWarning("recovery", `appendEvent failed for reactive skip recovery: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
+
+  clearPathCache();
+  clearParseCache();
+
+  return { blockerPath, completedTaskIds, skippedTaskIds, unchangedTaskIds };
+}
+
 /**
  * Write a placeholder artifact so the pipeline can advance past a stuck unit.
  * Returns the relative path written, or null if the path couldn't be resolved.

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

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Auto-mode bootstrap, worktree recovery, and fresh-start initialization.
 /**
  * Auto-mode bootstrap — fresh-start initialization path.

package/src/resources/extensions/gsd/auto-status-message.ts

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Compact connected status message formatting for GSD TUI notifications.
 
 const STATUS_INDENT = "    ";

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

@@ -23,6 +23,7 @@ import { closeoutUnit, type CloseoutOptions } from "./auto-unit-closeout.js";
 import { saveActivityLog } from "./activity-log.js";
 import { recoverTimedOutUnit, type RecoveryContext } from "./auto-timeout-recovery.js";
 import { resolveAgentEndCancelled } from "./auto/resolve.js";
+import type { PauseAutoOptions } from "./auto/loop-deps.js";
 import type { AutoSession } from "./auto/session.js";
 import { logWarning, logError } from "./workflow-logger.js";
 
@@ -35,7 +36,7 @@ export interface SupervisionContext {
   prefs: GSDPreferences | undefined;
   buildSnapshotOpts: () => CloseoutOptions & Record<string, unknown>;
   buildRecoveryContext: () => RecoveryContext;
-  pauseAuto: (ctx?: ExtensionContext, pi?: ExtensionAPI) => Promise<void>;
+  pauseAuto: (ctx?: ExtensionContext, pi?: ExtensionAPI, errorContext?: undefined, options?: PauseAutoOptions) => Promise<void>;
   /** Optional task estimate string (e.g. "30m", "2h") for timeout scaling (#2243). */
   taskEstimate?: string;
 }
@@ -113,7 +114,7 @@ export function startUnitSupervision(sctx: SupervisionContext): void {
   // If the task has an est: annotation, use it to extend the hard and soft timeouts
   // so longer tasks don't get prematurely timed out.
   let taskEstimate = sctx.taskEstimate;
-  if (!taskEstimate && unitType === "task" && isDbAvailable()) {
+  if (!taskEstimate && unitType === "execute-task" && isDbAvailable()) {
     // Look up the task estimate from the DB (#2243).
     try {
       if (s.currentMilestoneId) {
@@ -181,6 +182,11 @@ export function startUnitSupervision(sctx: SupervisionContext): void {
   s.idleWatchdogHandle = setInterval(async () => {
     try {
       if (!s.active || !s.currentUnit) return;
+      const expectedCurrentUnit = {
+        type: s.currentUnit.type,
+        id: s.currentUnit.id,
+        startedAt: s.currentUnit.startedAt,
+      };
       const runtime = readUnitRuntimeRecord(s.basePath, unitType, unitId);
       if (!runtime) return;
       if (Date.now() - runtime.lastProgressAt < idleTimeoutMs) return;
@@ -250,7 +256,7 @@ export function startUnitSupervision(sctx: SupervisionContext): void {
         `Unit ${unitType} ${unitId} made no meaningful progress for ${supervisor.idle_timeout_minutes}min. Pausing auto-mode.`,
         "warning",
       );
-      await pauseAuto(ctx, pi);
+      await pauseAuto(ctx, pi, undefined, { expectedCurrentUnit });
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       logError("timer", `[idle-watchdog] Unhandled error: ${message}`);
@@ -269,6 +275,9 @@ export function startUnitSupervision(sctx: SupervisionContext): void {
     try {
       s.unitTimeoutHandle = null;
       if (!s.active) return;
+      const expectedCurrentUnit = s.currentUnit
+        ? { type: s.currentUnit.type, id: s.currentUnit.id, startedAt: s.currentUnit.startedAt }
+        : null;
       if (s.currentUnit) {
         writeUnitRuntimeRecord(s.basePath, unitType, unitId, s.currentUnit.startedAt, {
           phase: "timeout",
@@ -286,7 +295,7 @@ export function startUnitSupervision(sctx: SupervisionContext): void {
         `Unit ${unitType} ${unitId} exceeded ${supervisor.hard_timeout_minutes}min hard timeout. Pausing auto-mode.`,
         "warning",
       );
-      await pauseAuto(ctx, pi);
+      await pauseAuto(ctx, pi, undefined, { expectedCurrentUnit });
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       logError("timer", `[hard-timeout] Unhandled error: ${message}`);

package/src/resources/extensions/gsd/auto-unit-closeout.ts

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Auto-mode unit closeout metrics, activity capture, and ghost-run detection.
 
 /**

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

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Post-unit verification gate for GSD auto-mode units.
 
 /**

package/src/resources/extensions/gsd/auto-worktree-repair.ts

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Helpers for safe auto-mode milestone worktree repair decisions.
 
 import { existsSync, lstatSync, readdirSync, type Stats } from "node:fs";

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

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Auto-mode worktree lifecycle, merge, and cleanup management.
 
 /**

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

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Auto-mode orchestration, session lifecycle, and stop handling.
 /**
  * GSD Auto Mode — Fresh Session Per Unit
@@ -241,7 +241,7 @@ import { bootstrapAutoSession, openProjectDbIfPresent, type BootstrapDeps } from
 import { initHealthWidget } from "./health-widget.js";
 import { runLegacyAutoLoop, runUokKernelLoop } from "./auto/loop.js";
 import { resolveAgentEnd, resolveAgentEndCancelled, _resetPendingResolve, isSessionSwitchInFlight } from "./auto/resolve.js";
-import type { LoopDeps, StopAutoOptions } from "./auto/loop-deps.js";
+import type { LoopDeps, PauseAutoOptions, PauseAutoUnitIdentity, StopAutoOptions } from "./auto/loop-deps.js";
 import type { ErrorContext } from "./auto/types.js";
 import { runAutoLoopWithUok } from "./uok/kernel.js";
 import { resolveUokFlags } from "./uok/flags.js";
@@ -1039,6 +1039,23 @@ function currentUnitLabel(): string | null {
   return `${unitVerb(s.currentUnit.type)} ${s.currentUnit.id}`;
 }
 
+export function capturePauseAutoUnitIdentity(): PauseAutoUnitIdentity | null {
+  if (!s.currentUnit) return null;
+  return {
+    type: s.currentUnit.type,
+    id: s.currentUnit.id,
+    startedAt: s.currentUnit.startedAt,
+  };
+}
+
+function pauseAutoUnitIdentityMatches(expected: PauseAutoUnitIdentity | null): boolean {
+  if (!s.currentUnit) return expected === null;
+  return expected !== null &&
+    s.currentUnit.type === expected.type &&
+    s.currentUnit.id === expected.id &&
+    s.currentUnit.startedAt === expected.startedAt;
+}
+
 function setLifecycleOutcome(
   ctx: ExtensionContext | undefined,
   input: {
@@ -1714,7 +1731,7 @@ export async function stopAuto(
     // Drop the active-tool baseline so a subsequent /gsd auto run on the
     // same `pi` instance recaptures from the live tool set rather than
     // restoring this session's snapshot and silently undoing any tool
-    // changes the user made between sessions (#4959 / CodeRabbit).
+    // changes the user made between sessions (#4959).
     if (pi) clearToolBaseline(pi);
 
     try {
@@ -1759,9 +1776,21 @@ export async function pauseAuto(
   ctx?: ExtensionContext,
   _pi?: ExtensionAPI,
   _errorContext?: ErrorContext,
+  options: PauseAutoOptions = {},
 ): Promise<void> {
   if (!s.active) return;
+  if (
+    Object.prototype.hasOwnProperty.call(options, "expectedCurrentUnit") &&
+    !pauseAutoUnitIdentityMatches(options.expectedCurrentUnit ?? null)
+  ) {
+    debugLog("pause-auto-stale-unit-guard", {
+      expectedCurrentUnit: options.expectedCurrentUnit ?? null,
+      currentUnit: s.currentUnit,
+    });
+    return;
+  }
   s.active = false;
+  s.paused = true;
   clearUnitTimeout();
   stopAutoCommandPolling();
 
@@ -1850,26 +1879,25 @@ export async function pauseAuto(
 
   if (s.workerId) {
     try {
+      if (s.currentMilestoneId && s.milestoneLeaseToken) {
+        releaseMilestoneLease(s.workerId, s.currentMilestoneId, s.milestoneLeaseToken);
+      }
       markWorkerStopping(s.workerId);
     } catch (err) {
       logWarning("engine", `pause worker cleanup failed: ${getErrorMessage(err)}`, { file: "auto.ts" });
     }
     s.workerId = null;
+    s.milestoneLeaseToken = null;
   }
 
   deregisterSigtermHandler();
 
-  // Unblock pending unitPromise so autoLoop exits cleanly (#1799)
-  resolveAgentEnd({ messages: [] });
-  _resetPendingResolve();
-
   try {
     await s.orchestration?.stop("pause");
   } catch (err) {
     debugLog("pause-orchestration-stop", { error: err instanceof Error ? err.message : String(err) });
   }
 
-  s.paused = true;
   deactivateGSD();
   restoreProjectRootEnv();
   restoreMilestoneLockEnv();
@@ -2521,7 +2549,7 @@ export async function startAuto(
   // leaves the last provider-trimmed active tools in place, so clearing here
   // would let the next selectAndApplyModel recapture that already-narrowed
   // set as the new baseline — exactly the cross-unit poisoning this PR is
-  // fixing (#4959 / CodeRabbit Major).  The pre-pause baseline survives in
+  // fixing (#4959).  The pre-pause baseline survives in
   // the WeakMap keyed by `pi`.
   if (!s.paused) clearToolBaseline(pi);
 

package/src/resources/extensions/gsd/bootstrap/agent-end-recovery.ts

@@ -1,4 +1,4 @@
-// GSD-2 + src/resources/extensions/gsd/bootstrap/agent-end-recovery.ts - Handles provider and agent-end recovery for GSD auto-mode.
+// gsd-pi + src/resources/extensions/gsd/bootstrap/agent-end-recovery.ts - Handles provider and agent-end recovery for GSD auto-mode.
 
 import type { ExtensionAPI, ExtensionContext } from "@gsd/pi-coding-agent";
 
@@ -172,10 +172,9 @@ export function isBareClaudeCodeStreamAbortPlaceholder(lastMsg: unknown): boolea
  * "Auto-mode stopped — Unit aborted: Claude Code process aborted by user"
  * even though no user input occurred.
  *
- * Claude Code abort markers are intentionally ignored when the abort fires
- * while the session-switch is in flight: the abort is the expected side-effect
- * of the transition, not a user signal. Other branches (genuine `stopReason
- * === "aborted"` with explicit errorMessage) preserve the prior behavior.
+ * Abort markers are intentionally ignored when the abort fires while the
+ * session-switch is in flight: the abort belongs to the old turn being torn
+ * down by newSession(), not to the next unit.
  */
 export function _handleSessionSwitchAgentEnd(
   lastMsg: unknown,
@@ -199,10 +198,7 @@ export function _handleSessionSwitchAgentEnd(
   }
 
   if (m.stopReason === "aborted") {
-    const hasErrorMessage = !!m.errorMessage;
-    if (hasErrorMessage) {
-      resolveCancelled(_buildAbortedPauseContext(m as { errorMessage?: unknown }));
-    }
+    return;
   }
 }
 

package/src/resources/extensions/gsd/bootstrap/crash-log.ts

@@ -1,5 +1,5 @@
 /**
- * crash-log.ts — Write crash diagnostics to ~/.gsd/crash/<timestamp>.log
+ * crash-log.ts — Write crash diagnostics to ~/.gsd/crash/pid-<pid>.log
  *
  * Zero cross-dependencies: only uses Node.js built-ins so it can be imported
  * safely from uncaughtException / unhandledRejection handlers and from tests
@@ -11,15 +11,14 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 
 /**
- * Write a crash log to ~/.gsd/crash/<timestamp>.log (or $GSD_HOME/crash/).
+ * Write a crash log to ~/.gsd/crash/pid-<pid>.log (or $GSD_HOME/crash/).
  * Never throws — must be safe to call from any error handler.
  */
 export function writeCrashLog(err: Error, source: string): void {
   try {
     const crashDir = join(process.env.GSD_HOME ?? join(homedir(), ".gsd"), "crash");
     mkdirSync(crashDir, { recursive: true });
-    const ts = new Date().toISOString().replace(/[:.]/g, "-");
-    const logPath = join(crashDir, `${ts}.log`);
+    const logPath = join(crashDir, `pid-${process.pid}.log`);
     const lines = [
       `[gsd] ${source}: ${err.message}`,
       `timestamp: ${new Date().toISOString()}`,

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

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Registers DB-backed GSD workflow tools and compatibility aliases.
 import { Type } from "@sinclair/typebox";
 import type { ExtensionAPI } from "@gsd/pi-coding-agent";
@@ -491,6 +491,7 @@ export function registerDbTools(pi: ExtensionAPI): void {
     promptSnippet: "Plan a milestone via DB write + roadmap render + cache invalidation",
     promptGuidelines: [
       "Use gsd_plan_milestone for milestone planning instead of writing ROADMAP.md directly.",
+      "Requires milestoneId, title, vision, and slices[] — never pass only milestoneId + sliceId (that is gsd_plan_slice).",
       "Keep parameters flat and provide the full milestone planning payload, including slices.",
       "Milestone and slice titles must not contain forward slash (/), en dash, or em dash characters.",
       "The tool validates input, writes milestone and slice planning data transactionally, renders ROADMAP.md from DB, and clears both state and parse caches after success.",

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

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Registers workspace-aware dynamic filesystem and shell tools.
 import { existsSync } from "node:fs";
 import { homedir } from "node:os";

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

@@ -1,6 +1,6 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Registers Context Mode execution tools.
-// GSD2 — Exec (context-mode) tool registration.
+// gsd-pi — Exec (context-mode) tool registration.
 //
 // Exposes the Context Mode runtime tools in-process. Default-on; opt out with
 // `context_mode.enabled: false` in preferences.

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

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Registers journal query tools.
 import { Type } from "@sinclair/typebox";
 import type { ExtensionAPI } from "@gsd/pi-coding-agent";

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

@@ -1,6 +1,6 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Registers memory-layer tools.
-// GSD2 — Memory tool registration
+// gsd-pi — Memory tool registration
 //
 // Exposes the memory-layer tools (capture_thought, memory_query, gsd_graph)
 // to the LLM over MCP. All three degrade gracefully when the GSD database

package/src/resources/extensions/gsd/bootstrap/plan-milestone-schema-recovery.ts

@@ -0,0 +1,119 @@
+/**
+ * Recovery for gsd_plan_milestone schema confusion (#2783 class).
+ * Detects milestoneId+sliceId-only payloads (gsd_plan_slice shape) and enriches
+ * validation errors + injects corrective steering with counter reset.
+ */
+
+const PLAN_MILESTONE_TOOL_NAMES = new Set(["gsd_plan_milestone", "gsd_milestone_plan"]);
+
+export function isPlanMilestoneToolName(toolName: string): boolean {
+  return PLAN_MILESTONE_TOOL_NAMES.has(toolName);
+}
+
+/**
+ * True when the model passed slice-level IDs without milestone planning fields.
+ */
+export function isPlanMilestoneSliceIdConfusion(args: Record<string, unknown>): boolean {
+  const hasMilestoneId = typeof args.milestoneId === "string" && args.milestoneId.length > 0;
+  const hasSliceId = typeof args.sliceId === "string" && args.sliceId.length > 0;
+  const hasTitle = typeof args.title === "string" && args.title.length > 0;
+  const hasVision = typeof args.vision === "string" && args.vision.length > 0;
+  const hasSlices = Array.isArray(args.slices) && args.slices.length > 0;
+  return hasMilestoneId && hasSliceId && !hasTitle && !hasVision && !hasSlices;
+}
+
+const MINIMAL_PAYLOAD_EXAMPLE = `{
+  "milestoneId": "M001",
+  "title": "Milestone title",
+  "vision": "One-sentence milestone vision.",
+  "slices": [
+    {
+      "sliceId": "S01",
+      "title": "Slice title",
+      "risk": "low",
+      "depends": [],
+      "demo": "After this: observable demo sentence.",
+      "goal": "Slice goal in one sentence."
+    }
+  ]
+}`;
+
+export function enrichPlanMilestoneValidationError(
+  baseMessage: string,
+  args: Record<string, unknown>,
+): string {
+  const milestoneId =
+    typeof args.milestoneId === "string" ? args.milestoneId : "M001";
+  return [
+    baseMessage,
+    "",
+    "Recovery hint: you called gsd_plan_milestone with slice-level IDs only.",
+    "- gsd_plan_milestone requires: milestoneId, title, vision, slices[] (each slice needs sliceId, title, risk, depends, demo, goal).",
+    "- Passing only milestoneId + sliceId is the gsd_plan_slice tool shape, not milestone planning.",
+    `- Retry gsd_plan_milestone for ${milestoneId} with the full roadmap payload from your Roadmap Preview.`,
+    "",
+    "Minimal valid shape (expand slices from your approved roadmap table):",
+    MINIMAL_PAYLOAD_EXAMPLE,
+  ].join("\n");
+}
+
+export function buildPlanMilestoneRecoverySteering(milestoneId: string): string {
+  return [
+    `gsd_plan_milestone schema recovery for ${milestoneId}.`,
+    "Your last call used only milestoneId and sliceId. That is invalid for gsd_plan_milestone.",
+    "Call gsd_plan_milestone now with title, vision, and the full slices[] array from the Roadmap Preview you printed.",
+    "Do not call gsd_plan_slice until after the milestone roadmap is persisted.",
+  ].join(" ");
+}
+
+const pendingPlanMilestoneArgs = new Map<string, Record<string, unknown>>();
+
+function findConfusedPlanMilestoneFailure(
+  failures: Array<{ toolName: string; arguments: Record<string, unknown> }>,
+): { toolName: string; arguments: Record<string, unknown> } | undefined {
+  return failures.find(
+    (f) => isPlanMilestoneToolName(f.toolName) && isPlanMilestoneSliceIdConfusion(f.arguments),
+  );
+}
+
+export function registerPlanMilestoneSchemaRecovery(pi: import("@gsd/pi-coding-agent").ExtensionAPI): void {
+  pi.on("tool_format_validation_error", (event) => {
+    if (!isPlanMilestoneToolName(event.toolName)) return;
+    if (!isPlanMilestoneSliceIdConfusion(event.arguments)) return;
+    return {
+      message: enrichPlanMilestoneValidationError(event.baseMessage, event.arguments),
+    };
+  });
+
+  pi.on("tool_preparation_errors_turn", (event) => {
+    const confused = findConfusedPlanMilestoneFailure(event.failures);
+    if (!confused) return;
+    const milestoneId = String(confused.arguments.milestoneId ?? "M001");
+    return {
+      steeringContent: buildPlanMilestoneRecoverySteering(milestoneId),
+      resetValidationFailureCap: true,
+    };
+  });
+
+  pi.on("tool_execution_start", (event) => {
+    if (!isPlanMilestoneToolName(event.toolName)) return;
+    if (event.args && typeof event.args === "object") {
+      pendingPlanMilestoneArgs.set(
+        event.toolCallId,
+        event.args as Record<string, unknown>,
+      );
+    }
+  });
+
+  pi.on("tool_execution_end", (event, ctx) => {
+    const args = pendingPlanMilestoneArgs.get(event.toolCallId);
+    pendingPlanMilestoneArgs.delete(event.toolCallId);
+    if (!args || !event.isError || !isPlanMilestoneSliceIdConfusion(args)) return;
+    const milestoneId = String(args.milestoneId ?? "M001");
+    ctx.ui.notify(
+      `Milestone ${milestoneId}: gsd_plan_milestone needs title, vision, and slices[]. ` +
+        "See the tool error for a minimal valid payload.",
+      "warning",
+    );
+  });
+}

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

@@ -1,6 +1,6 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Registers read-only DB query tools.
-// GSD2 — Read-only query tools exposing DB state to the LLM via the WAL connection
+// gsd-pi — Read-only query tools exposing DB state to the LLM via the WAL connection
 
 import { Type } from "@sinclair/typebox";
 import type { ExtensionAPI } from "@gsd/pi-coding-agent";