@opengsd/gsd-pi 1.2.0-dev.844675c9 → 1.2.0-dev.b1abb545

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

@@ -38,6 +38,8 @@ import {
 } from "../stream-adapter.ts";
 import type { AssistantMessage, Context, Message } from "@gsd/pi-ai";
 import type { SDKUserMessage } from "../sdk-types.ts";
+import { _setAutoActiveForTest } from "../../gsd/auto.ts";
+import { getInFlightToolCount, hasInteractiveToolInFlight, clearInFlightTools, isInteractiveElicitationInFlight } from "../../gsd/auto-tool-tracking.ts";
 
 // ---------------------------------------------------------------------------
 // Env helpers — `GSD_WORKFLOW_MCP_*` save/restore
@@ -58,6 +60,7 @@ const WORKFLOW_MCP_ENV_KEYS = [
 	"GSD_WORKFLOW_MCP_ARGS",
 	"GSD_WORKFLOW_MCP_ENV",
 	"GSD_WORKFLOW_MCP_CWD",
+	"GSD_WORKFLOW_MCP_STRUCTURED_QUESTIONS",
 	"GSD_PROJECT_ROOT",
 	"GSD_WORKFLOW_PROJECT_ROOT",
 ] as const;
@@ -1043,6 +1046,31 @@ describe("stream-adapter — session persistence (#2859)", () => {
 		}
 	});
 
+	test("buildSdkOptions can disable workflow MCP ask_user_questions explicitly", () => {
+		const restore = setWorkflowMcpEnv({
+			GSD_WORKFLOW_MCP_COMMAND: "node",
+			GSD_WORKFLOW_MCP_NAME: "gsd-workflow",
+			GSD_WORKFLOW_MCP_ARGS: JSON.stringify(["packages/mcp-server/dist/cli.js"]),
+			GSD_WORKFLOW_MCP_CWD: "/tmp/project",
+			GSD_WORKFLOW_MCP_STRUCTURED_QUESTIONS: "0",
+		});
+		const originalCwd = process.cwd();
+		const emptyDir = mkdtempSync(join(tmpdir(), "claude-mcp-ask-disabled-"));
+		try {
+			process.chdir(emptyDir);
+			const options = buildSdkOptions("claude-sonnet-4-20250514", "test");
+			assert.ok(
+				(options.disallowedTools as string[]).includes("mcp__gsd-workflow__ask_user_questions"),
+				"explicit opt-out must block the MCP question tool even when workflow wildcard is allowed",
+			);
+			assert.ok((options.disallowedTools as string[]).includes("AskUserQuestion"));
+		} finally {
+			process.chdir(originalCwd);
+			rmSync(emptyDir, { recursive: true, force: true });
+			restore();
+		}
+	});
+
 	test("buildSdkOptions scopes run-uat to exact workflow MCP tools", () => {
 		const restore = setWorkflowMcpEnv({
 			GSD_WORKFLOW_MCP_COMMAND: "node",
@@ -1140,6 +1168,38 @@ describe("stream-adapter — session persistence (#2859)", () => {
 		assert.equal(inferGsdPhaseFromContext(context), "plan-milestone");
 	});
 
+	test("buildSdkOptions presents ask_user_questions for discuss phases", () => {
+		const restore = setWorkflowMcpEnv({
+			GSD_WORKFLOW_MCP_COMMAND: "node",
+			GSD_WORKFLOW_MCP_NAME: "gsd-workflow",
+			GSD_WORKFLOW_MCP_ARGS: JSON.stringify(["packages/mcp-server/dist/cli.js"]),
+			GSD_WORKFLOW_MCP_ENV: JSON.stringify({ GSD_CLI_PATH: "/tmp/gsd" }),
+			GSD_WORKFLOW_MCP_CWD: "/tmp/project",
+		});
+		const originalCwd = process.cwd();
+		const emptyDir = mkdtempSync(join(tmpdir(), "claude-mcp-discuss-"));
+		try {
+			process.chdir(emptyDir);
+			const options = buildSdkOptions("claude-sonnet-4-20250514", "test", undefined, { gsdPhase: "discuss-milestone" });
+			const allowedTools = options.allowedTools as string[];
+			const disallowedTools = options.disallowedTools as string[];
+
+			assert.ok(
+				allowedTools.includes("mcp__gsd-workflow__ask_user_questions"),
+				"discuss phases must expose the exact workflow MCP question tool",
+			);
+			assert.ok(disallowedTools.includes("AskUserQuestion"));
+			assert.ok(
+				!disallowedTools.includes("mcp__gsd-workflow__ask_user_questions"),
+				"workflow MCP ask_user_questions should remain enabled by default",
+			);
+		} finally {
+			process.chdir(originalCwd);
+			rmSync(emptyDir, { recursive: true, force: true });
+			restore();
+		}
+	});
+
 	test("buildSdkOptions prefers custom workflow MCP question tools over native AskUserQuestion", () => {
 		const restore = setWorkflowMcpEnv({
 			GSD_WORKFLOW_MCP_COMMAND: "node",
@@ -1662,6 +1722,26 @@ describe("stream-adapter — MCP elicitation bridge", () => {
 		});
 	});
 
+	test("createClaudeCodeElicitationHandler returns cancel when custom UI is dismissed", async () => {
+		let selectCalls = 0;
+		const handler = createClaudeCodeElicitationHandler({
+			custom: async () => ({
+				endInterview: false,
+				answers: {},
+			}),
+			select: async () => {
+				selectCalls++;
+				return "Cloud-synced";
+			},
+		} as any);
+		assert.ok(handler);
+
+		const result = await handler!(askUserQuestionsRequest, { signal: new AbortController().signal });
+
+		assert.deepEqual(result, { action: "cancel" });
+		assert.equal(selectCalls, 0, "dismissed custom question must not re-open dialog fallback");
+	});
+
 	test("parseTextInputElicitation recognizes secure free-text MCP forms", () => {
 		const request = {
 			serverName: "gsd-workflow",
@@ -1773,6 +1853,166 @@ describe("stream-adapter — MCP elicitation bridge", () => {
 		assert.equal(inputCalls.length, 1);
 		assert.equal(inputCalls[0]?.opts?.secure, true, "secure_env_collect fields should request secure input");
 	});
+
+	// -- self-cancel loop fix (#2676 / claude-code-cli) ----------------------
+	//
+	// Under claude-code-cli, ask_user_questions arrives as an SDK elicitation,
+	// not an MCP tool dispatch, so the auto-mode watchdogs never saw an in-flight
+	// tool during the human wait and re-dispatched/aborted the turn hosting the
+	// question (the "self-cancel loop"). The fix brackets the human wait with the
+	// interactive-tool guard and disambiguates a system-teardown abort (decline)
+	// from a deliberate user dismissal (cancel).
+
+	test("makes the SDK elicitation visible to the interactive-tool guard during the human wait", async () => {
+		_setAutoActiveForTest(true);
+		clearInFlightTools();
+		try {
+			let countDuringWait = -1;
+			let interactiveDuringWait = false;
+			const handler = createClaudeCodeElicitationHandler({
+				custom: async () => {
+					// Observe the in-flight guard state WHILE the question is open —
+					// this is the window where the watchdogs previously saw 0 tools.
+					countDuringWait = getInFlightToolCount();
+					interactiveDuringWait = hasInteractiveToolInFlight();
+					return {
+						endInterview: false,
+						answers: { storage_scope: { selected: "Cloud-synced", notes: "" }, platform: { selected: ["Web"], notes: "" } },
+					};
+				},
+			} as any);
+			assert.ok(handler);
+
+			const result = await handler!(askUserQuestionsRequest, { signal: new AbortController().signal });
+
+			assert.equal(countDuringWait, 1, "elicitation must register as an in-flight tool during the human wait");
+			assert.equal(interactiveDuringWait, true, "elicitation must be recognized as an interactive tool during the wait");
+			assert.equal(result.action, "accept");
+			assert.equal(getInFlightToolCount(), 0, "in-flight tool must be cleared after the elicitation resolves");
+		} finally {
+			_setAutoActiveForTest(false);
+			clearInFlightTools();
+		}
+	});
+
+	test("clears the in-flight tool even when the interview UI throws (finally)", async () => {
+		_setAutoActiveForTest(true);
+		clearInFlightTools();
+		try {
+			const handler = createClaudeCodeElicitationHandler({
+				// custom throws -> showInterviewRound rejects -> handler falls back
+				// to dialogs; the in-flight entry must still be cleared via finally.
+				custom: async () => {
+					throw new Error("simulated UI failure");
+				},
+				select: async (_title: string, options: string[], opts?: { allowMultiple?: boolean }) => {
+					if (opts?.allowMultiple) return ["Web"];
+					return options[0];
+				},
+				input: async () => "note",
+			} as any);
+			assert.ok(handler);
+
+			await handler!(askUserQuestionsRequest, { signal: new AbortController().signal });
+			assert.equal(getInFlightToolCount(), 0, "in-flight tool must be cleared even when the UI throws");
+		} finally {
+			_setAutoActiveForTest(false);
+			clearInFlightTools();
+		}
+	});
+
+	test("returns decline (not cancel) when an interrupt empties the answers", async () => {
+		// A system/host teardown that aborts the signal mid-wait surfaces as
+		// interrupted:true -> the handler must return decline so the model does
+		// not re-ask against a clean user-declined cancel (the re-ask amplifier).
+		const handler = createClaudeCodeElicitationHandler({
+			custom: async () => ({ endInterview: false, answers: {}, interrupted: true }),
+			select: async () => {
+				throw new Error("interrupted elicitation must not re-open dialogs");
+			},
+		} as any);
+		assert.ok(handler);
+
+		const result = await handler!(askUserQuestionsRequest, { signal: new AbortController().signal });
+		assert.deepEqual(result, { action: "decline" });
+	});
+
+	test("returns cancel (today's semantics) when the user genuinely dismisses", async () => {
+		const handler = createClaudeCodeElicitationHandler({
+			custom: async () => ({ endInterview: false, answers: {} }),
+		} as any);
+		assert.ok(handler);
+
+		const result = await handler!(askUserQuestionsRequest, { signal: new AbortController().signal });
+		assert.deepEqual(result, { action: "cancel" });
+	});
+
+	test("does not register an in-flight tool outside auto-mode (wrapper self-gates)", async () => {
+		_setAutoActiveForTest(false);
+		clearInFlightTools();
+		let countDuringWait = -1;
+		const handler = createClaudeCodeElicitationHandler({
+			custom: async () => {
+				countDuringWait = getInFlightToolCount();
+				return { endInterview: false, answers: { storage_scope: { selected: "Cloud-synced", notes: "" }, platform: { selected: ["Web"], notes: "" } } };
+			},
+		} as any);
+		assert.ok(handler);
+
+		await handler!(askUserQuestionsRequest, { signal: new AbortController().signal });
+		assert.equal(countDuringWait, 0, "foreground/non-auto elicitation must not touch the in-flight guard");
+	});
+
+	// The FOREGROUND self-cancel regression guard: the s.active-gated in-flight
+	// guard above is a no-op in foreground, so the foreground approval-gate pause
+	// path needs a SEPARATE, ungated signal to see the elicitation as the active
+	// human boundary. isInteractiveElicitationInFlight() must be true DURING the
+	// wait and false after, even with auto inactive (#cc-elicitation-self-cancel).
+	test("sets the ungated interactive-elicitation marker in FOREGROUND (auto inactive)", async () => {
+		_setAutoActiveForTest(false);
+		clearInFlightTools();
+		try {
+			let markerDuringWait = false;
+			let countDuringWait = -1;
+			const handler = createClaudeCodeElicitationHandler({
+				custom: async () => {
+					markerDuringWait = isInteractiveElicitationInFlight();
+					countDuringWait = getInFlightToolCount();
+					return {
+						endInterview: false,
+						answers: { storage_scope: { selected: "Cloud-synced", notes: "" }, platform: { selected: ["Web"], notes: "" } },
+					};
+				},
+			} as any);
+			assert.ok(handler);
+
+			const result = await handler!(askUserQuestionsRequest, { signal: new AbortController().signal });
+
+			assert.equal(markerDuringWait, true, "ungated marker must be true during the foreground human wait");
+			assert.equal(countDuringWait, 0, "the separate marker must NOT touch the in-flight tool count in foreground");
+			assert.equal(result.action, "accept");
+			assert.equal(isInteractiveElicitationInFlight(), false, "marker must clear after the elicitation resolves");
+		} finally {
+			clearInFlightTools();
+		}
+	});
+
+	test("clears the ungated marker even when the interview UI throws in FOREGROUND (finally)", async () => {
+		_setAutoActiveForTest(false);
+		clearInFlightTools();
+		try {
+			const handler = createClaudeCodeElicitationHandler({
+				custom: async () => {
+					throw new Error("ui exploded");
+				},
+			} as any);
+			assert.ok(handler);
+			await handler!(askUserQuestionsRequest, { signal: new AbortController().signal }).catch(() => undefined);
+			assert.equal(isInteractiveElicitationInFlight(), false, "marker must clear via finally on throw");
+		} finally {
+			clearInFlightTools();
+		}
+	});
 });
 
 // ---------------------------------------------------------------------------

package/src/resources/extensions/claude-code-cli/turn-assembler.ts

@@ -0,0 +1,287 @@
+// gsd-pi - Claude Code logical turn assembly
+
+import type {
+	AssistantMessage,
+	AssistantMessageEvent,
+	ToolCall,
+} from "@gsd/pi-ai";
+import { PartialMessageBuilder } from "./partial-builder.js";
+import type {
+	BetaRawMessageStreamEvent,
+	SDKUserMessage,
+} from "./sdk-types.js";
+
+/** A single content block returned by an external (SDK-executed) tool call. */
+export interface ExternalToolResultContentBlock {
+	type: string;
+	text?: string;
+	data?: string;
+	mimeType?: string;
+}
+
+/** The full result payload returned by an external tool, including content blocks and error status. */
+export interface ExternalToolResultPayload {
+	content: ExternalToolResultContentBlock[];
+	details?: Record<string, unknown>;
+	isError: boolean;
+}
+
+/** A `ToolCall` block augmented with the external result attached by the SDK synthetic user message. */
+export type ToolCallWithExternalResult = ToolCall & {
+	externalResult?: ExternalToolResultPayload;
+};
+
+/** Normalise heterogeneous SDK tool-result content (string, array, or object) into a uniform `ExternalToolResultContentBlock[]`. */
+function normalizeToolResultContent(content: unknown): ExternalToolResultContentBlock[] {
+	if (typeof content === "string") {
+		return [{ type: "text", text: content }];
+	}
+
+	if (!Array.isArray(content)) {
+		if (content == null) return [{ type: "text", text: "" }];
+		return [{ type: "text", text: JSON.stringify(content) }];
+	}
+
+	const blocks: ExternalToolResultContentBlock[] = [];
+
+	for (const item of content) {
+		if (typeof item === "string") {
+			blocks.push({ type: "text", text: item });
+			continue;
+		}
+		if (!item || typeof item !== "object") {
+			blocks.push({ type: "text", text: String(item) });
+			continue;
+		}
+
+		const block = item as Record<string, unknown>;
+		if (block.type === "text") {
+			blocks.push({ type: "text", text: typeof block.text === "string" ? block.text : "" });
+			continue;
+		}
+		if (
+			block.type === "image"
+			&& typeof block.data === "string"
+			&& typeof block.mimeType === "string"
+		) {
+			blocks.push({ type: "image", data: block.data, mimeType: block.mimeType });
+			continue;
+		}
+
+		blocks.push({ type: "text", text: JSON.stringify(block) });
+	}
+
+	return blocks.length > 0 ? blocks : [{ type: "text", text: "" }];
+}
+
+/**
+ * Extract a `details` payload from an MCP tool-result block.
+ *
+ * MCP's `CallToolResult` carries structured data in `structuredContent` — the
+ * protocol's supported channel for non-text payloads. Claude Code's synthetic
+ * user message may surface that field in one of two shapes depending on SDK
+ * version: as a sibling on the `mcp_tool_result` block itself, or as a
+ * dedicated content sub-block with `type: "structuredContent"`. Snake-case
+ * (`structured_content`) is accepted defensively in case a transport hop
+ * rewrites casing. All other shapes return undefined, matching the nullable
+ * `details` contract consumed by tool result renderers.
+ */
+function extractStructuredDetailsFromBlock(block: Record<string, unknown>): Record<string, unknown> | undefined {
+	const sibling = block.structuredContent ?? (block as Record<string, unknown>).structured_content;
+	if (sibling && typeof sibling === "object" && !Array.isArray(sibling)) {
+		return sibling as Record<string, unknown>;
+	}
+
+	if (Array.isArray(block.content)) {
+		for (const item of block.content) {
+			if (!item || typeof item !== "object") continue;
+			const sub = item as Record<string, unknown>;
+			if (sub.type !== "structuredContent" && sub.type !== "structured_content") continue;
+			const payload = sub.structuredContent ?? sub.structured_content ?? sub.data ?? sub.value;
+			if (payload && typeof payload === "object" && !Array.isArray(payload)) {
+				return payload as Record<string, unknown>;
+			}
+		}
+	}
+
+	// Return undefined (not {}) when no structured payload is present, matching
+	// the pre-#4477 contract where `details` was nullable. An empty-object
+	// sentinel is truthy and breaks downstream consumers that gate on
+	// `if (details)`. `undefined` matches the type of the field these results
+	// flow into (`Record<string, unknown> | undefined`).
+	return undefined;
+}
+
+/**
+ * True for items that are MCP `structuredContent` pseudo-blocks living inside
+ * a tool-result `content[]` array. These blocks carry the structured payload
+ * (extracted separately by `extractStructuredDetailsFromBlock`) and must NOT
+ * leak into the visible content rendered to the user — otherwise the renderer
+ * stringifies the JSON pseudo-block and shows it next to the actual tool
+ * output. See PR #4477 review (post-fix-round).
+ */
+function isStructuredContentPseudoBlock(item: unknown): boolean {
+	if (!item || typeof item !== "object") return false;
+	const type = (item as Record<string, unknown>).type;
+	return type === "structuredContent" || type === "structured_content";
+}
+
+/**
+ * Strip `structuredContent` pseudo-blocks from a tool-result content array
+ * before normalization. The structured payload is extracted via the sibling
+ * `structuredContent` field (or a dedicated extractor pass on the raw block);
+ * the visible content path must not include the pseudo-block itself.
+ */
+function stripStructuredContentPseudoBlocks(content: unknown): unknown {
+	if (!Array.isArray(content)) return content;
+	return content.filter((item) => !isStructuredContentPseudoBlock(item));
+}
+
+/** Extract tool result payloads from an SDK synthetic user message, keyed by tool-use ID. */
+export function extractToolResultsFromSdkUserMessage(message: SDKUserMessage): Array<{
+	toolUseId: string;
+	result: ExternalToolResultPayload;
+}> {
+	const extracted: Array<{ toolUseId: string; result: ExternalToolResultPayload }> = [];
+	const seen = new Set<string>();
+	const rawMessage = message.message as Record<string, unknown> | null | undefined;
+	const content = Array.isArray(rawMessage?.content) ? rawMessage.content : [];
+
+	for (const item of content) {
+		if (!item || typeof item !== "object") continue;
+		const block = item as Record<string, unknown>;
+		const type = typeof block.type === "string" ? block.type : "";
+		if (type !== "tool_result" && type !== "mcp_tool_result") continue;
+
+		const toolUseId = typeof block.tool_use_id === "string" ? block.tool_use_id : "";
+		if (!toolUseId || seen.has(toolUseId)) continue;
+		seen.add(toolUseId);
+
+		extracted.push({
+			toolUseId,
+			result: {
+				content: normalizeToolResultContent(stripStructuredContentPseudoBlocks(block.content)),
+				details: extractStructuredDetailsFromBlock(block),
+				isError: block.is_error === true,
+			},
+		});
+	}
+
+	if (extracted.length === 0) {
+		const fallback = message.tool_use_result;
+		if (fallback && typeof fallback === "object") {
+			const toolResult = fallback as Record<string, unknown>;
+			const toolUseId = typeof toolResult.tool_use_id === "string" ? toolResult.tool_use_id : "";
+			if (toolUseId) {
+				extracted.push({
+					toolUseId,
+					result: {
+						content: normalizeToolResultContent(stripStructuredContentPseudoBlocks(toolResult.content)),
+						details: extractStructuredDetailsFromBlock(toolResult),
+						isError: toolResult.is_error === true,
+					},
+				});
+			}
+		}
+	}
+
+	return extracted;
+}
+
+/** Attach external tool results from the SDK synthetic user message to their corresponding tool-call blocks by ID. */
+export function attachExternalResultsToToolBlocks(
+	toolBlocks: AssistantMessage["content"],
+	toolResultsById: ReadonlyMap<string, ExternalToolResultPayload>,
+): void {
+	for (const block of toolBlocks) {
+		if (block.type !== "toolCall" && block.type !== "serverToolUse") continue;
+		const externalResult = toolResultsById.get(block.id);
+		if (!externalResult) continue;
+		(block as ToolCallWithExternalResult & { id: string }).externalResult = externalResult;
+	}
+}
+
+/**
+ * Build the final assistant content that Agent Core consumes in
+ * `externalToolExecution` mode. This preserves tool-call blocks, attaches any
+ * SDK-produced external results by tool-call id, and then appends the final
+ * text/thinking blocks for the completed turn.
+ */
+export function buildFinalAssistantContent(params: {
+	intermediateToolBlocks: AssistantMessage["content"];
+	pendingContent?: AssistantMessage["content"];
+	toolResultsById: ReadonlyMap<string, ExternalToolResultPayload>;
+	lastThinkingContent?: string;
+	lastTextContent?: string;
+	fallbackResultText?: string;
+}): AssistantMessage["content"] {
+	const mergedToolBlocks = [...params.intermediateToolBlocks];
+	if (params.pendingContent) {
+		mergePendingToolCalls(mergedToolBlocks, params.pendingContent);
+	}
+	attachExternalResultsToToolBlocks(mergedToolBlocks, params.toolResultsById);
+
+	const finalContent: AssistantMessage["content"] = [...mergedToolBlocks];
+	if (params.pendingContent && params.pendingContent.length > 0) {
+		for (const block of params.pendingContent) {
+			if (block.type === "text" || block.type === "thinking") {
+				finalContent.push(block);
+			}
+		}
+	} else {
+		if (params.lastThinkingContent) {
+			finalContent.push({ type: "thinking", thinking: params.lastThinkingContent });
+		}
+		if (params.lastTextContent) {
+			finalContent.push({ type: "text", text: params.lastTextContent });
+		}
+	}
+
+	if (finalContent.length === 0 && params.fallbackResultText) {
+		finalContent.push({ type: "text", text: params.fallbackResultText });
+	}
+
+	return finalContent;
+}
+
+/**
+ * Merge tool-call blocks from the active partial-message builder into the
+ * running list of intermediate tool calls, preserving order and de-duping
+ * by tool-call id. Exposed for testing the F3 fix (final-turn tool calls
+ * dropped when `result` arrives without a preceding synthetic `user`).
+ */
+export function mergePendingToolCalls(
+	intermediate: AssistantMessage["content"],
+	pending: AssistantMessage["content"],
+): AssistantMessage["content"] {
+	const alreadyIncluded = new Set<string>();
+	for (const block of intermediate) {
+		if (block.type === "toolCall") alreadyIncluded.add(block.id);
+	}
+	for (const block of pending) {
+		if (block.type !== "toolCall") continue;
+		if (alreadyIncluded.has(block.id)) continue;
+		alreadyIncluded.add(block.id);
+		intermediate.push(block);
+	}
+	return intermediate;
+}
+
+export function handleClaudeCodePartialStreamEvent(
+	builder: PartialMessageBuilder | null,
+	event: BetaRawMessageStreamEvent,
+	modelId: string,
+): { builder: PartialMessageBuilder | null; assistantEvent: AssistantMessageEvent | null } {
+	if (event.type === "message_start") {
+		// Claude Code can emit repeated SDK message_start events inside one
+		// logical assistant response. Keep appending until a synthetic user
+		// tool-result boundary explicitly clears the builder.
+		return {
+			builder: builder ?? new PartialMessageBuilder((event as any).message?.model ?? modelId),
+			assistantEvent: null,
+		};
+	}
+
+	if (!builder) return { builder, assistantEvent: null };
+	return { builder, assistantEvent: builder.handleEvent(event) };
+}

package/src/resources/extensions/github-sync/templates.ts

@@ -9,7 +9,7 @@
  * for the `gh` CLI body parameters.
  */
 
-import { buildPrEvidence } from "../gsd/pr-evidence.js";
+import { buildPullRequestEvidence } from "../gsd/pull-request-process.js";
 
 // ─── Helpers ────────────────────────────────────────────────────────────────
 
@@ -116,7 +116,7 @@ export function formatSlicePRBody(data: SliceData): string {
     .filter((issueNumber): issueNumber is number => typeof issueNumber === "number")
     .map((issueNumber) => `#${issueNumber}`);
 
-  return buildPrEvidence({
+  return buildPullRequestEvidence({
     milestoneId: data.id,
     subjectId: data.id,
     subjectKind: "slice",
@@ -267,7 +267,7 @@ export function formatSwarmLanePRBody(data: SwarmLanePRData): string {
     `### Transition risks\n${checkedList(data.transitionRisks, "No transition risks identified").join("\n")}`,
   ].filter(Boolean);
 
-  return buildPrEvidence({
+  return buildPullRequestEvidence({
     milestoneId: laneLabel,
     subjectId: laneLabel,
     subjectKind: "workflow",

package/src/resources/extensions/github-sync/tests/templates.test.ts

@@ -62,7 +62,7 @@ describe("templates", () => {
       assert.ok(body.includes("- Session type"));
       assert.ok(body.includes("## Linked Issue"));
       assert.ok(body.includes("## Tests Run"));
-      assert.ok(body.includes("## AI Assistance Disclosure"));
+      assert.ok(!body.includes("## AI Assistance Disclosure"));
     });
 
     it("renders task checklist with issue links", () => {
@@ -173,7 +173,7 @@ describe("templates", () => {
       assert.ok(body.includes("- Disable writer sequence enrichment"));
       assert.ok(body.includes("- npm run typecheck:extensions"));
       assert.ok(body.includes("Closes #123"));
-      assert.ok(body.includes("## AI Assistance Disclosure"));
+      assert.ok(!body.includes("## AI Assistance Disclosure"));
     });
 
     it("formats release checklist bodies from lane state", () => {

package/src/resources/extensions/gsd/artifact-projection.ts

@@ -0,0 +1,31 @@
+// Project/App: gsd-pi
+// File Purpose: Resolves closeout artifact projection roots across project and milestone worktrees.
+
+import { resolveCanonicalMilestoneRoot } from "./worktree-manager.js";
+import { resolveWorktreeProjectRoot } from "./worktree-root.js";
+
+export interface CloseoutArtifactProjectionInput {
+  milestoneId: string;
+  basePath: string;
+  originalBasePath?: string;
+}
+
+export interface CloseoutArtifactProjection {
+  projectRoot: string;
+  canonicalMilestoneRoot: string;
+  summaryArtifactBasePath: string;
+  gateEvidenceBasePath: string;
+}
+
+export function resolveCloseoutArtifactProjection(
+  input: CloseoutArtifactProjectionInput,
+): CloseoutArtifactProjection {
+  const projectRoot = resolveWorktreeProjectRoot(input.basePath, input.originalBasePath);
+  const canonicalMilestoneRoot = resolveCanonicalMilestoneRoot(projectRoot, input.milestoneId);
+  return {
+    projectRoot,
+    canonicalMilestoneRoot,
+    summaryArtifactBasePath: canonicalMilestoneRoot,
+    gateEvidenceBasePath: canonicalMilestoneRoot,
+  };
+}

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

@@ -27,13 +27,43 @@ export interface AutoStatus {
   transitionCount: number;
 }
 
+export type AutoTerminalOutcome =
+  | {
+      code: "all-complete";
+      displayReason: string;
+      allMilestonesComplete: true;
+    }
+  | {
+      code: "no-remaining-units";
+      displayReason: string;
+      allMilestonesComplete: false;
+    }
+  | {
+      code: "settlement-blocked";
+      displayReason: string;
+      nextAction: string;
+      milestoneId: string;
+      allMilestonesComplete: false;
+    };
+
 export type AutoAdvanceResult =
   | { kind: "started" }
   | { kind: "resumed" }
   | { kind: "advanced"; unit: UnitRef; stateSnapshot: GSDState }
   | { kind: "skipped"; reason: string; stateSnapshot?: GSDState }
-  | { kind: "blocked"; reason: string; action: "pause" | "stop"; stateSnapshot?: GSDState }
-  | { kind: "stopped"; reason: string; stateSnapshot?: GSDState }
+  | {
+      kind: "blocked";
+      reason: string;
+      action: "pause" | "stop";
+      stateSnapshot?: GSDState;
+      terminalOutcome?: AutoTerminalOutcome;
+    }
+  | {
+      kind: "stopped";
+      reason: string;
+      stateSnapshot?: GSDState;
+      terminalOutcome?: AutoTerminalOutcome;
+    }
   | { kind: "paused"; reason: string }
   | { kind: "error"; reason: string };