gsd-pi 2.79.0 → 2.80.0-dev.4ea7d80e7

package/src/resources/extensions/gsd/tests/journal-integration.test.ts

@@ -399,6 +399,140 @@ test("runDispatch pauses when complete-milestone summary exists on disk but the
   assert.equal(stopCalls, 0, "mismatch pause should not hard-stop the loop");
 });
 
+test("runDispatch clears stuck state after Level 1 artifact recovery", async (t) => {
+  const capture = createEventCapture();
+  let invalidateCalls = 0;
+  let stopCalls = 0;
+  const base = join(tmpdir(), `gsd-stuck-plan-${randomUUID()}`);
+  t.after(() => {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+  const tasksDir = join(sliceDir, "tasks");
+  mkdirSync(tasksDir, { recursive: true });
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Test", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "pending" });
+  insertTask({ id: "T01", milestoneId: "M001", sliceId: "S01", title: "First task", status: "pending" });
+  writeFileSync(join(sliceDir, "S01-PLAN.md"), "# S01\n\n## Tasks\n\n- [ ] **T01: First task** `est:1h`\n");
+  writeFileSync(join(tasksDir, "T01-PLAN.md"), "# T01 Plan\n");
+
+  const deps = makeMockDeps(capture, {
+    invalidateAllCaches: () => { invalidateCalls++; },
+    stopAuto: async () => { stopCalls++; },
+    resolveDispatch: async () => ({
+      action: "dispatch" as const,
+      unitType: "plan-slice",
+      unitId: "M001/S01",
+      prompt: "plan the slice",
+      matchedRule: "planning → plan-slice",
+    }),
+  });
+  const ic = makeIC(deps, {
+    s: {
+      ...makeSession(),
+      basePath: base,
+      originalBasePath: base,
+    } as any,
+  });
+  const preData: PreDispatchData = {
+    state: {
+      phase: "planning",
+      activeMilestone: { id: "M001", title: "Test", status: "active" },
+      activeSlice: { id: "S01", title: "Slice" },
+      registry: [{ id: "M001", status: "active" }],
+      blockers: [],
+    } as any,
+    mid: "M001",
+    midTitle: "Test Milestone",
+  };
+  const loopState: LoopState = {
+    recentUnits: [
+      { key: "plan-slice/M001/S01" },
+      { key: "plan-slice/M001/S01" },
+    ],
+    stuckRecoveryAttempts: 0,
+    consecutiveFinalizeTimeouts: 0,
+  };
+
+  const result = await runDispatch(ic, preData, loopState);
+
+  assert.equal(result.action, "continue");
+  assert.equal(invalidateCalls, 1, "Level 1 artifact recovery should invalidate caches");
+  assert.equal(stopCalls, 0, "Level 1 artifact recovery should not hard-stop");
+  assert.deepEqual(loopState.recentUnits, [], "Level 1 artifact recovery should clear the stuck window");
+  assert.equal(loopState.stuckRecoveryAttempts, 0, "Level 1 artifact recovery should reset the recovery counter");
+});
+
+test("runDispatch escapes Level 2 stuck stop when artifact verifies after cache invalidation", async (t) => {
+  const capture = createEventCapture();
+  let invalidateCalls = 0;
+  let stopCalls = 0;
+  const base = join(tmpdir(), `gsd-stuck-plan-l2-${randomUUID()}`);
+  t.after(() => {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+  const tasksDir = join(sliceDir, "tasks");
+  mkdirSync(tasksDir, { recursive: true });
+  openDatabase(join(base, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M001", title: "Test", status: "active" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "pending" });
+  insertTask({ id: "T01", milestoneId: "M001", sliceId: "S01", title: "First task", status: "pending" });
+  writeFileSync(join(sliceDir, "S01-PLAN.md"), "# S01\n\n## Tasks\n\n- [ ] **T01: First task** `est:1h`\n");
+  writeFileSync(join(tasksDir, "T01-PLAN.md"), "# T01 Plan\n");
+
+  const deps = makeMockDeps(capture, {
+    invalidateAllCaches: () => { invalidateCalls++; },
+    stopAuto: async () => { stopCalls++; },
+    resolveDispatch: async () => ({
+      action: "dispatch" as const,
+      unitType: "plan-slice",
+      unitId: "M001/S01",
+      prompt: "plan the slice",
+      matchedRule: "planning → plan-slice",
+    }),
+  });
+  const ic = makeIC(deps, {
+    s: {
+      ...makeSession(),
+      basePath: base,
+      originalBasePath: base,
+    } as any,
+  });
+  const preData: PreDispatchData = {
+    state: {
+      phase: "planning",
+      activeMilestone: { id: "M001", title: "Test", status: "active" },
+      activeSlice: { id: "S01", title: "Slice" },
+      registry: [{ id: "M001", status: "active" }],
+      blockers: [],
+    } as any,
+    mid: "M001",
+    midTitle: "Test Milestone",
+  };
+  const loopState: LoopState = {
+    recentUnits: [
+      { key: "plan-slice/M001/S01" },
+      { key: "plan-slice/M001/S01" },
+    ],
+    stuckRecoveryAttempts: 1,
+    consecutiveFinalizeTimeouts: 0,
+  };
+
+  const result = await runDispatch(ic, preData, loopState);
+
+  assert.equal(result.action, "continue");
+  assert.equal(invalidateCalls, 1, "Level 2 escape should invalidate caches before rechecking artifacts");
+  assert.equal(stopCalls, 0, "verified artifacts should escape Level 2 hard stop");
+  assert.deepEqual(loopState.recentUnits, [], "Level 2 artifact escape should clear the stuck window");
+  assert.equal(loopState.stuckRecoveryAttempts, 0, "Level 2 artifact escape should reset the recovery counter");
+});
+
 test("runUnitPhase emits unit-start and unit-end with causedBy reference", async () => {
   const capture = createEventCapture();
 

package/src/resources/extensions/gsd/tests/legacy-component-format-telemetry.test.ts

@@ -0,0 +1,62 @@
+// Project/App: GSD-2
+// File Purpose: Verifies telemetry for legacy component formats.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { loadComponentFromAgentFile, loadComponentFromDir } from "../component-loader.js";
+import { getLegacyTelemetry, resetLegacyTelemetry } from "../legacy-telemetry.js";
+
+function makeTempDir(): string {
+  return mkdtempSync(join(tmpdir(), "gsd-legacy-component-format-"));
+}
+
+test("legacy component telemetry counts successful skill and agent format loads", () => {
+  const dir = makeTempDir();
+  try {
+    resetLegacyTelemetry();
+
+    const modernDir = join(dir, "modern-skill");
+    mkdirSync(modernDir, { recursive: true });
+    writeFileSync(join(modernDir, "component.yaml"), `
+apiVersion: gsd/v1
+kind: skill
+metadata:
+  name: modern-skill
+  description: "Modern skill"
+spec:
+  prompt: SKILL.md
+`, "utf-8");
+    writeFileSync(join(modernDir, "SKILL.md"), "Modern content.", "utf-8");
+    assert.ok(loadComponentFromDir(modernDir, "user").component);
+    assert.equal(getLegacyTelemetry()["legacy.componentFormatUsed"], 0);
+
+    const legacySkillDir = join(dir, "legacy-skill");
+    mkdirSync(legacySkillDir, { recursive: true });
+    writeFileSync(join(legacySkillDir, "SKILL.md"), `---
+name: legacy-skill
+description: Legacy skill
+---
+Skill content.
+`, "utf-8");
+    assert.ok(loadComponentFromDir(legacySkillDir, "user").component);
+    assert.equal(getLegacyTelemetry()["legacy.componentFormatUsed"], 1);
+
+    const legacyAgentFile = join(dir, "legacy-agent.md");
+    writeFileSync(legacyAgentFile, `---
+name: legacy-agent
+description: Legacy agent
+tools: read, grep
+---
+Agent content.
+`, "utf-8");
+    assert.ok(loadComponentFromAgentFile(legacyAgentFile, "user").component);
+    assert.equal(getLegacyTelemetry()["legacy.componentFormatUsed"], 2);
+  } finally {
+    resetLegacyTelemetry();
+    rmSync(dir, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/legacy-telemetry.test.ts

@@ -0,0 +1,144 @@
+// Project/App: GSD-2
+// File Purpose: Tests for telemetry counters guarding legacy compatibility cleanup.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  getLegacyTelemetryReport,
+  getLegacyTelemetry,
+  incrementLegacyTelemetry,
+  listLegacyTelemetryCounters,
+  persistLegacyTelemetrySnapshot,
+  resetLegacyTelemetry,
+} from "../legacy-telemetry.ts";
+import { closeDatabase } from "../gsd-db.ts";
+import { deriveState, invalidateStateCache } from "../state.ts";
+import { _resetLogs, peekLogs, setStderrLoggingEnabled } from "../workflow-logger.ts";
+
+test("legacy telemetry exposes every Phase 8 cleanup counter", () => {
+  resetLegacyTelemetry();
+
+  assert.deepEqual(listLegacyTelemetryCounters(), [
+    "legacy.markdownFallbackUsed",
+    "legacy.workflowEngineUsed",
+    "legacy.uokFallbackUsed",
+    "legacy.mcpAliasUsed",
+    "legacy.componentFormatUsed",
+    "legacy.providerDefaultUsed",
+  ]);
+  assert.equal(getLegacyTelemetry()["legacy.markdownFallbackUsed"], 0);
+});
+
+test("legacy telemetry increments positive finite amounts only", () => {
+  resetLegacyTelemetry();
+
+  incrementLegacyTelemetry("legacy.workflowEngineUsed");
+  incrementLegacyTelemetry("legacy.workflowEngineUsed", 2);
+  incrementLegacyTelemetry("legacy.workflowEngineUsed", 0);
+  incrementLegacyTelemetry("legacy.workflowEngineUsed", Number.NaN);
+
+  assert.equal(getLegacyTelemetry()["legacy.workflowEngineUsed"], 3);
+});
+
+test("legacy telemetry emits one actionable diagnostic per counter", () => {
+  const previousStderr = setStderrLoggingEnabled(false);
+  try {
+    resetLegacyTelemetry();
+    _resetLogs();
+
+    incrementLegacyTelemetry("legacy.mcpAliasUsed");
+    incrementLegacyTelemetry("legacy.mcpAliasUsed");
+
+    const logs = peekLogs();
+    assert.equal(logs.length, 1);
+    assert.equal(logs[0]?.component, "migration");
+    assert.equal(logs[0]?.context?.counter, "legacy.mcpAliasUsed");
+    assert.match(logs[0]?.message ?? "", /canonical gsd_\* tool name/);
+  } finally {
+    _resetLogs();
+    resetLegacyTelemetry();
+    setStderrLoggingEnabled(previousStderr);
+  }
+});
+
+test("legacy telemetry can persist an opt-in snapshot file", () => {
+  const previousStderr = setStderrLoggingEnabled(false);
+  const previousOutput = process.env.GSD_LEGACY_TELEMETRY_FILE;
+  const base = mkdtempSync(join(tmpdir(), "gsd-legacy-telemetry-file-"));
+  const outputPath = join(base, "runtime", "legacy-telemetry.json");
+  try {
+    resetLegacyTelemetry();
+    _resetLogs();
+    process.env.GSD_LEGACY_TELEMETRY_FILE = outputPath;
+
+    incrementLegacyTelemetry("legacy.providerDefaultUsed", 2);
+
+    const report = JSON.parse(readFileSync(outputPath, "utf-8")) as ReturnType<typeof getLegacyTelemetryReport>;
+    assert.equal(typeof report.ts, "string");
+    assert.equal(report.counters["legacy.providerDefaultUsed"], 2);
+    assert.equal(report.counters["legacy.markdownFallbackUsed"], 0);
+  } finally {
+    if (previousOutput === undefined) delete process.env.GSD_LEGACY_TELEMETRY_FILE;
+    else process.env.GSD_LEGACY_TELEMETRY_FILE = previousOutput;
+    _resetLogs();
+    resetLegacyTelemetry();
+    setStderrLoggingEnabled(previousStderr);
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("legacy telemetry can persist a zero-use snapshot for deletion gates", () => {
+  const previousOutput = process.env.GSD_LEGACY_TELEMETRY_FILE;
+  const base = mkdtempSync(join(tmpdir(), "gsd-legacy-zero-telemetry-"));
+  const outputPath = join(base, "legacy-telemetry.json");
+  try {
+    resetLegacyTelemetry();
+    process.env.GSD_LEGACY_TELEMETRY_FILE = outputPath;
+
+    persistLegacyTelemetrySnapshot();
+
+    const report = JSON.parse(readFileSync(outputPath, "utf-8")) as ReturnType<typeof getLegacyTelemetryReport>;
+    assert.equal(typeof report.ts, "string");
+    assert.deepEqual(report.counters, {
+      "legacy.markdownFallbackUsed": 0,
+      "legacy.workflowEngineUsed": 0,
+      "legacy.uokFallbackUsed": 0,
+      "legacy.mcpAliasUsed": 0,
+      "legacy.componentFormatUsed": 0,
+      "legacy.providerDefaultUsed": 0,
+    });
+  } finally {
+    if (previousOutput === undefined) delete process.env.GSD_LEGACY_TELEMETRY_FILE;
+    else process.env.GSD_LEGACY_TELEMETRY_FILE = previousOutput;
+    resetLegacyTelemetry();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("deriveState increments markdown fallback telemetry on explicit legacy fallback", async () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-legacy-telemetry-"));
+  const originalFallback = process.env.GSD_ALLOW_MARKDOWN_DERIVE_FALLBACK;
+  try {
+    closeDatabase();
+    resetLegacyTelemetry();
+    invalidateStateCache();
+    process.env.GSD_ALLOW_MARKDOWN_DERIVE_FALLBACK = "1";
+    mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+    writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-CONTEXT.md"), "# M001: Legacy\n");
+
+    const state = await deriveState(base);
+
+    assert.equal(state.activeMilestone?.id, "M001");
+    assert.equal(getLegacyTelemetry()["legacy.markdownFallbackUsed"], 1);
+  } finally {
+    invalidateStateCache();
+    resetLegacyTelemetry();
+    if (originalFallback === undefined) delete process.env.GSD_ALLOW_MARKDOWN_DERIVE_FALLBACK;
+    else process.env.GSD_ALLOW_MARKDOWN_DERIVE_FALLBACK = originalFallback;
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/memory-pressure-stuck-state.test.ts

@@ -9,16 +9,36 @@ import { readFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 
+import { decideMemoryPressure } from "../auto/workflow-kernel.ts";
+import { measureMemoryPressure } from "../auto/workflow-memory-pressure.ts";
+
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const loopSource = readFileSync(join(__dirname, "..", "auto", "loop.ts"), "utf-8");
 
 describe("memory pressure monitoring (#3331)", () => {
-  test("checkMemoryPressure function exists", () => {
-    assert.match(loopSource, /function checkMemoryPressure/);
+  test("measureMemoryPressure reports pressure above threshold", () => {
+    const snapshot = measureMemoryPressure({
+      threshold: 0.5,
+      deps: {
+        memoryUsage: () => ({ heapUsed: 768 * 1024 * 1024 }),
+        heapLimitBytes: () => 1024 * 1024 * 1024,
+      },
+    });
+
+    assert.equal(snapshot.pressured, true);
+    assert.equal(snapshot.heapMB, 768);
+    assert.equal(snapshot.limitMB, 1024);
   });
 
-  test("MEMORY_PRESSURE_THRESHOLD constant is defined", () => {
-    assert.match(loopSource, /MEMORY_PRESSURE_THRESHOLD\s*=\s*0\.\d+/);
+  test("measureMemoryPressure defaults to a sub-100-percent threshold", () => {
+    const snapshot = measureMemoryPressure({
+      deps: {
+        memoryUsage: () => ({ heapUsed: 3584 * 1024 * 1024 }),
+        heapLimitBytes: () => 4096 * 1024 * 1024,
+      },
+    });
+
+    assert.equal(snapshot.pressured, true);
   });
 
   test("memory check runs every MEMORY_CHECK_INTERVAL iterations", () => {
@@ -26,8 +46,16 @@ describe("memory pressure monitoring (#3331)", () => {
   });
 
   test("memory pressure triggers graceful stopAuto", () => {
-    assert.match(loopSource, /mem\.pressured/);
-    assert.match(loopSource, /Stopping gracefully to prevent OOM/);
+    const decision = decideMemoryPressure({
+      pressured: true,
+      heapMB: 3900,
+      limitMB: 4096,
+      pct: 0.95,
+      iteration: 10,
+    });
+
+    assert.equal(decision.action, "stop");
+    assert.match(decision.stopMessage, /Stopping gracefully to prevent OOM/);
   });
 });
 
@@ -55,15 +83,11 @@ describe("stuck detection persistence (#3704)", () => {
   // unit_dispatches (recentUnits) + runtime_kv (stuckRecoveryAttempts).
   // The stuck-state-via-db.test.ts suite covers the round-trip.
 
-  test("saveStuckState called in standard dev path as well as custom engine path (#4382)", () => {
-    // Count all call-sites of saveStuckState (excluding the function definition itself).
-    // After the fix, both the custom-engine path and the standard dev path must each
-    // call saveStuckState so stuckRecoveryAttempts survives session restarts.
-    const callMatches = loopSource.match(/saveStuckState\(s,\s*loopState\)/g) ?? [];
-    assert.ok(
-      callMatches.length >= 2,
-      `saveStuckState must be called in both the custom-engine path and the standard dev path ` +
-      `(found ${callMatches.length} call(s) — standard path is missing its call, #4382)`,
-    );
+  test("completeIteration centralizes stuck-state persistence for both loop paths (#4382)", () => {
+    assert.match(loopSource, /const completeIteration = \(\): void =>/);
+    assert.match(loopSource, /completeWorkflowIteration\(/);
+    assert.match(loopSource, /saveStuckState:\s*\(\)\s*=>\s*saveStuckState\(s,\s*loopState\)/);
+    assert.match(loopSource, /completeIteration,/);
+    assert.match(loopSource, /completeIteration\(\);/);
   });
 });

package/src/resources/extensions/gsd/tests/model-router.test.ts

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: Verifies model routing decisions and legacy provider-default telemetry.
 import test, { describe } from "node:test";
 import assert from "node:assert/strict";
 
@@ -14,6 +16,7 @@ import {
 } from "../model-router.js";
 import type { DynamicRoutingConfig, RoutingDecision, ModelCapabilities } from "../model-router.js";
 import type { ClassificationResult } from "../complexity-classifier.js";
+import { getLegacyTelemetry, resetLegacyTelemetry } from "../legacy-telemetry.js";
 
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 
@@ -297,16 +300,28 @@ test("cross-provider: configured primary available by bare ID wins over equivale
 // ─── resolveModelForTier (provider-agnostic tier resolution) ────────────────
 
 test("resolveModelForTier: returns canonical Anthropic model when no available models", () => {
-  assert.equal(resolveModelForTier("heavy", []), "claude-opus-4-6");
-  assert.equal(resolveModelForTier("standard", []), "claude-sonnet-4-6");
-  assert.equal(resolveModelForTier("light", []), "claude-haiku-4-5");
+  try {
+    resetLegacyTelemetry();
+    assert.equal(resolveModelForTier("heavy", []), "claude-opus-4-6");
+    assert.equal(resolveModelForTier("standard", []), "claude-sonnet-4-6");
+    assert.equal(resolveModelForTier("light", []), "claude-haiku-4-5");
+    assert.equal(getLegacyTelemetry()["legacy.providerDefaultUsed"], 3);
+  } finally {
+    resetLegacyTelemetry();
+  }
 });
 
 test("resolveModelForTier: returns canonical model when it is available", () => {
-  assert.equal(
-    resolveModelForTier("heavy", ["claude-opus-4-6", "claude-sonnet-4-6"]),
-    "claude-opus-4-6",
-  );
+  try {
+    resetLegacyTelemetry();
+    assert.equal(
+      resolveModelForTier("heavy", ["claude-opus-4-6", "claude-sonnet-4-6"]),
+      "claude-opus-4-6",
+    );
+    assert.equal(getLegacyTelemetry()["legacy.providerDefaultUsed"], 0);
+  } finally {
+    resetLegacyTelemetry();
+  }
 });
 
 test("resolveModelForTier: does not prefer canonical over cheaper same-tier model", () => {
@@ -341,11 +356,17 @@ test("resolveModelForTier: picks light-tier cross-provider model", () => {
 });
 
 test("resolveModelForTier: falls back to canonical when no tier match available", () => {
-  // Only unknown models available — getModelTier classifies unknowns as
-  // "standard", so a request for "heavy" finds no match and the canonical
-  // Anthropic ID is returned as a documented fallback.
-  const result = resolveModelForTier("heavy", ["some-custom-model"]);
-  assert.equal(result, "claude-opus-4-6");
+  try {
+    resetLegacyTelemetry();
+    // Only unknown models available — getModelTier classifies unknowns as
+    // "standard", so a request for "heavy" finds no match and the canonical
+    // Anthropic ID is returned as a documented fallback.
+    const result = resolveModelForTier("heavy", ["some-custom-model"]);
+    assert.equal(result, "claude-opus-4-6");
+    assert.equal(getLegacyTelemetry()["legacy.providerDefaultUsed"], 1);
+  } finally {
+    resetLegacyTelemetry();
+  }
 });
 
 test("resolveModelForTier: handles provider-prefixed available models", () => {

package/src/resources/extensions/gsd/tests/notification-store.test.ts

@@ -19,6 +19,7 @@ import {
   onNotificationStoreChange,
   _resetNotificationStore,
 } from "../notification-store.js";
+import { resolveNotificationStoreBasePath } from "../bootstrap/register-hooks.js";
 
 describe("notification-store", () => {
   let tmp: string;
@@ -243,6 +244,13 @@ describe("notification-store", () => {
     rmSync(tmp2, { recursive: true, force: true });
   });
 
+  test("session notification base resolves auto-worktree paths to project root", () => {
+    const worktreePath = join(tmp, ".gsd", "worktrees", "M001");
+    mkdirSync(worktreePath, { recursive: true });
+
+    assert.equal(resolveNotificationStoreBasePath(worktreePath), tmp);
+  });
+
   test("counters resync from disk after markAllRead", () => {
     initNotificationStore(tmp);
     appendNotification("msg1", "info");

package/src/resources/extensions/gsd/tests/notification-widget.test.ts

@@ -5,7 +5,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 
 import { initNotificationStore, appendNotification, _resetNotificationStore } from "../notification-store.js";
-import { buildNotificationWidgetLines } from "../notification-widget.js";
+import { buildNotificationWidgetLines, initNotificationWidget, _resetNotificationWidgetForTests } from "../notification-widget.js";
 
 test("buildNotificationWidgetLines shows unread count with shortcut pair", () => {
   const tmp = mkdtempSync(join(tmpdir(), "gsd-notification-widget-"));
@@ -27,3 +27,42 @@ test("buildNotificationWidgetLines shows unread count with shortcut pair", () =>
     rmSync(tmp, { recursive: true, force: true });
   }
 });
+
+test("initNotificationWidget replaces prior interval and store subscription", () => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-notification-widget-"));
+  const firstStatuses: Array<string | undefined> = [];
+  const secondStatuses: Array<string | undefined> = [];
+  try {
+    mkdirSync(join(tmp, ".gsd"), { recursive: true });
+    _resetNotificationStore();
+    _resetNotificationWidgetForTests();
+    initNotificationStore(tmp);
+    appendNotification("Need attention", "warning");
+
+    const firstCleanup = initNotificationWidget({
+      hasUI: true,
+      ui: { setStatus: (_key: string, value: string | undefined) => firstStatuses.push(value) },
+    } as any);
+    initNotificationWidget({
+      hasUI: true,
+      ui: { setStatus: (_key: string, value: string | undefined) => secondStatuses.push(value) },
+    } as any);
+
+    const firstCountAfterReplace = firstStatuses.length;
+    firstCleanup();
+    assert.equal(firstStatuses.length, firstCountAfterReplace, "stale cleanup must not clear the replaced status chip");
+
+    appendNotification("Need follow-up", "warning");
+
+    assert.equal(
+      firstStatuses.length,
+      firstCountAfterReplace,
+      "replaced widget must not receive store-change refreshes",
+    );
+    assert.match(secondStatuses.at(-1) ?? "", /2 unread/);
+  } finally {
+    _resetNotificationWidgetForTests();
+    _resetNotificationStore();
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/parallel-skill-prompt-integration.test.ts

@@ -147,4 +147,12 @@ test("subagent dispatch prompt (buildParallelResearchSlicesPrompt) carries <skil
     prompt.includes(SKILL_ACTIVATION_SUBSTRING),
     `parallel-research-slices prompt should reference the always-used skill '${SKILL_NAME}'`,
   );
+  assert.ok(
+    prompt.includes("Context Mode (research lane):"),
+    "embedded parallel research subagent prompts should use nested Context Mode guidance",
+  );
+  assert.ok(
+    !prompt.includes("## Context Mode\n\nLane: **research lane**."),
+    "embedded parallel research subagent prompts should not use standalone Context Mode heading",
+  );
 });

package/src/resources/extensions/gsd/tests/paused-session-via-db.test.ts

@@ -64,6 +64,7 @@ test("readPausedSessionMetadata round-trips a real PausedSessionMetadata payload
     activeRunDir: null,
     autoStartTime: Date.now(),
     milestoneLock: null,
+    pauseReason: "Blocked: waiting for UAT",
   };
   setRuntimeKv("global", "", PAUSED_SESSION_KV_KEY, meta);
 
@@ -73,6 +74,7 @@ test("readPausedSessionMetadata round-trips a real PausedSessionMetadata payload
   assert.equal(loaded!.unitType, "plan-slice");
   assert.equal(loaded!.unitId, "M001/S01");
   assert.equal(loaded!.sessionFile, "/tmp/session.jsonl");
+  assert.equal(loaded!.pauseReason, "Blocked: waiting for UAT");
 });
 
 test("readPausedSessionMetadata auto-deletes stale pseudo-milestone pause rows", (t) => {

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

@@ -0,0 +1,45 @@
+// Project/App: GSD-2
+// File Purpose: Verifies the milestone planning prompt renders compact required guidance.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+test("plan-milestone prompt renders compact DB-backed planning guidance", async (t) => {
+  const previousGsdHome = process.env.GSD_HOME;
+  const providedGsdHome = process.env.GSD_TEST_HOME;
+  const isolatedHome = providedGsdHome ?? mkdtempSync(join(tmpdir(), "gsd-plan-milestone-render-"));
+  const fixtureRoot = process.env.GSD_TEST_WORKSPACE_ROOT ?? process.cwd();
+  process.env.GSD_HOME = isolatedHome;
+  t.after(() => {
+    if (previousGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = previousGsdHome;
+    if (!providedGsdHome) rmSync(isolatedHome, { recursive: true, force: true });
+  });
+
+  const { loadPrompt } = await import(`../prompt-loader.ts?test=${Date.now()}`);
+  const prompt = loadPrompt("plan-milestone", {
+    milestoneId: "M001",
+    milestoneTitle: "Reduce prompt cost",
+    workingDirectory: fixtureRoot,
+    inlinedContext: "## Roadmap\n\nUse the roadmap template.",
+    outputPath: ".gsd/milestones/M001/M001-ROADMAP.md",
+    skillDiscoveryMode: "filtered",
+    skillDiscoveryInstructions: "Use only relevant skills.",
+    sourceFilePaths: "- src/resources/extensions/gsd/prompts/plan-milestone.md",
+    researchOutputPath: ".gsd/milestones/M001/M001-RESEARCH.md",
+    secretsOutputPath: ".gsd/milestones/M001/SECRETS.md",
+  });
+
+  assert.match(prompt, /Explore First, Then Decompose/);
+  assert.match(prompt, /Call `gsd_plan_milestone`/);
+  assert.match(prompt, /call `gsd_decision_save`/);
+  assert.match(prompt, /Every relevant Active requirement must end as mapped/);
+  assert.match(prompt, /Risk-first means proof-first/);
+  assert.match(prompt, /Progressive Planning \(ADR-011\)/);
+  assert.match(prompt, /Single-Slice Fast Path/);
+  assert.match(prompt, /Secret Forecasting/);
+  assert.doesNotMatch(prompt, /\{\{[a-zA-Z][a-zA-Z0-9_]*\}\}/);
+});