gsd-pi 2.78.0 → 2.78.1-dev.82bcf6b71

package/dist/resources/extensions/gsd/guided-flow.js

@@ -18,6 +18,7 @@ import { clearLock } from "./crash-recovery.js";
 import { assessInterruptedSession, formatInterruptedSessionRunningMessage, formatInterruptedSessionSummary, } from "./interrupted-session.js";
 import { listUnitRuntimeRecords, clearUnitRuntimeRecord } from "./unit-runtime.js";
 import { resolveExpectedArtifactPath } from "./auto.js";
+import { getHomeDir } from "./home-dir.js";
 import { gsdRoot, milestonesDir, resolveMilestoneFile, resolveSliceFile, resolveSlicePath, resolveGsdRootFile, relGsdRootFile, relMilestoneFile, relSliceFile, } from "./paths.js";
 import { join } from "node:path";
 import { readFileSync, existsSync, mkdirSync, readdirSync, unlinkSync } from "node:fs";
@@ -33,7 +34,9 @@ import { showProjectInit, offerMigration } from "./init-wizard.js";
 import { validateDirectory } from "./validate-directory.js";
 import { showConfirm } from "../shared/tui.js";
 import { debugLog } from "./debug-logger.js";
-import { findMilestoneIds, nextMilestoneId, reserveMilestoneId, getReservedMilestoneIds, clearReservedMilestoneIds } from "./milestone-ids.js";
+import { findMilestoneIds, clearReservedMilestoneIds } from "./milestone-ids.js";
+import { nextMilestoneIdReserved } from "./milestone-id-reservation.js";
+export { nextMilestoneIdReserved } from "./milestone-id-reservation.js";
 import { parkMilestone, discardMilestone } from "./milestone-actions.js";
 import { selectAndApplyModel } from "./auto-model-selection.js";
 import { DISCUSS_TOOLS_ALLOWLIST } from "./constants.js";
@@ -43,18 +46,6 @@ import { runPreparation, formatCodebaseBrief, formatPriorContextBrief, } from ".
 export { MILESTONE_ID_RE, generateMilestoneSuffix, nextMilestoneId, extractMilestoneSeq, parseMilestoneId, milestoneIdSort, maxMilestoneNum, findMilestoneIds, reserveMilestoneId, claimReservedId, getReservedMilestoneIds, clearReservedMilestoneIds, } from "./milestone-ids.js";
 export { showQueue, handleQueueReorder, showQueueAdd, buildExistingMilestonesContext, } from "./guided-flow-queue.js";
 import { logWarning } from "./workflow-logger.js";
-// ─── ID Generation with Reservation ─────────────────────────────────────────
-/**
- * Generate the next milestone ID, accounting for reserved IDs, and reserve it.
- * Ensures any preview ID shown in the UI matches what `gsd_milestone_generate_id`
- * will later return.
- */
-function nextMilestoneIdReserved(existingIds, uniqueEnabled) {
-    const allIds = [...new Set([...existingIds, ...getReservedMilestoneIds()])];
-    const id = nextMilestoneId(allIds, uniqueEnabled);
-    reserveMilestoneId(id);
-    return id;
-}
 function needsPlanV2Gate(state) {
     return state.phase === "executing"
         || state.phase === "summarizing"
@@ -505,7 +496,7 @@ async function dispatchWorkflow(pi, note, customType = "gsd-run", ctx, unitType)
             removed: currentTools.length - scopedTools.length,
         });
     }
-    const workflowPath = process.env.GSD_WORKFLOW_PATH ?? join(process.env.HOME ?? "~", ".gsd", "agent", "GSD-WORKFLOW.md");
+    const workflowPath = process.env.GSD_WORKFLOW_PATH ?? join(getHomeDir(), ".gsd", "agent", "GSD-WORKFLOW.md");
     const workflow = readFileSync(workflowPath, "utf-8");
     pi.sendMessage({
         customType,
@@ -675,13 +666,17 @@ export async function showHeadlessMilestoneCreation(ctx, pi, basePath, seedConte
     clearReservedMilestoneIds();
     // Ensure .gsd/ is bootstrapped
     bootstrapGsdProject(basePath);
+    const { ensureDbOpen } = await import("./bootstrap/dynamic-tools.js");
+    await ensureDbOpen(basePath);
     // Generate next milestone ID
     const existingIds = findMilestoneIds(basePath);
     const prefs = loadEffectiveGSDPreferences();
-    const nextId = nextMilestoneIdReserved(existingIds, prefs?.preferences?.unique_milestone_ids ?? false);
-    // Create milestone directory
-    const milestoneDir = join(gsdRoot(basePath), "milestones", nextId, "slices");
-    mkdirSync(milestoneDir, { recursive: true });
+    const nextId = nextMilestoneIdReserved(existingIds, prefs?.preferences?.unique_milestone_ids ?? false, basePath);
+    // Fix #4996: Do NOT pre-create the milestone directory here.
+    // atomicWriteAsync (used by all artifact writers) calls mkdir lazily before
+    // each write, so every path through saveArtifactToDb / saveFile is already
+    // lazy-mkdir-safe. Pre-creating the dir before the discuss flow runs leaves
+    // an orphan stub if discuss is abandoned — that stub later skews nextMilestoneId.
     // Build and dispatch the headless discuss prompt
     const prompt = buildHeadlessDiscussPrompt(nextId, seedContext, basePath);
     // Set pending auto start (auto-mode triggers on "Milestone X ready." via checkAutoStartAfterDiscuss)
@@ -865,9 +860,11 @@ export async function showDiscuss(ctx, pi, basePath) {
             }), "gsd-discuss", ctx, "discuss-milestone");
         }
         else if (choice === "skip_milestone") {
+            const { ensureDbOpen } = await import("./bootstrap/dynamic-tools.js");
+            await ensureDbOpen(basePath);
             const milestoneIds = findMilestoneIds(basePath);
             const uniqueMilestoneIds = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
-            const nextId = nextMilestoneIdReserved(milestoneIds, uniqueMilestoneIds);
+            const nextId = nextMilestoneIdReserved(milestoneIds, uniqueMilestoneIds, basePath);
             pendingAutoStartMap.set(basePath, { ctx, pi, basePath, milestoneId: nextId, step: false, createdAt: Date.now() });
             await dispatchWorkflow(pi, await prepareAndBuildDiscussPrompt(ctx, pi, nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "discuss-milestone");
         }
@@ -1223,7 +1220,7 @@ async function handleMilestoneActions(ctx, pi, basePath, milestoneId, milestoneT
     if (choice === "skip") {
         const milestoneIds = findMilestoneIds(basePath);
         const uniqueMilestoneIds = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
-        const nextId = nextMilestoneIdReserved(milestoneIds, uniqueMilestoneIds);
+        const nextId = nextMilestoneIdReserved(milestoneIds, uniqueMilestoneIds, basePath);
         pendingAutoStartMap.set(basePath, { ctx, pi, basePath, milestoneId: nextId, step: stepMode, createdAt: Date.now() });
         await dispatchWorkflow(pi, await prepareAndBuildDiscussPrompt(ctx, pi, nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "discuss-milestone");
         return true;
@@ -1291,6 +1288,10 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
     // ── Ensure .gitignore has baseline patterns ──────────────────────────
     ensureGitignore(basePath);
     untrackRuntimeFiles(basePath);
+    {
+        const { ensureDbOpen } = await import("./bootstrap/dynamic-tools.js");
+        await ensureDbOpen(basePath);
+    }
     // ── Self-heal stale runtime records from crashed auto-mode sessions ──
     selfHealRuntimeRecords(basePath, ctx);
     const interrupted = await assessInterruptedSession(basePath);
@@ -1388,7 +1389,7 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
             }
         }
         const uniqueMilestoneIds = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
-        const nextId = nextMilestoneIdReserved(milestoneIds, uniqueMilestoneIds);
+        const nextId = nextMilestoneIdReserved(milestoneIds, uniqueMilestoneIds, basePath);
         const isFirst = milestoneIds.length === 0;
         if (isFirst) {
             // First ever — skip wizard, just ask directly
@@ -1446,7 +1447,7 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
         if (choice === "new_milestone") {
             const milestoneIds = findMilestoneIds(basePath);
             const uniqueMilestoneIds = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
-            const nextId = nextMilestoneIdReserved(milestoneIds, uniqueMilestoneIds);
+            const nextId = nextMilestoneIdReserved(milestoneIds, uniqueMilestoneIds, basePath);
             pendingAutoStartMap.set(basePath, { ctx, pi, basePath, milestoneId: nextId, step: stepMode, createdAt: Date.now() });
             await dispatchWorkflow(pi, await prepareAndBuildDiscussPrompt(ctx, pi, nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "discuss-milestone");
         }
@@ -1510,7 +1511,7 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
         else if (choice === "skip_milestone") {
             const milestoneIds = findMilestoneIds(basePath);
             const uniqueMilestoneIds = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
-            const nextId = nextMilestoneIdReserved(milestoneIds, uniqueMilestoneIds);
+            const nextId = nextMilestoneIdReserved(milestoneIds, uniqueMilestoneIds, basePath);
             pendingAutoStartMap.set(basePath, { ctx, pi, basePath, milestoneId: nextId, step: stepMode, createdAt: Date.now() });
             await dispatchWorkflow(pi, await prepareAndBuildDiscussPrompt(ctx, pi, nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "discuss-milestone");
         }
@@ -1600,7 +1601,7 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
             else if (choice === "skip_milestone") {
                 const milestoneIds = findMilestoneIds(basePath);
                 const uniqueMilestoneIds = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
-                const nextId = nextMilestoneIdReserved(milestoneIds, uniqueMilestoneIds);
+                const nextId = nextMilestoneIdReserved(milestoneIds, uniqueMilestoneIds, basePath);
                 pendingAutoStartMap.set(basePath, { ctx, pi, basePath, milestoneId: nextId, step: stepMode, createdAt: Date.now() });
                 await dispatchWorkflow(pi, await prepareAndBuildDiscussPrompt(ctx, pi, nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "discuss-milestone");
             }

package/dist/resources/extensions/gsd/home-dir.js

@@ -0,0 +1,16 @@
+/**
+ * Cross-platform home directory resolution.
+ *
+ * `process.env.HOME` is not set on Windows (CMD/PowerShell).
+ * Falls back to USERPROFILE, then os.homedir(), then throws.
+ *
+ * @see https://github.com/gsd-build/gsd-2/issues/5015
+ */
+import { homedir } from "node:os";
+export function getHomeDir() {
+    const home = process.env.HOME || process.env.USERPROFILE || homedir();
+    if (!home) {
+        throw new Error("Cannot resolve home directory. Set HOME or USERPROFILE environment variable.");
+    }
+    return home;
+}

package/dist/resources/extensions/gsd/key-manager.js

@@ -9,6 +9,7 @@ import { existsSync, statSync, chmodSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { mkdirSync } from "node:fs";
 import { getErrorMessage } from "./error-utils.js";
+import { getHomeDir } from "./home-dir.js";
 export const PROVIDER_REGISTRY = [
     // LLM Providers
     { id: "anthropic", label: "Anthropic (Claude)", category: "llm", envVar: "ANTHROPIC_API_KEY", prefixes: ["sk-ant-"], hasOAuth: true, dashboardUrl: "console.anthropic.com" },
@@ -98,7 +99,7 @@ export function describeCredential(cred) {
  * Get the auth.json path.
  */
 export function getAuthPath() {
-    return join(process.env.HOME ?? "~", ".gsd", "agent", "auth.json");
+    return join(getHomeDir(), ".gsd", "agent", "auth.json");
 }
 /**
  * Create an AuthStorage instance for key management.

package/dist/resources/extensions/gsd/memory-store.js

@@ -2,8 +2,9 @@
 //
 // Storage layer for auto-learned project memories. Follows context-store.ts patterns.
 // All functions degrade gracefully: return empty results when DB unavailable, never throw.
-import { isDbAvailable, _getAdapter, transaction, insertMemoryRow, rewriteMemoryId, updateMemoryContentRow, incrementMemoryHitCount, supersedeMemoryRow, markMemoryUnitProcessed, decayMemoriesBefore, supersedeLowestRankedMemories, deleteMemoryEmbedding, deleteMemoryRelationsFor, } from './gsd-db.js';
+import { isDbAvailable, _getAdapter, transaction, isInTransaction, insertMemoryRow, rewriteMemoryId, updateMemoryContentRow, incrementMemoryHitCount, supersedeMemoryRow, markMemoryUnitProcessed, decayMemoriesBefore, supersedeLowestRankedMemories, deleteMemoryEmbedding, deleteMemoryRelationsFor, } from './gsd-db.js';
 import { createMemoryRelation, isValidRelation } from './memory-relations.js';
+import { logWarning } from './workflow-logger.js';
 // ─── Category Display Order ─────────────────────────────────────────────────
 const CATEGORY_PRIORITY = {
     gotcha: 0,
@@ -367,7 +368,13 @@ export function nextMemoryId() {
  * Insert a new memory with a race-safe auto-assigned ID.
  * Uses AUTOINCREMENT seq to derive the ID after insert, avoiding
  * the read-then-write race in concurrent scenarios (e.g. worktrees).
- * Returns the assigned ID, or null on failure.
+ * Returns the assigned ID, or null when the DB is unavailable.
+ *
+ * Throws on genuine SQL errors (corruption, missing tables, constraint
+ * violations) so callers can surface the underlying message instead of
+ * collapsing the failure to a generic "create_failed". See issue #4967 —
+ * the previous bare-catch swallowed "database disk image is malformed"
+ * errors, leaving the memory subsystem broken without any signal.
  */
 export function createMemory(fields) {
     if (!isDbAvailable())
@@ -376,35 +383,57 @@ export function createMemory(fields) {
     if (!adapter)
         return null;
     try {
-        const now = new Date().toISOString();
-        // Insert with a temporary placeholder ID — seq is auto-assigned
-        const placeholder = `_TMP_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-        insertMemoryRow({
-            id: placeholder,
-            category: fields.category,
-            content: fields.content,
-            confidence: fields.confidence ?? 0.8,
-            sourceUnitType: fields.source_unit_type ?? null,
-            sourceUnitId: fields.source_unit_id ?? null,
-            createdAt: now,
-            updatedAt: now,
-            scope: fields.scope ?? 'project',
-            tags: fields.tags ?? [],
-            structuredFields: fields.structuredFields ?? null,
-        });
-        // Derive the real ID from the assigned seq (SELECT is still fine via adapter)
-        const row = adapter.prepare('SELECT seq FROM memories WHERE id = :id').get({ ':id': placeholder });
-        if (!row)
-            return placeholder; // fallback — should not happen
-        const seq = row['seq'];
-        const realId = `MEM${String(seq).padStart(3, '0')}`;
-        rewriteMemoryId(placeholder, realId);
-        return realId;
-    }
-    catch {
-        return null;
+        return transaction(() => doCreateMemory(adapter, fields));
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        // Targeted recovery: a malformed memory store can sometimes be rebuilt
+        // by VACUUM. Skip when inside a transaction — SQLite refuses VACUUM
+        // there and a secondary throw would mask the real fault.
+        if (message.toLowerCase().includes('malformed') && !isInTransaction()) {
+            try {
+                adapter.prepare('VACUUM').run();
+                const recoveryMessage = 'recovered malformed memory store via VACUUM';
+                process.stderr.write(`memory-store: ${recoveryMessage}\n`);
+                logWarning('memory-store', recoveryMessage);
+                return transaction(() => doCreateMemory(adapter, fields));
+            }
+            catch (retryErr) {
+                const retryMsg = retryErr instanceof Error ? retryErr.message : String(retryErr);
+                logWarning('memory-store', `VACUUM recovery for memory store failed: ${retryMsg}`);
+                // Surface the *original* malformed error — it's the actionable signal.
+                throw err;
+            }
+        }
+        throw err;
     }
 }
+function doCreateMemory(adapter, fields) {
+    const now = new Date().toISOString();
+    // Insert with a temporary placeholder ID — seq is auto-assigned
+    const placeholder = `_TMP_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    insertMemoryRow({
+        id: placeholder,
+        category: fields.category,
+        content: fields.content,
+        confidence: fields.confidence ?? 0.8,
+        sourceUnitType: fields.source_unit_type ?? null,
+        sourceUnitId: fields.source_unit_id ?? null,
+        createdAt: now,
+        updatedAt: now,
+        scope: fields.scope ?? 'project',
+        tags: fields.tags ?? [],
+        structuredFields: fields.structuredFields ?? null,
+    });
+    // Derive the real ID from the assigned seq (SELECT is still fine via adapter)
+    const row = adapter.prepare('SELECT seq FROM memories WHERE id = :id').get({ ':id': placeholder });
+    if (!row)
+        return placeholder; // fallback — should not happen
+    const seq = row['seq'];
+    const realId = `MEM${String(seq).padStart(3, '0')}`;
+    rewriteMemoryId(placeholder, realId);
+    return realId;
+}
 /**
  * Update a memory's content and optionally its confidence.
  */
@@ -591,8 +620,14 @@ export function applyMemoryActions(actions, unitType, unitId) {
             enforceMemoryCap();
         });
     }
-    catch {
-        // non-fatal — transaction will have rolled back
+    catch (err) {
+        // Non-fatal — the transaction has rolled back. We log a warning so a
+        // degraded memory subsystem (e.g. malformed store, missing tables) is
+        // visible to forensics instead of silently dropping every CREATE — see
+        // issue #4967, where this swallow combined with createMemory's bare
+        // catch hid SQLite corruption from the auto-mode flow entirely.
+        const message = err instanceof Error ? err.message : String(err);
+        logWarning('memory-store', `applyMemoryActions failed (memory subsystem degraded): ${message}`);
     }
 }
 // ─── LINK action ────────────────────────────────────────────────────────────

package/dist/resources/extensions/gsd/migrate/command.js

@@ -13,6 +13,7 @@ import { resolve, join, dirname } from "node:path";
 import { gsdRoot } from "../paths.js";
 import { fileURLToPath } from "node:url";
 import { showNextAction } from "../../shared/tui.js";
+import { getHomeDir } from "../home-dir.js";
 import { validatePlanningDirectory, parsePlanningDirectory, transformToGSD, generatePreview, writeGSDDirectory, } from "./index.js";
 /** Format preview stats for embedding in the review prompt. */
 function formatPreviewStats(preview) {
@@ -50,10 +51,10 @@ export async function handleMigrate(args, ctx, pi) {
     // Default to cwd when no args given; expand ~ to HOME
     let rawPath = args.trim() || ".";
     if (rawPath.startsWith("~/")) {
-        rawPath = join(process.env.HOME ?? "~", rawPath.slice(2));
+        rawPath = join(getHomeDir(), rawPath.slice(2));
     }
     else if (rawPath === "~") {
-        rawPath = process.env.HOME ?? "~";
+        rawPath = getHomeDir();
     }
     let sourcePath = resolve(process.cwd(), rawPath);
     if (!sourcePath.endsWith(".planning")) {

package/dist/resources/extensions/gsd/milestone-id-reservation.js

@@ -0,0 +1,36 @@
+import { isDbAvailable, getAllMilestones } from "./gsd-db.js";
+import { getReservedMilestoneIds, milestoneIdSort, nextMilestoneId, reserveMilestoneId, } from "./milestone-ids.js";
+import { isReusableGhostMilestone } from "./state.js";
+function getDatabaseMilestoneIds() {
+    if (!isDbAvailable())
+        return [];
+    return getAllMilestones().map((milestone) => milestone.id);
+}
+/**
+ * Generate the next milestone ID, accounting for DB rows and in-process
+ * reservations, and reserve it.
+ */
+export function nextMilestoneIdReserved(existingIds, uniqueEnabled, basePath) {
+    const reservedIds = getReservedMilestoneIds();
+    const allIds = [
+        ...new Set([
+            ...existingIds,
+            ...reservedIds,
+            ...getDatabaseMilestoneIds(),
+        ]),
+    ];
+    if (basePath) {
+        const sorted = [...allIds].sort(milestoneIdSort);
+        for (const candidate of sorted) {
+            if (reservedIds.has(candidate))
+                continue;
+            if (isReusableGhostMilestone(basePath, candidate)) {
+                reserveMilestoneId(candidate);
+                return candidate;
+            }
+        }
+    }
+    const id = nextMilestoneId(allIds, uniqueEnabled);
+    reserveMilestoneId(id);
+    return id;
+}

package/dist/resources/extensions/gsd/model-router.js

@@ -228,11 +228,8 @@ export function getEligibleModels(tier, availableModelIds, routingConfig) {
         if (availableModelIds.includes(explicitModel))
             return [explicitModel];
         // Provider-prefix-stripped match
-        const match = availableModelIds.find(id => {
-            const bareAvail = id.includes("/") ? id.split("/").pop() : id;
-            const bareExplicit = explicitModel.includes("/") ? explicitModel.split("/").pop() : explicitModel;
-            return bareAvail === bareExplicit;
-        });
+        const bareExplicit = bareModelId(explicitModel);
+        const match = availableModelIds.find(id => bareModelId(id) === bareExplicit);
         if (match)
             return [match];
     }
@@ -323,12 +320,31 @@ export function resolveModelForComplexity(classification, phaseConfig, routingCo
     }
     // 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: configuredPrimary,
-            fallbacks: phaseConfig.fallbacks,
+            modelId: crossProviderEquivalent ?? configuredPrimary,
+            fallbacks: crossProviderEquivalent
+                ? [...phaseConfig.fallbacks.filter(f => f !== crossProviderEquivalent), configuredPrimary]
+                : phaseConfig.fallbacks,
             tier: requestedTier,
             wasDowngraded: false,
-            reason: `tier ${requestedTier} >= configured ${configuredTier}`,
+            reason: crossProviderEquivalent
+                ? `cross-provider ${configuredTier}-tier equivalent`
+                : `tier ${requestedTier} >= configured ${configuredTier}`,
             selectionMethod: "tier-only",
         };
     }
@@ -404,7 +420,84 @@ export function defaultRoutingConfig() {
         hooks: true,
     };
 }
+// ─── 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 = {
+    light: "claude-haiku-4-5",
+    standard: "claude-sonnet-4-6",
+    heavy: "claude-opus-4-6",
+};
+export function canonicalModelForTier(tier) {
+    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, routingConfig, availableModelIds, crossProvider) {
+    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];
+}
+export function resolveModelForTier(tier, availableModelIds, routingConfigOrCrossProvider = defaultRoutingConfig(), crossProvider) {
+    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, availableModelIds) {
+    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) {
     // Strip provider prefix if present
     const bareId = bareModelId(modelId);
@@ -443,8 +536,20 @@ function getModelCost(modelId) {
     // Unknown cost — assume expensive to avoid routing to unknown cheap models
     return 999;
 }
+function normalizeResolvedTierModelId(modelId, tier, routingConfig) {
+    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) {
-    return modelId.includes("/") ? modelId.split("/").pop() : modelId;
+    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;
 }
 // ─── Provider-specific Tool Limits ─────────────────────────────────────────
 /**

package/dist/resources/extensions/gsd/native-git-bridge.js

@@ -10,6 +10,7 @@ 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.
 const NATIVE_GSD_GIT_ENABLED = process.env.GSD_ENABLE_NATIVE_GSD_GIT === "1";
@@ -695,6 +696,10 @@ export function nativeAddAllWithExclusions(basePath, exclusions) {
     }
     catch (err) {
         const stderr = err?.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")) {
@@ -709,7 +714,8 @@ export function nativeAddAllWithExclusions(basePath, exclusions) {
             fallbackStageWithSymlinkedDotGsd(basePath);
             return;
         }
-        throw new GSDError(GSD_GIT_ERROR, `git add -A with exclusions failed in ${basePath}: ${getErrorMessage(err)}`);
+        const stderrDetail = stderr.trim() ? `; stderr: ${stderr.trim()}` : "";
+        throw new GSDError(GSD_GIT_ERROR, `git add -A with exclusions failed in ${basePath}: ${getErrorMessage(err)}${stderrDetail}`);
     }
 }
 /**