@opengsd/gsd-pi 1.2.0 → 1.3.0-dev.65546769

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

@@ -101,6 +101,7 @@ export const MODEL_CAPABILITY_TIER: Record<string, ComplexityTier> = {
   "claude-opus-4-6": "heavy",
   "claude-opus-4-7": "heavy",
   "claude-opus-4-8": "heavy",
+  "claude-fable-5": "heavy",
   "claude-3-opus-latest": "heavy",
   "gpt-4-turbo": "heavy",
   "gpt-5": "heavy",
@@ -129,6 +130,7 @@ const MODEL_COST_PER_1K_INPUT: Record<string, number> = {
   "claude-opus-4-6": 0.005,
   "claude-opus-4-7": 0.005,
   "claude-opus-4-8": 0.005,
+  "claude-fable-5": 0.010,
   "gpt-4o-mini": 0.00015,
   "gpt-4o": 0.0025,
   "gpt-4.1": 0.002,
@@ -164,6 +166,7 @@ export const MODEL_CAPABILITY_PROFILES: Record<string, ModelCapabilities> = {
   "claude-opus-4-6":              { coding: 95, debugging: 90, research: 85, reasoning: 95, speed: 30, longContext: 80, instruction: 90 },
   "claude-opus-4-7":              { coding: 95, debugging: 90, research: 85, reasoning: 95, speed: 30, longContext: 80, instruction: 90 },
   "claude-opus-4-8":              { coding: 97, debugging: 92, research: 87, reasoning: 97, speed: 30, longContext: 85, instruction: 92 },
+  "claude-fable-5":               { coding: 97, debugging: 92, research: 87, reasoning: 97, speed: 30, longContext: 85, instruction: 92 },
   "claude-sonnet-4-6":            { coding: 85, debugging: 80, research: 75, reasoning: 80, speed: 60, longContext: 75, instruction: 85 },
   "claude-sonnet-4-5-20250514":   { coding: 85, debugging: 80, research: 75, reasoning: 80, speed: 60, longContext: 75, instruction: 85 },
   "claude-3-5-sonnet-latest":     { coding: 82, debugging: 78, research: 72, reasoning: 78, speed: 62, longContext: 70, instruction: 82 },
@@ -309,6 +312,8 @@ export function scoreEligibleModels(
 
 /**
  * Return all models eligible for a given tier, sorted cheapest first.
+ * A runtime preferred model (the user's selected/session model) is returned
+ * first when it is available and satisfies the requested tier.
  * If routingConfig.tier_models[tier] is set and available, returns only that
  * model. Otherwise filters availableModelIds by tier from MODEL_CAPABILITY_TIER.
  */
@@ -316,6 +321,7 @@ export function getEligibleModels(
   tier: ComplexityTier,
   availableModelIds: string[],
   routingConfig: DynamicRoutingConfig,
+  preferredModelId?: string,
 ): string[] {
   // 1. Check explicit tier_models config
   const explicitModel = routingConfig.tier_models?.[tier];
@@ -329,13 +335,17 @@ export function getEligibleModels(
   }
 
   // 2. Auto-detect: filter by tier, sort cheapest first
-  return availableModelIds
+  const tierMatches = availableModelIds
     .filter(id => getModelTier(id) === tier)
     .sort((a, b) => {
       const costA = getModelCost(a);
       const costB = getModelCost(b);
       return costA - costB;
     });
+
+  const preferred = findPreferredModelForTier(tier, availableModelIds, preferredModelId);
+  if (!preferred) return tierMatches;
+  return [preferred, ...tierMatches.filter(id => id !== preferred)];
 }
 
 /**
@@ -395,6 +405,7 @@ export function resolveModelForComplexity(
   unitType?: string,
   taskMetadata?: TaskMetadata,
   capabilityOverrides?: Record<string, Partial<ModelCapabilities>>,
+  preferredModelId?: string,
 ): RoutingDecision {
   // If no phase config or routing disabled, pass through
   if (!phaseConfig || !routingConfig.enabled) {
@@ -450,6 +461,7 @@ export function resolveModelForComplexity(
       routingConfig,
       availableModelIds,
       routingConfig.cross_provider !== false,
+      preferredModelId,
     );
 
     return {
@@ -467,7 +479,7 @@ export function resolveModelForComplexity(
   }
 
   // STEP 1: Get all eligible models for the requested tier
-  const eligible = getEligibleModels(requestedTier, availableModelIds, routingConfig);
+  const eligible = getEligibleModels(requestedTier, availableModelIds, routingConfig, preferredModelId);
 
   if (eligible.length === 0) {
     // No suitable model found — use configured primary
@@ -481,6 +493,19 @@ export function resolveModelForComplexity(
     };
   }
 
+  const preferred = findPreferredModelForTier(requestedTier, availableModelIds, preferredModelId);
+  if (preferred && eligible.includes(preferred)) {
+    const fallbacks = buildFallbackChain(preferred, phaseConfig);
+    return {
+      modelId: preferred,
+      fallbacks,
+      tier: requestedTier,
+      wasDowngraded: !isModelAvailable(configuredPrimary, [preferred]),
+      reason: `preferred session model ${preferred} satisfies ${requestedTier} tier`,
+      selectionMethod: "tier-only",
+    };
+  }
+
   // STEP 2: Capability scoring (when enabled and multiple eligible models exist)
   if (routingConfig.capability_routing !== false && eligible.length > 1 && unitType) {
     const requirements = computeTaskRequirements(unitType, taskMetadata);
@@ -548,15 +573,15 @@ export function defaultRoutingConfig(): DynamicRoutingConfig {
 // ─── Tier-Based Model Resolution (for profile defaults) ─────────────────────
 
 /**
- * Fallback-only canonical model IDs per tier. Returned when the
+ * Fallback-only canonical model IDs per tier. Returned only when the
  * available-model list is empty (e.g., preferences are loaded before the
- * model registry is populated at bootstrap), or when a non-empty registry has
- * no model at the requested tier.
+ * model registry is populated at bootstrap).
  *
  * Precedence (resolveModelForTier):
  *   1. configured `tier_models[tier]` (via getEligibleModels) — exact/bare match
- *   2. cheapest available model whose tier matches `tier`
- *   3. CANONICAL_TIER_MODELS[tier] as last-resort fallback
+ *   2. preferred/session model when it is available and satisfies `tier`
+ *   3. cheapest available model whose tier matches `tier`
+ *   4. CANONICAL_TIER_MODELS[tier] when the registry is empty
  */
 const CANONICAL_TIER_MODELS: Record<ComplexityTier, string> = {
   light: "claude-haiku-4-5",
@@ -570,9 +595,10 @@ export function canonicalModelForTier(tier: ComplexityTier): string {
 
 /**
  * Single source of truth for tier-based model selection.
- * Returns the cheapest available model whose capability tier matches `tier`,
- * honoring `routingConfig.tier_models[tier]` when set. Returns undefined when
- * no available model matches the tier.
+ * Returns the preferred/session model when it satisfies `tier`, otherwise the
+ * cheapest available model whose capability tier matches `tier`, honoring
+ * `routingConfig.tier_models[tier]` when set. Returns undefined when no
+ * available model satisfies the tier.
  *
  * `crossProvider`: when false, restricts the search to models that share the
  * canonical (Anthropic) provider for the tier. When true, any provider is
@@ -583,8 +609,9 @@ function findModelForTier(
   routingConfig: DynamicRoutingConfig,
   availableModelIds: string[],
   crossProvider: boolean,
+  preferredModelId?: string,
 ): string | undefined {
-  const eligible = getEligibleModels(tier, availableModelIds, routingConfig);
+  const eligible = getEligibleModels(tier, availableModelIds, routingConfig, preferredModelId);
   if (eligible.length === 0) return undefined;
 
   if (crossProvider) {
@@ -597,6 +624,13 @@ function findModelForTier(
     const bare = bareModelId(id);
     return MODEL_CAPABILITY_TIER[bare] === tier && bare.startsWith("claude-");
   });
+
+  // Honor the preferred/session model only when it is itself a same-provider
+  // (Anthropic/Claude) model. A non-Anthropic session model must not bypass
+  // the cross_provider:false restriction.
+  const preferred = findPreferredModelForTier(tier, availableModelIds, preferredModelId);
+  if (preferred && sameProvider.includes(preferred)) return preferred;
+
   return sameProvider[0];
 }
 
@@ -607,9 +641,11 @@ function findModelForTier(
  *
  * Precedence:
  *   1. configured `tier_models[tier]`, if provided and available
- *   2. tier-matching model from any provider in `availableModelIds`
- *   3. canonical Anthropic ID as a fallback only when nothing else matches
- *      (or `availableModelIds` is empty, e.g., during early bootstrap)
+ *   2. preferred/session model when available and satisfying the tier
+ *   3. tier-matching model from any provider in `availableModelIds`
+ *   4. preferred/session model, then first available model, when the registry
+ *      is non-empty but has no tier match
+ *   5. canonical Anthropic ID only when `availableModelIds` is empty
  *
  * @param tier              The capability tier to resolve
  * @param availableModelIds List of available model IDs (REQUIRED for
@@ -617,6 +653,7 @@ function findModelForTier(
  *                          the model registry is genuinely unavailable)
  * @param routingConfig     Optional routing config, or legacy crossProvider boolean
  * @param crossProvider     Whether to consider models from other providers
+ * @param preferredModelId  Optional selected/session model ID to prefer
  */
 export function resolveModelForTier(
   tier: ComplexityTier,
@@ -628,12 +665,14 @@ export function resolveModelForTier(
   availableModelIds: string[],
   routingConfig?: DynamicRoutingConfig,
   crossProvider?: boolean,
+  preferredModelId?: string,
 ): string;
 export function resolveModelForTier(
   tier: ComplexityTier,
   availableModelIds: string[],
   routingConfigOrCrossProvider: DynamicRoutingConfig | boolean = defaultRoutingConfig(),
   crossProvider?: boolean,
+  preferredModelId?: string,
 ): string {
   const routingConfig = typeof routingConfigOrCrossProvider === "boolean"
     ? defaultRoutingConfig()
@@ -642,24 +681,68 @@ export function resolveModelForTier(
     ? routingConfigOrCrossProvider
     : crossProvider ?? routingConfig.cross_provider !== false;
 
-  // No available models known — return canonical fallback
+  // No available models known — prefer the session model when provided, else canonical
   if (availableModelIds.length === 0) {
+    if (preferredModelId) {
+      return normalizeResolvedTierModelId(preferredModelId, tier, routingConfig);
+    }
     incrementLegacyTelemetry("legacy.providerDefaultUsed");
     return canonicalModelForTier(tier);
   }
 
   // Cross-provider tier search
-  const resolved = findModelForTier(tier, routingConfig, availableModelIds, allowCrossProvider);
+  const resolved = findModelForTier(tier, routingConfig, availableModelIds, allowCrossProvider, preferredModelId);
   if (resolved) {
     return normalizeResolvedTierModelId(resolved, tier, routingConfig);
   }
 
-  incrementLegacyTelemetry("legacy.providerDefaultUsed");
-  return canonicalModelForTier(tier);
+  const providerLocalFallback = findAvailableModelId(preferredModelId, availableModelIds)
+    ?? availableModelIds[0]
+    ?? canonicalModelForTier(tier);
+  return normalizeResolvedTierModelId(providerLocalFallback, tier, routingConfig);
 }
 
 // ─── Internal ────────────────────────────────────────────────────────────────
 
+function modelProvider(modelId: string): string | undefined {
+  const slash = modelId.indexOf("/");
+  return slash > 0 ? modelId.slice(0, slash) : undefined;
+}
+
+function findAvailableModelId(
+  preferredModelId: string | undefined,
+  availableModelIds: string[],
+): string | undefined {
+  if (!preferredModelId) return undefined;
+  if (availableModelIds.includes(preferredModelId)) return preferredModelId;
+
+  const preferredBare = bareModelId(preferredModelId);
+  if (!preferredBare) return undefined;
+  const preferredProvider = modelProvider(preferredModelId)?.toLowerCase();
+  if (preferredProvider) {
+    const providerMatch = availableModelIds.find(id =>
+      modelProvider(id)?.toLowerCase() === preferredProvider && bareModelId(id) === preferredBare
+    );
+    if (providerMatch) return providerMatch;
+  }
+
+  return availableModelIds.find(id => bareModelId(id) === preferredBare);
+}
+
+function modelSatisfiesTier(modelId: string, tier: ComplexityTier): boolean {
+  return tierOrdinal(getModelTier(modelId)) >= tierOrdinal(tier);
+}
+
+function findPreferredModelForTier(
+  tier: ComplexityTier,
+  availableModelIds: string[],
+  preferredModelId: string | undefined,
+): string | undefined {
+  const preferred = findAvailableModelId(preferredModelId, availableModelIds);
+  if (!preferred) return undefined;
+  return modelSatisfiesTier(preferred, tier) ? preferred : undefined;
+}
+
 /**
  * Check whether a model ID is present in the available models list.
  * Handles bare IDs ("claude-opus-4-6") and provider-prefixed IDs ("anthropic/claude-opus-4-6").

package/src/resources/extensions/gsd/native-git-bridge.ts

@@ -1101,6 +1101,45 @@ export function nativeMergeSquash(basePath: string, branch: string): GitMergeRes
   }
 }
 
+/**
+ * Regular (non-squash) merge a branch (stages changes, does NOT commit).
+ * Uses --no-ff to ensure a proper merge commit and --no-commit so the caller
+ * can supply a custom commit message via nativeCommit.
+ * Respects the user's global git merge.ff config; --no-ff is additive here.
+ */
+export function nativeMergeRegular(basePath: string, branch: string): GitMergeResult {
+  try {
+    execFileSync("git", ["merge", "--no-ff", "--no-commit", branch], {
+      cwd: basePath,
+      stdio: ["ignore", "pipe", "pipe"],
+      encoding: "utf-8",
+      env: GIT_NO_PROMPT_ENV,
+    });
+    return { success: true, conflicts: [] };
+  } catch (err: unknown) {
+    const stderr =
+      err instanceof Error ? (err as Error & { stderr?: string }).stderr ?? err.message : String(err);
+    if (
+      stderr.includes("local changes would be overwritten") ||
+      stderr.includes("not possible because you have unmerged files") ||
+      stderr.includes("overwritten by merge")
+    ) {
+      const dirtyFiles = stderr
+        .split("\n")
+        .filter((line) => line.startsWith("\t"))
+        .map((line) => line.trim())
+        .filter(Boolean);
+      return { success: false, conflicts: ["__dirty_working_tree__"], dirtyFiles };
+    }
+    const conflictOutput = gitExec(basePath, ["diff", "--name-only", "--diff-filter=U"], true);
+    const conflicts = conflictOutput ? conflictOutput.split("\n").filter(Boolean) : [];
+    if (conflicts.length > 0) {
+      return { success: false, conflicts };
+    }
+    throw err;
+  }
+}
+
 /**
  * Abort an in-progress merge.
  * Native: libgit2 reset + cleanup.

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

@@ -12,6 +12,17 @@ import { randomUUID } from "node:crypto";
 export type NotifySeverity = "info" | "success" | "warning" | "error";
 export type NotificationSource = "notify" | "workflow-logger";
 
+/**
+ * Optional structured identity for a notification. When present, `kind`
+ * (a stable machine name like "auto-stop" or "provider-error-pause") plus
+ * `scope` (e.g. a milestone/slice id) — not the prose — key deduplication,
+ * and consumers can filter without parsing message text.
+ */
+export interface NotificationMeta {
+  kind?: string;
+  scope?: string;
+}
+
 export interface NotificationEntry {
   id: string;
   ts: string;
@@ -19,6 +30,8 @@ export interface NotificationEntry {
   message: string;
   source: NotificationSource;
   read: boolean;
+  kind?: string;
+  scope?: string;
 }
 
 // ─── Constants ──────────────────────────────────────────────────────────
@@ -60,11 +73,15 @@ export function appendNotification(
   message: string,
   severity: NotifySeverity,
   source: NotificationSource = "notify",
+  meta?: NotificationMeta,
 ): void {
   if (!_basePath) return;
   if (_suppressCount > 0) return;
   const persistedMessage = message.length > 500 ? message.slice(0, 500) + "…" : message;
-  const dedupKey = `${_basePath}:${severity}:${source}:${persistedMessage}`;
+  // Structured identity (kind + scope) keys dedup when present, so a rephrased
+  // message of the same event still dedups; otherwise fall back to the prose.
+  const identity = meta?.kind ? `${meta.kind}:${meta.scope ?? ""}` : persistedMessage;
+  const dedupKey = `${_basePath}:${severity}:${source}:${identity}`;
   const now = Date.now();
   const lastSeen = _recentMessageTimestamps.get(dedupKey);
   if (lastSeen !== undefined && now - lastSeen < DEDUP_WINDOW_MS) return;
@@ -82,6 +99,8 @@ export function appendNotification(
     message: persistedMessage,
     source,
     read: false,
+    ...(meta?.kind ? { kind: meta.kind } : {}),
+    ...(meta?.scope ? { scope: meta.scope } : {}),
   };
 
   try {
@@ -102,11 +121,15 @@ export function appendNotification(
 
 /**
  * Read all notification entries from disk. Returns newest-first.
+ * An optional filter narrows by structured identity (kind and/or scope).
  */
-export function readNotifications(basePath?: string): NotificationEntry[] {
+export function readNotifications(basePath?: string, filter?: NotificationMeta): NotificationEntry[] {
   const bp = basePath ?? _basePath;
   if (!bp) return [];
-  return _readEntriesFromDisk(bp).reverse();
+  const entries = _readEntriesFromDisk(bp).filter(
+    (e) => (!filter?.kind || e.kind === filter.kind) && (!filter?.scope || e.scope === filter.scope),
+  );
+  return entries.reverse();
 }
 
 /**
@@ -287,40 +310,29 @@ function _atomicWrite(basePath: string, content: string): void {
 /**
  * Acquire an exclusive lockfile for rewrite operations.
  * Uses O_CREAT|O_EXCL for atomic creation — if the file exists, another
- * process holds the lock. Retries briefly, then proceeds anyway (best-effort)
- * to avoid deadlocking the UI on a stale lock.
+ * process holds the lock. Clears stale locks, then proceeds anyway
+ * (best-effort) to avoid blocking the UI.
  */
 function _withLock<T>(basePath: string, fn: () => T): T {
   const lockPath = join(basePath, ".gsd", LOCKFILE);
   let fd: number | null = null;
-  const maxAttempts = 5;
-  const retryMs = 20;
 
-  for (let i = 0; i < maxAttempts; i++) {
-    try {
-      mkdirSync(join(basePath, ".gsd"), { recursive: true });
-      fd = openSync(lockPath, "wx");
-      break;
-    } catch (err: any) {
-      if (err?.code === "EEXIST") {
-        // Check if lock is stale (older than 5s)
-        try {
-          const stat = readFileSync(lockPath, "utf-8");
-          const lockTime = parseInt(stat, 10);
-          if (Date.now() - lockTime > 5000) {
-            try { unlinkSync(lockPath); } catch { /* race ok */ }
-            continue;
-          }
-        } catch { /* can't read lock, retry */ }
-
-        // Wait and retry
-        const start = Date.now();
-        while (Date.now() - start < retryMs) { /* spin */ }
-        continue;
-      }
-      // Other error — proceed without lock
-      break;
+  try {
+    mkdirSync(join(basePath, ".gsd"), { recursive: true });
+    fd = openSync(lockPath, "wx");
+  } catch (err: any) {
+    if (err?.code === "EEXIST") {
+      // Check if lock is stale (older than 5s)
+      try {
+        const stat = readFileSync(lockPath, "utf-8");
+        const lockTime = parseInt(stat, 10);
+        if (Date.now() - lockTime > 5000) {
+          try { unlinkSync(lockPath); } catch { /* race ok */ }
+          try { fd = openSync(lockPath, "wx"); } catch { /* race ok */ }
+        }
+      } catch { /* proceed without lock */ }
     }
+    // Any lock acquisition error leaves fd null; proceed without lock.
   }
 
   // Best-effort: mutation runs regardless of lock status (idempotent overwrites).

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

@@ -1,10 +1,17 @@
 // GSD Extension — Desktop Notification Helper
 // Cross-platform desktop notifications for auto-mode events.
 
-import { execFileSync } from "node:child_process";
+import childProcess from "node:child_process";
+import { accessSync, constants } from "node:fs";
+import { delimiter, resolve } from "node:path";
 import type { NotificationPreferences } from "./types.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
-import { sendRemoteNotification } from "../remote-questions/notify.js";
+import { sendRemoteNotification as _sendRemoteNotification } from "../remote-questions/notify.js";
+
+/** Swappable dispatcher for remote notifications — exported so tests can mock it. */
+export const remoteNotificationDispatcher = {
+  send: _sendRemoteNotification,
+};
 
 export type NotifyLevel = "info" | "success" | "warning" | "error";
 export type NotificationKind = "complete" | "error" | "budget" | "milestone" | "attention";
@@ -20,6 +27,8 @@ interface BellStream {
   write(chunk: string): unknown;
 }
 
+const executablePathCache = new Map<string, string | null>();
+
 /**
  * Send a native desktop notification. Non-blocking, non-fatal.
  * macOS: osascript, Linux: notify-send, Windows: skipped.
@@ -30,28 +39,30 @@ export function sendDesktopNotification(
   level: NotifyLevel = "info",
   kind: NotificationKind = "complete",
   projectName?: string,
+  deps: { notifications?: NotificationPreferences } = {},
 ): void {
   // When a projectName is provided and the title is the default "GSD",
   // replace it with a project-qualified title for multi-project clarity.
   if (projectName && title === "GSD") {
     title = formatNotificationTitle(projectName);
   }
-  const loaded = loadEffectiveGSDPreferences()?.preferences;
+  const loadedPreferences = loadEffectiveGSDPreferences()?.preferences;
+  const notifications = deps.notifications ?? loadedPreferences?.notifications;
 
   // Remote notifications fire independently of desktop preferences.
   // sendRemoteNotification handles "not configured" gracefully (early return).
-  void sendRemoteNotification(title, message).catch(() => {});
+  void remoteNotificationDispatcher.send(title, message).catch(() => {});
 
-  if (!shouldSendDesktopNotification(kind, loaded?.notifications)) return;
+  if (!shouldSendDesktopNotification(kind, notifications)) return;
 
   // cmux delivery and desktop delivery are independent — if cmux import or
   // delivery fails, we must still attempt the native desktop notification.
   const runCmux = async () => {
     try {
       const { CmuxClient, emitOsc777Notification, resolveCmuxConfig } = await import("../cmux/index.js");
-      const cmux = resolveCmuxConfig(loaded);
+      const cmux = resolveCmuxConfig(loadedPreferences);
       if (cmux.notifications) {
-        const delivered = CmuxClient.fromPreferences(loaded).notify(title, message);
+        const delivered = CmuxClient.fromPreferences(loadedPreferences).notify(title, message);
         if (delivered) return true;
         emitOsc777Notification(title, message);
       }
@@ -66,13 +77,26 @@ export function sendDesktopNotification(
     try {
       const command = buildDesktopNotificationCommand(process.platform, title, message, level);
       if (!command) return;
-      execFileSync(command.file, command.args, { timeout: 3000, stdio: "ignore" });
+      launchDesktopNotification(command);
     } catch {
       // Non-fatal — desktop notifications are best-effort
     }
   }).catch(() => {});
 }
 
+export function launchDesktopNotification(command: NotificationCommand): void {
+  try {
+    const child = childProcess.spawn(command.file, command.args, {
+      detached: true,
+      stdio: "ignore",
+    });
+    child.on("error", () => {});
+    child.unref();
+  } catch {
+    // Non-fatal — desktop notifications are best-effort
+  }
+}
+
 export function shouldSendDesktopNotification(
   kind: NotificationKind,
   preferences: NotificationPreferences | undefined = loadEffectiveGSDPreferences()?.preferences.notifications,
@@ -187,11 +211,25 @@ function escapeAppleScript(s: string): string {
  * Non-fatal — returns null on any error.
  */
 function findExecutable(name: string): string | null {
-  try {
-    return execFileSync("which", [name], { timeout: 2000, stdio: ["ignore", "pipe", "ignore"] }).toString().trim() || null;
-  } catch {
-    return null;
+  if (executablePathCache.has(name)) return executablePathCache.get(name) ?? null;
+
+  let resolved: string | null = null;
+  const path = process.env.PATH;
+  if (path) {
+    for (const dir of path.split(delimiter)) {
+      const candidate = resolve(dir || ".", name);
+      try {
+        accessSync(candidate, constants.X_OK);
+        resolved = candidate;
+        break;
+      } catch {
+        // keep searching PATH
+      }
+    }
   }
+
+  executablePathCache.set(name, resolved);
+  return resolved;
 }
 
 function resolveBellStream(): BellStream | null {

package/src/resources/extensions/gsd/observability-validator.ts

@@ -396,11 +396,15 @@ export async function validatePlanBoundary(basePath: string, milestoneId: string
 
   const tasksDir = resolveTasksDir(basePath, milestoneId, sliceId);
   const taskPlans = tasksDir ? resolveTaskFiles(tasksDir, "PLAN") : [];
-  for (const file of taskPlans) {
+  const taskPlanPaths = taskPlans.flatMap(file => {
     const taskId = file.split("-")[0];
     const taskPlan = resolveTaskFile(basePath, milestoneId, sliceId, taskId, "PLAN");
+    return taskPlan ? [taskPlan] : [];
+  });
+  const taskPlanContents = await Promise.all(taskPlanPaths.map(loadFile));
+  for (const [index, content] of taskPlanContents.entries()) {
+    const taskPlan = taskPlanPaths[index];
     if (!taskPlan) continue;
-    const content = await loadFile(taskPlan);
     if (content) issues.push(...validateTaskPlanContent(taskPlan, content));
   }
 
@@ -428,11 +432,15 @@ export async function validateCompleteBoundary(basePath: string, milestoneId: st
   const issues: ValidationIssue[] = [];
   const tasksDir = resolveTasksDir(basePath, milestoneId, sliceId);
   const taskSummaries = tasksDir ? resolveTaskFiles(tasksDir, "SUMMARY") : [];
-  for (const file of taskSummaries) {
+  const taskSummaryPaths = taskSummaries.flatMap(file => {
     const taskId = file.split("-")[0];
     const taskSummary = resolveTaskFile(basePath, milestoneId, sliceId, taskId, "SUMMARY");
+    return taskSummary ? [taskSummary] : [];
+  });
+  const taskSummaryContents = await Promise.all(taskSummaryPaths.map(loadFile));
+  for (const [index, content] of taskSummaryContents.entries()) {
+    const taskSummary = taskSummaryPaths[index];
     if (!taskSummary) continue;
-    const content = await loadFile(taskSummary);
     if (content) issues.push(...validateTaskSummaryContent(taskSummary, content));
   }
 

package/src/resources/extensions/gsd/parallel-eligibility.ts

@@ -5,11 +5,11 @@
  * dependency satisfaction and file overlap across slice plans.
  */
 
-import { existsSync } from "node:fs";
 import { deriveState } from "./state.js";
-import { resolveGsdPathContract, resolveMilestoneFile, resolveSliceFile } from "./paths.js";
+import { resolveMilestoneFile, resolveSliceFile } from "./paths.js";
 import { findMilestoneIds } from "./guided-flow.js";
-import { isDbAvailable, getMilestoneSlices, getSliceTasks, openDatabase } from "./gsd-db.js";
+import { isDbAvailable, getMilestoneSlices, getSliceTasks } from "./gsd-db.js";
+import { openExistingWorkflowDatabase } from "./db-workspace.js";
 import type { MilestoneRegistryEntry } from "./types.js";
 
 // ─── Types ───────────────────────────────────────────────────────────────────
@@ -98,8 +98,7 @@ export async function analyzeParallelEligibility(
   basePath: string,
 ): Promise<ParallelCandidates> {
   if (!isDbAvailable()) {
-    const { projectDb } = resolveGsdPathContract(basePath);
-    if (existsSync(projectDb)) openDatabase(projectDb);
+    openExistingWorkflowDatabase(basePath);
   }
 
   const milestoneIds = findMilestoneIds(basePath);