@opengsd/gsd-pi 1.1.1-dev.3ea310e → 1.1.1-dev.595401e

package/src/resources/extensions/gsd/rule-types.ts

@@ -32,6 +32,8 @@ export interface RuleLifecycle {
   retry_on?: string;
   /** Max times this hook can fire for the same trigger unit. */
   max_cycles?: number;
+  /** Whether this hook is advisory or blocking. */
+  criticality?: PostUnitHookConfig["criticality"];
   /** Idempotency key pattern for this hook. */
   idempotency_key?: string;
 }

package/src/resources/extensions/gsd/safety/destructive-guard.ts

@@ -24,6 +24,9 @@ const DESTRUCTIVE_PATTERNS: readonly DestructivePattern[] = [
   { pattern: /\btruncate\s+table\b/i, label: "SQL truncate" },
   { pattern: /\bchmod\s+777\b/, label: "world-writable permissions" },
   { pattern: /\bcurl\s.*\|\s*(bash|sh|zsh)\b/, label: "pipe to shell" },
+  { pattern: /\bterra(form|grunt)\s+(apply|destroy)/i, label: "IaC apply/destroy" },
+  { pattern: /\baws\s+\w+\s+(delete|create|put|remove|terminate)\b/i, label: "AWS mutation" },
+  { pattern: /\bkubectl\s+(delete|apply)\b/i, label: "kubectl mutation" },
 ];
 
 // ─── Public API ─────────────────────────────────────────────────────────────

package/src/resources/extensions/gsd/skill-activation.ts

@@ -50,6 +50,16 @@ function tokenizeSkillContext(...parts: Array<string | null | undefined>): Set<s
   return tokens;
 }
 
+function tokenizeUnitType(unitType: string | undefined): Set<string> {
+  const tokens = new Set<string>();
+  const value = unitType?.trim().toLowerCase();
+  if (!value) return tokens;
+  tokens.add(value);
+  tokens.add(value.replace(/[-_]+/g, " "));
+  tokens.add(value.replace(/[-_\s]+/g, ""));
+  return tokens;
+}
+
 function skillMatchesContext(skill: Skill, contextTokens: Set<string>): boolean {
   const haystacks = [
     skill.name.toLowerCase(),
@@ -79,17 +89,25 @@ function ruleMatchesContext(when: string, contextTokens: Set<string>): boolean {
   );
 }
 
+function ruleMatchesUnitType(when: string, unitType: string | undefined): boolean {
+  if (!unitType) return false;
+  const whenTokens = tokenizeSkillContext(when);
+  const unitTokens = tokenizeUnitType(unitType);
+  return [...unitTokens].some(token => whenTokens.has(token));
+}
+
 function resolveSkillRuleMatches(
   prefs: GSDPreferences | undefined,
   contextTokens: Set<string>,
   base: string,
+  unitType?: string,
 ): { include: string[]; avoid: string[] } {
   if (!prefs?.skill_rules?.length) return { include: [], avoid: [] };
 
   const include: string[] = [];
   const avoid: string[] = [];
   for (const rule of prefs.skill_rules) {
-    if (!ruleMatchesContext(rule.when, contextTokens)) continue;
+    if (!ruleMatchesContext(rule.when, contextTokens) && !ruleMatchesUnitType(rule.when, unitType)) continue;
     include.push(...resolvePreferenceSkillNames([...(rule.use ?? []), ...(rule.prefer ?? [])], base));
     avoid.push(...resolvePreferenceSkillNames(rule.avoid ?? [], base));
   }
@@ -196,7 +214,7 @@ export function buildSkillActivationBlock(params: {
     matched.add(name);
   }
 
-  const ruleMatches = resolveSkillRuleMatches(prefs, contextTokens, params.base);
+  const ruleMatches = resolveSkillRuleMatches(prefs, contextTokens, params.base, params.unitType);
   for (const name of ruleMatches.include) matched.add(name);
   for (const name of ruleMatches.avoid) avoided.add(name);
 

package/src/resources/extensions/gsd/state-reconciliation/drift/roadmap.ts

@@ -9,6 +9,7 @@ import { existsSync, readFileSync } from "node:fs";
 import {
   getMilestone,
   getMilestoneSlices,
+  getSliceTasks,
   isDbAvailable,
 } from "../../gsd-db.js";
 import { renderRoadmapFromDb } from "../../markdown-renderer.js";
@@ -30,6 +31,19 @@ function arraysEqual(a: readonly string[], b: readonly string[]): boolean {
   return true;
 }
 
+function getSlicesReadyForDivergenceCheck(
+  milestoneId: string,
+  dbSlices: ReturnType<typeof getMilestoneSlices>,
+): Set<string> {
+  const ready = new Set<string>();
+  for (const slice of dbSlices) {
+    if (isClosedStatus(slice.status) || getSliceTasks(milestoneId, slice.id).length > 0) {
+      ready.add(slice.id);
+    }
+  }
+  return ready;
+}
+
 function milestoneHasDivergence(
   basePath: string,
   milestoneId: string,
@@ -46,6 +60,10 @@ function milestoneHasDivergence(
 
   const dbSlices = getMilestoneSlices(milestoneId);
   const dbSliceMap = new Map(dbSlices.map((s) => [s.id, s]));
+  const readySliceIds = getSlicesReadyForDivergenceCheck(milestoneId, dbSlices);
+  if (dbSlices.length > 0 && readySliceIds.size === 0) {
+    return false;
+  }
   const roadmapSliceIds = new Set<string>();
 
   for (let i = 0; i < roadmap.slices.length; i++) {
@@ -54,11 +72,13 @@ function milestoneHasDivergence(
     const expectedSequence = i + 1;
     const dbSlice = dbSliceMap.get(roadmapSlice.id);
     if (!dbSlice) return true; // Roadmap has a slice the DB doesn't.
+    if (!readySliceIds.has(dbSlice.id)) continue;
     if (dbSlice.sequence !== expectedSequence) return true;
     if (!arraysEqual(dbSlice.depends, roadmapSlice.depends)) return true;
     if (isClosedStatus(dbSlice.status) !== roadmapSlice.done) return true;
   }
   for (const dbSlice of dbSlices) {
+    if (!readySliceIds.has(dbSlice.id)) continue;
     if (!roadmapSliceIds.has(dbSlice.id)) return true;
   }
   return false;

package/src/resources/extensions/gsd/state-reconciliation/index.ts

@@ -6,6 +6,7 @@ import {
   deriveState as defaultDeriveState,
   invalidateStateCache as defaultInvalidate,
 } from "../state.js";
+import { clearParseCache as defaultClearParseCache } from "../files.js";
 import type { GSDState } from "../types.js";
 
 import {
@@ -37,6 +38,7 @@ const MAX_PASSES = 2;
 const defaultDeps: ReconciliationDeps = {
   invalidateStateCache: defaultInvalidate,
   deriveState: defaultDeriveState,
+  clearParseCache: defaultClearParseCache,
 };
 
 /**
@@ -58,6 +60,7 @@ export async function reconcileBeforeDispatch(
   deps: ReconciliationDeps = defaultDeps,
 ): Promise<ReconciliationResult> {
   const registry = deps.registry ?? DRIFT_REGISTRY;
+  const clearParseCache = deps.clearParseCache ?? defaultClearParseCache;
   const repaired: DriftRecord[] = [];
 
   for (let pass = 0; pass < MAX_PASSES; pass++) {
@@ -103,6 +106,9 @@ export async function reconcileBeforeDispatch(
       }
     }
 
+    if (repairedThisPass) {
+      clearParseCache();
+    }
     if (blockers.length > 0) {
       let blockerState = stateSnapshot;
       if (repairedThisPass) {

package/src/resources/extensions/gsd/state-reconciliation/types.ts

@@ -101,6 +101,7 @@ export interface ReconciliationDeps {
     basePath: string,
     opts?: DeriveStateOptions,
   ) => Promise<GSDState>;
+  clearParseCache?: () => void;
   /**
    * Override of the drift handler catalog. Defaults to DRIFT_REGISTRY. Each
    * handler is parameterized over its own DriftRecord variant; the union of

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

@@ -83,7 +83,7 @@ function formatNeedsRemediationBlocker(milestoneId: string): string {
   return [
     `Milestone ${milestoneId} is blocked because milestone validation returned needs-remediation, but all slices are complete.`,
     `Fix options:`,
-    `1. Add remediation slices with \`gsd_reassess_roadmap\`, then run \`/gsd auto\``,
+    `1. Run \`/gsd dispatch reassess\` to add remediation slices, then run \`/gsd auto\``,
     `2. If the finding is acceptable, override it: \`/gsd verdict pass --rationale "why this is okay"\``,
     `3. If this should wait, defer it explicitly: \`/gsd park ${milestoneId}\``,
   ].join("\n");
@@ -896,8 +896,8 @@ export async function deriveStateFromDb(
   }
 
   // ADR-011 Phase 2: pause-on-escalation takes precedence over dispatching the
-  // next task. `awaiting_review` tasks (continueWithDefault=true) are NOT
-  // surfaced here — they let the loop continue.
+  // next task. `awaiting_review` tasks (continueWithDefault=true) still pause
+  // here so silence is never treated as consent.
   //
   // We do NOT gate this on `phases.mid_execution_escalation` — creation of
   // new escalations is gated at the write site (tools/complete-task.ts:315),

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

@@ -132,14 +132,16 @@
   Verify field rules:
   - MUST be a mechanically executable command: `npm test`, `grep -q "pattern" file`, `test -f path`
   - MUST NOT use shell pipes, redirects, semicolons, backticks, command substitution, output trimming, or grep regex alternation with `|`
+  - For absence checks, use `! grep -q "pattern" file` or `! rg -q "pattern" file`; do not use `grep -c` or `rg -c` to assert zero matches because count commands exit 1 when they find zero matches
   - MUST NOT use inline `node -e` assertions for verification; put assertions in a real test file and run it with `node --test` or a package test script
   - For content/document tasks: verify file existence, section count, YAML validity, or word count
     NOT exact phrasing, specific formulas, or "zero TBD" aspirational criteria
   - If no command can verify the output, write: "Manual review — file exists and is non-empty"
   - BAD: `python3 -m pytest tests/ -q --tb=short 2>&1 | tail -5`
+  - BAD: `grep -c "old_api" src/index.ts`
   - BAD: "Sections 3.1 and 3.2 exist with exact formulas. Zero TBD/TODO."
   - GOOD: `python3 -m pytest tests/ -q --tb=short`
-  - GOOD: `node --test tests/verify-doc.test.js`, `grep -q "Required heading" doc.md`, `test -s doc.md`
+  - GOOD: `node --test tests/verify-doc.test.js`, `grep -q "Required heading" doc.md`, `! grep -q "old_api" src/index.ts`, `test -s doc.md`
 
   Integration closure rule:
   - At least one slice in any multi-boundary milestone should perform real composition/wiring, not just contract hardening

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

@@ -4,6 +4,7 @@ import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execFileSync } from "node:child_process";
+import { visibleWidth } from "@gsd/pi-tui";
 
 import {
   unitVerb,
@@ -16,11 +17,13 @@ import {
   buildPhaseHandoffOutcome,
   updateProgressWidget,
   setAutoOutcomeWidget,
+  setAutoActiveStatus,
   setCompletionProgressWidget,
   getRoadmapSlicesSync,
   clearSliceProgressCache,
   getWidgetMode,
   cycleWidgetMode,
+  setWidgetMode,
   _resetWidgetModeForTests,
   _resetLastCommitCacheForTests,
   _refreshLastCommitForTests,
@@ -55,6 +58,17 @@ function cleanup(dir: string): void {
   }
 }
 
+function assertLinesFit(lines: string[], width: number): void {
+  for (const line of lines) {
+    assert.ok(
+      visibleWidth(line) <= width,
+      `line exceeds width ${width}: ${visibleWidth(line)} "${line}"`,
+    );
+  }
+}
+
+type RenderableWidget = { render(width: number): string[]; invalidate(): void; dispose?: () => void };
+
 // ─── unitVerb ─────────────────────────────────────────────────────────────
 
 test("unitVerb maps known unit types to verbs", () => {
@@ -78,6 +92,26 @@ test("unitVerb handles hook types", () => {
   assert.equal(unitVerb("hook/"), "hook: ");
 });
 
+test("setAutoActiveStatus clears stale outcome surfaces", () => {
+  const statusCalls: Array<[string, string]> = [];
+  const widgetCalls: Array<[string, unknown]> = [];
+
+  setAutoActiveStatus({
+    hasUI: true,
+    ui: {
+      setStatus: (key: string, value: string) => {
+        statusCalls.push([key, value]);
+      },
+      setWidget: (key: string, value: unknown) => {
+        widgetCalls.push([key, value]);
+      },
+    },
+  } as any, "next");
+
+  assert.deepEqual(statusCalls, [["gsd-auto", "next"]]);
+  assert.deepEqual(widgetCalls, [["gsd-outcome", undefined]]);
+});
+
 // ─── unitPhaseLabel ───────────────────────────────────────────────────────
 
 test("unitPhaseLabel maps known types to labels", () => {
@@ -571,14 +605,21 @@ test("updateProgressWidget refreshes slice progress cache immediately", (t) => {
 test("updateProgressWidget full mode keeps footer-owned signals out of auto deck", (t) => {
   const dir = makeTempDir("command-deck");
   mkdirSync(join(dir, ".gsd"), { recursive: true });
+  const projectPrefsPath = join(dir, ".gsd", "preferences.md");
+  const globalPrefsPath = join(dir, ".gsd", "global-preferences.md");
+  writeFileSync(projectPrefsPath, "---\nversion: 1\n---\n", "utf-8");
   let widget: { render(width: number): string[]; dispose?: () => void } | null = null;
 
   t.after(() => {
     widget?.dispose?.();
+    _resetWidgetModeForTests();
     clearSliceProgressCache();
     cleanup(dir);
   });
 
+  _resetWidgetModeForTests();
+  setWidgetMode("full", projectPrefsPath, globalPrefsPath);
+
   updateProgressWidget(
     {
       hasUI: true,
@@ -633,6 +674,95 @@ test("updateProgressWidget full mode keeps footer-owned signals out of auto deck
   assert.doesNotMatch(rendered, /\$/, "footer owns session cost display");
 });
 
+test("updateProgressWidget small mode renders the dense horizontal grid", (t) => {
+  const dir = makeTempDir("small-dense-grid");
+  const homeDir = makeTempDir("small-dense-grid-home");
+  const projectPrefsPath = join(dir, ".gsd", "preferences.md");
+  const globalPrefsPath = join(homeDir, ".gsd", "preferences.md");
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  mkdirSync(join(homeDir, ".gsd"), { recursive: true });
+  writeFileSync(projectPrefsPath, "---\nversion: 1\nwidget_mode: full\n---\n", "utf-8");
+  writeFileSync(globalPrefsPath, "---\nversion: 1\nwidget_mode: full\n---\n", "utf-8");
+
+  const holder: { widget?: RenderableWidget } = {};
+
+  t.after(() => {
+    holder.widget?.dispose?.();
+    closeDatabase();
+    clearSliceProgressCache();
+    _resetWidgetModeForTests();
+    cleanup(dir);
+    cleanup(homeDir);
+  });
+
+  openDatabase(join(dir, ".gsd", "gsd.db"));
+  insertMilestone({ id: "M004", title: "Budget Tracking", status: "active" });
+  insertSlice({ milestoneId: "M004", id: "S01", title: "Schema migration", status: "complete", sequence: 1 });
+  insertSlice({ milestoneId: "M004", id: "S02", title: "Expense add", status: "pending", sequence: 2 });
+  insertTask({ milestoneId: "M004", sliceId: "S01", id: "T01", title: "Add repeat column via idempotent ALTER TABLE", status: "complete" });
+  insertTask({ milestoneId: "M004", sliceId: "S01", id: "T02", title: "Backfill repeat metadata", status: "pending" });
+
+  _resetWidgetModeForTests();
+  setWidgetMode("small", projectPrefsPath, globalPrefsPath);
+
+  updateProgressWidget(
+    {
+      hasUI: true,
+      ui: {
+        setHeader() {},
+        setStatus() {},
+        setWidget(_key: string, factory: any) {
+          if (_key === "gsd-progress") {
+            holder.widget = factory(
+              { requestRender() {} },
+              { fg: (_color: string, text: string) => text, bold: (text: string) => text },
+            );
+          }
+        },
+      },
+    } as any,
+    "execute-task",
+    "M004/S01/T02",
+    {
+      phase: "executing",
+      activeMilestone: { id: "M004", title: "Budget Tracking" },
+      activeSlice: { id: "S01", title: "Schema migration" },
+      activeTask: { id: "T02", title: "Backfill repeat metadata" },
+    } as any,
+    {
+      getAutoStartTime: () => Date.now() - 18_000,
+      isStepMode: () => false,
+      getCmdCtx: () => null,
+      getBasePath: () => dir,
+      isVerbose: () => false,
+      isSessionSwitching: () => false,
+      getCurrentDispatchedModelId: () => null,
+    },
+  );
+
+  assert.ok(holder.widget, "progress widget should be installed");
+  const widget = holder.widget;
+  const lines = widget.render(120);
+  const rendered = lines.join("\n");
+
+  assert.equal(lines.length, 4, `small widget should render as rule + two dense rows + rule:\n${rendered}`);
+  assert.match(rendered, /STATUS\s+.*AUTO\s+running/);
+  assert.match(rendered, /UNIT\s+M004\/S01\/T02/);
+  assert.match(rendered, /SPEND/);
+  assert.match(rendered, /TIME/);
+  assert.match(rendered, /PHASE\s+execute-task/);
+  assert.match(rendered, /WORK\s+T02: Backfill repeat m/);
+  assert.match(rendered, /TASK\s+2\/2/);
+  assert.match(rendered, /SLICE.*1\/2/);
+  assert.doesNotMatch(rendered, /\/gsd next|\/gsd status/);
+  assert.doesNotMatch(rendered, /dashboard|esc pause/);
+
+  for (const width of [40, 80, 120]) {
+    widget.invalidate();
+    assertLinesFit(widget.render(width), width);
+  }
+});
+
 test("updateProgressWidget shows provider-waiting state consistently for auto and next modes", (t) => {
   const dir = makeTempDir("auto-next-dashboard");
   mkdirSync(join(dir, ".gsd"), { recursive: true });
@@ -691,14 +821,14 @@ test("updateProgressWidget shows provider-waiting state consistently for auto an
   const autoRendered = renderDashboard(false);
   const nextRendered = renderDashboard(true);
 
-  assert.match(autoRendered, /GSD\s+·\s+AUTO\s+·\s+running/);
-  assert.match(nextRendered, /GSD\s+·\s+NEXT\s+·\s+running/);
+  assert.match(autoRendered, /STATUS\s+.*AUTO\s+running/);
+  assert.match(nextRendered, /STATUS\s+.*NEXT\s+running/);
   assert.doesNotMatch(autoRendered.split("\n")[1] ?? "", /completing M003\/S01/);
   assert.doesNotMatch(nextRendered.split("\n")[1] ?? "", /completing M003\/S01/);
   assert.doesNotMatch(autoRendered, /waiting on provider.*Waiting on provider/i);
   assert.doesNotMatch(nextRendered, /waiting on provider.*Waiting on provider/i);
-  assert.match(autoRendered, /completing\s+M003\/S01/);
-  assert.match(nextRendered, /completing\s+M003\/S01/);
+  assert.match(autoRendered, /PHASE\s+complete-slice/);
+  assert.match(nextRendered, /PHASE\s+complete-slice/);
   assert.doesNotMatch(autoRendered, /Working/);
   assert.doesNotMatch(nextRendered, /Working/);
 });
@@ -812,3 +942,25 @@ test("widget mode respects project preference precedence and persists there", (t
   assert.match(projectPrefs, /widget_mode:\s*min/);
   assert.match(globalPrefs, /widget_mode:\s*off/);
 });
+
+test("widget mode defaults to small when preferences do not set it", (t) => {
+  const homeDir = makeTempDir("home-no-widget-pref");
+  const projectDir = makeTempDir("project-no-widget-pref");
+  const globalPrefsPath = join(homeDir, ".gsd", "preferences.md");
+  const projectPrefsPath = join(projectDir, ".gsd", "preferences.md");
+
+  mkdirSync(join(homeDir, ".gsd"), { recursive: true });
+  mkdirSync(join(projectDir, ".gsd"), { recursive: true });
+  writeFileSync(globalPrefsPath, "---\nversion: 1\n---\n", "utf-8");
+  writeFileSync(projectPrefsPath, "---\nversion: 1\n---\n", "utf-8");
+
+  t.after(() => {
+    cleanup(homeDir);
+    cleanup(projectDir);
+    _resetWidgetModeForTests();
+  });
+
+  _resetWidgetModeForTests();
+
+  assert.equal(getWidgetMode(projectPrefsPath, globalPrefsPath), "small");
+});

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

@@ -574,6 +574,43 @@ test("completeActiveUnit allows a different next unit to advance", async () => {
   assert.deepEqual(second.unit, { unitType: "execute-task", unitId: "T02" });
 });
 
+test("completeActiveUnit guard survives an intervening advance and blocks X→Y→X re-dispatch", async () => {
+  // Regression test for issue #415: lastFinalizedUnitKey was wiped on every advance(),
+  // allowing completed units to be re-dispatched after any interleaving unit (X→Y→X).
+  let nextTaskId = "T01";
+  const { deps } = makeDeps({
+    dispatch: {
+      async decideNextUnit() {
+        return { unitType: "execute-task", unitId: nextTaskId, reason: "ready", preconditions: [] };
+      },
+    },
+  });
+  const orchestrator = createAutoOrchestrator(deps);
+
+  // Step 1: advance X (T01)
+  const first = await orchestrator.advance();
+  assert.equal(first.kind, "advanced");
+  if (first.kind !== "advanced") throw new Error("expected first advance");
+
+  // Step 2: complete X (T01) — sets lastFinalizedUnitKey = 'execute-task:T01'
+  await orchestrator.completeActiveUnit(first.unit);
+
+  // Step 3: advance Y (T02) — must NOT clear lastFinalizedUnitKey
+  nextTaskId = "T02";
+  const second = await orchestrator.advance();
+  assert.equal(second.kind, "advanced");
+  if (second.kind !== "advanced") throw new Error("expected second advance (T02)");
+  assert.deepEqual(second.unit, { unitType: "execute-task", unitId: "T02" });
+
+  // Step 4: re-select X (T01) — must be blocked because T01 was finalized
+  nextTaskId = "T01";
+  const third = await orchestrator.advance();
+  assert.equal(third.kind, "blocked");
+  if (third.kind !== "blocked") throw new Error("expected X→Y→X re-dispatch to be blocked");
+  assert.equal(third.action, "stop");
+  assert.equal(third.reason, "state did not advance after finalized execute-task T01");
+});
+
 test("retryActiveUnit clears in-flight idempotency without marking the unit finalized", async () => {
   const { deps, calls } = makeDeps();
   const orchestrator = createAutoOrchestrator(deps);

package/src/resources/extensions/gsd/tests/auto-start-orphan-bootstrap.test.ts

@@ -531,8 +531,13 @@ test("bootstrap honors explicit solo milestone lock when recovering stranded tar
     assert.equal(ready, true);
     assert.deepEqual(adoptCalls, [{ milestoneId: "M002", mode: "worktree" }]);
     assert.equal(s.currentMilestoneId, "M002");
-    assert.match(messages, /Recovering stranded work for M002/);
+    assert.match(messages, /Resuming saved milestone work for M002/);
     assert.doesNotMatch(messages, /blocks auto-mode before M001/);
+    assert.doesNotMatch(messages, /Stranded work for in-progress milestone M002/);
+    assert.ok(
+      notifications.some((entry) => entry.level === "info" && entry.message.includes("Resuming saved milestone work for M002")),
+      "active recovery should be presented as an info-level resume",
+    );
   } finally {
     if (previousLock === undefined) delete process.env.GSD_MILESTONE_LOCK;
     else process.env.GSD_MILESTONE_LOCK = previousLock;
@@ -624,7 +629,11 @@ test("bootstrap adopts stranded active branch even when isolation is none", asyn
     assert.equal(s.strandedRecoveryIsolationMode, "branch");
     assert.match(
       notifications.map((entry) => entry.message).join("\n"),
-      /Recovering stranded work for M001/,
+      /Resuming saved milestone work for M001/,
+    );
+    assert.ok(
+      notifications.every((entry) => entry.level !== "warning" || !entry.message.includes("Stranded work for in-progress milestone M001")),
+      "adopting the active milestone should not emit a scary stranded-work warning",
     );
   } finally {
     try {
@@ -713,7 +722,11 @@ test("bootstrap adopts stranded active branch before deep project setup", async
     assert.equal(s.strandedRecoveryIsolationMode, "branch");
     assert.match(
       notifications.map((entry) => entry.message).join("\n"),
-      /Recovering stranded work for M001/,
+      /Resuming saved milestone work for M001/,
+    );
+    assert.ok(
+      notifications.every((entry) => entry.level !== "warning" || !entry.message.includes("Stranded work for in-progress milestone M001")),
+      "adopting the active milestone should not emit a scary stranded-work warning",
     );
   } finally {
     try {

package/src/resources/extensions/gsd/tests/browser-evidence.test.ts

@@ -0,0 +1,142 @@
+// Project/App: gsd-pi
+// File Purpose: Unit tests for hasBrowserRequiredText heading-depth section guard.
+
+import { describe, test } from 'node:test';
+import assert from 'node:assert/strict';
+
+import { hasBrowserRequiredText } from '../browser-evidence.ts';
+
+describe('hasBrowserRequiredText', () => {
+  test('detects browser requirement in a plain test-cases section', () => {
+    const text = [
+      '## Test Cases',
+      '',
+      '1. Open index.html in a browser and navigate to /dashboard.',
+      '',
+    ].join('\n');
+    assert.ok(hasBrowserRequiredText(text), 'plain browser step should be detected');
+  });
+
+  test('ignores browser mention under a top-level non-requirement heading', () => {
+    const text = [
+      '## Not Proven',
+      '',
+      '- Keyboard usability through a real browser.',
+      '- Browser console cleanliness.',
+      '',
+    ].join('\n');
+    assert.ok(!hasBrowserRequiredText(text), 'browser mention under "Not Proven" should be ignored');
+  });
+
+  test('sub-heading inside a non-requirement section does not re-enable detection', () => {
+    // BUG (pre-fix): ### sub-heading under ## Not Proven resets inNonRequirementSection
+    // to false, causing subsequent lines to be detected as browser requirements.
+    const text = [
+      '## Not Proven By This UAT',
+      '',
+      '- No live browser session was used.',
+      '',
+      '### Visual Checks',
+      '',
+      '- Browser visual polish deferred to next slice.',
+      '- Keyboard interaction in a real browser is not proven here.',
+      '',
+    ].join('\n');
+    assert.ok(
+      !hasBrowserRequiredText(text),
+      'sub-heading under a non-requirement section must not re-enable browser detection',
+    );
+  });
+
+  test('requirement-level heading after non-requirement section re-enables detection', () => {
+    const text = [
+      '## Not Proven',
+      '',
+      '- Browser polish deferred.',
+      '',
+      '## Test Cases',
+      '',
+      '1. Launch browser and open localhost.',
+      '',
+    ].join('\n');
+    assert.ok(
+      hasBrowserRequiredText(text),
+      'browser step under "Test Cases" (same depth as "Not Proven") must still be detected',
+    );
+  });
+
+  test('deferred sub-heading inside a requirement section scopes exclusion to its own block', () => {
+    const text = [
+      '## Test Cases',
+      '',
+      '1. Open browser at localhost.',
+      '',
+      '### Deferred: keyboard check',
+      '',
+      '- Keyboard UAT deferred to next slice.',
+      '',
+      '### Step 2: Verify DOM',
+      '',
+      '1. Navigate to /dashboard in the browser.',
+      '',
+    ].join('\n');
+    assert.ok(
+      hasBrowserRequiredText(text),
+      'browser step under "Step 2" sub-heading must be detected after a sibling "Deferred" sub-heading',
+    );
+  });
+
+  test('deferred sub-heading at same depth as test cases does not escape to parent', () => {
+    const text = [
+      '## Test Cases',
+      '',
+      '### Deferred: responsive layout',
+      '',
+      '- Responsive layout check is deferred to S02.',
+      '',
+    ].join('\n');
+    assert.ok(
+      !hasBrowserRequiredText(text),
+      'content under a "Deferred" sub-heading should be excluded from detection',
+    );
+  });
+
+  test('detects browser requirement written only in a heading', () => {
+    // Regression: the line-by-line scan previously skip-continued past headings,
+    // missing browser obligations expressed only in heading text.
+    const text = '## Open browser session at localhost\n';
+    assert.ok(hasBrowserRequiredText(text), 'browser requirement in heading text must be detected');
+  });
+
+  test('heading that opens a non-requirement section is not itself detected as a requirement', () => {
+    const text = '## Not Proven\n\n- Some note.\n';
+    assert.ok(
+      !hasBrowserRequiredText(text),
+      'a non-requirement section heading should not trigger browser detection',
+    );
+  });
+
+  test('returns false for empty text', () => {
+    assert.ok(!hasBrowserRequiredText(''), 'empty string returns false');
+  });
+
+  test('notes-for-tester heading with sub-headings stays non-requirement', () => {
+    const text = [
+      '## Notes for Tester',
+      '',
+      '### Browser Setup',
+      '',
+      '- Run this spec without a browser; a DOM harness is sufficient.',
+      '- Browser-based visual checks are deferred.',
+      '',
+      '### Follow-up Items',
+      '',
+      '- Track browser session evidence in S02.',
+      '',
+    ].join('\n');
+    assert.ok(
+      !hasBrowserRequiredText(text),
+      'sub-headings under "Notes for Tester" should not re-enable browser detection',
+    );
+  });
+});