gsd-pi 2.73.1-dev.d987996 → 2.74.0-dev.0306a2e

package/src/resources/extensions/gsd/preferences-models.ts

@@ -7,6 +7,8 @@
  */
 
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
 import type { DynamicRoutingConfig } from "./model-router.js";
 import { defaultRoutingConfig } from "./model-router.js";
 import type { TokenProfile, InlineLevel } from "./types.js";
@@ -185,6 +187,45 @@ export function resolveDefaultSessionModel(
   return undefined;
 }
 
+/**
+ * Returns true if `provider` is defined as a custom provider in the user's
+ * `~/.gsd/agent/models.json` (Ollama, vLLM, LM Studio, OpenAI-compatible
+ * proxies, etc.).
+ *
+ * Used by auto-mode bootstrap to decide whether the session model
+ * (set via `/gsd model`) should override `PREFERENCES.md`.  Custom providers
+ * are never reachable from `PREFERENCES.md` (which only knows built-in
+ * providers), so when the user has explicitly selected one, it must take
+ * priority — otherwise auto-mode tries to start the built-in provider from
+ * PREFERENCES.md and fails with "Not logged in · Please run /login" (#4122).
+ *
+ * Reads models.json directly with a lightweight JSON parse to avoid
+ * pulling in the full model-registry at this call site.  Falls back to
+ * `~/.pi/agent/models.json` for parity with `resolveModelsJsonPath()`.
+ * Any read or parse error yields `false` (treat as not-custom) so a
+ * malformed models.json never breaks the session bootstrap.
+ */
+export function isCustomProvider(provider: string | undefined): boolean {
+  if (!provider) return false;
+  const candidates = [
+    join(homedir(), ".gsd", "agent", "models.json"),
+    join(homedir(), ".pi", "agent", "models.json"),
+  ];
+  for (const path of candidates) {
+    if (!existsSync(path)) continue;
+    try {
+      const raw = readFileSync(path, "utf-8");
+      const parsed = JSON.parse(raw) as { providers?: Record<string, unknown> };
+      if (parsed?.providers && Object.prototype.hasOwnProperty.call(parsed.providers, provider)) {
+        return true;
+      }
+    } catch {
+      // Ignore — malformed models.json must not break bootstrap.
+    }
+  }
+  return false;
+}
+
 /**
  * Determines the next fallback model to try when the current model fails.
  * If the current model is not in the configured list, returns the primary model.
@@ -314,7 +355,7 @@ export function resolveAutoSupervisorConfig(): AutoSupervisorConfig {
 
 // ─── Token Profile Resolution ─────────────────────────────────────────────
 
-const VALID_TOKEN_PROFILES = new Set<TokenProfile>(["budget", "balanced", "quality"]);
+const VALID_TOKEN_PROFILES = new Set<TokenProfile>(["budget", "balanced", "quality", "burn-max"]);
 
 /**
  * Resolve profile defaults for a given token profile tier.
@@ -359,6 +400,22 @@ export function resolveProfileDefaults(profile: TokenProfile): Partial<GSDPrefer
           skip_reassess: true,
         },
       };
+    case "burn-max":
+      return {
+        // Quality-first profile: keep user-selected models, disable downgrade routing.
+        // Policy constraints still apply at dispatch time.
+        dynamic_routing: {
+          enabled: false,
+        },
+        context_selection: "full",
+        phases: {
+          skip_research: false,
+          skip_slice_research: false,
+          skip_reassess: false,
+          skip_milestone_validation: false,
+          reassess_after_slice: true,
+        },
+      };
   }
 }
 
@@ -375,7 +432,7 @@ export function resolveEffectiveProfile(): TokenProfile {
 
 /**
  * Resolve the inline level from the active token profile.
- * budget -> minimal, balanced -> standard, quality -> full.
+ * budget -> minimal, balanced -> standard, quality/burn-max -> full.
  */
 export function resolveInlineLevel(): InlineLevel {
   const profile = resolveEffectiveProfile();
@@ -383,12 +440,13 @@ export function resolveInlineLevel(): InlineLevel {
     case "budget": return "minimal";
     case "balanced": return "standard";
     case "quality": return "full";
+    case "burn-max": return "full";
   }
 }
 
 /**
  * Resolve the context selection mode from the active token profile.
- * budget -> "smart", balanced/quality -> "full".
+ * budget -> "smart", balanced/quality/burn-max -> "full".
  * Explicit preference always wins.
  */
 export function resolveContextSelection(): import("./types.js").ContextSelectionMode {

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

@@ -83,6 +83,7 @@ export const KNOWN_PREFERENCE_KEYS = new Set<string>([
   "post_unit_hooks",
   "pre_dispatch_hooks",
   "dynamic_routing",
+  "uok",
   "token_profile",
   "phases",
   "auto_visualize",
@@ -113,6 +114,7 @@ export const KNOWN_PREFERENCE_KEYS = new Set<string>([
   "discuss_preparation",
   "discuss_web_research",
   "discuss_depth",
+  "flat_rate_providers",
 ]);
 
 /** Canonical list of all dispatch unit types. */
@@ -207,6 +209,35 @@ export interface CmuxPreferences {
   browser?: boolean;
 }
 
+export type UokTurnActionMode = "commit" | "snapshot" | "status-only";
+
+export interface UokPreferences {
+  enabled?: boolean;
+  legacy_fallback?: {
+    enabled?: boolean;
+  };
+  gates?: {
+    enabled?: boolean;
+  };
+  model_policy?: {
+    enabled?: boolean;
+  };
+  execution_graph?: {
+    enabled?: boolean;
+  };
+  gitops?: {
+    enabled?: boolean;
+    turn_action?: UokTurnActionMode;
+    turn_push?: boolean;
+  };
+  audit_unified?: {
+    enabled?: boolean;
+  };
+  plan_v2?: {
+    enabled?: boolean;
+  };
+}
+
 /**
  * Opt-in experimental features. All features in this block are disabled by
  * default and must be explicitly enabled. They may change or be removed without
@@ -255,6 +286,8 @@ export interface GSDPreferences {
   post_unit_hooks?: PostUnitHookConfig[];
   pre_dispatch_hooks?: PreDispatchHookConfig[];
   dynamic_routing?: DynamicRoutingConfig;
+  /** Unified Orchestration Kernel controls (all flags default off). */
+  uok?: UokPreferences;
   /** Per-model capability overrides. Deep-merged with built-in profiles for capability-aware routing (ADR-004). */
   modelOverrides?: Record<string, { capabilities?: Partial<ModelCapabilities> }>;
   context_management?: ContextManagementConfig;
@@ -359,6 +392,17 @@ export interface GSDPreferences {
    * Default: "standard".
    */
   discuss_depth?: "quick" | "standard" | "thorough";
+  /**
+   * Extra provider IDs to treat as flat-rate (no cost benefit from dynamic
+   * routing).  Dynamic routing is suppressed for any provider listed here,
+   * in addition to the built-in list (github-copilot, copilot, claude-code)
+   * and any provider auto-detected via `authMode: "externalCli"`.
+   *
+   * Intended for private subscription-backed proxies, enterprise-gated
+   * deployments, and custom CLI wrappers where every request costs the
+   * same regardless of model.  Case-insensitive.
+   */
+  flat_rate_providers?: string[];
 }
 
 export interface LoadedGSDPreferences {

package/src/resources/extensions/gsd/preferences-validation.ts

@@ -22,7 +22,12 @@ import {
   type GSDSkillRule,
 } from "./preferences-types.js";
 
-const VALID_TOKEN_PROFILES = new Set<TokenProfile>(["budget", "balanced", "quality"]);
+const VALID_TOKEN_PROFILES = new Set<TokenProfile>(["budget", "balanced", "quality", "burn-max"]);
+const VALID_UOK_TURN_ACTIONS = new Set<"commit" | "snapshot" | "status-only">([
+  "commit",
+  "snapshot",
+  "status-only",
+]);
 
 export function validatePreferences(preferences: GSDPreferences): {
   preferences: GSDPreferences;
@@ -161,12 +166,112 @@ export function validatePreferences(preferences: GSDPreferences): {
     }
   }
 
+  // ─── UOK Flags ──────────────────────────────────────────────────────
+  if (preferences.uok !== undefined) {
+    if (typeof preferences.uok === "object" && preferences.uok !== null) {
+      const raw = preferences.uok as Record<string, unknown>;
+      const valid: NonNullable<GSDPreferences["uok"]> = {};
+
+      if (raw.enabled !== undefined) {
+        if (typeof raw.enabled === "boolean") valid.enabled = raw.enabled;
+        else errors.push("uok.enabled must be a boolean");
+      }
+
+      const parseEnabledBlock = (
+        key: "legacy_fallback" | "gates" | "model_policy" | "execution_graph" | "audit_unified" | "plan_v2",
+      ): void => {
+        const value = raw[key];
+        if (value === undefined) return;
+        if (typeof value !== "object" || value === null) {
+          errors.push(`uok.${key} must be an object`);
+          return;
+        }
+        const block = value as Record<string, unknown>;
+        const parsed: { enabled?: boolean } = {};
+        if (block.enabled !== undefined) {
+          if (typeof block.enabled === "boolean") parsed.enabled = block.enabled;
+          else errors.push(`uok.${key}.enabled must be a boolean`);
+        }
+        const unknown = Object.keys(block).filter((k) => k !== "enabled");
+        for (const unk of unknown) {
+          warnings.push(`unknown uok.${key} key "${unk}" — ignored`);
+        }
+        if (Object.keys(parsed).length > 0) {
+          valid[key] = parsed;
+        }
+      };
+
+      parseEnabledBlock("legacy_fallback");
+      parseEnabledBlock("gates");
+      parseEnabledBlock("model_policy");
+      parseEnabledBlock("execution_graph");
+      parseEnabledBlock("audit_unified");
+      parseEnabledBlock("plan_v2");
+
+      if (raw.gitops !== undefined) {
+        if (typeof raw.gitops !== "object" || raw.gitops === null) {
+          errors.push("uok.gitops must be an object");
+        } else {
+          const gitops = raw.gitops as Record<string, unknown>;
+          const parsed: NonNullable<NonNullable<GSDPreferences["uok"]>["gitops"]> = {};
+          if (gitops.enabled !== undefined) {
+            if (typeof gitops.enabled === "boolean") parsed.enabled = gitops.enabled;
+            else errors.push("uok.gitops.enabled must be a boolean");
+          }
+          if (gitops.turn_action !== undefined) {
+            if (
+              typeof gitops.turn_action === "string" &&
+              VALID_UOK_TURN_ACTIONS.has(gitops.turn_action as "commit" | "snapshot" | "status-only")
+            ) {
+              parsed.turn_action = gitops.turn_action as "commit" | "snapshot" | "status-only";
+            } else {
+              errors.push("uok.gitops.turn_action must be one of: commit, snapshot, status-only");
+            }
+          }
+          if (gitops.turn_push !== undefined) {
+            if (typeof gitops.turn_push === "boolean") parsed.turn_push = gitops.turn_push;
+            else errors.push("uok.gitops.turn_push must be a boolean");
+          }
+          const unknown = Object.keys(gitops).filter((k) => !["enabled", "turn_action", "turn_push"].includes(k));
+          for (const unk of unknown) {
+            warnings.push(`unknown uok.gitops key "${unk}" — ignored`);
+          }
+          if (Object.keys(parsed).length > 0) {
+            valid.gitops = parsed;
+          }
+        }
+      }
+
+      const knownUokKeys = new Set([
+        "enabled",
+        "legacy_fallback",
+        "gates",
+        "model_policy",
+        "execution_graph",
+        "gitops",
+        "audit_unified",
+        "plan_v2",
+      ]);
+      for (const key of Object.keys(raw)) {
+        if (!knownUokKeys.has(key)) {
+          warnings.push(`unknown uok key "${key}" — ignored`);
+        }
+      }
+
+      if (Object.keys(valid).length > 0) {
+        validated.uok = valid;
+      }
+    } else {
+      errors.push("uok must be an object");
+    }
+  }
+
   // ─── Token Profile ─────────────────────────────────────────────────
   if (preferences.token_profile !== undefined) {
     if (typeof preferences.token_profile === "string" && VALID_TOKEN_PROFILES.has(preferences.token_profile as TokenProfile)) {
       validated.token_profile = preferences.token_profile as TokenProfile;
     } else {
-      errors.push(`token_profile must be one of: budget, balanced, quality`);
+      errors.push(`token_profile must be one of: budget, balanced, quality, burn-max`);
     }
   }
 
@@ -180,6 +285,29 @@ export function validatePreferences(preferences: GSDPreferences): {
     }
   }
 
+  // ─── Flat-rate Providers ────────────────────────────────────────────
+  // User-declared flat-rate providers for dynamic routing suppression.
+  // Built-in providers (github-copilot, copilot, claude-code) and any
+  // externalCli provider are already auto-detected; this list layers on
+  // top for private subscription proxies and custom CLI wrappers.
+  if (preferences.flat_rate_providers !== undefined) {
+    if (Array.isArray(preferences.flat_rate_providers)) {
+      const allStrings = preferences.flat_rate_providers.every(
+        (item: unknown) => typeof item === "string",
+      );
+      if (allStrings) {
+        // Strip empty/whitespace-only entries to avoid false matches.
+        validated.flat_rate_providers = preferences.flat_rate_providers
+          .map((s: string) => s.trim())
+          .filter((s: string) => s.length > 0);
+      } else {
+        errors.push("flat_rate_providers must be an array of strings");
+      }
+    } else {
+      errors.push("flat_rate_providers must be an array of strings");
+    }
+  }
+
   // ─── Phase Skip Preferences ─────────────────────────────────────────
   if (preferences.phases !== undefined) {
     if (typeof preferences.phases === "object" && preferences.phases !== null) {

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

@@ -50,6 +50,8 @@ export type {
   AutoSupervisorConfig,
   RemoteQuestionsConfig,
   CmuxPreferences,
+  UokTurnActionMode,
+  UokPreferences,
   CodebaseMapPreferences,
   GSDPreferences,
   LoadedGSDPreferences,
@@ -378,6 +380,32 @@ function mergePreferences(base: GSDPreferences, override: GSDPreferences): GSDPr
     dynamic_routing: (base.dynamic_routing || override.dynamic_routing)
       ? { ...(base.dynamic_routing ?? {}), ...(override.dynamic_routing ?? {}) } as DynamicRoutingConfig
       : undefined,
+    uok: (base.uok || override.uok)
+      ? {
+          enabled: override.uok?.enabled ?? base.uok?.enabled,
+          legacy_fallback: (base.uok?.legacy_fallback || override.uok?.legacy_fallback)
+            ? { ...(base.uok?.legacy_fallback ?? {}), ...(override.uok?.legacy_fallback ?? {}) }
+            : undefined,
+          gates: (base.uok?.gates || override.uok?.gates)
+            ? { ...(base.uok?.gates ?? {}), ...(override.uok?.gates ?? {}) }
+            : undefined,
+          model_policy: (base.uok?.model_policy || override.uok?.model_policy)
+            ? { ...(base.uok?.model_policy ?? {}), ...(override.uok?.model_policy ?? {}) }
+            : undefined,
+          execution_graph: (base.uok?.execution_graph || override.uok?.execution_graph)
+            ? { ...(base.uok?.execution_graph ?? {}), ...(override.uok?.execution_graph ?? {}) }
+            : undefined,
+          gitops: (base.uok?.gitops || override.uok?.gitops)
+            ? { ...(base.uok?.gitops ?? {}), ...(override.uok?.gitops ?? {}) }
+            : undefined,
+          audit_unified: (base.uok?.audit_unified || override.uok?.audit_unified)
+            ? { ...(base.uok?.audit_unified ?? {}), ...(override.uok?.audit_unified ?? {}) }
+            : undefined,
+          plan_v2: (base.uok?.plan_v2 || override.uok?.plan_v2)
+            ? { ...(base.uok?.plan_v2 ?? {}), ...(override.uok?.plan_v2 ?? {}) }
+            : undefined,
+        }
+      : undefined,
     token_profile: override.token_profile ?? base.token_profile,
     phases: (base.phases || override.phases)
       ? { ...(base.phases ?? {}), ...(override.phases ?? {}) }

package/src/resources/extensions/gsd/prompts/add-tests.md

@@ -0,0 +1,35 @@
+You are generating tests for recently completed GSD work.
+
+## Slice: {{sliceId}} — {{sliceTitle}}
+
+### Summary
+
+{{sliceSummary}}
+
+### Existing Test Patterns
+
+{{existingTestPatterns}}
+
+## Working Directory
+
+`{{workingDirectory}}`
+
+## Instructions
+
+1. Read the slice summary above to understand what was built
+2. Identify the source files that were created or modified for this slice
+3. Read the implementation code to understand behavior, edge cases, and error paths
+4. Write comprehensive tests following the project's existing test patterns and framework
+5. Run the tests to verify they pass
+6. Fix any failures
+
+### Rules
+
+- Follow the project's existing test patterns (framework, assertions, file structure)
+- Test behavior, not implementation details
+- Cover: happy path, edge cases, error conditions, boundary values
+- Do NOT modify implementation files — only create or update test files
+- Name test files consistently with the project's conventions
+- Keep tests focused and readable
+
+{{skillActivation}}

package/src/resources/extensions/gsd/session-lock.ts

@@ -52,6 +52,18 @@ export interface SessionLockStatus {
   recovered?: boolean;
 }
 
+interface ProperLockfileApi {
+  lockSync(
+    path: string,
+    options?: {
+      realpath?: boolean;
+      stale?: number;
+      update?: number;
+      onCompromised?: () => void;
+    },
+  ): () => void;
+}
+
 // ─── Module State ───────────────────────────────────────────────────────────
 
 /** Release function from proper-lockfile — calling it releases the OS lock. */
@@ -277,9 +289,9 @@ export function acquireSessionLock(basePath: string): SessionLockResult {
     unitStartedAt: new Date().toISOString(),
   };
 
-  let lockfile: typeof import("proper-lockfile");
+  let lockfile: ProperLockfileApi;
   try {
-    lockfile = _require("proper-lockfile") as typeof import("proper-lockfile");
+    lockfile = _require("proper-lockfile") as ProperLockfileApi;
   } catch {
     // proper-lockfile not available — fall back to PID-based check
     return acquireFallbackLock(basePath, lp, lockData);

package/src/resources/extensions/gsd/slice-parallel-orchestrator.ts

@@ -32,6 +32,7 @@ import {
 } from "./session-status-io.js";
 import { hasFileConflict } from "./slice-parallel-conflict.js";
 import { getErrorMessage } from "./error-utils.js";
+import { selectConflictFreeBatch } from "./uok/execution-graph.js";
 
 // ─── Types ─────────────────────────────────────────────────────────────────
 
@@ -61,6 +62,7 @@ export interface SliceOrchestratorState {
 export interface StartSliceParallelOpts {
   maxWorkers?: number;
   budgetCeiling?: number;
+  useExecutionGraph?: boolean;
 }
 
 // ─── Module State ──────────────────────────────────────────────────────────
@@ -118,7 +120,12 @@ export async function startSliceParallel(
   const errors: Array<{ sid: string; error: string }> = [];
 
   // Filter out conflicting slices (conservative: check all pairs)
-  const safeSlices = filterConflictingSlices(basePath, milestoneId, eligibleSlices);
+  const safeSlices = filterConflictingSlices(
+    basePath,
+    milestoneId,
+    eligibleSlices,
+    opts.useExecutionGraph === true,
+  );
 
   // Limit to maxWorkers
   const toSpawn = safeSlices.slice(0, maxWorkers);
@@ -245,7 +252,19 @@ function filterConflictingSlices(
   basePath: string,
   milestoneId: string,
   slices: Array<{ id: string }>,
+  useExecutionGraph: boolean,
 ): Array<{ id: string }> {
+  if (useExecutionGraph) {
+    const selectedIds = selectConflictFreeBatch({
+      orderedIds: slices.map((slice) => slice.id),
+      maxParallel: slices.length,
+      hasConflict: (candidate, existing) =>
+        hasFileConflict(basePath, milestoneId, candidate, existing),
+    });
+    const selected = new Set(selectedIds);
+    return slices.filter((slice) => selected.has(slice.id));
+  }
+
   const safe: Array<{ id: string }> = [];
 
   for (const candidate of slices) {

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

@@ -345,8 +345,15 @@ function reconcileDiskToDb(basePath: string): MilestoneRow[] {
     const dbSliceIds = new Set(dbSlices.map(s => s.id));
 
     let roadmapContent: string;
-    try { roadmapContent = readFileSync(roadmapPath, "utf-8"); }
-    catch { continue; }
+    try {
+      roadmapContent = readFileSync(roadmapPath, "utf-8");
+    } catch (err) {
+      logWarning("state", "reconcileDiskToDb: roadmap read failed, skipping milestone", {
+        mid,
+        error: (err as Error).message,
+      });
+      continue;
+    }
 
     const parsed = parseRoadmap(roadmapContent);
     for (const s of parsed.slices) {
@@ -386,6 +393,10 @@ function buildCompletenessSet(basePath: string, milestones: MilestoneRow[]) {
   const completeMilestoneIds = new Set<string>();
   const parkedMilestoneIds = new Set<string>();
 
+  // DB-authoritative: a milestone is only "complete" when its DB row says so.
+  // SUMMARY-file presence is NOT a completion signal here — an orphan SUMMARY
+  // (crashed complete-milestone turn, partial merge, manual edit) must not
+  // flip derived state to complete and cascade into a false auto-merge (#4179).
   for (const m of milestones) {
     const parkedFile = resolveMilestoneFile(basePath, m.id, "PARKED");
     if (parkedFile || m.status === 'parked') {
@@ -396,11 +407,6 @@ function buildCompletenessSet(basePath: string, milestones: MilestoneRow[]) {
       completeMilestoneIds.add(m.id);
       continue;
     }
-    const summaryFile = resolveMilestoneFile(basePath, m.id, "SUMMARY");
-    if (summaryFile) {
-      completeMilestoneIds.add(m.id);
-      continue;
-    }
   }
   return { completeMilestoneIds, parkedMilestoneIds };
 }
@@ -429,18 +435,22 @@ async function buildRegistryAndFindActive(
       if (isGhostMilestone(basePath, m.id)) continue;
     }
 
-    const summaryFile = resolveMilestoneFile(basePath, m.id, "SUMMARY");
-
-    if (completeMilestoneIds.has(m.id) || (summaryFile !== null)) {
+    // DB-authoritative completeness (#4179): only trust completeMilestoneIds,
+    // which is itself derived from DB status. SUMMARY-file presence alone must
+    // not imply completion. The summary file may still be consulted below as a
+    // title source for legitimately-complete milestones whose DB row has no title.
+    if (completeMilestoneIds.has(m.id)) {
       let title = stripMilestonePrefix(m.title) || m.id;
-      if (summaryFile && !m.title) {
-        const summaryContent = await loadFile(summaryFile);
-        if (summaryContent) {
-          title = parseSummary(summaryContent).title || m.id;
+      if (!m.title) {
+        const summaryFile = resolveMilestoneFile(basePath, m.id, "SUMMARY");
+        if (summaryFile) {
+          const summaryContent = await loadFile(summaryFile);
+          if (summaryContent) {
+            title = parseSummary(summaryContent).title || m.id;
+          }
         }
       }
       registry.push({ id: m.id, title, status: 'complete' });
-      completeMilestoneIds.add(m.id);
       continue;
     }
 
@@ -481,7 +491,14 @@ async function buildRegistryAndFindActive(
         const validationContent = validationFile ? await loadFile(validationFile) : null;
         const validationTerminal = validationContent ? isValidationTerminal(validationContent) : false;
 
-        if (!validationTerminal || (validationTerminal && !summaryFile)) {
+        // DB-authoritative (#4179): completeness is already decided by
+        // completeMilestoneIds above. If we reached this branch, the DB says
+        // the milestone is NOT complete — so any SUMMARY file on disk is an
+        // orphan (crashed complete-milestone, partial merge, manual edit) and
+        // must not short-circuit this path. When validation is terminal, fall
+        // through to the default active-push below so `complete-milestone` can
+        // re-run idempotently.
+        if (!validationTerminal) {
           activeMilestone = { id: m.id, title };
           activeMilestoneSlices = slices;
           activeMilestoneFound = true;
@@ -630,13 +647,39 @@ function resolveSliceDependencies(activeMilestoneSlices: SliceRow[]): { activeSl
     }
   }
 
+  // First pass: find a slice with ALL dependencies satisfied (strict)
+  let bestFallback: SliceRow | null = null;
+  let bestFallbackSatisfied = -1;
+
   for (const s of activeMilestoneSlices) {
     if (isStatusDone(s.status)) continue;
     if (isDeferredStatus(s.status)) continue;
     if (s.depends.every(dep => doneSliceIds.has(dep))) {
       return { activeSlice: { id: s.id, title: s.title }, activeSliceRow: s };
     }
+    // Track the slice with the most satisfied dependencies as fallback
+    const satisfied = s.depends.filter(dep => doneSliceIds.has(dep)).length;
+    if (satisfied > bestFallbackSatisfied || (satisfied === bestFallbackSatisfied && !bestFallback)) {
+      bestFallback = s;
+      bestFallbackSatisfied = satisfied;
+    }
+  }
+
+  // Fallback: if no slice has all deps met but there ARE incomplete non-deferred
+  // slices, pick the one with the most deps satisfied. This prevents hard-blocking
+  // when dependency metadata is stale (e.g. after reassessment added/removed slices)
+  // or when deps reference slices from previous milestones.
+  if (bestFallback) {
+    const unmet = bestFallback.depends.filter(dep => !doneSliceIds.has(dep));
+    logWarning("state",
+      `No slice has all deps satisfied — falling back to ${bestFallback.id} ` +
+      `(${bestFallbackSatisfied}/${bestFallback.depends.length} deps met, ` +
+      `unmet: ${unmet.join(", ")})`,
+      { mid: activeMilestoneSlices[0]?.milestone_id, sid: bestFallback.id },
+    );
+    return { activeSlice: { id: bestFallback.id, title: bestFallback.title }, activeSliceRow: bestFallback };
   }
+
   return { activeSlice: null, activeSliceRow: null };
 }
 
@@ -684,7 +727,7 @@ async function reconcileSliceTasks(
     const summaryPath = resolveTaskFile(basePath, milestoneId, sliceId, t.id, "SUMMARY");
     if (summaryPath && existsSync(summaryPath)) {
       try {
-        updateTaskStatus(milestoneId, sliceId, t.id, "complete");
+        updateTaskStatus(milestoneId, sliceId, t.id, "complete", new Date().toISOString());
         logWarning("reconcile", `task ${milestoneId}/${sliceId}/${t.id} status reconciled from "${t.status}" to "complete" (#2514)`, { mid: milestoneId, sid: sliceId, tid: t.id });
         reconciled = true;
       } catch (e) {
@@ -1431,12 +1474,32 @@ export async function _deriveStateImpl(basePath: string): Promise<GSDState> {
       };
     }
   } else {
+    let bestFallbackLegacy: { id: string; title: string; depends: string[] } | null = null;
+    let bestFallbackLegacySatisfied = -1;
+
     for (const s of activeRoadmap.slices) {
       if (s.done) continue;
       if (s.depends.every(dep => doneSliceIds.has(dep))) {
         activeSlice = { id: s.id, title: s.title };
         break;
       }
+      // Track best fallback
+      const satisfied = s.depends.filter(dep => doneSliceIds.has(dep)).length;
+      if (satisfied > bestFallbackLegacySatisfied) {
+        bestFallbackLegacy = s;
+        bestFallbackLegacySatisfied = satisfied;
+      }
+    }
+
+    // Fallback: if no slice has all deps met, pick the one with the most deps satisfied
+    if (!activeSlice && bestFallbackLegacy) {
+      const unmet = bestFallbackLegacy.depends.filter(dep => !doneSliceIds.has(dep));
+      logWarning("state",
+        `No slice has all deps satisfied — falling back to ${bestFallbackLegacy.id} ` +
+        `(${bestFallbackLegacySatisfied}/${bestFallbackLegacy.depends.length} deps met, ` +
+        `unmet: ${unmet.join(", ")})`,
+      );
+      activeSlice = { id: bestFallbackLegacy.id, title: bestFallbackLegacy.title };
     }
   }