gsd-pi 2.46.1 → 2.47.0-dev.8cfe772

package/dist/resources/extensions/claude-code-cli/stream-adapter.js

@@ -0,0 +1,309 @@
+/**
+ * Stream adapter: bridges the Claude Agent SDK into GSD's streamSimple contract.
+ *
+ * The SDK runs the full agentic loop (multi-turn, tool execution, compaction)
+ * in one call. This adapter translates the SDK's streaming output into
+ * AssistantMessageEvents for TUI rendering, then strips tool-call blocks from
+ * the final AssistantMessage so GSD's agent loop doesn't try to dispatch them.
+ */
+import { EventStream } from "@gsd/pi-ai";
+import { execSync } from "node:child_process";
+import { PartialMessageBuilder, ZERO_USAGE, mapUsage } from "./partial-builder.js";
+// ---------------------------------------------------------------------------
+// Stream factory
+// ---------------------------------------------------------------------------
+/**
+ * Construct an AssistantMessageEventStream using EventStream directly.
+ * (The class itself is only re-exported as a type from the @gsd/pi-ai barrel.)
+ */
+function createAssistantStream() {
+    return new EventStream((event) => event.type === "done" || event.type === "error", (event) => {
+        if (event.type === "done")
+            return event.message;
+        if (event.type === "error")
+            return event.error;
+        throw new Error("Unexpected event type for final result");
+    });
+}
+// ---------------------------------------------------------------------------
+// Claude binary resolution
+// ---------------------------------------------------------------------------
+let cachedClaudePath = null;
+/**
+ * Resolve the path to the system-installed `claude` binary.
+ * The SDK defaults to a bundled cli.js which doesn't exist when
+ * installed as a library — we need to point it at the real CLI.
+ */
+function getClaudePath() {
+    if (cachedClaudePath)
+        return cachedClaudePath;
+    try {
+        cachedClaudePath = execSync("which claude", { timeout: 5_000, stdio: "pipe" })
+            .toString()
+            .trim();
+    }
+    catch {
+        cachedClaudePath = "claude"; // fall back to PATH resolution
+    }
+    return cachedClaudePath;
+}
+// ---------------------------------------------------------------------------
+// Prompt extraction
+// ---------------------------------------------------------------------------
+/**
+ * Extract the last user prompt text from GSD's context messages.
+ * The SDK manages its own conversation history — we only send
+ * the latest user message as the prompt.
+ */
+function extractLastUserPrompt(context) {
+    for (let i = context.messages.length - 1; i >= 0; i--) {
+        const msg = context.messages[i];
+        if (msg.role === "user") {
+            if (typeof msg.content === "string")
+                return msg.content;
+            if (Array.isArray(msg.content)) {
+                const textParts = msg.content
+                    .filter((part) => part.type === "text")
+                    .map((part) => part.text);
+                if (textParts.length > 0)
+                    return textParts.join("\n");
+            }
+        }
+    }
+    return "";
+}
+// ---------------------------------------------------------------------------
+// Error helper
+// ---------------------------------------------------------------------------
+function makeErrorMessage(model, errorMsg) {
+    return {
+        role: "assistant",
+        content: [{ type: "text", text: `Claude Code error: ${errorMsg}` }],
+        api: "anthropic-messages",
+        provider: "claude-code",
+        model,
+        usage: { ...ZERO_USAGE },
+        stopReason: "error",
+        errorMessage: errorMsg,
+        timestamp: Date.now(),
+    };
+}
+// ---------------------------------------------------------------------------
+// streamSimple implementation
+// ---------------------------------------------------------------------------
+/**
+ * GSD streamSimple function that delegates to the Claude Agent SDK.
+ *
+ * Emits AssistantMessageEvent deltas for real-time TUI rendering
+ * (thinking, text, tool calls). The final AssistantMessage has tool-call
+ * blocks stripped so the agent loop ends the turn without local dispatch.
+ */
+export function streamViaClaudeCode(model, context, options) {
+    const stream = createAssistantStream();
+    void pumpSdkMessages(model, context, options, stream);
+    return stream;
+}
+async function pumpSdkMessages(model, context, options, stream) {
+    const modelId = model.id;
+    let builder = null;
+    /** Track the last text content seen across all assistant turns for the final message. */
+    let lastTextContent = "";
+    let lastThinkingContent = "";
+    /** Collect tool calls from intermediate SDK turns for tool_execution events. */
+    const intermediateToolCalls = [];
+    try {
+        // Dynamic import — the SDK is an optional dependency.
+        const sdkModule = "@anthropic-ai/claude-agent-sdk";
+        const sdk = (await import(/* webpackIgnore: true */ sdkModule));
+        // Bridge GSD's AbortSignal to SDK's AbortController
+        const controller = new AbortController();
+        if (options?.signal) {
+            options.signal.addEventListener("abort", () => controller.abort(), { once: true });
+        }
+        const prompt = extractLastUserPrompt(context);
+        const queryResult = sdk.query({
+            prompt,
+            options: {
+                pathToClaudeCodeExecutable: getClaudePath(),
+                model: modelId,
+                includePartialMessages: true,
+                persistSession: false,
+                abortController: controller,
+                cwd: process.cwd(),
+                permissionMode: "bypassPermissions",
+                allowDangerouslySkipPermissions: true,
+                settingSources: ["project"],
+                systemPrompt: { type: "preset", preset: "claude_code" },
+                betas: modelId.includes("sonnet") ? ["context-1m-2025-08-07"] : [],
+            },
+        });
+        // Emit start with an empty partial
+        const initialPartial = {
+            role: "assistant",
+            content: [],
+            api: "anthropic-messages",
+            provider: "claude-code",
+            model: modelId,
+            usage: { ...ZERO_USAGE },
+            stopReason: "stop",
+            timestamp: Date.now(),
+        };
+        stream.push({ type: "start", partial: initialPartial });
+        for await (const msg of queryResult) {
+            if (options?.signal?.aborted)
+                break;
+            switch (msg.type) {
+                // -- Init --
+                case "system": {
+                    // Nothing to emit — the stream is already started.
+                    break;
+                }
+                // -- Streaming partial messages --
+                case "stream_event": {
+                    const partial = msg;
+                    if (partial.parent_tool_use_id !== null)
+                        break; // skip subagent
+                    const event = partial.event;
+                    // New assistant turn starts with message_start
+                    if (event.type === "message_start") {
+                        builder = new PartialMessageBuilder(event.message?.model ?? modelId);
+                        break;
+                    }
+                    if (!builder)
+                        break;
+                    const assistantEvent = builder.handleEvent(event);
+                    if (assistantEvent) {
+                        // Skip toolcall events — the agent loop's externalToolExecution
+                        // path emits tool_execution_start/end events after streamSimple
+                        // returns. Streaming toolcall events would render tool calls
+                        // out of order in the TUI's accumulated message content.
+                        const t = assistantEvent.type;
+                        if (t !== "toolcall_start" && t !== "toolcall_delta" && t !== "toolcall_end") {
+                            stream.push(assistantEvent);
+                        }
+                    }
+                    break;
+                }
+                // -- Complete assistant message (non-streaming fallback) --
+                case "assistant": {
+                    const sdkAssistant = msg;
+                    if (sdkAssistant.parent_tool_use_id !== null)
+                        break;
+                    // Capture text content from complete messages
+                    for (const block of sdkAssistant.message.content) {
+                        if (block.type === "text") {
+                            lastTextContent = block.text;
+                        }
+                        else if (block.type === "thinking") {
+                            lastThinkingContent = block.thinking;
+                        }
+                    }
+                    break;
+                }
+                // -- User message (synthetic tool result — signals turn boundary) --
+                case "user": {
+                    const userMsg = msg;
+                    if (userMsg.parent_tool_use_id !== null)
+                        break;
+                    // Capture content from the completed turn before resetting
+                    if (builder) {
+                        for (const block of builder.message.content) {
+                            if (block.type === "text" && block.text) {
+                                lastTextContent = block.text;
+                            }
+                            else if (block.type === "thinking" && block.thinking) {
+                                lastThinkingContent = block.thinking;
+                            }
+                            else if (block.type === "toolCall") {
+                                // Collect tool calls for externalToolExecution rendering
+                                intermediateToolCalls.push(block);
+                            }
+                        }
+                    }
+                    builder = null;
+                    break;
+                }
+                // -- Result (terminal) --
+                case "result": {
+                    const result = msg;
+                    // Build final message. Include intermediate tool calls so the
+                    // agent loop's externalToolExecution path emits tool_execution
+                    // events for proper TUI rendering, followed by the text response.
+                    const finalContent = [];
+                    // Add tool calls from intermediate turns first (renders above text)
+                    finalContent.push(...intermediateToolCalls);
+                    // Add text/thinking from the last turn
+                    if (builder && builder.message.content.length > 0) {
+                        for (const block of builder.message.content) {
+                            if (block.type === "text" || block.type === "thinking") {
+                                finalContent.push(block);
+                            }
+                        }
+                    }
+                    else {
+                        if (lastThinkingContent) {
+                            finalContent.push({ type: "thinking", thinking: lastThinkingContent });
+                        }
+                        if (lastTextContent) {
+                            finalContent.push({ type: "text", text: lastTextContent });
+                        }
+                    }
+                    // Fallback: use the SDK's result text if we have no content
+                    if (finalContent.length === 0 && result.subtype === "success" && result.result) {
+                        finalContent.push({ type: "text", text: result.result });
+                    }
+                    const finalMessage = {
+                        role: "assistant",
+                        content: finalContent,
+                        api: "anthropic-messages",
+                        provider: "claude-code",
+                        model: modelId,
+                        usage: mapUsage(result.usage, result.total_cost_usd),
+                        stopReason: result.is_error ? "error" : "stop",
+                        timestamp: Date.now(),
+                    };
+                    if (result.is_error) {
+                        const errText = "errors" in result
+                            ? result.errors?.join("; ")
+                            : result.subtype;
+                        finalMessage.errorMessage = errText;
+                        stream.push({ type: "error", reason: "error", error: finalMessage });
+                    }
+                    else {
+                        stream.push({ type: "done", reason: "stop", message: finalMessage });
+                    }
+                    return;
+                }
+                default:
+                    break;
+            }
+        }
+        // Generator exhausted without a result message (unexpected)
+        const fallbackContent = [];
+        if (lastTextContent) {
+            fallbackContent.push({ type: "text", text: lastTextContent });
+        }
+        if (fallbackContent.length === 0) {
+            fallbackContent.push({ type: "text", text: "(Claude Code session ended without a response)" });
+        }
+        const fallback = {
+            role: "assistant",
+            content: fallbackContent,
+            api: "anthropic-messages",
+            provider: "claude-code",
+            model: modelId,
+            usage: { ...ZERO_USAGE },
+            stopReason: "stop",
+            timestamp: Date.now(),
+        };
+        stream.push({ type: "done", reason: "stop", message: fallback });
+    }
+    catch (err) {
+        const errorMsg = err instanceof Error ? err.message : String(err);
+        stream.push({
+            type: "error",
+            reason: "error",
+            error: makeErrorMessage(modelId, errorMsg),
+        });
+    }
+}

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

@@ -20,7 +20,7 @@ import { synthesizeCrashRecovery } from "./session-forensics.js";
 import { writeLock, clearLock, readCrashLock, formatCrashInfo, isLockProcessAlive, } from "./crash-recovery.js";
 import { acquireSessionLock, releaseSessionLock, updateSessionLock, } from "./session-lock.js";
 import { ensureGitignore, untrackRuntimeFiles } from "./gitignore.js";
-import { nativeIsRepo, nativeInit, nativeAddAll, nativeCommit, } from "./native-git-bridge.js";
+import { nativeInit, nativeAddAll, nativeCommit, } from "./native-git-bridge.js";
 import { GitServiceImpl } from "./git-service.js";
 import { captureIntegrationBranch, detectWorktreeName, setActiveMilestoneId, } from "./worktree.js";
 import { getAutoWorktreePath } from "./auto-worktree.js";
@@ -30,7 +30,7 @@ import { initRoutingHistory } from "./routing-history.js";
 import { restoreHookState, resetHookState } from "./post-unit-hooks.js";
 import { resetProactiveHealing, setLevelChangeCallback } from "./doctor-proactive.js";
 import { snapshotSkills } from "./skill-discovery.js";
-import { isDbAvailable } from "./gsd-db.js";
+import { isDbAvailable, getMilestone } from "./gsd-db.js";
 import { hideFooter } from "./auto-dashboard.js";
 import { debugLog, enableDebug, isDebugEnabled, getDebugLogPath, } from "./debug-logger.js";
 import { existsSync, mkdirSync, readdirSync, statSync, unlinkSync, } from "node:fs";
@@ -69,13 +69,14 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
             ctx.ui.notify(`GSD_PROJECT_ID must contain only alphanumeric characters, hyphens, and underscores. Got: "${customProjectId}"`, "error");
             return releaseLockAndReturn();
         }
-        // Ensure git repo exists.
-        // Guard against inherited repos: if `base` is a subdirectory of another
-        // git repo that has no .gsd (i.e. the parent project was never initialised
-        // with GSD), create a fresh git repo at `base` so it gets its own identity
-        // hash. Without this, repoIdentity() resolves to the parent repo's hash
-        // and loads milestones from an unrelated project (#1639).
-        if (!nativeIsRepo(base) || isInheritedRepo(base)) {
+        // Ensure git repo exists *locally* at base.
+        // nativeIsRepo() uses `git rev-parse` which traverses up to parent dirs,
+        // so a parent repo can make it return true even when base has no .git of
+        // its own. Check for a local .git instead (defense-in-depth for the case
+        // where isInheritedRepo() returns a false negative, e.g. stale .gsd at
+        // the parent git root). See #2393 and related issue.
+        const hasLocalGit = existsSync(join(base, ".git"));
+        if (!hasLocalGit || isInheritedRepo(base)) {
             const mainBranch = loadEffectiveGSDPreferences()?.preferences?.git?.main_branch || "main";
             nativeInit(base, mainBranch);
         }
@@ -502,6 +503,13 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
                 if (milestoneIds.length > 1) {
                     const issues = [];
                     for (const id of milestoneIds) {
+                        // Skip completed/parked milestones — a leftover CONTEXT-DRAFT.md
+                        // on a finished milestone is harmless residue, not an actionable warning.
+                        if (isDbAvailable()) {
+                            const ms = getMilestone(id);
+                            if (ms?.status === "complete" || ms?.status === "parked")
+                                continue;
+                        }
                         const draft = resolveMilestoneFile(base, id, "CONTEXT-DRAFT");
                         if (draft)
                             issues.push(`${id}: has CONTEXT-DRAFT.md (will pause for discussion)`);

package/dist/resources/extensions/gsd/guided-flow.js

@@ -403,9 +403,14 @@ export async function showDiscuss(ctx, pi, basePath) {
     // Invalidate caches to pick up artifacts written by a just-completed discuss/plan
     invalidateAllCaches();
     const state = await deriveState(basePath);
-    // Guard: no active milestone
+    // No active milestone — check for pending milestones to discuss instead
     if (!state.activeMilestone) {
-        ctx.ui.notify("No active milestone. Run /gsd to create one first.", "warning");
+        const pendingMilestones = state.registry.filter(m => m.status === "pending");
+        if (pendingMilestones.length === 0) {
+            ctx.ui.notify("No active milestone. Run /gsd to create one first.", "warning");
+            return;
+        }
+        await showDiscussQueuedMilestone(ctx, pi, basePath, pendingMilestones);
         return;
     }
     const mid = state.activeMilestone.id;
@@ -526,6 +531,16 @@ export async function showDiscuss(ctx, pi, basePath) {
                 recommended: s.id === firstUndiscussedId,
             };
         });
+        // Offer access to queued milestones when any exist
+        const pendingMilestones = state.registry.filter(m => m.status === "pending");
+        if (pendingMilestones.length > 0) {
+            actions.push({
+                id: "discuss_queued_milestone",
+                label: "Discuss a queued milestone",
+                description: `Refine context for ${pendingMilestones.length} queued milestone(s). Does not affect current execution.`,
+                recommended: false,
+            });
+        }
         const choice = await showNextAction(ctx, {
             title: "GSD — Discuss a slice",
             summary: [
@@ -537,6 +552,10 @@ export async function showDiscuss(ctx, pi, basePath) {
         });
         if (choice === "not_yet")
             return;
+        if (choice === "discuss_queued_milestone") {
+            await showDiscussQueuedMilestone(ctx, pi, basePath, pendingMilestones);
+            return;
+        }
         const chosen = pendingSlices.find(s => s.id === choice);
         if (!chosen)
             return;
@@ -564,6 +583,63 @@ export async function showDiscuss(ctx, pi, basePath) {
         invalidateAllCaches();
     }
 }
+// ─── Queued Milestone Discussion ─────────────────────────────────────────────
+/**
+ * Show a picker of queued (pending) milestones and dispatch a discuss flow for
+ * the chosen one. Discussing a queued milestone does NOT activate it — it only
+ * refines the CONTEXT.md artifact so it is better prepared when auto-mode
+ * eventually reaches it.
+ */
+async function showDiscussQueuedMilestone(ctx, pi, basePath, pendingMilestones) {
+    const actions = pendingMilestones.map((m, i) => {
+        const hasContext = !!resolveMilestoneFile(basePath, m.id, "CONTEXT");
+        const hasDraft = !hasContext && !!resolveMilestoneFile(basePath, m.id, "CONTEXT-DRAFT");
+        const contextStatus = hasContext ? "context ✓" : hasDraft ? "draft context" : "no context yet";
+        return {
+            id: m.id,
+            label: `${m.id}: ${m.title}`,
+            description: `[queued] · ${contextStatus}`,
+            recommended: i === 0,
+        };
+    });
+    const choice = await showNextAction(ctx, {
+        title: "GSD — Discuss a queued milestone",
+        summary: [
+            "Select a queued milestone to discuss.",
+            "Discussing will update its context file. It will not be activated.",
+        ],
+        actions,
+        notYetMessage: "Run /gsd discuss when ready.",
+    });
+    if (choice === "not_yet")
+        return;
+    const chosen = pendingMilestones.find(m => m.id === choice);
+    if (!chosen)
+        return;
+    await dispatchDiscussForMilestone(ctx, pi, basePath, chosen.id, chosen.title);
+}
+/**
+ * Dispatch the guided-discuss-milestone prompt for a milestone without
+ * setting pendingAutoStart — so discussing a queued milestone does not
+ * implicitly activate it when the session ends.
+ */
+async function dispatchDiscussForMilestone(ctx, pi, basePath, mid, milestoneTitle) {
+    const draftFile = resolveMilestoneFile(basePath, mid, "CONTEXT-DRAFT");
+    const draftContent = draftFile ? await loadFile(draftFile) : null;
+    const discussMilestoneTemplates = inlineTemplate("context", "Context");
+    const structuredQuestionsAvailable = pi.getActiveTools().includes("ask_user_questions") ? "true" : "false";
+    const basePrompt = loadPrompt("guided-discuss-milestone", {
+        milestoneId: mid,
+        milestoneTitle,
+        inlinedTemplates: discussMilestoneTemplates,
+        structuredQuestionsAvailable,
+        commitInstruction: buildDocsCommitInstruction(`docs(${mid}): milestone context from discuss`),
+    });
+    const prompt = draftContent
+        ? `${basePrompt}\n\n## Prior Discussion (Draft Seed)\n\n${draftContent}`
+        : basePrompt;
+    await dispatchWorkflow(pi, prompt, "gsd-discuss", ctx, "plan-milestone");
+}
 // ─── Smart Entry Point ────────────────────────────────────────────────────────
 /**
  * The one wizard. Reads state, shows contextual options, dispatches into the workflow doc.

package/dist/resources/extensions/gsd/prompts/complete-slice.md

@@ -32,6 +32,6 @@ Then:
 11. Do not run git commands — the system commits your changes and handles any merge after this unit succeeds.
 12. Update `.gsd/PROJECT.md` if it exists — refresh current state if needed.
 
-**You MUST do ALL THREE before finishing: (1) write `{{sliceSummaryPath}}`, (2) write `{{sliceUatPath}}`, (3) call `gsd_complete_slice`. The unit will not be marked complete if any of these are missing.**
+**You MUST call `gsd_complete_slice` with the slice summary and UAT content before finishing. The tool persists to both DB and disk and renders `{{sliceSummaryPath}}` and `{{sliceUatPath}}` automatically.**
 
 When done, say: "Slice {{sliceId}} complete."

package/dist/resources/extensions/gsd/prompts/guided-plan-milestone.md

@@ -10,10 +10,10 @@ Plan milestone {{milestoneId}} ("{{milestoneTitle}}"). Read `.gsd/DECISIONS.md`
 ## Planning Doctrine
 
 - **Risk-first means proof-first.** The earliest slices should prove the hardest thing works by shipping the real feature through the uncertain path. If auth is the risk, the first slice ships a real login page with real session handling that a user can actually use — not a CLI command that returns "authenticated: true". Proof is the shipped feature working. There is no separate "proof" artifact. Do not plan spikes, proof-of-concept slices, or validation-only slices — the proof is the real feature, built through the risky path.
-- **Every slice is vertical, demoable, and shippable.** Every slice ships real, user-facing functionality. "Demoable" means you could show a stakeholder and they'd see real product progress — not a developer showing a terminal command. If the only way to demonstrate the slice is through a test runner or a curl command, the slice is missing its UI/UX surface. Add it. A slice that only proves something but doesn't ship real working code is not a slice — restructure it.
+- **Every slice is vertical, demoable, and shippable.** Every slice ships real, user-facing functionality. "Demoable" means the intended user can exercise the capability through its real interface — for a web app that's the UI, for a CLI tool that's the terminal, for an API that's a consuming client or curl. The test is: can someone *use* it, not just *assert* it passes. A slice that only proves something but doesn't ship real working code is not a slice — restructure it.
 - **Brownfield bias.** When planning against an existing codebase, ground slices in existing modules, conventions, and seams. Prefer extending real patterns over inventing new ones.
 - **Each slice should establish something downstream slices can depend on.** Think about what stable surface this slice creates for later work — an API, a data shape, a proven integration path.
-- **Avoid foundation-only slices.** If a slice doesn't produce something demoable end-to-end, it's probably a layer, not a vertical slice. Restructure it.
+- **Avoid foundation-only slices.** If a slice doesn't produce something demoable end-to-end, it's probably a layer, not a vertical slice. Restructure it. Exception: if the infrastructure *is* the product surface (a new protocol, extension API, or provider interface), the slice is vertical by definition — the downstream consumer is the demo.
 - **Verification-first.** When planning slices, know what "done" looks like before detailing implementation. Each slice's demo line should describe concrete, verifiable evidence — not vague "it works" claims.
 - **Plan for integrated reality, not just local proof.** Distinguish contract proof from live integration proof. If the milestone involves multiple runtime boundaries, one slice must explicitly prove the assembled system through the real entrypoint or runtime path.
 - **Truthful demo lines only.** If a slice is proven by fixtures or tests only, say so. Do not phrase harness-level proof as if the user can already perform the live end-to-end behavior unless that has actually been exercised.

package/dist/resources/extensions/gsd/prompts/plan-milestone.md

@@ -64,10 +64,10 @@ Then:
 Apply these when decomposing and ordering slices:
 
 - **Risk-first means proof-first.** The earliest slices should prove the hardest thing works by shipping the real feature through the uncertain path. If auth is the risk, the first slice ships a real login page with real session handling that a user can actually use — not a CLI command that returns "authenticated: true". Proof is the shipped feature working. There is no separate "proof" artifact. Do not plan spikes, proof-of-concept slices, or validation-only slices — the proof is the real feature, built through the risky path.
-- **Every slice is vertical, demoable, and shippable.** Every slice ships real, user-facing functionality. "Demoable" means you could show a stakeholder and they'd see real product progress — not a developer showing a terminal command. If the only way to demonstrate the slice is through a test runner or a curl command, the slice is missing its UI/UX surface. Add it. A slice that only proves something but doesn't ship real working code is not a slice — restructure it.
+- **Every slice is vertical, demoable, and shippable.** Every slice ships real, user-facing functionality. "Demoable" means the intended user can exercise the capability through its real interface — for a web app that's the UI, for a CLI tool that's the terminal, for an API that's a consuming client or curl. The test is: can someone *use* it, not just *assert* it passes. A slice that only proves something but doesn't ship real working code is not a slice — restructure it.
 - **Brownfield bias.** When planning against an existing codebase, ground slices in existing modules, conventions, and seams. Prefer extending real patterns over inventing new ones.
 - **Each slice should establish something downstream slices can depend on.** Think about what stable surface this slice creates for later work — an API, a data shape, a proven integration path.
-- **Avoid foundation-only slices.** If a slice doesn't produce something demoable end-to-end, it's probably a layer, not a vertical slice. Restructure it.
+- **Avoid foundation-only slices.** If a slice doesn't produce something demoable end-to-end, it's probably a layer, not a vertical slice. Restructure it. Exception: if the infrastructure *is* the product surface (a new protocol, extension API, or provider interface), the slice is vertical by definition — the downstream consumer is the demo.
 - **Verification-first.** When planning slices, know what "done" looks like before detailing implementation. Each slice's demo line should describe concrete, verifiable evidence — not vague "it works" claims.
 - **Plan for integrated reality, not just local proof.** Distinguish contract proof from live integration proof. If the milestone involves multiple runtime boundaries, one slice must explicitly prove the assembled system through the real entrypoint or runtime path.
 - **Truthful demo lines only.** If a slice is proven by fixtures or tests only, say so. Do not phrase harness-level proof as if the user can already perform the live end-to-end behavior unless that has actually been exercised.

package/dist/resources/extensions/gsd/prompts/plan-slice.md

@@ -77,6 +77,6 @@ Then:
 
 The slice directory and tasks/ subdirectory already exist. Do NOT mkdir. All work stays in your working directory: `{{workingDirectory}}`.
 
-**You MUST write the file `{{outputPath}}` before finishing.**
+**You MUST call `gsd_plan_slice` to persist the planning state before finishing.**
 
 When done, say: "Slice {{sliceId}} planned."

package/dist/resources/extensions/gsd/prompts/research-milestone.md

@@ -28,7 +28,7 @@ Then research the codebase and relevant technologies. Narrate key findings and s
 5. **Web search budget:** You have a limited budget of web searches (max ~15 per session). Use them strategically — prefer `resolve_library` / `get_library_docs` for library documentation. Do NOT repeat the same or similar queries. If a search didn't find what you need, rephrase once or move on. Target 3-5 total web searches for a typical research unit.
 6. Use the **Research** output template from the inlined context above — include only sections that have real content
 7. If `.gsd/REQUIREMENTS.md` exists, research against it. Identify which Active requirements are table stakes, likely omissions, overbuilt risks, or domain-standard behaviors the user may or may not want.
-8. Write `{{outputPath}}`
+8. Call `gsd_summary_save` with `milestone_id: {{milestoneId}}`, `artifact_type: "RESEARCH"`, and the full research markdown as `content` — the tool computes the file path and persists to both DB and disk.
 
 ## Strategic Questions to Answer
 
@@ -42,6 +42,6 @@ Then research the codebase and relevant technologies. Narrate key findings and s
 
 **Research is advisory, not auto-binding.** Surface candidate requirements clearly instead of silently expanding scope.
 
-**You MUST write the file `{{outputPath}}` before finishing.**
+**You MUST call `gsd_summary_save` with the research content before finishing.**
 
 When done, say: "Milestone {{milestoneId}} researched."

package/dist/resources/extensions/gsd/prompts/run-uat.md

@@ -55,7 +55,7 @@ After running all checks, compute the **overall verdict**:
 - `FAIL` — one or more checks failed
 - `PARTIAL` — some checks passed, but one or more checks were skipped, inconclusive, or still require human judgment
 
-Write `{{uatResultPath}}` with:
+Call `gsd_summary_save` with `milestone_id: {{milestoneId}}`, `slice_id: {{sliceId}}`, `artifact_type: "ASSESSMENT"`, and the full UAT result markdown as `content` — the tool computes the file path and persists to both DB and disk. The content should follow this format:
 
 ```markdown
 ---
@@ -84,6 +84,6 @@ date: <ISO 8601 timestamp>
 
 ---
 
-**You MUST write `{{uatResultPath}}` before finishing.**
+**You MUST call `gsd_summary_save` with the UAT result content before finishing.**
 
 When done, say: "UAT {{sliceId}} complete."

package/dist/resources/extensions/gsd/repo-identity.js

@@ -112,8 +112,11 @@ export function isInheritedRepo(basePath) {
         // (i.e. the parent project was initialised with GSD).
         if (isProjectGsd(join(root, ".gsd")))
             return false;
-        // Also walk up from basePath to the git root checking for .gsd
-        let dir = normalizedBase;
+        // Walk up from basePath's parent to the git root checking for .gsd.
+        // Start at dirname(normalizedBase), NOT normalizedBase itself — finding
+        // .gsd at basePath means GSD state is set up for THIS project, which
+        // says nothing about whether the git repo is inherited from an ancestor.
+        let dir = dirname(normalizedBase);
         while (dir !== normalizedRoot && dir !== dirname(dir)) {
             if (isProjectGsd(join(dir, ".gsd")))
                 return false;

package/dist/resources/extensions/gsd/session-forensics.js

@@ -126,7 +126,16 @@ export function extractTrace(entries) {
                 }
             }
             if (isError && resultText) {
-                errors.push(resultText.slice(0, 300));
+                // Filter out benign "errors" that are normal during code exploration:
+                // - grep/rg/find returning exit code 1 (no matches) is expected POSIX behavior
+                // - User interrupts (Escape/skip) are intentional, not failures
+                const trimmed = resultText.trim();
+                const isBenignNoMatch = pending?.name === "bash" &&
+                    /^\(no output\)\s*\n\s*Command exited with code 1$/m.test(trimmed);
+                const isUserSkip = /^Skipped due to queued user message/i.test(trimmed);
+                if (!isBenignNoMatch && !isUserSkip) {
+                    errors.push(resultText.slice(0, 300));
+                }
             }
         }
     }

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

@@ -9,7 +9,7 @@ import { nativeBatchParseGsdFiles } from './native-parser-bridge.js';
 import { join, resolve } from 'path';
 import { existsSync, readdirSync } from 'node:fs';
 import { debugCount, debugTime } from './debug-logger.js';
-import { isDbAvailable, getAllMilestones, getMilestoneSlices, getSliceTasks, getReplanHistory, getSlice, insertMilestone, } from './gsd-db.js';
+import { isDbAvailable, getAllMilestones, getMilestoneSlices, getSliceTasks, getReplanHistory, getSlice, insertMilestone, updateTaskStatus, } from './gsd-db.js';
 /**
  * A "ghost" milestone directory contains only META.json (and no substantive
  * files like CONTEXT, CONTEXT-DRAFT, ROADMAP, or SUMMARY).  These appear when
@@ -524,7 +524,34 @@ export async function deriveStateFromDb(basePath) {
         };
     }
     // ── Get tasks from DB ────────────────────────────────────────────────
-    const tasks = getSliceTasks(activeMilestone.id, activeSlice.id);
+    let tasks = getSliceTasks(activeMilestone.id, activeSlice.id);
+    // ── Reconcile stale task status (#2514) ──────────────────────────────
+    // When a session disconnects after the agent writes SUMMARY + VERIFY
+    // artifacts but before postUnitPostVerification updates the DB, tasks
+    // remain "pending" in the DB despite being complete on disk. Without
+    // reconciliation, deriveState keeps returning the stale task as active,
+    // causing the dispatcher to re-dispatch the same completed task forever.
+    let reconciled = false;
+    for (const t of tasks) {
+        if (isStatusDone(t.status))
+            continue;
+        const summaryPath = resolveTaskFile(basePath, activeMilestone.id, activeSlice.id, t.id, "SUMMARY");
+        if (summaryPath && existsSync(summaryPath)) {
+            try {
+                updateTaskStatus(activeMilestone.id, activeSlice.id, t.id, "complete");
+                process.stderr.write(`gsd-reconcile: task ${activeMilestone.id}/${activeSlice.id}/${t.id} had SUMMARY on disk but DB status was "${t.status}" — updated to "complete" (#2514)\n`);
+                reconciled = true;
+            }
+            catch (e) {
+                // DB write failed — continue with stale status rather than crash
+                process.stderr.write(`gsd-reconcile: failed to update task ${t.id}: ${e.message}\n`);
+            }
+        }
+    }
+    // Re-fetch tasks if any were reconciled so downstream logic sees fresh status
+    if (reconciled) {
+        tasks = getSliceTasks(activeMilestone.id, activeSlice.id);
+    }
     const taskProgress = {
         done: tasks.filter(t => isStatusDone(t.status)).length,
         total: tasks.length,