@opengsd/gsd-pi 1.2.0 → 1.3.0-dev.72e3af2a

package/dist/resources/extensions/gsd/milestone-readiness.js

@@ -0,0 +1,77 @@
+// Project/App: gsd-pi
+// File Purpose: Classify milestone readiness from DB status, slices, and artifacts.
+import { readFileSync } from "node:fs";
+import { getMilestone, getMilestoneSlices, isDbAvailable } from "./gsd-db.js";
+import { parseRoadmapSlices } from "./roadmap-slices.js";
+import { logWarning } from "./workflow-logger.js";
+export function classifyMilestoneReadiness(input) {
+    const hasContext = input.hasContext === true;
+    const hasDraftContext = !hasContext && input.hasDraftContext === true;
+    const hasSummary = input.hasSummary === true;
+    const sliceCount = input.sliceCount ?? 0;
+    const hasExecutablePlan = sliceCount > 0;
+    const status = input.status ?? null;
+    if (status === "complete" || hasSummary) {
+        return { kind: "terminal", hasContext, hasDraftContext, hasExecutablePlan };
+    }
+    if (status === "queued" && !hasContext && sliceCount === 0) {
+        return { kind: "queued-shell", hasContext, hasDraftContext, hasExecutablePlan };
+    }
+    if ((status === "needs-discussion" && !hasContext) || hasDraftContext) {
+        return { kind: "needs-discussion", hasContext, hasDraftContext, hasExecutablePlan };
+    }
+    if (hasExecutablePlan) {
+        return { kind: "executable-plan", hasContext, hasDraftContext, hasExecutablePlan };
+    }
+    return { kind: "planning-pending", hasContext, hasDraftContext, hasExecutablePlan };
+}
+export function readinessNeedsDiscussion(readiness) {
+    return readiness.kind === "needs-discussion" ||
+        (readiness.kind === "queued-shell" && readiness.hasDraftContext);
+}
+export function describeMilestoneReadinessPhase(phase) {
+    switch (phase) {
+        case "needs-discussion":
+            return {
+                label: "Discuss milestone draft",
+                description: "Milestone has a draft context — needs discussion before planning.",
+            };
+        case "pre-planning":
+            return {
+                label: "Research & plan milestone",
+                description: "Scout the landscape and create the roadmap.",
+            };
+        default:
+            return null;
+    }
+}
+function executablePlanSliceCount(milestoneId, roadmapFile) {
+    if (isDbAvailable()) {
+        return getMilestoneSlices(milestoneId).length;
+    }
+    if (!roadmapFile)
+        return 0;
+    try {
+        return parseRoadmapSlices(readFileSync(roadmapFile, "utf-8")).length;
+    }
+    catch (e) {
+        logWarning("guided", `failed to parse roadmap slices for ${milestoneId}: ${e.message}`);
+        return 0;
+    }
+}
+export function assessMilestoneHandoffReadiness(input) {
+    const milestone = isDbAvailable() ? getMilestone(input.milestoneId) : null;
+    return classifyMilestoneReadiness({
+        status: milestone?.status,
+        hasContext: input.contextFile != null,
+        sliceCount: executablePlanSliceCount(input.milestoneId, input.roadmapFile),
+    });
+}
+export function formatAcceptedDiscussHandoffMessage(milestoneId, readiness) {
+    if (readiness.hasExecutablePlan)
+        return `Milestone ${milestoneId} ready.`;
+    if (readiness.hasContext) {
+        return `Milestone ${milestoneId} context captured. Continuing the planning pipeline.`;
+    }
+    return `Milestone ${milestoneId} planning artifacts captured. Continuing the planning pipeline.`;
+}

package/dist/resources/extensions/gsd/milestone-reopen-events.js

@@ -1,11 +1,9 @@
-import { join } from "node:path";
-import { gsdRoot } from "./paths.js";
+import { workflowEventArchivePath, workflowEventLogPath } from "./workflow-event-ledger.js";
 import { readEvents } from "./workflow-events.js";
 export function latestExplicitReopenAt(basePath, milestoneId) {
-    const root = gsdRoot(basePath);
     const candidates = [
-        join(root, "event-log.jsonl"),
-        join(root, `event-log-${milestoneId}.jsonl.archived`),
+        workflowEventLogPath(basePath),
+        workflowEventArchivePath(basePath, milestoneId),
     ];
     let latest = null;
     for (const file of candidates) {

package/dist/resources/extensions/gsd/milestone-settlement.js

@@ -0,0 +1,50 @@
+// Project/App: gsd-pi
+// File Purpose: Milestone closeout settlement state across DB proof, artifacts, merge, and cleanup.
+import { isInAutoWorktree } from "./auto-worktree.js";
+import { formatCloseoutProofBlock, proveMilestoneCloseout, } from "./milestone-closeout-proof.js";
+import { resolveCloseoutArtifactProjection } from "./artifact-projection.js";
+function isActiveUnmergedWorktree(input) {
+    if (!input.milestoneId || input.milestoneMerged)
+        return false;
+    return isInAutoWorktree(input.basePath);
+}
+export function evaluateAllCompleteSettlement(input) {
+    if (input.statePhase !== "complete") {
+        return { ok: true, reason: "not-applicable" };
+    }
+    if (!isActiveUnmergedWorktree(input)) {
+        return { ok: true, reason: "settled" };
+    }
+    const milestoneId = input.milestoneId;
+    if (!milestoneId) {
+        return { ok: true, reason: "settled" };
+    }
+    const projection = resolveCloseoutArtifactProjection({
+        milestoneId,
+        basePath: input.basePath,
+        originalBasePath: input.originalBasePath,
+    });
+    const proof = proveMilestoneCloseout(milestoneId, {
+        refreshFromDisk: true,
+        summaryArtifactBasePath: projection.summaryArtifactBasePath,
+    });
+    if (!proof.ok) {
+        return {
+            ok: false,
+            reason: "closeout-blocked",
+            action: "pause",
+            message: `${formatCloseoutProofBlock(proof)} The milestone branch has not been merged to main.`,
+            nextAction: `Resolve closeout blockers, then retry \`/gsd dispatch complete-milestone ${milestoneId}\`.`,
+            milestoneId,
+        };
+    }
+    return {
+        ok: false,
+        reason: "merge-pending",
+        action: "pause",
+        message: `Milestone ${milestoneId} is complete, but its worktree branch has not been merged to main. ` +
+            `Retry with \`/gsd dispatch complete-milestone ${milestoneId}\` to finish the system-owned merge.`,
+        nextAction: `Retry \`/gsd dispatch complete-milestone ${milestoneId}\`.`,
+        milestoneId,
+    };
+}

package/dist/resources/extensions/gsd/milestone-validation-evidence.js

@@ -0,0 +1,73 @@
+// Project/App: gsd-pi
+// File Purpose: Forwarded validation evidence rules for milestone validation.
+import { getArtifact, getMilestone, getMilestoneSlices } from "./gsd-db.js";
+import { loadFile } from "./files.js";
+import { resolveSliceFile } from "./paths.js";
+import { compactTextParts, hasBrowserEvidenceText, hasBrowserRequiredText, } from "./browser-evidence.js";
+export function hasRuntimeExecutableUatEvidenceText(text) {
+    if (!/\buatType:\s*runtime-executable\b/i.test(text))
+        return false;
+    if (!/\bverdict:\s*PASS\b/i.test(text))
+        return false;
+    return /^\|\s*[^|\n]+\s*\|\s*runtime\s*\|\s*PASS\s*\|[^|\n]*\bgsd_uat_exec\b/mi.test(text);
+}
+export async function browserEvidenceGateRequiresAttention(params, basePath) {
+    if (params.verdict !== "pass")
+        return false;
+    const milestone = getMilestone(params.milestoneId);
+    const slices = getMilestoneSlices(params.milestoneId);
+    const requirementText = compactTextParts([
+        milestone?.vision,
+        milestone?.success_criteria,
+        milestone?.verification_uat,
+        params.successCriteriaChecklist,
+        params.verificationClasses,
+        ...slices.flatMap((slice) => [
+            slice.demo,
+            slice.goal,
+            slice.success_criteria,
+        ]),
+    ]);
+    if (!hasBrowserRequiredText(requirementText))
+        return false;
+    const sliceEvidencePairs = [];
+    for (const slice of slices) {
+        const chunks = [];
+        const artifactPath = `milestones/${params.milestoneId}/slices/${slice.id}/${slice.id}-ASSESSMENT.md`;
+        const artifact = getArtifact(artifactPath);
+        if (artifact?.full_content)
+            chunks.push(artifact.full_content);
+        const assessmentPath = resolveSliceFile(basePath, params.milestoneId, slice.id, "ASSESSMENT");
+        const assessmentContent = assessmentPath ? await loadFile(assessmentPath) : null;
+        if (assessmentContent)
+            chunks.push(assessmentContent);
+        sliceEvidencePairs.push({
+            sliceRequirementText: compactTextParts([slice.demo, slice.goal, slice.success_criteria]),
+            evidenceText: chunks.join("\n\n"),
+        });
+    }
+    const browserRequiringSlices = sliceEvidencePairs.filter((slice) => hasBrowserRequiredText(slice.sliceRequirementText));
+    const runtimeBypasses = browserRequiringSlices.length > 0
+        ? browserRequiringSlices.every((slice) => hasRuntimeExecutableUatEvidenceText(slice.evidenceText))
+        : sliceEvidencePairs.some((slice) => hasRuntimeExecutableUatEvidenceText(slice.evidenceText));
+    if (runtimeBypasses)
+        return false;
+    const persistedEvidence = sliceEvidencePairs.map((slice) => slice.evidenceText).join("\n\n");
+    const validationEvidence = compactTextParts([
+        params.successCriteriaChecklist,
+        params.verificationClasses,
+        params.verdictRationale,
+        params.remediationPlan,
+    ]);
+    return !hasBrowserEvidenceText(`${persistedEvidence}\n\n${validationEvidence}`);
+}
+export function applyBrowserEvidenceGate(params) {
+    const note = "Browser evidence gate: Browser-observable acceptance criteria were detected, but no persisted ASSESSMENT or validation evidence recorded browser actions with assertions. Downgraded from pass to needs-attention.";
+    return {
+        ...params,
+        verdict: "needs-attention",
+        verdictRationale: params.verdictRationale.trim()
+            ? `${params.verdictRationale.trim()}\n\n${note}`
+            : note,
+    };
+}

package/dist/resources/extensions/gsd/milestone-validation-verdict.js

@@ -0,0 +1,60 @@
+// Project/App: gsd-pi
+// File Purpose: Resolve the authoritative milestone validation verdict across DB and disk projections.
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { resolveExpectedArtifactPath } from "./auto-artifact-paths.js";
+import { loadFile } from "./files.js";
+import { getLatestAssessmentByScope, isDbAvailable } from "./gsd-db.js";
+import { relMilestoneFile } from "./paths.js";
+import { extractVerdict, isValidMilestoneVerdict, } from "./verdict-parser.js";
+import { resolveCanonicalMilestoneRoot } from "./worktree-manager.js";
+import { resolveWorktreeProjectRoot } from "./worktree-root.js";
+function verdictFromContent(content) {
+    if (!content)
+        return undefined;
+    const verdict = extractVerdict(content);
+    return verdict && isValidMilestoneVerdict(verdict) ? verdict : undefined;
+}
+function verdictFromDb(milestoneId) {
+    if (!isDbAvailable())
+        return undefined;
+    const assessment = getLatestAssessmentByScope(milestoneId, "milestone-validation");
+    const status = typeof assessment?.status === "string" ? assessment.status : undefined;
+    return status && isValidMilestoneVerdict(status) ? status : undefined;
+}
+async function verdictFromValidationPath(path) {
+    if (!path || !existsSync(path))
+        return undefined;
+    return verdictFromContent(await loadFile(path));
+}
+/**
+ * Resolve the milestone validation verdict using the same authority order as
+ * DB-backed state derivation, with filesystem fallbacks that mirror
+ * `resolveExpectedArtifactPath` (canonical worktree projection, then project
+ * root). Manual `/gsd verdict` overrides persist to the DB first; a stale
+ * worktree-local VALIDATION.md must not re-block auto-mode after the override.
+ */
+export async function resolveMilestoneValidationVerdict(basePath, milestoneId) {
+    const dbVerdict = verdictFromDb(milestoneId);
+    if (dbVerdict)
+        return dbVerdict;
+    const canonicalBase = resolveCanonicalMilestoneRoot(basePath, milestoneId);
+    const canonicalPath = resolveExpectedArtifactPath("validate-milestone", milestoneId, canonicalBase);
+    const canonicalVerdict = await verdictFromValidationPath(canonicalPath);
+    if (canonicalVerdict)
+        return canonicalVerdict;
+    const projectRoot = resolveWorktreeProjectRoot(basePath);
+    if (projectRoot !== canonicalBase) {
+        const projectPath = resolveExpectedArtifactPath("validate-milestone", milestoneId, projectRoot);
+        const projectVerdict = await verdictFromValidationPath(projectPath);
+        if (projectVerdict)
+            return projectVerdict;
+    }
+    // Last resort: layout-aware fallback path when resolveDir helpers
+    // haven't materialized the milestone directory yet. relMilestoneFile()
+    // builds the canonical NN-VALIDATION.md path for flat-phase and the
+    // legacy MID-VALIDATION.md path for projects that haven't migrated.
+    // See open-gsd/gsd-pi#876.
+    const directPath = join(canonicalBase, relMilestoneFile(canonicalBase, milestoneId, "VALIDATION"));
+    return verdictFromValidationPath(directPath);
+}

package/dist/resources/extensions/gsd/model-cost-table.js

@@ -13,6 +13,7 @@ export const BUNDLED_COST_TABLE = [
     { id: "claude-opus-4-6", inputPer1k: 0.005, outputPer1k: 0.025, updatedAt: "2026-04-16" },
     { id: "claude-opus-4-7", inputPer1k: 0.005, outputPer1k: 0.025, updatedAt: "2026-04-16" },
     { id: "claude-opus-4-8", inputPer1k: 0.005, outputPer1k: 0.025, updatedAt: "2026-05-28" },
+    { id: "claude-fable-5", inputPer1k: 0.010, outputPer1k: 0.050, updatedAt: "2026-06-09" },
     { id: "claude-sonnet-4-6", inputPer1k: 0.003, outputPer1k: 0.015, updatedAt: "2025-03-15" },
     { id: "claude-haiku-4-5", inputPer1k: 0.0008, outputPer1k: 0.004, updatedAt: "2025-03-15" },
     { id: "claude-sonnet-4-5-20250514", inputPer1k: 0.003, outputPer1k: 0.015, updatedAt: "2025-03-15" },

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

@@ -35,6 +35,7 @@ export const MODEL_CAPABILITY_TIER = {
     "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",
@@ -61,6 +62,7 @@ const MODEL_COST_PER_1K_INPUT = {
     "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,
@@ -94,6 +96,7 @@ export const MODEL_CAPABILITY_PROFILES = {
     "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 },
@@ -220,10 +223,12 @@ export function scoreEligibleModels(eligibleModelIds, requirements, capabilityOv
 }
 /**
  * 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.
  */
-export function getEligibleModels(tier, availableModelIds, routingConfig) {
+export function getEligibleModels(tier, availableModelIds, routingConfig, preferredModelId) {
     // 1. Check explicit tier_models config
     const explicitModel = routingConfig.tier_models?.[tier];
     if (explicitModel) {
@@ -237,13 +242,17 @@ export function getEligibleModels(tier, availableModelIds, routingConfig) {
             return [match];
     }
     // 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)];
 }
 /**
  * Build a fallback chain for a selected model: [selectedModel, ...configuredFallbacks, configuredPrimary]
@@ -291,7 +300,7 @@ export function loadCapabilityOverrides(prefs) {
  * @param taskMetadata        Task metadata for refined requirement vectors (optional)
  * @param capabilityOverrides User-provided capability overrides (deep-merged with built-in profiles, optional)
  */
-export function resolveModelForComplexity(classification, phaseConfig, routingConfig, availableModelIds, unitType, taskMetadata, capabilityOverrides) {
+export function resolveModelForComplexity(classification, phaseConfig, routingConfig, availableModelIds, unitType, taskMetadata, capabilityOverrides, preferredModelId) {
     // If no phase config or routing disabled, pass through
     if (!phaseConfig || !routingConfig.enabled) {
         return {
@@ -337,7 +346,7 @@ export function resolveModelForComplexity(classification, phaseConfig, routingCo
         // 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);
+        const crossProviderEquivalent = findModelForTier(configuredTier, routingConfig, availableModelIds, routingConfig.cross_provider !== false, preferredModelId);
         return {
             modelId: crossProviderEquivalent ?? configuredPrimary,
             fallbacks: crossProviderEquivalent
@@ -352,7 +361,7 @@ export function resolveModelForComplexity(classification, phaseConfig, routingCo
         };
     }
     // 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
         return {
@@ -364,6 +373,18 @@ export function resolveModelForComplexity(classification, phaseConfig, routingCo
             selectionMethod: "tier-only",
         };
     }
+    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);
@@ -425,15 +446,15 @@ export function defaultRoutingConfig() {
 }
 // ─── 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 = {
     light: "claude-haiku-4-5",
@@ -445,16 +466,17 @@ export function canonicalModelForTier(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.
+ * 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
  * eligible.
  */
-function findModelForTier(tier, routingConfig, availableModelIds, crossProvider) {
-    const eligible = getEligibleModels(tier, availableModelIds, routingConfig);
+function findModelForTier(tier, routingConfig, availableModelIds, crossProvider, preferredModelId) {
+    const eligible = getEligibleModels(tier, availableModelIds, routingConfig, preferredModelId);
     if (eligible.length === 0)
         return undefined;
     if (crossProvider) {
@@ -466,29 +488,69 @@ function findModelForTier(tier, routingConfig, availableModelIds, crossProvider)
         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];
 }
-export function resolveModelForTier(tier, availableModelIds, routingConfigOrCrossProvider = defaultRoutingConfig(), crossProvider) {
+export function resolveModelForTier(tier, availableModelIds, routingConfigOrCrossProvider = defaultRoutingConfig(), crossProvider, preferredModelId) {
     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
+    // 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) {
+    const slash = modelId.indexOf("/");
+    return slash > 0 ? modelId.slice(0, slash) : undefined;
+}
+function findAvailableModelId(preferredModelId, availableModelIds) {
+    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, tier) {
+    return tierOrdinal(getModelTier(modelId)) >= tierOrdinal(tier);
+}
+function findPreferredModelForTier(tier, availableModelIds, preferredModelId) {
+    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/dist/resources/extensions/gsd/native-git-bridge.js

@@ -930,6 +930,42 @@ export function nativeMergeSquash(basePath, branch) {
         throw err;
     }
 }
+/**
+ * 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, branch) {
+    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) {
+        const stderr = err instanceof Error ? err.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.