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

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) {
@@ -136,6 +136,11 @@ export function startUnitSupervision(sctx) {
         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;
@@ -198,7 +203,7 @@ export function startUnitSupervision(sctx) {
                 phase: "paused",
             });
             ctx.ui.notify(`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);
@@ -219,6 +224,9 @@ export function startUnitSupervision(sctx) {
             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",
@@ -233,7 +241,7 @@ export function startUnitSupervision(sctx) {
             if (recovery === "recovered")
                 return;
             ctx.ui.notify(`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);

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
@@ -677,6 +677,23 @@ function currentUnitLabel() {
         return null;
     return `${unitVerb(s.currentUnit.type)} ${s.currentUnit.id}`;
 }
+export function capturePauseAutoUnitIdentity() {
+    if (!s.currentUnit)
+        return null;
+    return {
+        type: s.currentUnit.type,
+        id: s.currentUnit.id,
+        startedAt: s.currentUnit.startedAt,
+    };
+}
+function pauseAutoUnitIdentityMatches(expected) {
+    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, input) {
     if (!ctx?.hasUI)
         return;
@@ -1288,7 +1305,7 @@ export async function stopAuto(ctx, pi, reason, options = {}) {
         // 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 {
@@ -1319,10 +1336,19 @@ export function _selectStopAutoWorktreeExit(args) {
  * The user can interact with the agent, then `/gsd auto` resumes
  * from disk state. Called when the user presses Escape during auto-mode.
  */
-export async function pauseAuto(ctx, _pi, _errorContext) {
+export async function pauseAuto(ctx, _pi, _errorContext, options = {}) {
     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();
     // Flush queued follow-up messages (#3512).
@@ -1406,24 +1432,24 @@ export async function pauseAuto(ctx, _pi, _errorContext) {
     }
     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();
@@ -2013,7 +2039,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
     // 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/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";
@@ -135,10 +135,9 @@ export function isBareClaudeCodeStreamAbortPlaceholder(lastMsg) {
  * "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, resolveCancelled) {
     if (!lastMsg || typeof lastMsg !== "object")
@@ -157,10 +156,7 @@ export function _handleSessionSwitchAgentEnd(lastMsg, resolveCancelled) {
         return;
     }
     if (m.stopReason === "aborted") {
-        const hasErrorMessage = !!m.errorMessage;
-        if (hasErrorMessage) {
-            resolveCancelled(_buildAbortedPauseContext(m));
-        }
+        return;
     }
 }
 export function resolveAgentEndErrorDisplay(rawErrorMsg, content) {

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";
@@ -7,6 +7,7 @@ import { registerExecTools } from "./exec-tools.js";
 import { registerJournalTools } from "./journal-tools.js";
 import { registerMemoryTools } from "./memory-tools.js";
 import { registerQueryTools } from "./query-tools.js";
+import { registerScheduleWakeupTool } from "./schedule-wakeup-tool.js";
 import { registerHooks } from "./register-hooks.js";
 import { registerShortcuts } from "./register-shortcuts.js";
 import { writeCrashLog } from "./crash-log.js";
@@ -21,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") {
@@ -107,6 +107,7 @@ export function registerGsdExtension(pi) {
         ["query-tools", () => registerQueryTools(pi)],
         ["memory-tools", () => registerMemoryTools(pi)],
         ["exec-tools", () => registerExecTools(pi)],
+        ["schedule-wakeup-tool", () => registerScheduleWakeupTool(pi)],
         ["shortcuts", () => registerShortcuts(pi)],
         // cmux is a library (no pi), so gsd sets up the event listeners on its
         // behalf using the shared event channel contract. Registration is

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);
@@ -742,6 +744,8 @@ export function registerHooks(pi, ecosystemHandlers) {
         // subagent dispatch. Closes the b23 bug class where a discuss-milestone
         // turn used the host Edit tool to modify user source files.
         const dash = getAutoRuntimeSnapshot();
+        // ScheduleWakeup is registered by the GSD extension so auto-mode can
+        // continue the same unit session after long external waits.
         const guidedUnit = getGuidedUnitContext(discussionBasePath);
         const activeUnitType = dash.currentUnit?.type ?? guidedUnit?.unitType;
         if (activeUnitType) {

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";