@opengsd/gsd-pi 1.1.1-dev.616a1a1 → 1.1.1-dev.9bb7453

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/artifact-db.ts

@@ -434,7 +434,8 @@ export function repairArtifactDbDrift(
     `Artifact/DB status drift in ${record.milestoneId}` +
       `${record.sliceId ? `/${record.sliceId}` : ""}` +
       `${record.taskId ? `/${record.taskId}` : ""}: ${record.reason}. ` +
-      "Runtime will not silently import completion artifacts into DB state; run explicit recovery/repair after review.",
+      "Runtime will not silently import completion artifacts into DB state. " +
+      "Run `/gsd rebuild markdown` after review to quarantine stale projections and re-render from the DB; use `/gsd recover --confirm` only when markdown should repopulate a lost or corrupt DB.",
   );
 }
 
@@ -461,7 +462,8 @@ export function describeArtifactDbDriftBlocker(
     `Artifact/DB status drift in ${record.milestoneId}` +
     `${record.sliceId ? `/${record.sliceId}` : ""}` +
     `${record.taskId ? `/${record.taskId}` : ""}: ${record.reason}. ` +
-    "Runtime will not silently import completion artifacts into DB state; run explicit recovery/repair after review."
+    "Runtime will not silently import completion artifacts into DB state. " +
+    "Run `/gsd rebuild markdown` after review to quarantine stale projections and re-render from the DB; use `/gsd recover --confirm` only when markdown should repopulate a lost or corrupt DB."
   );
 }
 

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

@@ -55,7 +55,7 @@ export function repairUnregisteredMilestone(
 ): void {
   throw new Error(
     `Milestone ${record.milestoneId} exists only as markdown projection. ` +
-      "Runtime reconciliation will not import markdown into the authoritative DB; run `/gsd recover` if this markdown should repopulate the database.",
+      "Runtime reconciliation will not import markdown into the authoritative DB; run `/gsd recover --confirm` if this markdown should repopulate the database.",
   );
 }
 

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");
@@ -279,10 +279,17 @@ export function invalidateStateCache(): void {
 /**
  * Returns the ID of the first incomplete milestone, or null if all are complete.
  */
+function getRequestedMilestoneLock(): string | undefined {
+  const lock = process.env.GSD_MILESTONE_LOCK?.trim();
+  return lock || undefined;
+}
+
 export async function getActiveMilestoneId(basePath: string): Promise<string | null> {
-  // Parallel worker isolation. Normal DB state derivation remains DB-only;
-  // lock env vars are execution routing for explicit worker processes.
-  const milestoneLock = process.env.GSD_PARALLEL_WORKER ? process.env.GSD_MILESTONE_LOCK : undefined;
+  // Milestone-scoped execution. Parallel workers and explicit solo commands
+  // such as `/gsd auto M002` both set GSD_MILESTONE_LOCK; state derivation must
+  // honor it so recovery/adoption sees the requested milestone, not the first
+  // open milestone in queue order.
+  const milestoneLock = getRequestedMilestoneLock();
   if (milestoneLock) {
     if (isDbAvailable()) {
       const locked = getAllMilestones().find(m => m.id === milestoneLock);
@@ -720,7 +727,7 @@ export async function deriveStateFromDb(
 
   const allMilestones = getAllMilestones();
 
-  const milestoneLock = process.env.GSD_PARALLEL_WORKER ? process.env.GSD_MILESTONE_LOCK : undefined;
+  const milestoneLock = getRequestedMilestoneLock();
   const milestones = milestoneLock
     ? allMilestones.filter(m => m.id === milestoneLock)
     : allMilestones;
@@ -889,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),
@@ -959,13 +966,10 @@ export async function _deriveStateImpl(
   const customOrder = loadQueueOrder(basePath);
   const milestoneIds = sortByQueueOrder(diskIds, customOrder);
 
-  // ── Parallel worker isolation ──────────────────────────────────────────
-  // When GSD_PARALLEL_WORKER and GSD_MILESTONE_LOCK are set, this process is a parallel worker
-  // scoped to a single milestone. Filter the milestone list so this worker
-  // only sees its assigned milestone (all others are treated as if they
-  // don't exist). This gives each worker complete isolation without
-  // modifying any other state derivation logic.
-  const milestoneLock = process.env.GSD_PARALLEL_WORKER ? process.env.GSD_MILESTONE_LOCK : undefined;
+  // ── Milestone-scoped execution ─────────────────────────────────────────
+  // Parallel workers and explicit solo recovery both scope auto-mode to one
+  // milestone through GSD_MILESTONE_LOCK.
+  const milestoneLock = getRequestedMilestoneLock();
   if (milestoneLock && milestoneIds.includes(milestoneLock)) {
     milestoneIds.length = 0;
     milestoneIds.push(milestoneLock);

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);
@@ -1246,6 +1283,92 @@ test("wired DispatchAdapter forwards constructor session when advance input omit
   }
 });
 
+test("wired DispatchAdapter adopts next active milestone after the session milestone is closed", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-orchestrator-milestone-adopt-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  const stateSnapshot: GSDState = {
+    ...makeState(),
+    activeMilestone: { id: "M002", title: "Next" },
+    registry: [
+      { id: "M001", title: "First", status: "complete" },
+      { id: "M002", title: "Next", status: "active" },
+    ],
+  };
+  const captured: DispatchContext[] = [];
+  const captureRule: UnifiedRule = {
+    name: "test-milestone-adoption",
+    when: "dispatch",
+    evaluation: "first-match",
+    where: async (ctx: DispatchContext) => {
+      captured.push(ctx);
+      return {
+        action: "dispatch" as const,
+        unitType: "execute-task",
+        unitId: "M002/S01/T01",
+        prompt: "adopted-milestone-fixture",
+      };
+    },
+    then: (r: unknown) => r,
+  };
+  setRegistry(new RuleRegistry([captureRule]));
+
+  try {
+    const ctx = { model: {}, modelRegistry: { getAll: () => [] } } as any;
+    const pi = { getActiveTools: () => [] } as any;
+    const session = {
+      basePath: base,
+      originalBasePath: base,
+      currentMilestoneId: "M001",
+    } as any;
+    const adapter = createWiredDispatchAdapter(ctx, pi, base, session);
+
+    const result = await adapter.decideNextUnit({ stateSnapshot });
+
+    assert.ok(result);
+    if (!("unitType" in result)) assert.fail(`expected dispatch decision, got ${JSON.stringify(result)}`);
+    assert.equal(result.unitId, "M002/S01/T01");
+    assert.equal(session.currentMilestoneId, "M002");
+    assert.equal(captured[0]?.session?.currentMilestoneId, "M002");
+  } finally {
+    resetRegistry();
+  }
+});
+
+test("wired DispatchAdapter keeps blocking stale milestone worktree scope", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-orchestrator-worktree-block-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+
+  const stateSnapshot: GSDState = {
+    ...makeState(),
+    activeMilestone: { id: "M002", title: "Next" },
+    registry: [
+      { id: "M001", title: "First", status: "complete" },
+      { id: "M002", title: "Next", status: "active" },
+    ],
+  };
+  const worktreePath = join(base, ".gsd", "worktrees", "M001");
+  mkdirSync(worktreePath, { recursive: true });
+  const ctx = { model: {}, modelRegistry: { getAll: () => [] } } as any;
+  const pi = { getActiveTools: () => [] } as any;
+  const session = {
+    basePath: worktreePath,
+    originalBasePath: base,
+    currentMilestoneId: "M001",
+  } as any;
+  const adapter = createWiredDispatchAdapter(ctx, pi, base, session);
+
+  const result = await adapter.decideNextUnit({ stateSnapshot });
+
+  assert.deepEqual(result, {
+    kind: "blocked",
+    reason:
+      'Dispatch milestone mismatch: context mid "M002" does not match session.currentMilestoneId "M001". The active worktree/session and derived project state disagree; recover, park, or discard the stranded milestone before continuing.',
+    action: "pause",
+  });
+  assert.equal(session.currentMilestoneId, "M001");
+});
+
 test("wired DispatchAdapter replays pending verification retry dispatch", async () => {
   const stateSnapshot = makeState();
   const ctx = { model: {}, modelRegistry: { getAll: () => [] } } as any;