gsd-pi 2.46.0 → 2.46.1-dev.44f59e2

package/src/resources/extensions/claude-code-cli/sdk-types.ts

@@ -0,0 +1,149 @@
+/**
+ * Lightweight type mirrors for the Claude Agent SDK.
+ *
+ * These stubs allow the extension to compile without a hard dependency on
+ * `@anthropic-ai/claude-agent-sdk`. The real SDK is imported dynamically
+ * at runtime in stream-adapter.ts.
+ */
+
+/** UUID branded string from the SDK. */
+export type UUID = string;
+
+/** BetaMessage from the Anthropic SDK, as wrapped by SDKAssistantMessage. */
+export interface BetaMessage {
+	id: string;
+	type: "message";
+	role: "assistant";
+	content: BetaContentBlock[];
+	model: string;
+	stop_reason: "end_turn" | "max_tokens" | "stop_sequence" | "tool_use" | null;
+	usage: { input_tokens: number; output_tokens: number };
+}
+
+export type BetaContentBlock =
+	| { type: "text"; text: string }
+	| { type: "thinking"; thinking: string; signature?: string }
+	| { type: "tool_use"; id: string; name: string; input: Record<string, unknown> }
+	| { type: "server_tool_use"; id: string; name: string; input: unknown }
+	| { type: "web_search_tool_result"; tool_use_id: string; content: unknown };
+
+/** Streaming event emitted when includePartialMessages is true. */
+export interface BetaRawMessageStreamEvent {
+	type: string;
+	index?: number;
+	content_block?: BetaContentBlock;
+	delta?: Record<string, unknown>;
+}
+
+export interface SDKAssistantMessage {
+	type: "assistant";
+	uuid: UUID;
+	session_id: string;
+	message: BetaMessage;
+	parent_tool_use_id: string | null;
+	error?: { type: string; message: string };
+}
+
+export interface SDKUserMessage {
+	type: "user";
+	uuid?: UUID;
+	session_id: string;
+	message: unknown;
+	parent_tool_use_id: string | null;
+	isSynthetic?: boolean;
+	tool_use_result?: unknown;
+}
+
+export interface SDKSystemMessage {
+	type: "system";
+	subtype: "init";
+	[key: string]: unknown;
+}
+
+export interface SDKStatusMessage {
+	type: "system";
+	subtype: "status";
+	status: "compacting" | null;
+	uuid: UUID;
+	session_id: string;
+}
+
+export interface SDKPartialAssistantMessage {
+	type: "stream_event";
+	event: BetaRawMessageStreamEvent;
+	parent_tool_use_id: string | null;
+	uuid: UUID;
+	session_id: string;
+}
+
+export interface SDKToolProgressMessage {
+	type: "tool_progress";
+	tool_use_id: string;
+	tool_name: string;
+	parent_tool_use_id: string | null;
+	elapsed_time_seconds: number;
+	task_id?: string;
+	uuid: UUID;
+	session_id: string;
+}
+
+export interface NonNullableUsage {
+	input_tokens: number;
+	output_tokens: number;
+	cache_read_input_tokens: number;
+	cache_creation_input_tokens: number;
+}
+
+export type SDKResultMessage =
+	| {
+			type: "result";
+			subtype: "success";
+			uuid: UUID;
+			session_id: string;
+			duration_ms: number;
+			duration_api_ms: number;
+			is_error: boolean;
+			num_turns: number;
+			result: string;
+			stop_reason: string | null;
+			total_cost_usd: number;
+			usage: NonNullableUsage;
+	  }
+	| {
+			type: "result";
+			subtype:
+				| "error_max_turns"
+				| "error_during_execution"
+				| "error_max_budget_usd"
+				| "error_max_structured_output_retries";
+			uuid: UUID;
+			session_id: string;
+			duration_ms: number;
+			duration_api_ms: number;
+			is_error: boolean;
+			num_turns: number;
+			stop_reason: string | null;
+			total_cost_usd: number;
+			usage: NonNullableUsage;
+			errors: string[];
+	  };
+
+/** Catch-all for SDK message types we don't map. */
+export interface SDKOtherMessage {
+	type: string;
+	[key: string]: unknown;
+}
+
+/**
+ * Union of all SDK message types this extension handles.
+ * Mirrors the real `SDKMessage` from `@anthropic-ai/claude-agent-sdk`.
+ */
+export type SDKMessage =
+	| SDKAssistantMessage
+	| SDKUserMessage
+	| SDKResultMessage
+	| SDKSystemMessage
+	| SDKStatusMessage
+	| SDKPartialAssistantMessage
+	| SDKToolProgressMessage
+	| SDKOtherMessage;

package/src/resources/extensions/claude-code-cli/stream-adapter.ts

@@ -0,0 +1,355 @@
+/**
+ * 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 type {
+	AssistantMessage,
+	AssistantMessageEvent,
+	AssistantMessageEventStream,
+	Context,
+	Model,
+	SimpleStreamOptions,
+} from "@gsd/pi-ai";
+import { EventStream } from "@gsd/pi-ai";
+import { execSync } from "node:child_process";
+import { PartialMessageBuilder, ZERO_USAGE, mapUsage } from "./partial-builder.js";
+import type {
+	SDKAssistantMessage,
+	SDKMessage,
+	SDKPartialAssistantMessage,
+	SDKResultMessage,
+	SDKSystemMessage,
+	SDKStatusMessage,
+	SDKUserMessage,
+} from "./sdk-types.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(): AssistantMessageEventStream {
+	return new EventStream<AssistantMessageEvent, AssistantMessage>(
+		(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");
+		},
+	) as AssistantMessageEventStream;
+}
+
+// ---------------------------------------------------------------------------
+// Claude binary resolution
+// ---------------------------------------------------------------------------
+
+let cachedClaudePath: string | null = 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(): string {
+	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: Context): string {
+	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: any) => part.type === "text")
+					.map((part: any) => part.text);
+				if (textParts.length > 0) return textParts.join("\n");
+			}
+		}
+	}
+	return "";
+}
+
+// ---------------------------------------------------------------------------
+// Error helper
+// ---------------------------------------------------------------------------
+
+function makeErrorMessage(model: string, errorMsg: string): AssistantMessage {
+	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: Model<any>,
+	context: Context,
+	options?: SimpleStreamOptions,
+): AssistantMessageEventStream {
+	const stream = createAssistantStream();
+
+	void pumpSdkMessages(model, context, options, stream);
+
+	return stream;
+}
+
+async function pumpSdkMessages(
+	model: Model<any>,
+	context: Context,
+	options: SimpleStreamOptions | undefined,
+	stream: AssistantMessageEventStream,
+): Promise<void> {
+	const modelId = model.id;
+	let builder: PartialMessageBuilder | null = null;
+	/** Track the last text content seen across all assistant turns for the final message. */
+	let lastTextContent = "";
+	let lastThinkingContent = "";
+
+	try {
+		// Dynamic import — the SDK is an optional dependency.
+		const sdkModule = "@anthropic-ai/claude-agent-sdk";
+		const sdk = (await import(/* webpackIgnore: true */ sdkModule)) as {
+			query: (args: {
+				prompt: string | AsyncIterable<unknown>;
+				options?: Record<string, unknown>;
+			}) => AsyncIterable<SDKMessage>;
+		};
+
+		// 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: AssistantMessage = {
+			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 as AsyncIterable<SDKMessage>) {
+			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 as SDKPartialAssistantMessage;
+					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 as any).message?.model ?? modelId,
+						);
+						break;
+					}
+
+					if (!builder) break;
+
+					const assistantEvent = builder.handleEvent(event);
+					if (assistantEvent) {
+						stream.push(assistantEvent);
+					}
+					break;
+				}
+
+				// -- Complete assistant message (non-streaming fallback) --
+				case "assistant": {
+					const sdkAssistant = msg as SDKAssistantMessage;
+					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 as SDKUserMessage;
+					if (userMsg.parent_tool_use_id !== null) break;
+
+					// Capture accumulated text from the builder 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;
+							}
+						}
+					}
+					builder = null;
+					break;
+				}
+
+				// -- Result (terminal) --
+				case "result": {
+					const result = msg as SDKResultMessage;
+
+					// Build final message with text/thinking only (strip tool calls)
+					const finalContent: AssistantMessage["content"] = [];
+
+					// Use builder's accumulated content if available, falling back to captured text
+					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;
+							}
+						}
+					}
+
+					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: AssistantMessage = {
+						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 as any).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: AssistantMessage["content"] = [];
+		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: AssistantMessage = {
+			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/src/resources/extensions/gsd/auto-start.ts

@@ -140,13 +140,14 @@ export async function bootstrapAutoSession(
       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);
@@ -549,17 +550,17 @@ export async function bootstrapAutoSession(
       const hasDecisions = existsSync(join(gsdDirPath, "DECISIONS.md"));
       const hasRequirements = existsSync(join(gsdDirPath, "REQUIREMENTS.md"));
       const hasMilestones = existsSync(join(gsdDirPath, "milestones"));
-      if (hasDecisions || hasRequirements || hasMilestones) {
-        try {
-          const { openDatabase: openDb } = await import("./gsd-db.js");
+      try {
+        const { openDatabase: openDb } = await import("./gsd-db.js");
+        openDb(gsdDbPath);
+        if (hasDecisions || hasRequirements || hasMilestones) {
           const { migrateFromMarkdown } = await import("./md-importer.js");
-          openDb(gsdDbPath);
           migrateFromMarkdown(s.basePath);
-        } catch (err) {
-          process.stderr.write(
-            `gsd-migrate: auto-migration failed: ${(err as Error).message}\n`,
-          );
         }
+      } catch (err) {
+        process.stderr.write(
+          `gsd-migrate: auto-migration failed: ${(err as Error).message}\n`,
+        );
       }
     }
     if (existsSync(gsdDbPath) && !isDbAvailable()) {

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

@@ -67,6 +67,9 @@ export async function ensureDbOpen(): Promise<boolean> {
         }
         return opened;
       }
+
+      // .gsd/ exists but has no Markdown content (fresh project) — create empty DB
+      return db.openDatabase(dbPath);
     }
 
     return false;

package/src/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/src/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/src/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/src/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/src/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/src/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/src/resources/extensions/gsd/repo-identity.ts

@@ -127,8 +127,11 @@ export function isInheritedRepo(basePath: string): boolean {
     // (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;
       dir = dirname(dir);