@opengsd/gsd-pi 1.1.1-dev.9f86580 → 1.1.1-dev.b2556262

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

@@ -7,6 +7,8 @@ import {
   invalidateStateCache as defaultInvalidate,
 } from "../state.js";
 import { clearParseCache as defaultClearParseCache } from "../files.js";
+import { clearPathCache } from "../paths.js";
+import { logWarning } from "../workflow-logger.js";
 import type { GSDState } from "../types.js";
 
 import {
@@ -68,18 +70,24 @@ export async function reconcileBeforeDispatch(
     const stateSnapshot = await deps.deriveState(basePath, deps.deriveStateOptions);
     const ctx: DriftContext = { basePath, state: stateSnapshot };
 
-    const drift = await detectAllDrift(stateSnapshot, ctx, registry, pass);
+    const detection = await detectAllDrift(stateSnapshot, ctx, registry);
+    const drift = detection.records;
     if (drift.length === 0) {
       return {
         ok: true,
         stateSnapshot,
         repaired,
-        blockers: stateSnapshot.blockers ?? [],
+        blockers: [
+          ...new Set([
+            ...(stateSnapshot.blockers ?? []),
+            ...detection.detectBlockers,
+          ]),
+        ],
       };
     }
 
     const failures: ReconciliationFailureDetail[] = [];
-    const blockers: string[] = [];
+    const blockers: string[] = [...detection.detectBlockers];
     let repairedThisPass = false;
     for (const record of drift) {
       const handler = registry.find((h) => h.kind === record.kind);
@@ -107,7 +115,11 @@ export async function reconcileBeforeDispatch(
     }
 
     if (repairedThisPass) {
+      // A repair may have mutated on-disk structure (e.g. quarantined a slice
+      // dir). Clear both the parse cache and the path/dir cache centrally so
+      // later passes and any subsequent repair see fresh filesystem state.
       clearParseCache();
+      clearPathCache();
     }
     if (blockers.length > 0) {
       let blockerState = stateSnapshot;
@@ -132,10 +144,11 @@ export async function reconcileBeforeDispatch(
   deps.invalidateStateCache();
   const finalState = await deps.deriveState(basePath, deps.deriveStateOptions);
   const finalCtx: DriftContext = { basePath, state: finalState };
-  const persistent = await detectAllDrift(finalState, finalCtx, registry);
+  const finalDetection = await detectAllDrift(finalState, finalCtx, registry);
+  const persistent = finalDetection.records;
 
   if (persistent.length > 0) {
-    const blockers: string[] = [];
+    const blockers: string[] = [...finalDetection.detectBlockers];
     const unblockedPersistent: DriftRecord[] = [];
     for (const record of persistent) {
       const handler = registry.find((h) => h.kind === record.kind);
@@ -161,28 +174,45 @@ export async function reconcileBeforeDispatch(
     ok: true,
     stateSnapshot: finalState,
     repaired,
-    blockers: finalState.blockers ?? [],
+    blockers: [
+      ...new Set([
+        ...(finalState.blockers ?? []),
+        ...finalDetection.detectBlockers,
+      ]),
+    ],
   };
 }
 
+interface DetectionOutcome {
+  records: DriftRecord[];
+  /** One blocker string per handler whose detect() threw. */
+  detectBlockers: string[];
+}
+
+/**
+ * Run every detector. A single detector throwing (e.g. a transient file read
+ * error) must NOT abort the whole cycle and hide every later handler's drift —
+ * it is collected as a blocker so dispatch is still gated, while the remaining
+ * detectors run and their drift gets repaired (graceful degradation, ADR-017).
+ */
 async function detectAllDrift(
   state: GSDState,
   ctx: DriftContext,
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   registry: ReadonlyArray<DriftHandler<any>>,
-  pass?: number,
-): Promise<DriftRecord[]> {
-  const collected: DriftRecord[] = [];
+): Promise<DetectionOutcome> {
+  const records: DriftRecord[] = [];
+  const detectBlockers: string[] = [];
   for (const handler of registry) {
     try {
       const detected = await handler.detect(state, ctx);
-      collected.push(...detected);
+      records.push(...detected);
     } catch (cause) {
-      throw new ReconciliationFailedError({
-        failures: [{ drift: { kind: handler.kind } as DriftRecord, cause }],
-        pass,
-      });
+      const message = cause instanceof Error ? cause.message : String(cause);
+      const blocker = `Drift detection failed for "${handler.kind}": ${message}`;
+      logWarning("reconcile", blocker);
+      detectBlockers.push(blocker);
     }
   }
-  return collected;
+  return { records, detectBlockers };
 }

package/src/resources/extensions/gsd/state-reconciliation/spawn-gate.ts

@@ -21,10 +21,10 @@ export interface SpawnGateDeps extends Partial<ReconciliationDeps> {
 }
 
 /**
- * Run reconciliation before spawning workers. Returns ok=true when the run
- * completed without throwing (blockers ride along but don't fail the gate —
- * spawn callers can choose how to handle them). On
- * ReconciliationFailedError, returns ok=false with the error message so the
+ * Run reconciliation before spawning workers. Returns ok=true only when the run
+ * completed without throwing AND surfaced no blockers; any blocker fails the
+ * gate (ok=false, reason carries the first blocker) so callers must not spawn.
+ * On ReconciliationFailedError, returns ok=false with the error message so the
  * caller can surface it to the user without re-throwing.
  *
  * Other unexpected errors propagate; they are not part of the drift

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

@@ -483,7 +483,7 @@ async function buildRegistryAndFindActive(
   let activeMilestoneSlices: SliceRow[] = [];
   let activeMilestoneFound = false;
   let activeMilestoneHasDraft = false;
-  let firstDeferredQueuedShell: { id: string; title: string; deps: string[] } | null = null;
+  let firstDeferredQueuedShell: { id: string; title: string; deps: string[]; hasDraftContext: boolean } | null = null;
 
   for (const m of milestones) {
     if (parkedMilestoneIds.has(m.id)) {
@@ -505,6 +505,8 @@ async function buildRegistryAndFindActive(
     const allSlicesDone = slices.length > 0 && slices.every(s => isStatusDone(s.status));
 
     const title = stripMilestonePrefix(m.title) || m.id;
+    const hasContext = !!resolveMilestoneFile(basePath, m.id, "CONTEXT");
+    const hasDraftContext = !hasContext && !!resolveMilestoneFile(basePath, m.id, "CONTEXT-DRAFT");
 
     if (!activeMilestoneFound) {
       const deps = m.depends_on;
@@ -515,9 +517,9 @@ async function buildRegistryAndFindActive(
         continue;
       }
 
-      if (m.status === 'queued' && slices.length === 0) {
+      if (m.status === 'queued' && slices.length === 0 && !hasContext) {
         if (!firstDeferredQueuedShell) {
-          firstDeferredQueuedShell = { id: m.id, title, deps };
+          firstDeferredQueuedShell = { id: m.id, title, deps, hasDraftContext };
         }
         registry.push({ id: m.id, title, status: 'pending', ...(deps.length > 0 ? { dependsOn: deps } : {}) });
         continue;
@@ -531,7 +533,7 @@ async function buildRegistryAndFindActive(
         continue;
       }
 
-      if (m.status === 'needs-discussion') activeMilestoneHasDraft = true;
+      if ((m.status === 'needs-discussion' && !hasContext) || hasDraftContext) activeMilestoneHasDraft = true;
 
       activeMilestone = { id: m.id, title };
       activeMilestoneSlices = slices;
@@ -548,6 +550,7 @@ async function buildRegistryAndFindActive(
     activeMilestone = { id: shell.id, title: shell.title };
     activeMilestoneSlices = [];
     activeMilestoneFound = true;
+    if (shell.hasDraftContext) activeMilestoneHasDraft = true;
     const entry = registry.find(e => e.id === shell.id);
     if (entry) entry.status = 'active';
   }

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

@@ -36,6 +36,7 @@ import { registerAutoWorker } from "../db/auto-workers.js";
 import { claimMilestoneLease } from "../db/milestone-leases.js";
 import { recordDispatchClaim, markCanceled } from "../db/unit-dispatches.js";
 import { setRuntimeKv, getRuntimeKv } from "../db/runtime-kv.js";
+import { SourceObservationStore } from "../source-observations.js";
 
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 
@@ -1102,6 +1103,7 @@ function makeLoopSession(overrides?: Partial<Record<string, unknown>>) {
     currentMilestoneId: "M001",
     currentUnit: null,
     currentUnitRouting: null,
+    sourceObservations: new SourceObservationStore(),
     completedUnits: [],
     resourceVersionOnStart: null,
     lastPromptCharCount: undefined,
@@ -1126,6 +1128,19 @@ function makeLoopSession(overrides?: Partial<Record<string, unknown>>) {
       newSession: () => Promise.resolve({ cancelled: false }),
       getContextUsage: () => ({ percent: 10, tokens: 1000, limit: 10000 }),
     },
+    setCurrentUnit(this: any, unit: any) {
+      this.currentUnit = unit;
+      this.sourceObservations.beginUnit({
+        unitType: unit.type,
+        unitId: unit.id,
+        startedAt: unit.startedAt,
+        basePath: unit.workspaceRoot ?? this.basePath,
+      });
+    },
+    clearCurrentUnit(this: any) {
+      this.currentUnit = null;
+      this.sourceObservations.clear();
+    },
     clearTimers: () => {},
     ...overrides,
   } as any;

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

@@ -7,7 +7,7 @@ import { fileURLToPath } from "node:url";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
-import { ModelPolicyDispatchBlockedError, resolvePreferredModelConfig, resolveModelId, selectAndApplyModel } from "../auto-model-selection.js";
+import { ModelPolicyDispatchBlockedError, resolvePreferredModelConfig, resolveModelId, selectAndApplyModel, floorThinkingLevelForUnit } from "../auto-model-selection.js";
 
 function makeTempDir(prefix: string): string {
   return mkdtempSync(join(tmpdir(), prefix));
@@ -534,6 +534,304 @@ test("selectAndApplyModel re-applies captured thinking level after setModel succ
   assert.deepEqual(thinkingLevels, [{ effort: "high" }]);
 });
 
+// ─── floorThinkingLevelForUnit (#read-bash-thrash) ─────────────────────
+test("floorThinkingLevelForUnit raises minimal/low to the floor for execute-task", () => {
+  assert.equal(floorThinkingLevelForUnit("execute-task", "off" as any), "medium");
+  assert.equal(floorThinkingLevelForUnit("execute-task", "minimal" as any), "medium");
+  assert.equal(floorThinkingLevelForUnit("execute-task", "low" as any), "medium");
+});
+
+test("floorThinkingLevelForUnit never lowers a level already at/above the floor", () => {
+  assert.equal(floorThinkingLevelForUnit("execute-task", "medium" as any), "medium");
+  assert.equal(floorThinkingLevelForUnit("execute-task", "high" as any), "high");
+  assert.equal(floorThinkingLevelForUnit("execute-task", "xhigh" as any), "xhigh");
+});
+
+test("floorThinkingLevelForUnit leaves non-execute-task units untouched", () => {
+  for (const unit of ["plan-slice", "plan-milestone", "research-milestone", "complete-slice", "validate-milestone"]) {
+    assert.equal(floorThinkingLevelForUnit(unit, "minimal" as any), "minimal");
+  }
+});
+
+test("floorThinkingLevelForUnit passes through null/undefined and unrecognized shapes", () => {
+  assert.equal(floorThinkingLevelForUnit("execute-task", null), null);
+  assert.equal(floorThinkingLevelForUnit("execute-task", undefined), undefined);
+  // A richer host snapshot object must not be coerced into a bare string.
+  const snapshot = { effort: "minimal" } as any;
+  assert.deepEqual(floorThinkingLevelForUnit("execute-task", snapshot), snapshot);
+});
+
+test("selectAndApplyModel raises minimal thinking to the floor for execute-task", async (t) => {
+  const originalCwd = process.cwd();
+  const tempProject = makeTempDir("gsd-routing-thinking-floor-");
+  const thinkingLevels: unknown[] = [];
+  t.after(() => {
+    process.chdir(originalCwd);
+    rmSync(tempProject, { recursive: true, force: true });
+  });
+
+  mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+  writeFileSync(
+    join(tempProject, ".gsd", "PREFERENCES.md"),
+    ["---", "models:", "  execute-task: claude-sonnet-4-6", "---"].join("\n"),
+    "utf-8",
+  );
+  process.chdir(tempProject);
+
+  await selectAndApplyModel(
+    {
+      modelRegistry: { getAvailable: () => [{ id: "claude-sonnet-4-6", provider: "anthropic", api: "anthropic-messages" }] },
+      sessionManager: { getSessionId: () => "test-session" },
+      ui: { notify: () => {} },
+      model: { provider: "anthropic", id: "claude-sonnet-4-6", api: "anthropic-messages" },
+    } as any,
+    {
+      setModel: async () => true,
+      setThinkingLevel: (level: unknown) => { thinkingLevels.push(level); },
+      emitBeforeModelSelect: async () => undefined,
+      getActiveTools: () => [],
+      emitAdjustToolSet: async () => undefined,
+      setActiveTools: () => {},
+    } as any,
+    "execute-task",
+    "M001/S01/T01",
+    tempProject,
+    undefined,
+    false,
+    { provider: "anthropic", id: "claude-sonnet-4-6" },
+    undefined,
+    true,
+    undefined,
+    "minimal" as any,
+  );
+
+  assert.deepEqual(thinkingLevels, ["medium"]);
+});
+
+test("selectAndApplyModel capability-clamps an unsupported thinking level (ADR-026)", async (t) => {
+  const originalCwd = process.cwd();
+  const tempProject = makeTempDir("gsd-routing-thinking-clamp-");
+  const thinkingLevels: unknown[] = [];
+  t.after(() => {
+    process.chdir(originalCwd);
+    rmSync(tempProject, { recursive: true, force: true });
+  });
+
+  // Reasoning-capable model whose map omits xhigh → xhigh must clamp to high.
+  const model = {
+    id: "claude-sonnet-4-6",
+    provider: "anthropic",
+    api: "anthropic-messages",
+    reasoning: true,
+    thinkingLevelMap: { low: "low", medium: "medium", high: "high" },
+  };
+  mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+  writeFileSync(
+    join(tempProject, ".gsd", "PREFERENCES.md"),
+    ["---", "models:", "  planning: claude-sonnet-4-6", "---"].join("\n"),
+    "utf-8",
+  );
+  process.chdir(tempProject);
+
+  await selectAndApplyModel(
+    {
+      modelRegistry: { getAvailable: () => [model] },
+      sessionManager: { getSessionId: () => "test-session" },
+      ui: { notify: () => {} },
+      model: { provider: "anthropic", id: "claude-sonnet-4-6", api: "anthropic-messages" },
+    } as any,
+    {
+      setModel: async () => true,
+      setThinkingLevel: (level: unknown) => { thinkingLevels.push(level); },
+      emitBeforeModelSelect: async () => undefined,
+      getActiveTools: () => [],
+      emitAdjustToolSet: async () => undefined,
+      setActiveTools: () => {},
+    } as any,
+    "plan-slice",
+    "M001/S01",
+    tempProject,
+    undefined,
+    false,
+    { provider: "anthropic", id: "claude-sonnet-4-6" },
+    undefined,
+    true,
+    undefined,
+    "xhigh" as any,
+  );
+
+  assert.deepEqual(thinkingLevels, ["high"]);
+});
+
+test("selectAndApplyModel applies an explicit per-phase thinking level (ADR-026)", async (t) => {
+  const originalCwd = process.cwd();
+  const tempProject = makeTempDir("gsd-routing-thinking-explicit-");
+  const thinkingLevels: unknown[] = [];
+  t.after(() => {
+    process.chdir(originalCwd);
+    rmSync(tempProject, { recursive: true, force: true });
+  });
+
+  const model = {
+    id: "claude-sonnet-4-6",
+    provider: "anthropic",
+    api: "anthropic-messages",
+    reasoning: true,
+    thinkingLevelMap: { low: "low", medium: "medium", high: "high", xhigh: "xhigh" },
+  };
+  mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+  writeFileSync(
+    join(tempProject, ".gsd", "PREFERENCES.md"),
+    ["---", "models:", "  planning:", "    model: claude-sonnet-4-6", "    thinking: xhigh", "---"].join("\n"),
+    "utf-8",
+  );
+  process.chdir(tempProject);
+
+  await selectAndApplyModel(
+    {
+      modelRegistry: { getAvailable: () => [model] },
+      sessionManager: { getSessionId: () => "test-session" },
+      ui: { notify: () => {} },
+      model: { provider: "anthropic", id: "claude-sonnet-4-6", api: "anthropic-messages" },
+    } as any,
+    {
+      setModel: async () => true,
+      setThinkingLevel: (level: unknown) => { thinkingLevels.push(level); },
+      emitBeforeModelSelect: async () => undefined,
+      getActiveTools: () => [],
+      emitAdjustToolSet: async () => undefined,
+      setActiveTools: () => {},
+    } as any,
+    "plan-slice",
+    "M001/S01",
+    tempProject,
+    undefined,
+    false,
+    { provider: "anthropic", id: "claude-sonnet-4-6" },
+    undefined,
+    true,
+    undefined,
+    // Session level is "low"; the explicit planning thinking (xhigh) must win.
+    "low" as any,
+  );
+
+  assert.deepEqual(thinkingLevels, ["xhigh"]);
+});
+
+test("selectAndApplyModel applies explicit thinking with no model pin (interactive, ADR-026)", async (t) => {
+  const originalCwd = process.cwd();
+  const tempProject = makeTempDir("gsd-routing-thinking-nomodel-");
+  const thinkingLevels: unknown[] = [];
+  t.after(() => {
+    process.chdir(originalCwd);
+    rmSync(tempProject, { recursive: true, force: true });
+  });
+
+  const model = {
+    id: "claude-sonnet-4-6",
+    provider: "anthropic",
+    api: "anthropic-messages",
+    reasoning: true,
+    thinkingLevelMap: { low: "low", medium: "medium", high: "high", xhigh: "xhigh" },
+  };
+  mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+  // A `thinking:` block with NO models config — the interactive guided-flow
+  // scenario the bug report flagged (no per-phase model, no start model).
+  writeFileSync(
+    join(tempProject, ".gsd", "PREFERENCES.md"),
+    ["---", "thinking:", "  planning: high", "---"].join("\n"),
+    "utf-8",
+  );
+  process.chdir(tempProject);
+
+  await selectAndApplyModel(
+    {
+      modelRegistry: { getAvailable: () => [model] },
+      sessionManager: { getSessionId: () => "test-session" },
+      ui: { notify: () => {} },
+      model: { provider: "anthropic", id: "claude-sonnet-4-6", api: "anthropic-messages" },
+    } as any,
+    {
+      setModel: async () => true,
+      setThinkingLevel: (level: unknown) => { thinkingLevels.push(level); },
+      emitBeforeModelSelect: async () => undefined,
+      getActiveTools: () => [],
+      emitAdjustToolSet: async () => undefined,
+      setActiveTools: () => {},
+    } as any,
+    "plan-slice",
+    "M001/S01",
+    tempProject,
+    undefined,
+    false,
+    null,            // no autoModeStartModel
+    undefined,
+    false,           // isAutoMode = false (interactive)
+    undefined,
+    undefined,       // no captured session thinking level
+  );
+
+  // No model branch runs, but the explicit block thinking must still apply.
+  assert.deepEqual(thinkingLevels, ["high"]);
+});
+
+test("selectAndApplyModel clamps explicit no-model thinking via ctx.model when registry lookup fails (ADR-026)", async (t) => {
+  const originalCwd = process.cwd();
+  const tempProject = makeTempDir("gsd-routing-thinking-ctxmodel-");
+  const thinkingLevels: unknown[] = [];
+  t.after(() => {
+    process.chdir(originalCwd);
+    rmSync(tempProject, { recursive: true, force: true });
+  });
+
+  // ctx.model carries reasoning capability (map omits xhigh) but the registry
+  // returns nothing, so resolveModelId fails and ctx.model is the clamp source.
+  const ctxModel = {
+    id: "claude-sonnet-4-6",
+    provider: "anthropic",
+    api: "anthropic-messages",
+    reasoning: true,
+    thinkingLevelMap: { low: "low", medium: "medium", high: "high" },
+  };
+  mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+  writeFileSync(
+    join(tempProject, ".gsd", "PREFERENCES.md"),
+    ["---", "thinking:", "  planning: xhigh", "---"].join("\n"),
+    "utf-8",
+  );
+  process.chdir(tempProject);
+
+  await selectAndApplyModel(
+    {
+      modelRegistry: { getAvailable: () => [] },   // registry lookup fails
+      sessionManager: { getSessionId: () => "test-session" },
+      ui: { notify: () => {} },
+      model: ctxModel,
+    } as any,
+    {
+      setModel: async () => true,
+      setThinkingLevel: (level: unknown) => { thinkingLevels.push(level); },
+      emitBeforeModelSelect: async () => undefined,
+      getActiveTools: () => [],
+      emitAdjustToolSet: async () => undefined,
+      setActiveTools: () => {},
+    } as any,
+    "plan-slice",
+    "M001/S01",
+    tempProject,
+    undefined,
+    false,
+    null,
+    undefined,
+    false,
+    undefined,
+    undefined,
+  );
+
+  // xhigh is unsupported by ctx.model → clamped to high, never sent verbatim.
+  assert.deepEqual(thinkingLevels, ["high"]);
+});
+
 test("resolveModelId: anthropic wins over claude-code when session provider is not claude-code", () => {
   const availableModels = [
     { id: "claude-sonnet-4-6", provider: "claude-code" },

package/src/resources/extensions/gsd/tests/auto-paused-ui-cleanup.test.ts

@@ -173,6 +173,38 @@ test("cleanupAfterLoopExit preserves completion closeout surface after stopAuto
   }
 });
 
+test("cleanupAfterLoopExit clears completionStopInProgress even when preserveStepSurfaceAfterLoopExit is also set", async () => {
+  const statusCalls: unknown[] = [];
+  const widgetCalls: unknown[] = [];
+
+  autoSession.reset();
+  autoSession.active = true;
+  autoSession.paused = false;
+  autoSession.completionStopInProgress = true;
+  autoSession.preserveStepSurfaceAfterLoopExit = true;
+
+  try {
+    await cleanupAfterLoopExit({
+      hasUI: true,
+      ui: {
+        setStatus: (...args: unknown[]) => statusCalls.push(args),
+        setWidget: (...args: unknown[]) => widgetCalls.push(args),
+        setHeader: () => {},
+        notify: () => {},
+      },
+    } as any);
+
+    assert.equal(
+      autoSession.completionStopInProgress,
+      false,
+      "completionStopInProgress must be cleared even when preserveStepSurfaceAfterLoopExit was also set",
+    );
+    assert.equal(autoSession.preserveStepSurfaceAfterLoopExit, false);
+  } finally {
+    autoSession.reset();
+  }
+});
+
 test("pauseAuto preserves artifact retry counts across pause/resume", async () => {
   const base = mkdtempSync(join(tmpdir(), "gsd-pause-retry-count-"));
   const previousCwd = process.cwd();