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

package/dist/resources/extensions/gsd/auto/workflow-worker-heartbeat.js

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Best-effort worker heartbeat adapter for auto-mode loop.
 export function maintainWorkerHeartbeat(session, deps) {
     if (!session.workerId)

package/dist/resources/extensions/gsd/auto-artifact-paths.js

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Resolves expected auto-mode artifact paths across project and worktree projections.
 // GSD Auto-mode — Artifact Path Resolution
 //
@@ -124,8 +124,9 @@ export function resolveExpectedArtifactPath(unitType, unitId, base) {
             // Gate evaluate writes to DB quality_gates table — verified via state derivation
             return null;
         case "reactive-execute":
-            // Reactive execute produces multiple task summaries — verified separately
-            return null;
+            // Reactive execute normally produces multiple task summaries. On terminal
+            // batch recovery, the engine writes a slice-level blocker sentinel.
+            return mid && sid ? resolveSliceArtifactPath(base, mid, sid, "REACTIVE-BLOCKER") : null;
         default:
             return null;
     }

package/dist/resources/extensions/gsd/auto-budget.js

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Pure budget and context guard decisions for GSD auto-mode.
 /**
  * Budget alert level tracking and enforcement for auto-mode.

package/dist/resources/extensions/gsd/auto-dashboard.js

@@ -1,4 +1,4 @@
-// GSD-2 + src/resources/extensions/gsd/auto-dashboard.ts - Auto-mode progress widget rendering and dashboard helpers.
+// gsd-pi + src/resources/extensions/gsd/auto-dashboard.ts - Auto-mode progress widget rendering and dashboard helpers.
 import { getActiveHook } from "./post-unit-hooks.js";
 import { getLedger } from "./metrics.js";
 import { getErrorMessage } from "./error-utils.js";

package/dist/resources/extensions/gsd/auto-dispatch.js

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Declarative auto-mode dispatch rules and dispatch resolver.
 import { loadFile, extractUatType, loadActiveOverrides } from "./files.js";
 import { isDbAvailable, getMilestoneSlices, getPendingGates, markAllGatesOmitted, getMilestone, insertAssessment, setSliceSketchFlag, transaction, getAssessment } from "./gsd-db.js";
@@ -1043,6 +1043,8 @@ export const DISPATCH_RULES = [
                 return null;
             const sid = state.activeSlice.id;
             const sTitle = state.activeSlice.title;
+            if (resolveSliceFile(basePath, mid, sid, "REACTIVE-BLOCKER"))
+                return null;
             const maxParallel = reactiveConfig?.max_parallel ?? 2;
             const subagentModel = reactiveConfig?.subagent_model ?? resolveModelWithFallbacksForUnit("subagent")?.primary;
             // Default-on safety threshold: only activate reactive dispatch when at

package/dist/resources/extensions/gsd/auto-post-unit.js

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Auto-mode post-unit git, verification, projection, and hook processing.
 /**
  * Post-unit processing for auto-loop — auto-commit, doctor run,
@@ -23,7 +23,7 @@ import { rebuildState } from "./doctor.js";
 import { parseUnitId } from "./unit-id.js";
 import { closeoutUnit } from "./auto-unit-closeout.js";
 import { runTurnGitAction, } from "./git-service.js";
-import { verifyExpectedArtifact, resolveExpectedArtifactPath, writeBlockerPlaceholder, diagnoseExpectedArtifact, diagnoseWorktreeIntegrityFailure, } from "./auto-recovery.js";
+import { verifyExpectedArtifact, resolveExpectedArtifactPath, writeBlockerPlaceholder, diagnoseExpectedArtifact, diagnoseWorktreeIntegrityFailure, writeReactiveExecuteBlocker, } from "./auto-recovery.js";
 import { regenerateIfMissing } from "./workflow-projections.js";
 import { WorktreeStateProjection } from "./worktree-state-projection.js";
 import { createWorkspace, scopeMilestone } from "./workspace.js";
@@ -1540,6 +1540,25 @@ export async function postUnitPreVerification(pctx, opts) {
                     const attempt = (s.verificationRetryCount.get(retryKey) ?? 0) + 1;
                     const failureDetails = describeArtifactVerificationFailure(s.currentUnit.type, s.currentUnit.id, verificationBasePath, s.lastUnitAgentEndMessages);
                     if (attempt > MAX_ARTIFACT_VERIFICATION_RETRIES) {
+                        if (s.currentUnit.type === "reactive-execute") {
+                            const recovery = writeReactiveExecuteBlocker(s.currentUnit.id, verificationBasePath, failureDetails);
+                            if (recovery) {
+                                s.pendingVerificationRetry = null;
+                                s.verificationRetryCount.delete(retryKey);
+                                s.verificationRetryFailureHashes.delete(retryKey);
+                                invalidateAllCaches();
+                                debugLog("postUnit", {
+                                    phase: "reactive-execute-blocker-recovery",
+                                    unitType: s.currentUnit.type,
+                                    unitId: s.currentUnit.id,
+                                    blockerPath: recovery.blockerPath,
+                                    completedTaskIds: recovery.completedTaskIds,
+                                    skippedTaskIds: recovery.skippedTaskIds,
+                                });
+                                ctx.ui.notify(`${failureDetails} Wrote reactive blocker and advanced: ${recovery.completedTaskIds.length} complete, ${recovery.skippedTaskIds.length} skipped.`, "warning");
+                                return "continue";
+                            }
+                        }
                         s.exhaustedVerificationUnits.add(retryKey);
                         debugLog("postUnit", { phase: "artifact-verify-exhausted", unitType: s.currentUnit.type, unitId: s.currentUnit.id, attempt });
                         ctx.ui.notify(`${failureDetails} Pausing auto-mode after ${MAX_ARTIFACT_VERIFICATION_RETRIES} retries.`, "error");

package/dist/resources/extensions/gsd/auto-prompts.js

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Builds GSD auto-mode unit prompts and pre-dispatch checks.
 /**
  * Auto-mode Prompt Builders — construct dispatch prompts for each unit type.

package/dist/resources/extensions/gsd/auto-recovery.js

@@ -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,
@@ -14,7 +14,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";
@@ -23,6 +23,8 @@ import { isClosedStatus } from "./status-guards.js";
 import { resolveSlicePath, resolveSliceFile, resolveTasksDir, resolveTaskFiles, relMilestoneFile, relSliceFile, buildSliceFileName, resolveMilestoneFile, clearPathCache, resolveGsdRootFile, } from "./paths.js";
 import { existsSync, mkdirSync, readFileSync, 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, diagnoseExpectedArtifact, } from "./auto-artifact-paths.js";
 import { classifyMilestoneSummaryContent } from "./milestone-summary-classifier.js";
@@ -362,7 +364,7 @@ function getChangedFilesSinceBranch(basePath, targetBranch) {
         // Try merge-base approach first
         const mergeBase = execFileSync("git", ["merge-base", targetBranch, "HEAD"], { cwd: basePath, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
         if (mergeBase) {
-            const result = execFileSync("git", ["diff", "--name-only", mergeBase, "HEAD"], { cwd: basePath, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
+            const result = execFileSync("git", ["diff", "--name-only", mergeBase, "HEAD"], { 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) : [] };
         }
     }
@@ -515,6 +517,7 @@ function getCommitRecords(basePath) {
         cwd: basePath,
         stdio: ["ignore", "pipe", "pipe"],
         encoding: "utf-8",
+        maxBuffer: GIT_LOG_MAX_BUFFER,
     });
     return logOutput
         .split("\x1e")
@@ -537,6 +540,7 @@ function scanGsdTaggedCommits(basePath, milestoneId, gitArgs) {
             cwd: basePath,
             stdio: ["ignore", "pipe", "pipe"],
             encoding: "utf-8",
+            maxBuffer: GIT_LOG_MAX_BUFFER,
         });
         const records = logOutput
             .split("\x1e")
@@ -694,6 +698,10 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
         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"
@@ -979,6 +987,110 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
     }
     return true;
 }
+/**
+ * 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, base, reason) {
+    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 = [];
+    const skippedTaskIds = [];
+    const unchangedTaskIds = [];
+    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/dist/resources/extensions/gsd/auto-start.js

@@ -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/dist/resources/extensions/gsd/auto-status-message.js

@@ -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 = "    ";
 const STATUS_RULE = "────────────────────────────────────────";

package/dist/resources/extensions/gsd/auto-timers.js

@@ -75,7 +75,7 @@ export function startUnitSupervision(sctx) {
     // 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) {

package/dist/resources/extensions/gsd/auto-unit-closeout.js

@@ -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.
 import { snapshotUnitMetrics } from "./metrics.js";
 import { saveActivityLog } from "./activity-log.js";

package/dist/resources/extensions/gsd/auto-verification.js

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Post-unit verification gate for GSD auto-mode units.
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
 import { gsdProjectionRoot, resolveSlicePath, resolveMilestoneFile } from "./paths.js";

package/dist/resources/extensions/gsd/auto-worktree-repair.js

@@ -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 } from "node:fs";
 import { join } from "node:path";

package/dist/resources/extensions/gsd/auto-worktree.js

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

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

@@ -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
@@ -1348,6 +1348,7 @@ export async function pauseAuto(ctx, _pi, _errorContext, options = {}) {
         return;
     }
     s.active = false;
+    s.paused = true;
     clearUnitTimeout();
     stopAutoCommandPolling();
     // Flush queued follow-up messages (#3512).
@@ -1431,24 +1432,24 @@ export async function pauseAuto(ctx, _pi, _errorContext, options = {}) {
     }
     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();

package/dist/resources/extensions/gsd/bootstrap/agent-end-recovery.js

@@ -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 { logWarning } from "../workflow-logger.js";
 import { checkDeepProjectSetupAfterTurn, checkAutoStartAfterDiscuss, maybeHandleReadyPhraseWithoutFiles, maybeHandleEmptyIntentTurn, resetEmptyTurnCounter, } from "../guided-flow.js";
 import { clearPathCache } from "../paths.js";

package/dist/resources/extensions/gsd/bootstrap/crash-log.js

@@ -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
@@ -9,15 +9,14 @@ import { appendFileSync, mkdirSync } from "node:fs";
 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, source) {
     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/dist/resources/extensions/gsd/bootstrap/db-tools.js

@@ -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 { Text } from "@gsd/pi-tui";
@@ -472,6 +472,7 @@ export function registerDbTools(pi) {
         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/dist/resources/extensions/gsd/bootstrap/dynamic-tools.js

@@ -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/dist/resources/extensions/gsd/bootstrap/exec-tools.js

@@ -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/dist/resources/extensions/gsd/bootstrap/journal-tools.js

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

package/dist/resources/extensions/gsd/bootstrap/memory-tools.js

@@ -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/dist/resources/extensions/gsd/bootstrap/plan-milestone-schema-recovery.js

@@ -0,0 +1,98 @@
+/**
+ * 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) {
+    return PLAN_MILESTONE_TOOL_NAMES.has(toolName);
+}
+/**
+ * True when the model passed slice-level IDs without milestone planning fields.
+ */
+export function isPlanMilestoneSliceIdConfusion(args) {
+    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, args) {
+    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) {
+    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();
+function findConfusedPlanMilestoneFailure(failures) {
+    return failures.find((f) => isPlanMilestoneToolName(f.toolName) && isPlanMilestoneSliceIdConfusion(f.arguments));
+}
+export function registerPlanMilestoneSchemaRecovery(pi) {
+    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);
+        }
+    });
+    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/dist/resources/extensions/gsd/bootstrap/query-tools.js

@@ -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 { ensureDbOpen, resolveCtxCwd } from "./dynamic-tools.js";
 export function registerQueryTools(pi) {

package/dist/resources/extensions/gsd/bootstrap/register-extension.js

@@ -1,4 +1,4 @@
-// GSD2 — Extension registration: wires all GSD tools, commands, and hooks into pi
+// gsd-pi — Extension registration: wires all GSD tools, commands, and hooks into pi
 import { registerExitCommand } from "../exit-command.js";
 import { registerLazyWorktreeCommands } from "../worktree-command-bootstrap.js";
 import { registerDbTools } from "./db-tools.js";
@@ -22,12 +22,11 @@ import { initCmuxEventListeners } from "../../cmux/index.js";
 export { writeCrashLog } from "./crash-log.js";
 export function handleRecoverableExtensionProcessError(err) {
     if (err.code === "EPIPE") {
-        writeCrashLog(err, "EPIPE");
         const stdoutGone = process.stdout.destroyed || process.stdout.writableEnded;
         if (stdoutGone) {
             process.exit(0);
         }
-        process.stderr.write(`[gsd] swallowed EPIPE (syscall=${err.syscall ?? "?"}); see ~/.gsd/crash/ for details\n`);
+        process.stderr.write(`[gsd] swallowed EPIPE (syscall=${err.syscall ?? "?"})\n`);
         return true;
     }
     if (err.code === "EIO") {

package/dist/resources/extensions/gsd/bootstrap/register-hooks.js

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Registers GSD extension runtime hooks and token-saving tool policies.
 import { existsSync } from "node:fs";
 import { dirname, join } from "node:path";
@@ -25,6 +25,7 @@ import { extractSubagentAgentClasses } from "./subagent-input.js";
 import { approvalGateIdForUnit, isExplicitApprovalResponse, shouldPauseForUserApprovalQuestion } from "../user-input-boundary.js";
 import { resolveSkillManifest } from "../skill-manifest.js";
 import { getGuidedUnitContext } from "../guided-unit-context.js";
+import { registerPlanMilestoneSchemaRecovery } from "./plan-milestone-schema-recovery.js";
 let approvalQuestionAbortInFlight = false;
 async function loadWelcomeScreenModule() {
     const candidates = [];
@@ -412,6 +413,7 @@ export function registerHooks(pi, ecosystemHandlers) {
     // ADR-005 Phase 3b: surface pi-ai ProviderSwitchReport via audit, notification, and counter.
     // Idempotent — only the first registerHooks call installs.
     void import("../provider-switch-observer.js").then((m) => m.installProviderSwitchObserver());
+    registerPlanMilestoneSchemaRecovery(pi);
     pi.on("session_start", async (_event, ctx) => {
         const basePath = contextBasePath(ctx);
         initSessionNotifications(ctx);

package/dist/resources/extensions/gsd/bootstrap/register-shortcuts.js

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Registers GSD keyboard shortcuts for dashboard, notifications, and parallel overlays.
 import { existsSync } from "node:fs";
 import { join } from "node:path";

package/dist/resources/extensions/gsd/bootstrap/schedule-wakeup-tool.js

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: Registers the auto-mode ScheduleWakeup continuation tool.
 import { Type } from "@sinclair/typebox";
 import { getAutoRuntimeSnapshot } from "../auto-runtime-state.js";

package/dist/resources/extensions/gsd/bootstrap/system-context.js

@@ -1,4 +1,4 @@
-// Project/App: GSD-2
+// Project/App: gsd-pi
 // File Purpose: System prompt and hidden context bootstrap for GSD sessions.
 import { existsSync, readFileSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
@@ -76,7 +76,7 @@ function buildBundledSkillsTable() {
         rows.push(`| ${trigger} | \`${resolution.resolvedPath}\` |`);
     }
     if (rows.length === 0) {
-        return "*No bundled skills found. Install skills to `~/.agents/skills/` or `~/.claude/skills/`.*";
+        return "*No bundled skills found. Install or sync skills to `~/.gsd/agent/skills/`, `~/.agents/skills/`, or `~/.claude/skills/`.*";
     }
     return `| Trigger | Skill to load |\n|---|---|\n${rows.join("\n")}`;
 }