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

package/src/resources/extensions/gsd/pull-request-process.ts

@@ -0,0 +1,41 @@
+// Project/App: gsd-pi
+// File Purpose: Process-level pull request policy for GSD-generated PRs.
+
+import { createDraftPR } from "./git-service.js";
+import {
+  buildPrEvidence,
+  type PrEvidence,
+  type PrEvidenceInput,
+} from "./pr-evidence.js";
+
+export interface DraftPullRequestOptions {
+  head: string;
+  base: string;
+}
+
+export interface DraftPullRequestDeps {
+  createDraftPR: (
+    basePath: string,
+    milestoneId: string,
+    title: string,
+    body: string,
+    opts: DraftPullRequestOptions,
+  ) => string | null;
+}
+
+export function buildPullRequestEvidence(input: PrEvidenceInput): PrEvidence {
+  return buildPrEvidence({
+    ...input,
+    aiAssisted: false,
+  });
+}
+
+export function createDraftPullRequestFromEvidence(
+  basePath: string,
+  milestoneId: string,
+  evidence: PrEvidence,
+  options: DraftPullRequestOptions,
+  deps: DraftPullRequestDeps = { createDraftPR },
+): string | null {
+  return deps.createDraftPR(basePath, milestoneId, evidence.title, evidence.body, options);
+}

package/src/resources/extensions/gsd/quality-gate-closure.ts

@@ -0,0 +1,140 @@
+// Project/App: gsd-pi
+// File Purpose: Canonical quality-gate closure from durable DB and artifact evidence.
+
+import { existsSync, readFileSync } from "node:fs";
+
+import { extractSection } from "./files.js";
+import { getGateDefinition } from "./gate-registry.js";
+import { getMilestoneSlices, getPendingGates, saveGateResult } from "./gsd-db.js";
+import { resolveSliceFile, resolveTaskFile } from "./paths.js";
+import type { GateId, GateRow, GateVerdict } from "./types.js";
+
+export interface QualityGateClosureOptions {
+  artifactBasePath?: string;
+  milestoneValidationPassed?: boolean;
+}
+
+export interface QualityGateClosureResult {
+  repaired: Array<{ gateId: GateId; sliceId: string; taskId?: string; verdict: GateVerdict }>;
+  unresolved: GateRow[];
+}
+
+interface GateEvidence {
+  verdict: GateVerdict;
+  rationale: string;
+  findings: string;
+}
+
+const GATE_SECTION_HEADINGS: Partial<Record<GateId, string[]>> = {
+  Q3: ["Threat Surface", "Abuse Surface"],
+  Q4: ["Requirement Impact", "Broken Promises"],
+  Q5: ["Failure Modes"],
+  Q6: ["Load Profile"],
+  Q7: ["Negative Tests"],
+  Q8: ["Operational Readiness"],
+};
+
+function readFile(path: string | null): string | null {
+  if (!path || !existsSync(path)) return null;
+  return readFileSync(path, "utf-8");
+}
+
+function firstSection(content: string | null, gateId: GateId): string | null {
+  if (!content) return null;
+  for (const heading of GATE_SECTION_HEADINGS[gateId] ?? []) {
+    const section = extractSection(content, heading);
+    if (section) return section;
+  }
+  return null;
+}
+
+function evidenceArtifactContent(row: GateRow, basePath: string): string | null {
+  const def = getGateDefinition(row.gate_id);
+  switch (def?.ownerTurn) {
+    case "gate-evaluate":
+      return readFile(resolveSliceFile(basePath, row.milestone_id, row.slice_id, "PLAN"));
+    case "execute-task":
+      return readFile(resolveTaskFile(basePath, row.milestone_id, row.slice_id, row.task_id, "SUMMARY"));
+    case "complete-slice":
+      return readFile(resolveSliceFile(basePath, row.milestone_id, row.slice_id, "SUMMARY"));
+    default:
+      return null;
+  }
+}
+
+function closureEvidence(row: GateRow, options: QualityGateClosureOptions): GateEvidence | null {
+  const def = getGateDefinition(row.gate_id);
+  if (!def) return null;
+
+  if (def.ownerTurn === "validate-milestone" && options.milestoneValidationPassed) {
+    return {
+      verdict: "pass",
+      rationale: `${def.promptSection} covered by passing milestone validation`,
+      findings: "",
+    };
+  }
+
+  if (!options.artifactBasePath) return null;
+
+  const section = firstSection(evidenceArtifactContent(row, options.artifactBasePath), row.gate_id);
+  if (section) {
+    return {
+      verdict: "pass",
+      rationale: `${def.promptSection} evidence found in durable artifact`,
+      findings: section,
+    };
+  }
+
+  if (!options.milestoneValidationPassed) return null;
+  return {
+    verdict: "omitted",
+    rationale: `${def.promptSection} has no durable artifact section; milestone validation passed`,
+    findings: "",
+  };
+}
+
+function closeGate(row: GateRow, evidence: GateEvidence): void {
+  saveGateResult({
+    milestoneId: row.milestone_id,
+    sliceId: row.slice_id,
+    gateId: row.gate_id,
+    taskId: row.task_id,
+    verdict: evidence.verdict,
+    rationale: evidence.rationale,
+    findings: evidence.findings,
+  });
+}
+
+export function closeQualityGatesFromEvidence(
+  milestoneId: string,
+  options: QualityGateClosureOptions = {},
+): QualityGateClosureResult {
+  const repaired: QualityGateClosureResult["repaired"] = [];
+  const unresolved: GateRow[] = [];
+
+  for (const slice of getMilestoneSlices(milestoneId)) {
+    const sliceId = slice.id;
+    for (const row of getPendingGates(milestoneId, sliceId)) {
+      if (!getGateDefinition(row.gate_id)) {
+        unresolved.push(row);
+        continue;
+      }
+
+      const evidence = closureEvidence(row, options);
+      if (!evidence) {
+        unresolved.push(row);
+        continue;
+      }
+
+      closeGate(row, evidence);
+      repaired.push({
+        gateId: row.gate_id,
+        sliceId: row.slice_id,
+        ...(row.task_id ? { taskId: row.task_id } : {}),
+        verdict: evidence.verdict,
+      });
+    }
+  }
+
+  return { repaired, unresolved };
+}

package/src/resources/extensions/gsd/question-transport.ts

@@ -0,0 +1,138 @@
+// Project/App: gsd-pi
+// File Purpose: Resolve how workflow units should ask the user for input.
+
+import { parseMcpToolName, toMcpToolName } from "./mcp-tool-name.js";
+
+export type StructuredQuestionsFlag = "true" | "false";
+
+export interface QuestionTransportOptions {
+  activeTools: string[];
+  authMode?: "apiKey" | "oauth" | "externalCli" | "none";
+  baseUrl?: string;
+  env?: NodeJS.ProcessEnv;
+}
+
+export interface QuestionTransportResolution {
+  structuredQuestionsAvailable: StructuredQuestionsFlag;
+  questionToolAvailable: boolean;
+  usesWorkflowMcp: boolean;
+  reason: "question-tool-available" | "question-tool-missing" | "workflow-mcp-disabled";
+}
+
+export interface WorkflowQuestionToolSurfaceOptions {
+  workflowServerName?: string;
+  workflowExplicitlyBlocked?: boolean;
+  workflowMcpTools: string[];
+  exactWorkflowMcpTools: string[];
+  env?: NodeJS.ProcessEnv;
+}
+
+export interface WorkflowQuestionToolSurfaceResolution extends QuestionTransportResolution {
+  questionToolName?: string;
+  workflowQuestionsEnabled: boolean;
+  disallowedTools: string[];
+}
+
+function isWorkflowMcpServerName(serverName: string): boolean {
+  const normalized = serverName.toLowerCase();
+  return normalized === "gsd" || normalized.includes("workflow");
+}
+
+export function usesWorkflowMcpTransport(
+  authMode: QuestionTransportOptions["authMode"],
+  baseUrl: string | undefined,
+): boolean {
+  return authMode === "externalCli" && typeof baseUrl === "string" && baseUrl.startsWith("local://");
+}
+
+export function hasAskUserQuestionsTool(activeTools: string[]): boolean {
+  return activeTools.some((toolName) => {
+    if (toolName === "ask_user_questions") return true;
+    const mcp = parseMcpToolName(toolName);
+    if (!mcp) return false;
+    if (mcp.toolName === "ask_user_questions") return true;
+    return mcp.toolName === "*" && isWorkflowMcpServerName(mcp.serverName);
+  });
+}
+
+function workflowMcpStructuredQuestionsEnabled(env: NodeJS.ProcessEnv = process.env): boolean {
+  const value = env.GSD_WORKFLOW_MCP_STRUCTURED_QUESTIONS?.trim().toLowerCase();
+  return value !== "0" && value !== "false" && value !== "off";
+}
+
+export function resolveQuestionTransport(
+  options: QuestionTransportOptions,
+): QuestionTransportResolution {
+  const questionToolAvailable = hasAskUserQuestionsTool(options.activeTools);
+  const usesWorkflowMcp = usesWorkflowMcpTransport(options.authMode, options.baseUrl);
+
+  if (!questionToolAvailable) {
+    return {
+      structuredQuestionsAvailable: "false",
+      questionToolAvailable,
+      usesWorkflowMcp,
+      reason: "question-tool-missing",
+    };
+  }
+
+  if (options.authMode === "externalCli" && !workflowMcpStructuredQuestionsEnabled(options.env)) {
+    return {
+      structuredQuestionsAvailable: "false",
+      questionToolAvailable,
+      usesWorkflowMcp,
+      reason: "workflow-mcp-disabled",
+    };
+  }
+
+  return {
+    structuredQuestionsAvailable: "true",
+    questionToolAvailable,
+    usesWorkflowMcp,
+    reason: "question-tool-available",
+  };
+}
+
+export function supportsStructuredQuestions(
+  activeTools: string[],
+  options: Omit<QuestionTransportOptions, "activeTools"> = {},
+): boolean {
+  return resolveQuestionTransport({
+    ...options,
+    activeTools,
+  }).structuredQuestionsAvailable === "true";
+}
+
+export function resolveWorkflowQuestionToolSurface(
+  options: WorkflowQuestionToolSurfaceOptions,
+): WorkflowQuestionToolSurfaceResolution {
+  const questionToolName = options.workflowServerName && !options.workflowExplicitlyBlocked
+    ? toMcpToolName(options.workflowServerName, "ask_user_questions")
+    : undefined;
+  const activeTools = [
+    ...options.exactWorkflowMcpTools,
+    ...options.workflowMcpTools,
+    ...(questionToolName ? [questionToolName] : []),
+  ];
+  const transport = resolveQuestionTransport({
+    activeTools,
+    authMode: "externalCli",
+    baseUrl: "local://claude-code",
+    env: options.env,
+  });
+  const exactQuestionToolAllowed =
+    !!questionToolName && options.exactWorkflowMcpTools.includes(questionToolName);
+  const workflowQuestionsEnabled =
+    transport.structuredQuestionsAvailable === "true" &&
+    (options.workflowMcpTools.length > 0 || exactQuestionToolAllowed);
+  const disallowedTools =
+    options.workflowServerName && transport.questionToolAvailable && !workflowQuestionsEnabled
+      ? [toMcpToolName(options.workflowServerName, "ask_user_questions")]
+      : [];
+
+  return {
+    ...transport,
+    questionToolName,
+    workflowQuestionsEnabled,
+    disallowedTools,
+  };
+}

package/src/resources/extensions/gsd/roadmap-slices.ts

@@ -189,9 +189,15 @@ export function parseRoadmapSlices(content: string): RoadmapSliceEntry[] {
       const risk = (riskMatch ? riskMatch[1] : "low") as RiskLevel;
 
       const depsMatch = rest.match(/`depends:\[([^\]]*)\]`/);
-      const depends = depsMatch && depsMatch[1]!.trim()
-        ? expandDependencies(depsMatch[1]!.split(",").map(s => s.trim()))
+      // Recovery fallback: double-bracket form `[[id]]` from serialized bracket-wrapped IDs
+      const fallbackDepsMatch = depsMatch ? null : rest.match(/`depends:\[(\[(?:[^\]]*)\](?:,\[(?:[^\]]*)\])*)\]`/);
+      const rawDepContent = (depsMatch ?? fallbackDepsMatch)?.[1] ?? "";
+      const SLICE_ID_RE = /^[A-Za-z0-9][A-Za-z0-9-]*$/;
+      const RANGE_RE = /^[A-Za-z]+\d+(?:-|\.\.)[A-Za-z]+\d+$/;
+      const rawDepParts = rawDepContent.trim()
+        ? rawDepContent.replace(/\[|\]/g, "").split(",").map(s => s.trim()).filter(s => SLICE_ID_RE.test(s) || RANGE_RE.test(s))
         : [];
+      const depends = expandDependencies(rawDepParts);
 
       // ADR-011: the renderer writes a `[sketch]` badge for sketch slices.
       // Parse it back so the is_sketch flag survives a markdown → DB re-import

package/src/resources/extensions/gsd/slice-parallel-orchestrator.ts

@@ -30,7 +30,8 @@ import { isAbsolute, join, dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { gsdRoot } from "./paths.js";
 import { createWorktree, worktreePath, removeWorktree } from "./worktree-manager.js";
-import { autoWorktreeBranch, runWorktreePostCreateHook, syncGsdStateToWorktree } from "./auto-worktree.js";
+import { autoWorktreeBranch, runWorktreePostCreateHook, syncGsdStateToWorktreeByScope } from "./auto-worktree.js";
+import { createWorkspace, scopeMilestone } from "./workspace.js";
 import {
   writeSessionStatus,
   removeSessionStatus,
@@ -163,7 +164,10 @@ function createSliceWorktree(basePath: string, milestoneId: string, sliceId: str
   if (hookError) {
     throw new Error(`slice worktree post-create hook failed (${wtName}): ${hookError}`);
   }
-  syncGsdStateToWorktree(basePath, wtPath);
+  syncGsdStateToWorktreeByScope(
+    scopeMilestone(createWorkspace(basePath), milestoneId),
+    scopeMilestone(createWorkspace(wtPath), milestoneId),
+  );
 
   if (!existsSync(join(wtPath, ".gsd"))) {
     throw new Error(`slice worktree preflight failed (${wtName}): missing .gsd in worktree`);

package/src/resources/extensions/gsd/state.ts

@@ -52,7 +52,6 @@ import { isTerminalMilestoneSummaryContent } from './milestone-summary-classifie
 
 import {
   isDbAvailable,
-  wasDbOpenAttempted,
   getAllMilestones,
   getMilestone,
   getMilestoneSlices,
@@ -63,9 +62,14 @@ import {
   getLatestAssessmentByScope,
   getPendingGateCountForTurn,
 } from './gsd-db.js';
+import { wasWorkflowDatabaseOpenAttempted } from './db-workspace.js';
 import { formatCompletePhaseNextAction, countUnmappedActiveRequirements } from './requirements-backlog.js';
 import type { MilestoneRow } from './db-milestone-artifact-rows.js';
 import type { SliceRow, TaskRow } from './db-task-slice-rows.js';
+import {
+  classifyMilestoneReadiness,
+  readinessNeedsDiscussion,
+} from './milestone-readiness.js';
 
 function formatNeedsAttentionBlocker(milestoneId: string): string {
   return [
@@ -395,7 +399,7 @@ export async function deriveState(
     stopDbTimer({ phase: result.phase, milestone: result.activeMilestone?.id });
     _telemetry.dbDeriveCount++;
   } else {
-    if (wasDbOpenAttempted()) {
+    if (wasWorkflowDatabaseOpenAttempted()) {
       logWarning("state", "DB unavailable — refusing implicit markdown state derivation");
     }
     result = {
@@ -507,6 +511,12 @@ async function buildRegistryAndFindActive(
     const title = stripMilestonePrefix(m.title) || m.id;
     const hasContext = !!resolveMilestoneFile(basePath, m.id, "CONTEXT");
     const hasDraftContext = !hasContext && !!resolveMilestoneFile(basePath, m.id, "CONTEXT-DRAFT");
+    const readiness = classifyMilestoneReadiness({
+      status: m.status,
+      hasContext,
+      hasDraftContext,
+      sliceCount: slices.length,
+    });
 
     if (!activeMilestoneFound) {
       const deps = m.depends_on;
@@ -517,9 +527,9 @@ async function buildRegistryAndFindActive(
         continue;
       }
 
-      if (m.status === 'queued' && slices.length === 0 && !hasContext) {
+      if (readiness.kind === 'queued-shell') {
         if (!firstDeferredQueuedShell) {
-          firstDeferredQueuedShell = { id: m.id, title, deps, hasDraftContext };
+          firstDeferredQueuedShell = { id: m.id, title, deps, hasDraftContext: readiness.hasDraftContext };
         }
         registry.push({ id: m.id, title, status: 'pending', ...(deps.length > 0 ? { dependsOn: deps } : {}) });
         continue;
@@ -533,7 +543,7 @@ async function buildRegistryAndFindActive(
         continue;
       }
 
-      if ((m.status === 'needs-discussion' && !hasContext) || hasDraftContext) activeMilestoneHasDraft = true;
+      if (readinessNeedsDiscussion(readiness)) activeMilestoneHasDraft = true;
 
       activeMilestone = { id: m.id, title };
       activeMilestoneSlices = slices;

package/src/resources/extensions/gsd/templates/plan.md

@@ -46,6 +46,13 @@
      For simple projects or scripts:
      - Executable verification commands (bash assertions, curl checks, etc.) are sufficient
 
+     For browser-facing web apps (React, Next, Vue, Vite, static HTML, etc.):
+     - Prefer `npx playwright test <spec>` in Verification when `@playwright/test` exists
+     - If Playwright is not set up yet, the first UI slice should add `playwright.config.ts`,
+       a minimal smoke spec (for example `e2e/smoke.spec.ts`), and a safe verify command
+     - Slice closeout UAT must declare `browser-executable` or `runtime-executable` — not
+       `artifact-driven` — when checks navigate to localhost or exercise the live UI
+
      If the project has no test framework and the work is non-trivial,
      the first task should set one up. A test runner costs 2 minutes
      and pays for itself immediately.

package/src/resources/extensions/gsd/templates/project.md

@@ -20,6 +20,7 @@
 
 - **Complexity:** {{simple | complex}}
 - **Why:** {{one-line rationale citing the signals that decided it}}
+- **Web stack:** {{browser-facing framework or "not a web UI" — e.g. Next.js + Playwright, static HTML, N/A for CLI/API-only}}
 
 ## Current State
 

package/src/resources/extensions/gsd/templates/roadmap.md

@@ -42,7 +42,7 @@
 - Contract verification: {{tests / shell verifiers / fixtures / artifact checks}}
 - Integration verification: {{real subsystem interaction that must be exercised, or none}}
 - Operational verification: {{service lifecycle / restart / reconnect / supervision / deploy-install behavior, or none}}
-- UAT / human verification: {{what needs real human judgment, or none}}
+- UAT / human verification: {{what needs real human judgment, or none — for web apps prefer browser-executable / runtime-executable Playwright checks over deferring UI proof to humans}}
 
 ## Milestone Definition of Done
 

package/src/resources/extensions/gsd/templates/uat.md

@@ -5,9 +5,13 @@
 
 ## UAT Type
 
-- UAT mode: {{artifact-driven | live-runtime | human-experience | mixed}}
+- UAT mode: {{artifact-driven | browser-executable | runtime-executable | live-runtime | human-experience | mixed}}
 - Why this mode is sufficient: {{reason}}
 
+<!-- Web apps: never use artifact-driven when steps open a browser, navigate to localhost,
+     or capture screenshots. Use browser-executable (browser_* tools) or runtime-executable
+     (npx playwright test). Name dev-server preconditions below. -->
+
 ## Preconditions
 
 {{whatMustBeTrueBeforeTesting — server running, data seeded, etc.}}

package/src/resources/extensions/gsd/tests/ask-user-questions-render.test.ts

@@ -0,0 +1,92 @@
+/**
+ * Regression tests for ask_user_questions renderResult when Claude Code MCP
+ * omits structuredContent and the chat controller passes details as undefined
+ * or an empty object.
+ */
+
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import askUserQuestionsExtension from "../../ask-user-questions.ts";
+
+const fakeTheme = {
+	fg: (_color: string, text: string) => text,
+	bold: (text: string) => text,
+};
+
+function getAskUserQuestionsTool() {
+	const tools: any[] = [];
+	askUserQuestionsExtension({ registerTool: (tool: any) => tools.push(tool) } as any);
+	const tool = tools.find((t) => t.name === "ask_user_questions");
+	assert.ok(tool, "ask_user_questions should be registered");
+	return tool;
+}
+
+function renderText(tool: any, result: unknown, args?: unknown): string {
+	const rendered = tool.renderResult(result, {}, fakeTheme, { args });
+	return String((rendered as any).content ?? (rendered as any).text ?? rendered);
+}
+
+const depthQuestion = {
+	id: "depth_check",
+	header: "Depth Check",
+	question: "Did I capture the depth right?",
+	options: [
+		{ label: "Yes, you got it", description: "Proceed" },
+		{ label: "Not quite - let me clarify", description: "Clarify" },
+	],
+};
+
+test("ask_user_questions renderResult shows answers when details is undefined (MCP text-only wire)", () => {
+	const tool = getAskUserQuestionsTool();
+	const contentText = JSON.stringify({
+		answers: { depth_check: { answers: ["Yes, you got it"] } },
+	});
+	const text = renderText(
+		tool,
+		{
+			content: [{ type: "text", text: contentText }],
+			details: undefined,
+			isError: false,
+		},
+		{ questions: [depthQuestion] },
+	);
+
+	assert.match(text, /✓/);
+	assert.match(text, /Depth Check/);
+	assert.match(text, /Yes, you got it/);
+	assert.doesNotMatch(text, /Cancelled/i);
+});
+
+test("ask_user_questions renderResult shows answers when details is empty object (#cc-elicitation)", () => {
+	const tool = getAskUserQuestionsTool();
+	const contentText = JSON.stringify({
+		answers: { depth_check: { answers: ["Yes, you got it"] } },
+	});
+	const text = renderText(
+		tool,
+		{
+			content: [{ type: "text", text: contentText }],
+			details: {},
+			isError: false,
+		},
+		{ questions: [depthQuestion] },
+	);
+
+	assert.match(text, /Yes, you got it/);
+	assert.doesNotMatch(text, /Cancelled/i);
+});
+
+test("ask_user_questions renderResult still shows Cancelled for explicit cancel payload", () => {
+	const tool = getAskUserQuestionsTool();
+	const text = renderText(
+		tool,
+		{
+			content: [{ type: "text", text: "ask_user_questions was cancelled before receiving a response" }],
+			details: { questions: [depthQuestion], response: null, cancelled: true },
+			isError: false,
+		},
+		{ questions: [depthQuestion] },
+	);
+
+	assert.match(text, /Cancelled/i);
+});

package/src/resources/extensions/gsd/tests/auto-dashboard.test.ts

@@ -29,11 +29,16 @@ import {
   _refreshLastCommitForTests,
   _getLastCommitForTests,
   _getLastCommitFetchedAtForTests,
+  formatToolSurfaceSnapshot,
   formatRuntimeHealthSignal,
   shouldRenderRoadmapProgress,
 } from "../auto-dashboard.ts";
 import { getAutoDashboardData } from "../auto.ts";
-import { autoSession } from "../auto-runtime-state.ts";
+import {
+  autoSession,
+  clearAutoToolSurfaceSnapshot,
+  recordAutoToolSurfaceSnapshot,
+} from "../auto-runtime-state.ts";
 import { formatRtkSavingsLabel } from "../../shared/rtk-session-stats.ts";
 import {
   openDatabase,
@@ -530,6 +535,29 @@ test("getAutoDashboardData returns RTK savings in the dashboard payload", () =>
   }
 });
 
+test("getAutoDashboardData exposes typed tool-surface snapshots", () => {
+  autoSession.reset();
+  clearAutoToolSurfaceSnapshot();
+  autoSession.active = true;
+  recordAutoToolSurfaceSnapshot({
+    source: "provider-adjustment",
+    unitType: "run-uat",
+    modelFacingToolNames: ["read"],
+    registeredToolNames: ["read", "browser_navigate"],
+    scopedToolNames: ["read", "browser_navigate"],
+    presentedToolNames: ["browser_navigate"],
+    capturedAt: 456,
+  });
+
+  const data = getAutoDashboardData();
+
+  assert.equal(data.toolSurface?.source, "provider-adjustment");
+  assert.equal(formatToolSurfaceSnapshot(data.toolSurface), "run-uat: model 1 / registered 2 / scoped 2 / presented 1");
+
+  autoSession.reset();
+  clearAutoToolSurfaceSnapshot();
+});
+
 test("RTK savings label formats the dashboard footer text", () => {
   assert.equal(formatRtkSavingsLabel(null), null);
   assert.equal(