gsd-pi 2.78.1-dev.84a383f51 → 2.78.1

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

@@ -320,8 +320,11 @@ export function getEligibleModels(
     // Exact match
     if (availableModelIds.includes(explicitModel)) return [explicitModel];
     // Provider-prefix-stripped match
-    const bareExplicit = bareModelId(explicitModel);
-    const match = availableModelIds.find(id => bareModelId(id) === bareExplicit);
+    const match = availableModelIds.find(id => {
+      const bareAvail = id.includes("/") ? id.split("/").pop()! : id;
+      const bareExplicit = explicitModel.includes("/") ? explicitModel.split("/").pop()! : explicitModel;
+      return bareAvail === bareExplicit;
+    });
     if (match) return [match];
   }
 
@@ -427,38 +430,12 @@ export function resolveModelForComplexity(
 
   // Downgrade-only: if requested tier >= configured tier, no change
   if (tierOrdinal(requestedTier) >= tierOrdinal(configuredTier)) {
-    // If the configured primary is directly available, use it
-    if (isModelAvailable(configuredPrimary, availableModelIds)) {
-      return {
-        modelId: configuredPrimary,
-        fallbacks: phaseConfig.fallbacks,
-        tier: requestedTier,
-        wasDowngraded: false,
-        reason: `tier ${requestedTier} >= configured ${configuredTier}`,
-        selectionMethod: "tier-only",
-      };
-    }
-
-    // Configured primary is unavailable (e.g. Anthropic model configured but
-    // running on a non-Anthropic provider). Find the best available model at
-    // the same capability tier so routing still works cross-provider.
-    const crossProviderEquivalent = findModelForTier(
-      configuredTier,
-      routingConfig,
-      availableModelIds,
-      routingConfig.cross_provider !== false,
-    );
-
     return {
-      modelId: crossProviderEquivalent ?? configuredPrimary,
-      fallbacks: crossProviderEquivalent
-        ? [...phaseConfig.fallbacks.filter(f => f !== crossProviderEquivalent), configuredPrimary]
-        : phaseConfig.fallbacks,
+      modelId: configuredPrimary,
+      fallbacks: phaseConfig.fallbacks,
       tier: requestedTier,
       wasDowngraded: false,
-      reason: crossProviderEquivalent
-        ? `cross-provider ${configuredTier}-tier equivalent`
-        : `tier ${requestedTier} >= configured ${configuredTier}`,
+      reason: `tier ${requestedTier} >= configured ${configuredTier}`,
       selectionMethod: "tier-only",
     };
   }
@@ -542,131 +519,8 @@ export function defaultRoutingConfig(): DynamicRoutingConfig {
   };
 }
 
-// ─── Tier-Based Model Resolution (for profile defaults) ─────────────────────
-
-/**
- * Fallback-only canonical model IDs per tier. Returned 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.
- *
- * 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
- */
-const CANONICAL_TIER_MODELS: Record<ComplexityTier, string> = {
-  light: "claude-haiku-4-5",
-  standard: "claude-sonnet-4-6",
-  heavy: "claude-opus-4-6",
-};
-
-export function canonicalModelForTier(tier: ComplexityTier): string {
-  return CANONICAL_TIER_MODELS[tier];
-}
-
-/**
- * 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.
- *
- * `crossProvider`: when false, restricts the search to models that share the
- * canonical (Anthropic) provider for the tier. When true, any provider is
- * eligible.
- */
-function findModelForTier(
-  tier: ComplexityTier,
-  routingConfig: DynamicRoutingConfig,
-  availableModelIds: string[],
-  crossProvider: boolean,
-): string | undefined {
-  const eligible = getEligibleModels(tier, availableModelIds, routingConfig);
-  if (eligible.length === 0) return undefined;
-
-  if (crossProvider) {
-    return eligible[0];
-  }
-
-  // Same-provider only: keep models whose bare ID matches a canonical
-  // Anthropic ID at this tier (i.e., a claude-* model in the tier map).
-  const sameProvider = eligible.filter(id => {
-    const bare = bareModelId(id);
-    return MODEL_CAPABILITY_TIER[bare] === tier && bare.startsWith("claude-");
-  });
-  return sameProvider[0];
-}
-
-/**
- * Resolve a concrete model ID for a given capability tier using the
- * available model list. Provider-agnostic: picks the best available
- * model at the requested tier.
- *
- * 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)
- *
- * @param tier              The capability tier to resolve
- * @param availableModelIds List of available model IDs (REQUIRED for
- *                          provider-agnostic resolution; pass [] only when
- *                          the model registry is genuinely unavailable)
- * @param routingConfig     Optional routing config, or legacy crossProvider boolean
- * @param crossProvider     Whether to consider models from other providers
- */
-export function resolveModelForTier(
-  tier: ComplexityTier,
-  availableModelIds: string[],
-  crossProvider?: boolean,
-): string;
-export function resolveModelForTier(
-  tier: ComplexityTier,
-  availableModelIds: string[],
-  routingConfig?: DynamicRoutingConfig,
-  crossProvider?: boolean,
-): string;
-export function resolveModelForTier(
-  tier: ComplexityTier,
-  availableModelIds: string[],
-  routingConfigOrCrossProvider: DynamicRoutingConfig | boolean = defaultRoutingConfig(),
-  crossProvider?: boolean,
-): string {
-  const routingConfig = typeof routingConfigOrCrossProvider === "boolean"
-    ? defaultRoutingConfig()
-    : { ...defaultRoutingConfig(), ...routingConfigOrCrossProvider };
-  const allowCrossProvider = typeof routingConfigOrCrossProvider === "boolean"
-    ? routingConfigOrCrossProvider
-    : crossProvider ?? routingConfig.cross_provider !== false;
-
-  // No available models known — return canonical fallback
-  if (availableModelIds.length === 0) {
-    return canonicalModelForTier(tier);
-  }
-
-  // Cross-provider tier search
-  const resolved = findModelForTier(tier, routingConfig, availableModelIds, allowCrossProvider);
-  return resolved
-    ? normalizeResolvedTierModelId(resolved, tier, routingConfig)
-    : canonicalModelForTier(tier);
-}
-
 // ─── Internal ────────────────────────────────────────────────────────────────
 
-/**
- * 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").
- */
-function isModelAvailable(modelId: string, availableModelIds: string[]): boolean {
-  if (availableModelIds.includes(modelId)) return true;
-  // Strip provider prefix for comparison. Treat trailing-slash IDs ("provider/")
-  // as no-bare-ID rather than empty-string match (which would erroneously match
-  // any other "provider/" ID).
-  const bare = bareModelId(modelId);
-  if (!bare) return false;
-  return availableModelIds.some(id => bareModelId(id) === bare);
-}
-
 function getModelTier(modelId: string): ComplexityTier {
   // Strip provider prefix if present
   const bareId = bareModelId(modelId);
@@ -709,25 +563,8 @@ function getModelCost(modelId: string): number {
   return 999;
 }
 
-function normalizeResolvedTierModelId(
-  modelId: string,
-  tier: ComplexityTier,
-  routingConfig: DynamicRoutingConfig,
-): string {
-  const explicitModel = routingConfig.tier_models?.[tier];
-  if (explicitModel?.includes("/")) {
-    return modelId;
-  }
-
-  const bareId = bareModelId(modelId);
-  return MODEL_CAPABILITY_TIER[bareId] ? bareId : modelId;
-}
-
 function bareModelId(modelId: string): string {
-  if (!modelId.includes("/")) return modelId;
-  // .pop() never returns undefined on a non-empty string but ?? guards future
-  // refactors and avoids the misleading non-null assertion.
-  return modelId.split("/").pop() ?? modelId;
+  return modelId.includes("/") ? modelId.split("/").pop()! : modelId;
 }
 
 // ─── Provider-specific Tool Limits ─────────────────────────────────────────

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

@@ -11,7 +11,6 @@ import { join } from "node:path";
 import { GSDError, GSD_GIT_ERROR } from "./errors.js";
 import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
 import { getErrorMessage } from "./error-utils.js";
-import { isInfrastructureError } from "./auto/infra-errors.js";
 
 // Issue #453: keep auto-mode bookkeeping on the stable git CLI path unless a
 // caller explicitly opts into the native helper.
@@ -847,10 +846,6 @@ export function nativeAddAllWithExclusions(basePath: string, exclusions: readonl
     });
   } catch (err: unknown) {
     const stderr = (err as { stderr?: string })?.stderr ?? "";
-    const infraCode = isInfrastructureError(err) ?? isInfrastructureError(stderr);
-    if (infraCode) {
-      throw err;
-    }
     // git exits 1 when pathspec exclusions reference paths already covered
     // by .gitignore. The staging itself succeeds — only suppress that case.
     if (stderr.includes("ignored by one of your .gitignore files")) {
@@ -865,8 +860,7 @@ export function nativeAddAllWithExclusions(basePath: string, exclusions: readonl
       fallbackStageWithSymlinkedDotGsd(basePath);
       return;
     }
-    const stderrDetail = stderr.trim() ? `; stderr: ${stderr.trim()}` : "";
-    throw new GSDError(GSD_GIT_ERROR, `git add -A with exclusions failed in ${basePath}: ${getErrorMessage(err)}${stderrDetail}`);
+    throw new GSDError(GSD_GIT_ERROR, `git add -A with exclusions failed in ${basePath}: ${getErrorMessage(err)}`);
   }
 }
 

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

@@ -10,8 +10,7 @@ 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 { canonicalModelForTier, defaultRoutingConfig, resolveModelForTier } from "./model-router.js";
-import type { ComplexityTier } from "./complexity-classifier.js";
+import { defaultRoutingConfig } from "./model-router.js";
 import type { TokenProfile, InlineLevel } from "./types.js";
 
 import type {
@@ -44,7 +43,7 @@ export function resolveModelForUnit(unitType: string): string | undefined {
  * - Extended: `planning: { model: claude-opus-4-6, fallbacks: [glm-5, minimax-m2.5] }`
  */
 export function resolveModelWithFallbacksForUnit(unitType: string): ResolvedModelConfig | undefined {
-  const prefs = loadEffectiveGSDPreferences(undefined, { availableModelIds: [] });
+  const prefs = loadEffectiveGSDPreferences();
   if (!prefs?.preferences.models) return undefined;
   const m = prefs.preferences.models as GSDModelConfigV2;
 
@@ -133,7 +132,7 @@ export function resolveModelWithFallbacksForUnit(unitType: string): ResolvedMode
 export function resolveDefaultSessionModel(
   sessionProvider?: string,
 ): { provider: string; id: string } | undefined {
-  const prefs = loadEffectiveGSDPreferences(undefined, { availableModelIds: [] });
+  const prefs = loadEffectiveGSDPreferences();
   if (!prefs?.preferences.models) return undefined;
 
   const m = prefs.preferences.models as GSDModelConfigV2;
@@ -359,86 +358,22 @@ export function resolveAutoSupervisorConfig(): AutoSupervisorConfig {
 
 const VALID_TOKEN_PROFILES = new Set<TokenProfile>(["budget", "balanced", "quality", "burn-max"]);
 
-/**
- * Per-phase tier intentions for each token profile.
- * Profiles express capability tiers, not model IDs. Concrete model
- * resolution happens at runtime via resolveModelForTier() which is
- * provider-agnostic — it picks the best available model at each tier.
- */
-const PROFILE_TIER_MAP: Record<TokenProfile, Record<string, ComplexityTier>> = {
-  budget: {
-    planning: "standard",
-    research: "light",
-    execution: "standard",
-    execution_simple: "light",
-    completion: "light",
-    subagent: "light",
-  },
-  balanced: {
-    planning: "standard",
-    research: "standard",
-    execution: "standard",
-    execution_simple: "light",
-    completion: "light",
-    subagent: "light",
-  },
-  quality: {
-    planning: "heavy",
-    research: "standard",
-    execution: "standard",
-    execution_simple: "light",
-    completion: "light",
-    subagent: "standard",
-  },
-  // burn-max intentionally omits a tier map: it never writes model defaults
-  // (it preserves the user's explicit model selection), so resolveProfileDefaults
-  // skips model resolution for this profile.
-  "burn-max": {},
-};
-
 /**
  * Resolve profile defaults for a given token profile tier.
  * Returns a partial GSDPreferences that is used as the base layer --
  * explicit user preferences always override these defaults.
- *
- * Model IDs are resolved from capability tiers, not hardcoded to any
- * provider. When available models are known (runtime), the resolver picks
- * the best match across all configured providers. When not known (e.g.,
- * early startup), falls back to canonical Anthropic model IDs.
- *
- * @param profile           The token profile to resolve
- * @param availableModelIds Optional list of available model IDs for cross-provider resolution.
- *                          Undefined means the registry is unavailable.
- * @param routingConfig     Optional routing config for tier model pins.
  */
-export function resolveProfileDefaults(
-  profile: TokenProfile,
-  availableModelIds?: string[],
-  routingConfig: DynamicRoutingConfig = defaultRoutingConfig(),
-): Partial<GSDPreferences> {
-  // burn-max never writes model defaults — preserve user-selected models.
-  // For the other three profiles, derive concrete model IDs from the tier map
-  // against the available-model list when the registry is provided. If callers
-  // omit the registry entirely, use canonical fallbacks explicitly.
-  const tierMap = PROFILE_TIER_MAP[profile];
-  const resolveTierModel = (tier: ComplexityTier): string => Array.isArray(availableModelIds)
-    ? resolveModelForTier(tier, availableModelIds, routingConfig)
-    : canonicalModelForTier(tier);
-  const models: GSDModelConfigV2 | undefined = profile === "burn-max"
-    ? undefined
-    : {
-        planning: resolveTierModel(tierMap.planning),
-        research: resolveTierModel(tierMap.research),
-        execution: resolveTierModel(tierMap.execution),
-        execution_simple: resolveTierModel(tierMap.execution_simple),
-        completion: resolveTierModel(tierMap.completion),
-        subagent: resolveTierModel(tierMap.subagent),
-      };
-
+export function resolveProfileDefaults(profile: TokenProfile): Partial<GSDPreferences> {
   switch (profile) {
     case "budget":
       return {
-        models,
+        models: {
+          planning: "claude-sonnet-4-5-20250514",
+          execution: "claude-sonnet-4-5-20250514",
+          execution_simple: "claude-haiku-4-5-20250414",
+          completion: "claude-haiku-4-5-20250414",
+          subagent: "claude-haiku-4-5-20250414",
+        },
         phases: {
           skip_research: true,
           skip_reassess: true,
@@ -448,7 +383,9 @@ export function resolveProfileDefaults(
       };
     case "balanced":
       return {
-        models,
+        models: {
+          subagent: "claude-sonnet-4-5-20250514",
+        },
         phases: {
           skip_research: true,
           skip_reassess: true,
@@ -457,7 +394,7 @@ export function resolveProfileDefaults(
       };
     case "quality":
       return {
-        models,
+        models: {},
         phases: {
           skip_research: true,
           skip_slice_research: true,
@@ -483,14 +420,6 @@ export function resolveProfileDefaults(
   }
 }
 
-/**
- * Get the tier intentions for a profile without resolving to model IDs.
- * Useful for display, debugging, and testing.
- */
-export function getProfileTierMap(profile: TokenProfile): Record<string, ComplexityTier> {
-  return { ...PROFILE_TIER_MAP[profile] };
-}
-
 /**
  * Resolve the effective token profile from preferences.
  * Returns "balanced" when no profile is set (D046).
@@ -536,18 +465,3 @@ export function resolveSearchProviderFromPreferences(): GSDPreferences["search_p
   const prefs = loadEffectiveGSDPreferences();
   return prefs?.preferences.search_provider;
 }
-
-/**
- * Resolve provider IDs excluded from model selection/routing.
- * Returns a normalized, de-duplicated list.
- */
-export function resolveDisabledModelProvidersFromPreferences(): string[] {
-  const prefs = loadEffectiveGSDPreferences();
-  const raw = prefs?.preferences.disabled_model_providers;
-  if (!Array.isArray(raw)) return [];
-  return Array.from(new Set(
-    raw
-      .map((provider) => provider.trim())
-      .filter((provider) => provider.length > 0),
-  ));
-}

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

@@ -114,7 +114,6 @@ export const KNOWN_PREFERENCE_KEYS = new Set<string>([
   "post_unit_hooks",
   "pre_dispatch_hooks",
   "dynamic_routing",
-  "disabled_model_providers",
   "uok",
   "token_profile",
   "phases",
@@ -133,7 +132,6 @@ export const KNOWN_PREFERENCE_KEYS = new Set<string>([
   "service_tier",
   "forensics_dedup",
   "show_token_cost",
-  "min_request_interval_ms",
   "stale_commit_threshold_minutes",
   "context_management",
   "experimental",
@@ -322,8 +320,6 @@ export interface GSDPreferences {
   post_unit_hooks?: PostUnitHookConfig[];
   pre_dispatch_hooks?: PreDispatchHookConfig[];
   dynamic_routing?: DynamicRoutingConfig;
-  /** Provider IDs to exclude from /model and automatic model routing while leaving tool auth intact. */
-  disabled_model_providers?: string[];
   /** Unified Orchestration Kernel controls (default-on, with opt-out and emergency legacy fallback). */
   uok?: UokPreferences;
   /** Per-model capability overrides. Deep-merged with built-in profiles for capability-aware routing (ADR-004). */
@@ -369,8 +365,6 @@ export interface GSDPreferences {
   forensics_dedup?: boolean;
   /** Opt-in: show per-prompt and cumulative session token cost in the footer. Default: false. */
   show_token_cost?: boolean;
-  /** Proactive rate limiting: minimum milliseconds between auto-mode LLM requests. Prevents 429s on rate-limited providers. 0 = disabled (default). */
-  min_request_interval_ms?: number;
   /**
    * Minutes without a commit before flagging uncommitted changes as stale.
    * When the threshold is exceeded and the working tree is dirty, doctor will

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

@@ -610,27 +610,6 @@ export function validatePreferences(preferences: GSDPreferences): {
     }
   }
 
-  // ─── Disabled Model Providers ───────────────────────────────────────
-  if (preferences.disabled_model_providers !== undefined) {
-    if (Array.isArray(preferences.disabled_model_providers)) {
-      const allStrings = preferences.disabled_model_providers.every(
-        (provider: unknown) => typeof provider === "string",
-      );
-      if (!allStrings) {
-        errors.push("disabled_model_providers must be an array of strings");
-      } else {
-        const normalized = preferences.disabled_model_providers
-          .map((provider) => provider.trim())
-          .filter((provider) => provider.length > 0);
-        if (normalized.length > 0) {
-          validated.disabled_model_providers = Array.from(new Set(normalized));
-        }
-      }
-    } else {
-      errors.push("disabled_model_providers must be an array of strings");
-    }
-  }
-
   // ─── Context Management ──────────────────────────────────────────────
   if (preferences.context_management !== undefined) {
     if (typeof preferences.context_management === "object" && preferences.context_management !== null) {
@@ -1122,20 +1101,6 @@ export function validatePreferences(preferences: GSDPreferences): {
     }
   }
 
-  // ─── Auto-Mode Request Interval ───────────────────────────────────
-  if (preferences.min_request_interval_ms !== undefined) {
-    if (
-      typeof preferences.min_request_interval_ms === "number" &&
-      Number.isFinite(preferences.min_request_interval_ms) &&
-      preferences.min_request_interval_ms >= 0 &&
-      preferences.min_request_interval_ms <= 2_147_483_647
-    ) {
-      validated.min_request_interval_ms = Math.floor(preferences.min_request_interval_ms);
-    } else {
-      errors.push("min_request_interval_ms must be a non-negative number <= 2147483647");
-    }
-  }
-
   // ─── Experimental Features ────────────────────────────────────────
   if (preferences.experimental !== undefined) {
     if (typeof preferences.experimental === "object" && preferences.experimental !== null) {

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

@@ -89,12 +89,10 @@ export {
   resolveDynamicRoutingConfig,
   resolveAutoSupervisorConfig,
   resolveProfileDefaults,
-  getProfileTierMap,
   resolveEffectiveProfile,
   resolveInlineLevel,
   resolveContextSelection,
   resolveSearchProviderFromPreferences,
-  resolveDisabledModelProvidersFromPreferences,
 } from "./preferences-models.js";
 
 // ─── Path Constants & Getters ───────────────────────────────────────────────
@@ -148,10 +146,7 @@ export function loadProjectGSDPreferences(basePath?: string): LoadedGSDPreferenc
     ?? loadPreferencesFile(legacyProjectPreferencesPathLowercase(basePath), "project");
 }
 
-export function loadEffectiveGSDPreferences(
-  basePath?: string,
-  opts?: { availableModelIds?: string[] },
-): LoadedGSDPreferences | null {
+export function loadEffectiveGSDPreferences(basePath?: string): LoadedGSDPreferences | null {
   const globalPreferences = loadGlobalGSDPreferences();
   const projectPreferences = loadProjectGSDPreferences(basePath);
 
@@ -180,11 +175,7 @@ export function loadEffectiveGSDPreferences(
   // Explicit user preferences always override profile defaults.
   const profile = result.preferences.token_profile as TokenProfile | undefined;
   if (profile) {
-    const profileDefaults = _resolveProfileDefaults(
-      profile,
-      opts?.availableModelIds,
-      result.preferences.dynamic_routing,
-    );
+    const profileDefaults = _resolveProfileDefaults(profile);
     result = {
       ...result,
       preferences: mergePreferences(profileDefaults as GSDPreferences, result.preferences),
@@ -389,10 +380,6 @@ function mergePreferences(base: GSDPreferences, override: GSDPreferences): GSDPr
     dynamic_routing: (base.dynamic_routing || override.dynamic_routing)
       ? { ...(base.dynamic_routing ?? {}), ...(override.dynamic_routing ?? {}) } as DynamicRoutingConfig
       : undefined,
-    disabled_model_providers: mergeStringLists(
-      base.disabled_model_providers,
-      override.disabled_model_providers,
-    ),
     uok: (base.uok || override.uok)
       ? {
           enabled: override.uok?.enabled ?? base.uok?.enabled,
@@ -446,7 +433,6 @@ function mergePreferences(base: GSDPreferences, override: GSDPreferences): GSDPr
     service_tier: override.service_tier ?? base.service_tier,
     forensics_dedup: override.forensics_dedup ?? base.forensics_dedup,
     show_token_cost: override.show_token_cost ?? base.show_token_cost,
-    min_request_interval_ms: override.min_request_interval_ms ?? base.min_request_interval_ms,
     codebase: (base.codebase || override.codebase)
       ? {
           ...(base.codebase ?? {}),

package/src/resources/extensions/gsd/prompt-loader.ts

@@ -7,13 +7,14 @@
  * Templates live at prompts/ relative to this module's directory.
  * They use {{variableName}} syntax for substitution.
  *
- * Templates are snapshotted shortly after module init via warmCache().
- * This keeps import/extension-registration fast while still preventing a
- * running session from being invalidated when another `gsd` launch overwrites
- * ~/.gsd/agent/ with newer templates via initResources(). Without caching, the
- * in-memory extension code (which knows variable set A) can read a newer
- * template from disk (which expects variable set B), causing a
- * "template declares {{X}} but no value was provided" crash mid-session.
+ * All templates are eagerly loaded into cache at module init via warmCache().
+ * This prevents a running session from being invalidated when another `gsd`
+ * launch overwrites ~/.gsd/agent/ with newer templates via initResources().
+ * Without eager caching, the in-memory extension code (which knows variable
+ * set A) can read a newer template from disk (which expects variable set B),
+ * causing a "template declares {{X}} but no value was provided" crash
+ * mid-session — especially for late-loading templates like complete-milestone
+ * that aren't read until the end of a long auto-mode run.
  */
 
 import { readFileSync, readdirSync, existsSync } from "node:fs";
@@ -81,8 +82,8 @@ export function getTemplatesDir(): string {
   return templatesDir;
 }
 
-// Cache all templates from a startup snapshot — a running session uses the
-// template versions that were on disk near startup, immune to later overwrites.
+// Cache all templates eagerly at module load — a running session uses the
+// template versions that were on disk at startup, immune to later overwrites.
 const templateCache = new Map<string, string>();
 
 /**
@@ -123,23 +124,8 @@ function warmCache(): void {
   }
 }
 
-let warmCacheScheduled = false;
-
-function scheduleWarmCache(): void {
-  if (warmCacheScheduled) return;
-  warmCacheScheduled = true;
-
-  const run = () => {
-    warmCache();
-  };
-
-  const timer = setTimeout(run, 1000);
-  timer.unref?.();
-}
-
-// Snapshot the full prompt/template tree after import so extension startup only
-// pays for prompts that are actually needed immediately.
-scheduleWarmCache();
+// Snapshot all templates at module load time
+warmCache();
 
 /**
  * Load a prompt template and substitute variables.

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

@@ -82,7 +82,6 @@ let sliceState: SliceOrchestratorState | null = null;
 
 const SLICE_ORCHESTRATOR_STATE_FILE = "slice-orchestrator.json";
 const TMP_SUFFIX = ".tmp";
-export const SLICE_WORKER_AUTO_ARGS = ["headless", "--json", "auto"] as const;
 
 interface PersistedSliceWorker {
   milestoneId: string;
@@ -357,7 +356,7 @@ export function getSliceOrchestratorState(): SliceOrchestratorState | null {
 /**
  * Start parallel execution for eligible slices within a milestone.
  *
- * For each eligible slice: create a worktree, spawn `gsd headless --json auto`
+ * For each eligible slice: create a worktree, spawn `gsd --mode json --print "/gsd auto"`
  * with env GSD_SLICE_LOCK=<SID> + GSD_MILESTONE_LOCK=<MID> + GSD_PARALLEL_WORKER=1.
  */
 export async function startSliceParallel(
@@ -599,13 +598,8 @@ function resolveGsdBin(): string | null {
 
 /**
  * Spawn a worker process for a slice.
- * The worker runs `gsd headless --json auto` in the slice's worktree
+ * The worker runs `gsd --mode json --print "/gsd auto"` in the slice's worktree
  * with GSD_SLICE_LOCK, GSD_MILESTONE_LOCK, and GSD_PARALLEL_WORKER set.
- *
- * Print-mode slash commands return after the command handler schedules
- * auto-mode, so the worker process can exit before doing any LLM work. The
- * headless auto entrypoint keeps the process alive until auto-mode reaches a
- * terminal notification, matching milestone-level parallel workers.
  */
 function spawnSliceWorker(
   basePath: string,
@@ -622,7 +616,7 @@ function spawnSliceWorker(
 
   let child: ChildProcess;
   try {
-    child = spawn(process.execPath, [binPath, ...SLICE_WORKER_AUTO_ARGS], {
+    child = spawn(process.execPath, [binPath, "--mode", "json", "--print", "/gsd auto"], {
       cwd: worker.worktreePath,
       env: {
         ...process.env,