gsd-pi 2.81.0 → 2.82.0-dev.c22380fc3

package/src/resources/extensions/gsd/tests/plan-milestone-sketch-render.test.ts

@@ -0,0 +1,157 @@
+// ADR-011 #5750: ROADMAP.md renders sketch slices with a `[sketch]` badge.
+//
+// Locks in the visual distinction so an auditor scanning the rendered roadmap
+// can tell which slices are sketches awaiting refine-slice expansion vs which
+// already carry a full plan. Sits alongside `plan-milestone.test.ts` which
+// covers the full-plan render path.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { openDatabase, closeDatabase } from "../gsd-db.ts";
+import { handlePlanMilestone, type PlanMilestoneParams } from "../tools/plan-milestone.ts";
+
+function makeTmpBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-plan-sketch-render-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  return base;
+}
+
+function cleanup(base: string): void {
+  try {
+    closeDatabase();
+  } catch {
+    /* noop */
+  }
+  try {
+    rmSync(base, { recursive: true, force: true });
+  } catch {
+    /* noop */
+  }
+}
+
+function planMilestoneWithSketches(): PlanMilestoneParams {
+  return {
+    milestoneId: "M001",
+    title: "Progressive Planning Demo",
+    vision: "Demonstrate sketch slices in ROADMAP rendering.",
+    successCriteria: ["S01 full, S02 sketch", "ROADMAP distinguishes them"],
+    keyRisks: [{ risk: "Visual collision", whyItMatters: "Auditors need to spot sketches." }],
+    proofStrategy: [{ riskOrUnknown: "Render correctness", retireIn: "S01", whatWillBeProven: "Roadmap shows the badge." }],
+    verificationContract: "Contract verification text",
+    verificationIntegration: "Integration verification text",
+    verificationOperational: "Operational verification text",
+    verificationUat: "UAT verification text",
+    definitionOfDone: ["Renderer emits badge", "Test asserts it"],
+    requirementCoverage: "Covers ADR-011 #5750.",
+    boundaryMapMarkdown: "| From | To | Produces | Consumes |\n|------|----|----------|----------|\n| S01 | S02 | scaffold | nothing |",
+    slices: [
+      {
+        sliceId: "S01",
+        title: "Fully planned scaffold",
+        risk: "medium" as const,
+        depends: [],
+        demo: "Scaffold is in place.",
+        goal: "Lay down the structural foundation.",
+        successCriteria: "Scaffold tests pass.",
+        proofLevel: "integration" as const,
+        integrationClosure: "Downstream slices depend on this scaffold.",
+        observabilityImpact: "No new telemetry.",
+        // No isSketch flag — defaults to full plan.
+      },
+      {
+        sliceId: "S02",
+        title: "Refinement candidate",
+        risk: "low" as const,
+        depends: ["S01"],
+        demo: "Sketched until S01 ships.",
+        goal: "Refine into a full plan after S01 lands.",
+        successCriteria: "",
+        proofLevel: "",
+        integrationClosure: "",
+        observabilityImpact: "",
+        isSketch: true,
+        sketchScope: "Pick up the scaffold from S01 and add the demo behavior. Stay inside the existing module boundaries.",
+      },
+    ],
+  };
+}
+
+test("ROADMAP renders sketch slices with [sketch] badge and full slices without", async () => {
+  const base = makeTmpBase();
+  try {
+    const params = planMilestoneWithSketches();
+    const result = await handlePlanMilestone(params, base);
+    if ("error" in result) {
+      assert.fail(`handlePlanMilestone failed: ${result.error}`);
+    }
+
+    const roadmapPath = join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md");
+    const roadmap = readFileSync(roadmapPath, "utf-8");
+
+    // S01 is a full slice — no sketch badge.
+    const s01Line = roadmap.split("\n").find((line) => line.includes("**S01:"));
+    assert.ok(s01Line, "S01 slice line must exist in roadmap");
+    assert.equal(
+      s01Line.includes("`[sketch]`"),
+      false,
+      "fully-planned S01 must NOT carry the sketch badge",
+    );
+    assert.match(s01Line, /`risk:medium`/);
+
+    // S02 is a sketch — badge required, positioned before risk.
+    const s02Line = roadmap.split("\n").find((line) => line.includes("**S02:"));
+    assert.ok(s02Line, "S02 slice line must exist in roadmap");
+    assert.ok(
+      s02Line.includes("`[sketch]`"),
+      `sketch slice S02 must carry the sketch badge, got: ${s02Line}`,
+    );
+    // Badge sits before risk so it stays visible if the line truncates.
+    const sketchIdx = s02Line.indexOf("`[sketch]`");
+    const riskIdx = s02Line.indexOf("`risk:");
+    assert.ok(
+      sketchIdx >= 0 && riskIdx >= 0 && sketchIdx < riskIdx,
+      "sketch badge must appear before the risk tag",
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("ROADMAP omits sketch badge when no slices are sketches", async () => {
+  const base = makeTmpBase();
+  try {
+    const params = planMilestoneWithSketches();
+    // Strip the sketch designation from S02 so both slices are fully planned.
+    params.slices[1] = {
+      ...params.slices[1],
+      isSketch: false,
+      successCriteria: "Demo behavior works.",
+      proofLevel: "unit" as const,
+      integrationClosure: "S02 closes the demo behavior.",
+      observabilityImpact: "No new telemetry.",
+    };
+
+    const result = await handlePlanMilestone(params, base);
+    if ("error" in result) {
+      assert.fail(`handlePlanMilestone failed: ${result.error}`);
+    }
+
+    const roadmap = readFileSync(
+      join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
+      "utf-8",
+    );
+
+    assert.equal(
+      roadmap.includes("`[sketch]`"),
+      false,
+      "roadmap must not carry the sketch badge when no slice is a sketch",
+    );
+  } finally {
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/post-exec-retry-bypass.test.ts

@@ -250,14 +250,14 @@ describe("Post-execution blocking failure retry bypass", () => {
     const s = makeMockSession(tempDir, { type: "execute-task", id: "M001/S01/T01" });
     
     // Pre-set some retry state
-    s.verificationRetryCount.set("M001/S01/T01", 2);
+    s.verificationRetryCount.set("execute-task:M001/S01/T01", 2);
 
     const vctx: VerificationContext = { s, ctx, pi };
     const result = await runPostUnitVerification(vctx, pauseAutoMock);
 
     // On success, retry count should be cleared
     assert.equal(result, "continue");
-    assert.equal(s.verificationRetryCount.has("M001/S01/T01"), false);
+    assert.equal(s.verificationRetryCount.has("execute-task:M001/S01/T01"), false);
   });
 
   test("post-exec failure notification mentions cross-task consistency", async () => {

package/src/resources/extensions/gsd/tests/progressive-planning.test.ts

@@ -14,9 +14,9 @@ import {
   insertMilestone,
   insertSlice,
   setSliceSketchFlag,
-  autoHealSketchFlags,
   getSlice,
 } from "../gsd-db.ts";
+import { autoHealSketchFlags } from "../state-reconciliation/drift/sketch-flag.ts";
 import { deriveStateFromDb } from "../state.ts";
 import { resolveDispatch } from "../auto-dispatch.ts";
 import type { DispatchContext } from "../auto-dispatch.ts";

package/src/resources/extensions/gsd/tests/prompt-contracts.test.ts

@@ -55,6 +55,14 @@ test("system prompt hard rules forbid fabricating user responses", () => {
   assert.match(prompt, /ask_user_questions.*only valid structured user input/i);
 });
 
+test("system prompt requires reading before edit or overwrite", () => {
+  const prompt = readPrompt("system");
+  assert.match(prompt, /Read before edit or overwrite/i);
+  assert.match(prompt, /Before any write that creates or replaces a file/i);
+  assert.match(prompt, /confirm whether the path exists; if it does, `read` it first/i);
+  assert.match(prompt, /For truly new files, confirm the path does not already exist/i);
+});
+
 test("discuss prompt allows implementation questions when they materially matter", () => {
   const prompt = readPrompt("discuss");
   assert.match(prompt, /Lead with experience, but ask implementation when it materially matters/i);
@@ -64,6 +72,16 @@ test("discuss prompt allows implementation questions when they materially matter
   assert.doesNotMatch(prompt, /Questions must be about the experience, not the implementation/i);
 });
 
+test("discuss prompt ends milestone planning with next-step handoff", () => {
+  const prompt = readPrompt("discuss");
+  assert.match(prompt, /Next steps:/);
+  assert.match(prompt, /\/gsd auto/);
+  assert.match(prompt, /\/gsd status/);
+  assert.match(prompt, /\/gsd visualize/);
+  assert.match(prompt, /\/gsd notifications/);
+  assert.doesNotMatch(prompt, /nothing else\. Auto-mode will start automatically/);
+});
+
 test("guided discussion prompts avoid wrap-up prompts after every round", () => {
   const milestonePrompt = readPrompt("guided-discuss-milestone");
   const slicePrompt = readPrompt("guided-discuss-slice");
@@ -217,6 +235,17 @@ test("complete-slice prompt does not instruct LLM to toggle checkboxes manually"
   assert.doesNotMatch(prompt, /change \[ \] to \[x\]/);
 });
 
+test("complete-slice prompt keeps source fixes in execution units", () => {
+  const prompt = readPrompt("complete-slice");
+  assert.match(prompt, /Do not use direct `bash` for verification commands/i);
+  assert.match(prompt, /do \*\*not\*\* edit source files in this unit/i);
+  assert.match(prompt, /do \*\*not\*\* call `gsd_slice_complete`/i);
+  assert.match(prompt, /gsd_task_reopen/);
+  assert.match(prompt, /gsd_replan_slice/);
+  assert.match(prompt, /needs execution follow-up/i);
+  assert.doesNotMatch(prompt, /Fix failures before marking done/i);
+});
+
 test("complete-slice prompt instructs writing summary and UAT files before tool call", () => {
   const prompt = readPrompt("complete-slice");
   assert.match(prompt, /\{\{sliceSummaryPath\}\}/);
@@ -363,7 +392,9 @@ test("execute-task prompt uses camelCase parameter names matching TypeBox schema
 test("complete-slice prompt uses camelCase parameter names matching TypeBox schema", () => {
   const prompt = readPrompt("complete-slice");
   // The gsd_complete_slice tool schema uses camelCase: milestoneId, sliceId
-  const toolCallLine = prompt.split("\n").find((l) => /gsd_complete_slice/.test(l) || /gsd_slice_complete/.test(l));
+  const toolCallLine = prompt.split("\n").find((l) =>
+    (/gsd_complete_slice/.test(l) || /gsd_slice_complete/.test(l)) && /milestoneId/.test(l) && /sliceId/.test(l)
+  );
   assert.ok(toolCallLine, "prompt must contain a gsd_complete_slice or gsd_slice_complete tool call line");
   assert.doesNotMatch(toolCallLine!, /milestone_id/, "must use milestoneId, not milestone_id");
   assert.doesNotMatch(toolCallLine!, /slice_id/, "must use sliceId, not slice_id");

package/src/resources/extensions/gsd/tests/provider-switch-observer.test.ts

@@ -0,0 +1,252 @@
+// GSD-2 — ADR-005 Phase 3b: ProviderSwitchObserver Tests
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, readFileSync, rmSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { setProviderSwitchObserver, type ProviderSwitchReport } from "@gsd/pi-ai";
+
+import { autoSession } from "../auto-runtime-state.ts";
+import {
+  initNotificationStore,
+  readNotifications,
+  _resetNotificationStore,
+} from "../notification-store.ts";
+import {
+  _resetProviderSwitchStats,
+  getProviderSwitchStats,
+  installProviderSwitchObserver,
+  uninstallProviderSwitchObserver,
+} from "../provider-switch-observer.ts";
+
+function makeReport(overrides: Partial<ProviderSwitchReport> = {}): ProviderSwitchReport {
+  return {
+    fromApi: "anthropic-messages",
+    toApi: "openai-responses",
+    thinkingBlocksDropped: 0,
+    thinkingBlocksDowngraded: 0,
+    toolCallIdsRemapped: 0,
+    syntheticToolResultsInserted: 0,
+    thoughtSignaturesDropped: 0,
+    ...overrides,
+  };
+}
+
+function withTempBasePath(): { basePath: string; cleanup: () => void } {
+  const basePath = mkdtempSync(join(tmpdir(), "gsd-provider-switch-"));
+  return {
+    basePath,
+    cleanup: () => rmSync(basePath, { recursive: true, force: true }),
+  };
+}
+
+test.beforeEach(() => {
+  _resetProviderSwitchStats();
+  _resetNotificationStore();
+  autoSession.currentTraceId = null;
+  autoSession.basePath = "";
+});
+
+test.afterEach(() => {
+  uninstallProviderSwitchObserver();
+  _resetNotificationStore();
+  autoSession.currentTraceId = null;
+  autoSession.basePath = "";
+});
+
+test("installProviderSwitchObserver wires the pi-ai observer hook", () => {
+  installProviderSwitchObserver();
+  // Indirect: a second install is a no-op. We verify by checking the counter
+  // increments exactly once when we fire a single report directly into pi-ai's
+  // observer slot.
+  installProviderSwitchObserver();
+
+  // Drive the pi-ai observer directly. The install above pointed it at our
+  // handler; firing here exercises the same code path as a real transform.
+  // We can't reach the installed handler reference from here, so we re-install
+  // a sentinel and confirm setProviderSwitchObserver accepts undefined.
+  setProviderSwitchObserver(undefined);
+  assert.ok(true); // install/uninstall did not throw
+});
+
+test("non-empty report increments the in-memory counter", () => {
+  installProviderSwitchObserver();
+
+  // Reach into the installed handler via setProviderSwitchObserver re-binding.
+  // We snapshot the handler by re-installing, capturing nothing — instead we
+  // use the public API: drive a report through the observer hook directly by
+  // calling setProviderSwitchObserver with a wrapper that proxies into the
+  // installed handler. This is awkward without a separate seam, so we test
+  // the recordReport path end-to-end by firing through pi-ai's transform helper
+  // pattern in a sibling test below. Here we exercise install idempotency only.
+
+  // Fire by setting our own observer that forwards to the module API isn't
+  // possible without exporting handleReport. Instead, verify install state
+  // doesn't crash; the real fire path is covered by the integration test
+  // below that exercises transformMessagesWithReport.
+  assert.deepEqual(getProviderSwitchStats().totalSwitches, 0);
+});
+
+test("end-to-end: transformMessagesWithReport fires the observer and updates stats + notifications", async () => {
+  const { transformMessagesWithReport } = await import("@gsd/pi-ai");
+
+  const { basePath, cleanup } = withTempBasePath();
+  try {
+    initNotificationStore(basePath);
+    installProviderSwitchObserver();
+
+    // Construct a cross-API transform that will drop a redacted thinking block.
+    const targetModel = {
+      id: "gpt-5",
+      name: "GPT-5",
+      api: "openai-responses",
+      provider: "openai",
+      baseUrl: "",
+      reasoning: false,
+      input: ["text"],
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+      contextWindow: 128000,
+      maxTokens: 8192,
+    } as Parameters<typeof transformMessagesWithReport>[1];
+
+    const messages = [
+      {
+        role: "assistant" as const,
+        content: [
+          { type: "thinking" as const, thinking: "", redacted: true },
+          { type: "text" as const, text: "hi" },
+        ],
+        api: "anthropic-messages",
+        provider: "anthropic",
+        model: "claude-sonnet-4-6",
+        usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
+        stopReason: "stop" as const,
+        timestamp: Date.now(),
+      },
+    ];
+
+    transformMessagesWithReport(messages as Parameters<typeof transformMessagesWithReport>[0], targetModel, undefined, "anthropic-messages");
+
+    const stats = getProviderSwitchStats();
+    assert.equal(stats.totalSwitches, 1, "non-empty report should bump the counter");
+    assert.ok(stats.totals.thinkingBlocksDropped >= 1, "thinking block drop should be tallied");
+    assert.ok(stats.lastReport, "last report should be retained");
+    assert.equal(stats.lastReport?.fromApi, "anthropic-messages");
+    assert.equal(stats.lastReport?.toApi, "openai-responses");
+
+    // Notification persistence — the observer is interactive (no traceId), so
+    // the byTrace key falls back to "interactive".
+    assert.ok("interactive" in stats.byTrace, "interactive trace bucket should exist");
+    assert.equal(stats.byTrace.interactive?.switches, 1);
+
+    const notifications = readNotifications(basePath);
+    const switchNotifs = notifications.filter((n) => n.message.includes("Provider switch"));
+    assert.ok(switchNotifs.length >= 1, "a provider-switch notification should be persisted");
+    assert.equal(switchNotifs[0]?.severity, "warning");
+  } finally {
+    cleanup();
+  }
+});
+
+test("end-to-end: audit event is emitted when an auto trace is active", async () => {
+  const { transformMessagesWithReport } = await import("@gsd/pi-ai");
+
+  const { basePath, cleanup } = withTempBasePath();
+  try {
+    initNotificationStore(basePath);
+    installProviderSwitchObserver();
+    autoSession.basePath = basePath;
+    autoSession.currentTraceId = "trace-provider-switch-1";
+
+    const targetModel = {
+      id: "gpt-5",
+      name: "GPT-5",
+      api: "openai-responses",
+      provider: "openai",
+      baseUrl: "",
+      reasoning: false,
+      input: ["text"],
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+      contextWindow: 128000,
+      maxTokens: 8192,
+    } as Parameters<typeof transformMessagesWithReport>[1];
+
+    const messages = [
+      {
+        role: "assistant" as const,
+        content: [
+          { type: "thinking" as const, thinking: "", redacted: true },
+          { type: "text" as const, text: "hi" },
+        ],
+        api: "anthropic-messages",
+        provider: "anthropic",
+        model: "claude-sonnet-4-6",
+        usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
+        stopReason: "stop" as const,
+        timestamp: Date.now(),
+      },
+    ];
+
+    transformMessagesWithReport(messages as Parameters<typeof transformMessagesWithReport>[0], targetModel, undefined, "anthropic-messages");
+
+    const auditLogPath = join(basePath, ".gsd", "audit", "events.jsonl");
+    assert.ok(existsSync(auditLogPath), "audit events file should be created");
+    const auditLines = readFileSync(auditLogPath, "utf-8")
+      .trim()
+      .split("\n")
+      .map((line) => JSON.parse(line) as { category: string; type: string; traceId: string; payload: Record<string, unknown> });
+    const switchEvent = auditLines.find((e) => e.category === "model-policy" && e.type === "provider-switch");
+    assert.ok(switchEvent, "a model-policy/provider-switch audit event should be present");
+    assert.equal(switchEvent?.traceId, "trace-provider-switch-1");
+    assert.equal(switchEvent?.payload.fromApi, "anthropic-messages");
+    assert.equal(switchEvent?.payload.toApi, "openai-responses");
+
+    const stats = getProviderSwitchStats();
+    assert.ok("trace-provider-switch-1" in stats.byTrace, "trace-keyed bucket should be populated");
+    assert.equal(stats.byTrace["trace-provider-switch-1"]?.switches, 1);
+  } finally {
+    cleanup();
+  }
+});
+
+test("empty report does not bump counter or emit a notification", async () => {
+  const { transformMessagesWithReport } = await import("@gsd/pi-ai");
+
+  const { basePath, cleanup } = withTempBasePath();
+  try {
+    initNotificationStore(basePath);
+    installProviderSwitchObserver();
+
+    // Same-API transform → no transformations → empty report.
+    const sameApiModel = {
+      id: "claude-sonnet-4-6",
+      name: "Claude Sonnet 4.6",
+      api: "anthropic-messages",
+      provider: "anthropic",
+      baseUrl: "",
+      reasoning: false,
+      input: ["text"],
+      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+      contextWindow: 200000,
+      maxTokens: 8192,
+    } as Parameters<typeof transformMessagesWithReport>[1];
+
+    transformMessagesWithReport(
+      [
+        {
+          role: "user" as const,
+          content: "plain text — no transforms triggered",
+        },
+      ] as Parameters<typeof transformMessagesWithReport>[0],
+      sameApiModel,
+      undefined,
+      "anthropic-messages",
+    );
+
+    assert.equal(getProviderSwitchStats().totalSwitches, 0);
+    assert.equal(readNotifications(basePath).length, 0);
+  } finally {
+    cleanup();
+  }
+});

package/src/resources/extensions/gsd/tests/resume-dispatch-worktree.test.ts

@@ -10,7 +10,11 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
 
-import { _resolvePausedResumeBasePathForTest } from "../auto.ts";
+// ADR-016 phase 2 / B3 (#5621): the legacy `resolvePausedResumeBasePath`
+// helper was retired and folded into `WorktreeLifecycle.resumeFromPausedSession`.
+// The pure path-resolution function lives in `worktree-lifecycle.ts` for tests
+// that exercise the path-resolution invariant without constructing a session.
+import { resolvePausedResumeBasePath } from "../worktree-lifecycle.ts";
 
 function makeTmpBase(): string {
   const base = join(tmpdir(), `gsd-resume-wt-${randomUUID()}`);
@@ -59,7 +63,7 @@ test("resume base path uses paused-session worktreePath when the worktree exists
   try {
     setupWorktreeOnDisk(wt);
     assert.equal(
-      _resolvePausedResumeBasePathForTest(base, wt),
+      resolvePausedResumeBasePath(base, wt),
       wt,
     );
   } finally {
@@ -72,7 +76,7 @@ test("resume base path falls back to project root when paused worktree is missin
   const wt = makeWorktreePath(base, "M001-test");
   try {
     assert.equal(
-      _resolvePausedResumeBasePathForTest(base, wt),
+      resolvePausedResumeBasePath(base, wt),
       base,
     );
   } finally {

package/src/resources/extensions/gsd/tests/runtime-invariant-modules.test.ts

@@ -42,16 +42,19 @@ test("State Reconciliation invalidates cache and returns reconciled state", asyn
   assert.equal(result.ok && result.stateSnapshot, state);
 });
 
-test("State Reconciliation blocks when derived state carries blockers", async () => {
+test("State Reconciliation surfaces terminal blockers in result (ADR-017)", async () => {
+  // Under ADR-017, blockers are terminal but do not throw — they ride along
+  // in the result so the orchestrator adapter can map them to ok=false.
   const result = await reconcileBeforeDispatch("/project", {
     invalidateStateCache() {},
     async deriveState() {
       return makeState({ phase: "blocked", blockers: ["slice lock missing"] });
     },
+    registry: [],
   });
 
-  assert.equal(result.ok, false);
-  assert.equal(!result.ok && result.reason, "slice lock missing");
+  assert.equal(result.ok, true);
+  assert.deepEqual(result.blockers, ["slice lock missing"]);
 });
 
 test("Tool Contract compiles known Unit prompt and tool policy", () => {

package/src/resources/extensions/gsd/tests/session-start-footer.test.ts

@@ -1,9 +1,11 @@
+// Project/App: GSD-2
+// File Purpose: Verifies GSD session hook widget and footer lifecycle behavior.
+
 /**
- * session-start-footer.test.ts
- *
  * Verifies that register-hooks.ts suppresses the gsd-health widget (not the
- * built-in footer) when isAutoActive() is true, and that setFooter is never
- * called by the extension in either session_start or session_switch.
+ * built-in footer) when isAutoActive() is true, clears stale completion widgets
+ * on inactive session switches, and that setFooter is never called by the
+ * extension in either session_start or session_switch.
  *
  * Testing strategy:
  *   1. Source-code regression guards: structural checks on register-hooks.ts.
@@ -139,6 +141,16 @@ test("session_switch toggles gsd-health from runtime auto state without touching
   widgetCalls.length = 0;
   autoSession.active = false;
   await sessionSwitch!({ reason: "resume" }, ctx);
+  assert.deepEqual(
+    widgetCalls
+      .filter((call) => call.key === "gsd-progress" || call.key === "gsd-outcome")
+      .map((call) => [call.key, call.value]),
+    [
+      ["gsd-progress", undefined],
+      ["gsd-outcome", undefined],
+    ],
+    "session_switch should clear stale GSD completion widgets when auto is inactive",
+  );
   const healthWidgetValues = widgetCalls
     .filter((call) => call.key === "gsd-health")
     .map((call) => call.value);

package/src/resources/extensions/gsd/tests/session-switch-abort-misclassification.test.ts

@@ -188,6 +188,30 @@ test("empty-content aborted during session-switch is silently ignored", () => {
   assert.equal(cancelledWith, null);
 });
 
+test("completed assistant content with aborted stopReason during session-switch is ignored", () => {
+  // newSession() can abort the just-finished provider stream while the last
+  // assistant message still carries the completed unit summary. That is a
+  // session-transition artifact, not a cancellation for the next unit.
+  let cancelledWith: unknown = null;
+  const resolveCancelled = (ctx: ErrorContext) => {
+    cancelledWith = ctx;
+    return true;
+  };
+
+  _handleSessionSwitchAgentEnd(
+    {
+      stopReason: "aborted",
+      content: [{
+        type: "text",
+        text: "Implemented T01 and verified the slice task is complete.",
+      }],
+    },
+    resolveCancelled,
+  );
+
+  assert.equal(cancelledWith, null);
+});
+
 test("non-abort errors during session-switch are not propagated through this helper", () => {
   // Real provider errors (rate-limit, network, unsupported-model) are handled
   // by the post-switch retry pipeline — not by the in-flight switch handler.