@opengsd/gsd-pi 1.2.0 → 1.3.0-dev.72e3af2a

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

@@ -0,0 +1,324 @@
+// 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;
+	}
+}
+
+function textFromExternalResult(result: ExternalToolResultPayload | undefined): string {
+	return (result?.content ?? [])
+		.map((block) => typeof block.text === "string" ? block.text : "")
+		.join("\n");
+}
+
+function isEmptyToolArguments(value: unknown): boolean {
+	return !!value
+		&& typeof value === "object"
+		&& !Array.isArray(value)
+		&& Object.keys(value as Record<string, unknown>).length === 0;
+}
+
+function sameToolSurface(a: ToolCall, b: ToolCall): boolean {
+	return a.name === b.name
+		&& (a as ToolCall & { mcpServer?: string }).mcpServer === (b as ToolCall & { mcpServer?: string }).mcpServer;
+}
+
+export function shouldSuppressDuplicateToolUnavailableBlock(
+	block: AssistantMessage["content"][number],
+	allBlocks: AssistantMessage["content"],
+): boolean {
+	if (block.type !== "toolCall") return false;
+	const externalResult = (block as ToolCallWithExternalResult).externalResult;
+	if (!externalResult?.isError) return false;
+	if (!isEmptyToolArguments(block.arguments)) return false;
+	if (!/No such tool available:/i.test(textFromExternalResult(externalResult))) return false;
+
+	return allBlocks.some((candidate) => {
+		if (candidate.type !== "toolCall" || candidate.id === block.id) return false;
+		const candidateResult = (candidate as ToolCallWithExternalResult).externalResult;
+		return candidateResult?.isError === false && sameToolSurface(block, candidate);
+	});
+}
+
+/**
+ * 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.filter(
+		(block) => !shouldSuppressDuplicateToolUnavailableBlock(block, 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/google-cli/stream-adapter.ts

@@ -20,7 +20,13 @@ const ZERO_USAGE = {
 	cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
 };
 
-type GoogleCliProviderId = "google-gemini-cli" | "google-antigravity";
+export type GoogleCliProviderId = "google-gemini-cli" | "google-antigravity";
+
+export interface GoogleCliRunPlan {
+	command: string;
+	args: string[];
+	stdin?: string;
+}
 
 interface CliRunResult {
 	stdout: string;
@@ -29,6 +35,71 @@ interface CliRunResult {
 	signal: NodeJS.Signals | null;
 }
 
+const WINDOWS_CHILD_ENV_KEYS = new Set([
+	"ALLUSERSPROFILE",
+	"APPDATA",
+	"COMSPEC",
+	"COMMONPROGRAMFILES",
+	"COMMONPROGRAMFILES(X86)",
+	"FORCE_COLOR",
+	"HOME",
+	"HOMEDRIVE",
+	"HOMEPATH",
+	"LANG",
+	"LC_ALL",
+	"LOCALAPPDATA",
+	"NODE_EXTRA_CA_CERTS",
+	"NO_COLOR",
+	"NO_PROXY",
+	"PATHEXT",
+	"PATH",
+	"PROGRAMDATA",
+	"PROGRAMFILES",
+	"PROGRAMFILES(X86)",
+	"SSL_CERT_FILE",
+	"SYSTEMROOT",
+	"TEMP",
+	"TERM",
+	"TMP",
+	"TMPDIR",
+	"USER",
+	"USERNAME",
+	"USERPROFILE",
+	"WINDIR",
+	"XDG_CACHE_HOME",
+	"XDG_CONFIG_HOME",
+	"HTTP_PROXY",
+	"HTTPS_PROXY",
+]);
+
+const WINDOWS_CHILD_ENV_PREFIXES = [
+	"AGY_",
+	"ANTIGRAVITY_",
+	"CLOUDSDK_",
+	"GEMINI_",
+	"GOOGLE_",
+];
+
+export function buildGoogleCliChildEnv(
+	env: NodeJS.ProcessEnv = process.env,
+	platform: NodeJS.Platform = process.platform,
+): NodeJS.ProcessEnv {
+	if (platform !== "win32") return env;
+
+	const childEnv: NodeJS.ProcessEnv = {};
+	for (const [key, value] of Object.entries(env)) {
+		if (typeof value !== "string") continue;
+		const upperKey = key.toUpperCase();
+		if (
+			WINDOWS_CHILD_ENV_KEYS.has(upperKey) ||
+			WINDOWS_CHILD_ENV_PREFIXES.some((prefix) => upperKey.startsWith(prefix))
+		) {
+			childEnv[key] = value;
+		}
+	}
+	return childEnv;
+}
+
 function textBlocks(content: (TextContent | { type: string })[]): string {
 	return content
 		.map((block) => block.type === "text" ? (block as TextContent).text : `[${block.type} omitted]`)
@@ -120,15 +191,15 @@ function commandForProvider(provider: GoogleCliProviderId): string {
 	return provider === "google-gemini-cli" ? "gemini" : "agy";
 }
 
-function argsForProvider(provider: GoogleCliProviderId, model: Model<Api>, prompt: string): string[] {
+function argsForProvider(provider: GoogleCliProviderId, modelId: string, prompt?: string): string[] {
 	if (provider === "google-gemini-cli") {
-		const args = ["-p", prompt, "--output-format", "json"];
-		if (model.id !== "default") args.unshift("-m", model.id);
+		const args = prompt === undefined ? ["--output-format", "json"] : ["-p", prompt, "--output-format", "json"];
+		if (modelId !== "default") args.unshift("-m", modelId);
 		return args;
 	}
 
-	const args = ["-p", prompt];
-	if (model.id !== "default") args.unshift("-m", model.id);
+	const args = prompt === undefined ? [] : ["-p", prompt];
+	if (modelId !== "default") args.unshift("-m", modelId);
 	return args;
 }
 
@@ -136,20 +207,33 @@ export function buildGoogleCliSpawnInvocation(
 	command: string,
 	args: string[],
 	platform: NodeJS.Platform = process.platform,
-): { command: string; args: string[] } {
+): Omit<GoogleCliRunPlan, "stdin"> {
 	if (platform === "win32") {
 		return { command: "cmd", args: ["/c", command, ...args] };
 	}
 	return { command, args };
 }
 
-function runCli(command: string, args: string[], options?: SimpleStreamOptions): Promise<CliRunResult> {
+export function buildGoogleCliRunPlan(
+	provider: GoogleCliProviderId,
+	modelId: string,
+	prompt: string,
+	platform: NodeJS.Platform = process.platform,
+): GoogleCliRunPlan {
+	const pipePrompt = platform === "win32";
+	const args = argsForProvider(provider, modelId, pipePrompt ? undefined : prompt);
+	return {
+		...buildGoogleCliSpawnInvocation(commandForProvider(provider), args, platform),
+		...(pipePrompt ? { stdin: prompt } : {}),
+	};
+}
+
+function runCli(plan: GoogleCliRunPlan, options?: SimpleStreamOptions): Promise<CliRunResult> {
 	return new Promise((resolve, reject) => {
-		const invocation = buildGoogleCliSpawnInvocation(command, args);
-		const child = spawn(invocation.command, invocation.args, {
+		const child = spawn(plan.command, plan.args, {
 			cwd: options?.cwd || process.cwd(),
-			env: process.env,
-			stdio: ["ignore", "pipe", "pipe"],
+			env: buildGoogleCliChildEnv(),
+			stdio: [plan.stdin === undefined ? "ignore" : "pipe", "pipe", "pipe"],
 		});
 
 		let stdout = "";
@@ -174,12 +258,17 @@ function runCli(command: string, args: string[], options?: SimpleStreamOptions):
 		}
 		options?.signal?.addEventListener("abort", onAbort);
 
-		child.stdout.setEncoding("utf8");
-		child.stderr.setEncoding("utf8");
-		child.stdout.on("data", (chunk) => {
+		if (plan.stdin !== undefined) {
+			child.stdin?.on("error", () => {});
+			child.stdin?.end(plan.stdin);
+		}
+
+		child.stdout!.setEncoding("utf8");
+		child.stderr!.setEncoding("utf8");
+		child.stdout!.on("data", (chunk) => {
 			stdout += chunk;
 		});
-		child.stderr.on("data", (chunk) => {
+		child.stderr!.on("data", (chunk) => {
 			stderr += chunk;
 		});
 
@@ -204,6 +293,27 @@ function emitText(stream: AssistantMessageEventStream, message: AssistantMessage
 	stream.end(message);
 }
 
+function isGeminiCliDeprecatedCliOutput(text: string): boolean {
+	return (
+		/IneligibleTierError/i.test(text)
+		|| /UNSUPPORTED_CLIENT/i.test(text)
+		|| /no longer supported for Gemini Code Assist for individuals/i.test(text)
+		|| /migrate to the Antigravity suite/i.test(text)
+	);
+}
+
+const GEMINI_CLI_DEPRECATION_HINT =
+	"Gemini CLI is no longer supported for individual users. Install Antigravity CLI " +
+	"(curl -fsSL https://antigravity.google/cli/install.sh | bash), run `agy` to authenticate, " +
+	"then use /login → Antigravity or restart GSD to auto-migrate.";
+
+function formatGoogleCliError(detail: string, provider: GoogleCliProviderId): string {
+	if (provider === "google-gemini-cli" && isGeminiCliDeprecatedCliOutput(detail)) {
+		return `${detail}\n\n${GEMINI_CLI_DEPRECATION_HINT}`;
+	}
+	return detail;
+}
+
 function emitError(stream: AssistantMessageEventStream, model: Model<Api>, error: unknown): void {
 	const message = error instanceof Error ? error.message : String(error);
 	const output = buildAssistantMessage(model, "", "error", message);
@@ -222,13 +332,11 @@ export function streamViaGoogleCli(
 	queueMicrotask(async () => {
 		try {
 			const prompt = buildGoogleCliPrompt(context);
-			const command = commandForProvider(provider);
-			const args = argsForProvider(provider, model, prompt);
-			const result = await runCli(command, args, options);
+			const result = await runCli(buildGoogleCliRunPlan(provider, model.id, prompt), options);
 
 			if (result.code !== 0) {
 				const detail = (result.stderr || result.stdout || `CLI exited with code ${result.code}`).trim();
-				throw new Error(detail);
+				throw new Error(formatGoogleCliError(detail, provider));
 			}
 
 			const text = provider === "google-gemini-cli"

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,
+  };
+}