gsd-pi 2.60.0-dev.2580e65 → 2.60.0-dev.d9052f5

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

@@ -76,9 +76,6 @@ const MODEL_COST_PER_1K_INPUT = {
     "gemini-2.5-pro": 0.00125,
     "deepseek-chat": 0.00014,
 };
-// ─── Capability Profiles Data Table ──────────────────────────────────────────
-// Per-model capability profiles (0–100 scale). Used for capability-aware
-// model selection within an eligible tier set.
 export const MODEL_CAPABILITY_PROFILES = {
     "claude-opus-4-6": { coding: 95, debugging: 90, research: 85, reasoning: 95, speed: 30, longContext: 80, instruction: 90 },
     "claude-sonnet-4-6": { coding: 85, debugging: 80, research: 75, reasoning: 80, speed: 60, longContext: 75, instruction: 85 },
@@ -90,10 +87,7 @@ export const MODEL_CAPABILITY_PROFILES = {
     "deepseek-chat": { coding: 75, debugging: 65, research: 55, reasoning: 70, speed: 70, longContext: 55, instruction: 65 },
     "o3": { coding: 80, debugging: 85, research: 80, reasoning: 92, speed: 25, longContext: 70, instruction: 85 },
 };
-// ─── Base Task Requirements Data Table ───────────────────────────────────────
-// Per-unit-type base requirement vectors. Weights indicate how important each
-// capability dimension is for this unit type.
-export const BASE_REQUIREMENTS = {
+const BASE_REQUIREMENTS = {
     "execute-task": { coding: 0.9, instruction: 0.7, speed: 0.3 },
     "research-milestone": { research: 0.9, longContext: 0.7, reasoning: 0.5 },
     "research-slice": { research: 0.9, longContext: 0.7, reasoning: 0.5 },
@@ -106,28 +100,11 @@ export const BASE_REQUIREMENTS = {
     "discuss-milestone": { reasoning: 0.6, instruction: 0.7 },
     "complete-milestone": { instruction: 0.8, reasoning: 0.5 },
 };
-// ─── Public API ──────────────────────────────────────────────────────────────
-/**
- * Score a model's suitability for a task given a requirement vector.
- * Returns a weighted average of capability dimensions (0–100).
- * Returns 50 if requirements are empty (neutral score).
- */
-export function scoreModel(model, requirements) {
-    let weightedSum = 0;
-    let weightSum = 0;
-    for (const [dim, weight] of Object.entries(requirements)) {
-        const capability = model[dim] ?? 50;
-        weightedSum += weight * capability;
-        weightSum += weight;
-    }
-    return weightSum > 0 ? weightedSum / weightSum : 50;
-}
 /**
- * Compute dynamic task requirements from unit type and optional task metadata.
- * Returns a requirement vector refined by task-specific signals.
+ * Compute a task requirement vector from unit type and optional metadata.
  */
 export function computeTaskRequirements(unitType, metadata) {
-    const base = BASE_REQUIREMENTS[unitType] ?? { reasoning: 0.5 };
+    const base = { ...(BASE_REQUIREMENTS[unitType] ?? { reasoning: 0.5 }) };
     if (unitType === "execute-task" && metadata) {
         if (metadata.tags?.some(t => /^(docs?|readme|comment|config|typo|rename)$/i.test(t))) {
             return { ...base, instruction: 0.9, coding: 0.3, speed: 0.7 };
@@ -145,108 +122,32 @@ export function computeTaskRequirements(unitType, metadata) {
     return base;
 }
 /**
- * Score all eligible models against a requirement vector and return them
- * sorted by score descending. Within 2 points: prefer cheaper; equal cost:
- * lexicographic tie-break by model ID.
- */
-export function scoreEligibleModels(eligibleModelIds, requirements, capabilityOverrides) {
-    const scored = eligibleModelIds.map(modelId => {
-        const builtin = MODEL_CAPABILITY_PROFILES[modelId];
-        const override = capabilityOverrides?.[modelId];
-        const profile = builtin
-            ? override ? { ...builtin, ...override } : builtin
-            : { coding: 50, debugging: 50, research: 50, reasoning: 50, speed: 50, longContext: 50, instruction: 50 };
-        return { modelId, score: scoreModel(profile, requirements) };
-    });
-    scored.sort((a, b) => {
-        const scoreDiff = b.score - a.score;
-        if (Math.abs(scoreDiff) > 2)
-            return scoreDiff;
-        const costA = MODEL_COST_PER_1K_INPUT[a.modelId] ?? Infinity;
-        const costB = MODEL_COST_PER_1K_INPUT[b.modelId] ?? Infinity;
-        if (costA !== costB)
-            return costA - costB;
-        return a.modelId.localeCompare(b.modelId);
-    });
-    return scored;
-}
-/**
- * Return all models eligible for a given tier, sorted cheapest first.
- * 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) {
-    // 1. Check explicit tier_models config
-    const explicitModel = routingConfig.tier_models?.[tier];
-    if (explicitModel) {
-        // Exact match
-        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;
-        });
-        if (match)
-            return [match];
-    }
-    // 2. Auto-detect: filter by tier, sort cheapest first
-    return availableModelIds
-        .filter(id => getModelTier(id) === tier)
-        .sort((a, b) => {
-        const costA = getModelCost(a);
-        const costB = getModelCost(b);
-        return costA - costB;
-    });
-}
-/**
- * Build a fallback chain for a selected model: [selectedModel, ...configuredFallbacks, configuredPrimary]
- * Deduplicates entries while preserving order.
- */
-function buildFallbackChain(selectedModelId, phaseConfig) {
-    return [
-        ...phaseConfig.fallbacks.filter(f => f !== selectedModelId),
-        phaseConfig.primary,
-    ].filter(f => f !== selectedModelId);
-}
-/**
- * Load capability overrides from user preferences' modelOverrides section.
- * Returns a map of model ID → partial capability overrides to deep-merge with built-in profiles.
- *
- * Per D-17: partial capability overrides via models.json modelOverrides, deep-merged with defaults.
+ * Score a model against a task requirement vector.
+ * Returns weighted average in range 0–100. Returns 50 for empty requirements.
  */
-export function loadCapabilityOverrides(prefs) {
-    const result = {};
-    if (!prefs.modelOverrides)
-        return result;
-    for (const [modelId, overrideEntry] of Object.entries(prefs.modelOverrides)) {
-        if (overrideEntry.capabilities) {
-            result[modelId] = overrideEntry.capabilities;
-        }
+export function scoreModel(capabilities, requirements) {
+    let weightedSum = 0;
+    let weightSum = 0;
+    for (const [dim, weight] of Object.entries(requirements)) {
+        const capability = capabilities[dim] ?? 50;
+        weightedSum += weight * capability;
+        weightSum += weight;
     }
-    return result;
+    return weightSum > 0 ? weightedSum / weightSum : 50;
 }
+// ─── Public API ──────────────────────────────────────────────────────────────
 /**
  * Resolve the model to use for a given complexity tier.
  *
  * Downgrade-only: the returned model is always equal to or cheaper than
  * the user's configured primary model. Never upgrades beyond configuration.
  *
- * STEP 1: Filter to eligible models for the requested tier.
- * STEP 2: Capability scoring — ranks eligible models by task-capability match
- *         when capability_routing is enabled and multiple eligible models exist.
- * STEP 3: Fallback chain assembly.
- *
- * @param classification      The complexity classification result
- * @param phaseConfig         The user's configured model for this phase (ceiling)
- * @param routingConfig       Dynamic routing configuration
- * @param availableModelIds   List of available model IDs (from registry)
- * @param unitType            The unit type for capability requirement computation (optional)
- * @param taskMetadata        Task metadata for refined requirement vectors (optional)
- * @param capabilityOverrides User-provided capability overrides (deep-merged with built-in profiles, optional)
+ * @param classification  The complexity classification result
+ * @param phaseConfig     The user's configured model for this phase (ceiling)
+ * @param routingConfig   Dynamic routing configuration
+ * @param availableModelIds  List of available model IDs (from registry)
  */
-export function resolveModelForComplexity(classification, phaseConfig, routingConfig, availableModelIds, unitType, taskMetadata, capabilityOverrides) {
+export function resolveModelForComplexity(classification, phaseConfig, routingConfig, availableModelIds, unitType, metadata) {
     // If no phase config or routing disabled, pass through
     if (!phaseConfig || !routingConfig.enabled) {
         return {
@@ -255,7 +156,6 @@ export function resolveModelForComplexity(classification, phaseConfig, routingCo
             tier: classification.tier,
             wasDowngraded: false,
             reason: "dynamic routing disabled or no phase config",
-            selectionMethod: "tier-only",
         };
     }
     const configuredPrimary = phaseConfig.primary;
@@ -273,7 +173,6 @@ export function resolveModelForComplexity(classification, phaseConfig, routingCo
             tier: requestedTier,
             wasDowngraded: false,
             reason: `configured model "${configuredPrimary}" is not in the known tier map — honoring explicit config`,
-            selectionMethod: "tier-only",
         };
     }
     // Downgrade-only: if requested tier >= configured tier, no change
@@ -284,55 +183,47 @@ export function resolveModelForComplexity(classification, phaseConfig, routingCo
             tier: requestedTier,
             wasDowngraded: false,
             reason: `tier ${requestedTier} >= configured ${configuredTier}`,
-            selectionMethod: "tier-only",
         };
     }
-    // STEP 1: Get all eligible models for the requested tier
-    const eligible = getEligibleModels(requestedTier, availableModelIds, routingConfig);
-    if (eligible.length === 0) {
-        // No suitable model found — use configured primary
+    // Find the best model for the requested tier
+    const useCapabilityScoring = routingConfig.capability_routing && unitType;
+    let targetModelId;
+    let capabilityScores;
+    let taskRequirements;
+    let selectionMethod = "tier-only";
+    if (useCapabilityScoring) {
+        const result = findModelForTierWithCapability(requestedTier, routingConfig, availableModelIds, routingConfig.cross_provider !== false, unitType, metadata);
+        targetModelId = result.modelId;
+        capabilityScores = Object.keys(result.scores).length > 0 ? result.scores : undefined;
+        taskRequirements = Object.keys(result.requirements).length > 0 ? result.requirements : undefined;
+        selectionMethod = capabilityScores ? "capability-scored" : "tier-only";
+    }
+    else {
+        targetModelId = findModelForTier(requestedTier, routingConfig, availableModelIds, routingConfig.cross_provider !== false);
+    }
+    if (!targetModelId) {
         return {
             modelId: configuredPrimary,
             fallbacks: phaseConfig.fallbacks,
             tier: requestedTier,
             wasDowngraded: false,
             reason: `no ${requestedTier}-tier model available`,
-            selectionMethod: "tier-only",
+            selectionMethod,
         };
     }
-    // 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);
-        const scored = scoreEligibleModels(eligible, requirements, capabilityOverrides);
-        const winner = scored[0];
-        if (winner) {
-            const capScores = {};
-            for (const s of scored)
-                capScores[s.modelId] = s.score;
-            const fallbacks = buildFallbackChain(winner.modelId, phaseConfig);
-            return {
-                modelId: winner.modelId,
-                fallbacks,
-                tier: requestedTier,
-                wasDowngraded: true,
-                reason: `capability-scored: ${winner.modelId} (${winner.score.toFixed(1)}) for ${unitType}`,
-                capabilityScores: capScores,
-                taskRequirements: requirements,
-                selectionMethod: "capability-scored",
-            };
-        }
-    }
-    // STEP 3: Fallback — use first eligible model (cheapest in tier, or single eligible)
-    const targetModelId = eligible[0];
-    // Build fallback chain: [downgraded_model, ...configured_fallbacks, configured_primary]
-    const fallbacks = buildFallbackChain(targetModelId, phaseConfig);
+    const fallbacks = [
+        ...phaseConfig.fallbacks.filter(f => f !== targetModelId),
+        configuredPrimary,
+    ].filter(f => f !== targetModelId);
     return {
         modelId: targetModelId,
         fallbacks,
         tier: requestedTier,
         wasDowngraded: true,
         reason: classification.reason,
-        selectionMethod: "tier-only",
+        selectionMethod,
+        capabilityScores,
+        taskRequirements,
     };
 }
 /**
@@ -352,7 +243,7 @@ export function escalateTier(currentTier) {
 export function defaultRoutingConfig() {
     return {
         enabled: true,
-        capability_routing: true,
+        capability_routing: false,
         escalate_on_failure: true,
         budget_pressure: true,
         cross_provider: true,
@@ -371,8 +262,8 @@ function getModelTier(modelId) {
         if (bareId.includes(knownId) || knownId.includes(bareId))
             return tier;
     }
-    // Unknown models are assumed standard (per D-15: avoids silently ignoring user config)
-    return "standard";
+    // Unknown models are assumed heavy (safest assumption)
+    return "heavy";
 }
 /** Check if a model ID has a known capability tier mapping. (#2192) */
 function isKnownModel(modelId) {
@@ -385,6 +276,80 @@ function isKnownModel(modelId) {
     }
     return false;
 }
+function findModelForTier(tier, config, availableModelIds, crossProvider) {
+    // 1. Check explicit tier_models config
+    const explicitModel = config.tier_models?.[tier];
+    if (explicitModel && availableModelIds.includes(explicitModel)) {
+        return explicitModel;
+    }
+    // Also check with provider prefix stripped
+    if (explicitModel) {
+        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;
+    }
+    // 2. Auto-detect: find the cheapest available model in the requested tier
+    const candidates = availableModelIds
+        .filter(id => {
+        const modelTier = getModelTier(id);
+        return modelTier === tier;
+    })
+        .sort((a, b) => {
+        if (!crossProvider)
+            return 0;
+        const costA = getModelCost(a);
+        const costB = getModelCost(b);
+        return costA - costB;
+    });
+    return candidates[0] ?? null;
+}
+function findModelForTierWithCapability(tier, config, availableModelIds, crossProvider, unitType, metadata) {
+    const explicitModel = config.tier_models?.[tier];
+    if (explicitModel) {
+        const match = availableModelIds.find(id => {
+            const bareAvail = id.includes("/") ? id.split("/").pop() : id;
+            const bareExplicit = explicitModel.includes("/") ? explicitModel.split("/").pop() : explicitModel;
+            return bareAvail === bareExplicit || id === explicitModel;
+        });
+        if (match)
+            return { modelId: match, scores: {}, requirements: {} };
+    }
+    const requirements = computeTaskRequirements(unitType, metadata);
+    const candidates = availableModelIds.filter(id => getModelTier(id) === tier);
+    if (candidates.length === 0)
+        return { modelId: null, scores: {}, requirements };
+    const scores = {};
+    for (const id of candidates) {
+        const bareId = id.includes("/") ? id.split("/").pop() : id;
+        const profile = getModelProfile(bareId);
+        scores[id] = scoreModel(profile, requirements);
+    }
+    candidates.sort((a, b) => {
+        const scoreDiff = scores[b] - scores[a];
+        if (Math.abs(scoreDiff) > 2)
+            return scoreDiff;
+        if (crossProvider) {
+            const costDiff = getModelCost(a) - getModelCost(b);
+            if (costDiff !== 0)
+                return costDiff;
+        }
+        return a.localeCompare(b);
+    });
+    return { modelId: candidates[0], scores, requirements };
+}
+function getModelProfile(bareId) {
+    if (MODEL_CAPABILITY_PROFILES[bareId])
+        return MODEL_CAPABILITY_PROFILES[bareId];
+    for (const [knownId, profile] of Object.entries(MODEL_CAPABILITY_PROFILES)) {
+        if (bareId.includes(knownId) || knownId.includes(bareId))
+            return profile;
+    }
+    return { coding: 50, debugging: 50, research: 50, reasoning: 50, speed: 50, longContext: 50, instruction: 50 };
+}
 function getModelCost(modelId) {
     const bareId = modelId.includes("/") ? modelId.split("/").pop() : modelId;
     if (MODEL_COST_PER_1K_INPUT[bareId] !== undefined) {

package/dist/resources/extensions/gsd/parallel-merge.js

@@ -13,7 +13,6 @@ import { mergeMilestoneToMain } from "./auto-worktree.js";
 import { MergeConflictError } from "./git-service.js";
 import { removeSessionStatus } from "./session-status-io.js";
 import { getErrorMessage } from "./error-utils.js";
-import { logWarning } from "./workflow-logger.js";
 // ─── Merge Queue ───────────────────────────────────────────────────────────
 /**
  * Check whether a milestone is complete by querying its worktree SQLite DB.
@@ -28,8 +27,7 @@ export function isMilestoneCompleteInWorktreeDb(basePath, mid) {
         const result = spawnSync("sqlite3", [dbPath, `SELECT status FROM milestones WHERE id='${mid}' LIMIT 1`], { timeout: 3000, encoding: "utf-8" });
         return (result.stdout || "").trim() === "complete";
     }
-    catch (e) {
-        logWarning("parallel", `spawnSync milestone completion check failed for ${mid}: ${e.message}`);
+    catch {
         return false;
     }
 }
@@ -47,8 +45,8 @@ function discoverDbCompletedMilestones(basePath) {
             }
         }
     }
-    catch (e) {
-        logWarning("parallel", `readdirSync for completed set failed: ${e.message}`);
+    catch {
+        // worktrees dir may not exist
     }
     return completed;
 }

package/dist/resources/extensions/gsd/parallel-orchestrator.js

@@ -19,7 +19,6 @@ import { resolveParallelConfig } from "./preferences.js";
 import { writeSessionStatus, readAllSessionStatuses, readSessionStatus, removeSessionStatus, sendSignal, cleanupStaleSessions, } from "./session-status-io.js";
 import { analyzeParallelEligibility, } from "./parallel-eligibility.js";
 import { getErrorMessage } from "./error-utils.js";
-import { logWarning } from "./workflow-logger.js";
 // ─── Module State ──────────────────────────────────────────────────────────
 let state = null;
 // ─── Persistence ──────────────────────────────────────────────────────────
@@ -62,9 +61,7 @@ export function persistState(basePath) {
         writeFileSync(tmp, JSON.stringify(persisted, null, 2), "utf-8");
         renameSync(tmp, dest);
     }
-    catch (e) {
-        logWarning("parallel", `persist parallel state failed: ${e.message}`);
-    }
+    catch { /* non-fatal */ }
 }
 /**
  * Remove the persisted state file.
@@ -75,9 +72,7 @@ function removeStateFile(basePath) {
         if (existsSync(p))
             unlinkSync(p);
     }
-    catch (e) {
-        logWarning("parallel", `clear parallel state file failed: ${e.message}`);
-    }
+    catch { /* non-fatal */ }
 }
 function isPidAlive(pid) {
     if (!Number.isInteger(pid) || pid <= 0)
@@ -86,8 +81,7 @@ function isPidAlive(pid) {
         process.kill(pid, 0);
         return true;
     }
-    catch (e) {
-        logWarning("parallel", `pid alive check failed for pid ${pid}: ${e.message}`);
+    catch {
         return false;
     }
 }
@@ -118,8 +112,7 @@ export function restoreState(basePath) {
         }
         return persisted;
     }
-    catch (e) {
-        logWarning("parallel", `readParallelState JSON parse failed: ${e.message}`);
+    catch {
         return null;
     }
 }
@@ -133,8 +126,8 @@ function appendWorkerLog(basePath, milestoneId, chunk) {
             mkdirSync(dir, { recursive: true });
         appendFileSync(workerLogPath(basePath, milestoneId), chunk, "utf-8");
     }
-    catch (e) {
-        logWarning("parallel", `appendFileSync worker log failed for ${milestoneId}: ${e.message}`);
+    catch {
+        // Non-fatal — diagnostics should never break orchestration.
     }
 }
 function restoreRuntimeState(basePath) {
@@ -338,8 +331,9 @@ export async function startParallel(basePath, milestoneIds, prefs) {
             try {
                 wtPath = createMilestoneWorktree(basePath, mid);
             }
-            catch (e) {
-                logWarning("parallel", `createMilestoneWorktree fallback for ${mid}: ${e.message}`);
+            catch {
+                // Worktree creation may fail in test environments or when git
+                // is not available. Fall back to a placeholder path.
                 wtPath = worktreePath(basePath, mid);
             }
             const worker = {
@@ -457,8 +451,7 @@ export function spawnWorker(basePath, milestoneId) {
             detached: false,
         });
     }
-    catch (e) {
-        logWarning("parallel", `spawnSync worker failed for ${milestoneId}: ${e.message}`);
+    catch {
         return false;
     }
     // Handle spawn errors (e.g., ENOENT when binary doesn't exist)
@@ -579,8 +572,7 @@ function resolveGsdBin() {
     try {
         thisDir = dirname(fileURLToPath(import.meta.url));
     }
-    catch (e) {
-        logWarning("parallel", `dirname(fileURLToPath) failed: ${e.message}`);
+    catch {
         thisDir = process.cwd();
     }
     const candidates = [
@@ -607,7 +599,7 @@ function processWorkerLine(basePath, milestoneId, line) {
         event = JSON.parse(line);
     }
     catch {
-        return; // Non-NDJSON lines (progress text, tool output) are expected — silent drop
+        return; // Not valid JSON — skip (stderr leakage, debug output, etc.)
     }
     const type = String(event.type ?? "");
     // message_end carries usage data with cost
@@ -692,9 +684,7 @@ export async function stopParallel(basePath, milestoneId) {
                     process.kill(worker.pid, "SIGTERM");
                 }
             }
-            catch (e) {
-                logWarning("parallel", `process.kill SIGTERM failed for pid ${worker.pid}: ${e.message}`);
-            }
+            catch { /* process may already be dead */ }
         }
         // Wait for the headless process to cascade SIGTERM to its RPC child.
         // The headless signal handler calls client.stop() which sends SIGTERM
@@ -711,9 +701,7 @@ export async function stopParallel(basePath, milestoneId) {
                     process.kill(worker.pid, "SIGKILL");
                 }
             }
-            catch (e) {
-                logWarning("parallel", `process.kill SIGKILL failed for pid ${worker.pid}: ${e.message}`);
-            }
+            catch { /* process may already be dead */ }
             await waitForWorkerExit(worker, 250);
         }
         // Remove stream listeners before releasing the process handle

package/dist/resources/extensions/gsd/preferences-types.js

@@ -73,7 +73,6 @@ export const KNOWN_PREFERENCE_KEYS = new Set([
     "stale_commit_threshold_minutes",
     "context_management",
     "experimental",
-    "codebase",
 ]);
 /** Canonical list of all dispatch unit types. */
 export const KNOWN_UNIT_TYPES = [

package/dist/resources/extensions/gsd/preferences-validation.js

@@ -894,50 +894,5 @@ export function validatePreferences(preferences) {
             errors.push("experimental must be an object");
         }
     }
-    // ─── Codebase Map ──────────────────────────────────────────────────
-    if (preferences.codebase !== undefined) {
-        if (typeof preferences.codebase === "object" && preferences.codebase !== null) {
-            const cb = preferences.codebase;
-            const validCb = {};
-            if (cb.exclude_patterns !== undefined) {
-                if (Array.isArray(cb.exclude_patterns) && cb.exclude_patterns.every((p) => typeof p === "string")) {
-                    validCb.exclude_patterns = cb.exclude_patterns;
-                }
-                else {
-                    errors.push("codebase.exclude_patterns must be an array of strings");
-                }
-            }
-            if (cb.max_files !== undefined) {
-                const mf = typeof cb.max_files === "number" ? cb.max_files : Number(cb.max_files);
-                if (Number.isFinite(mf) && mf >= 1) {
-                    validCb.max_files = Math.floor(mf);
-                }
-                else {
-                    errors.push("codebase.max_files must be a positive integer");
-                }
-            }
-            if (cb.collapse_threshold !== undefined) {
-                const ct = typeof cb.collapse_threshold === "number" ? cb.collapse_threshold : Number(cb.collapse_threshold);
-                if (Number.isFinite(ct) && ct >= 1) {
-                    validCb.collapse_threshold = Math.floor(ct);
-                }
-                else {
-                    errors.push("codebase.collapse_threshold must be a positive integer");
-                }
-            }
-            const knownCbKeys = new Set(["exclude_patterns", "max_files", "collapse_threshold"]);
-            for (const key of Object.keys(cb)) {
-                if (!knownCbKeys.has(key)) {
-                    warnings.push(`unknown codebase key "${key}" — ignored`);
-                }
-            }
-            if (Object.keys(validCb).length > 0) {
-                validated.codebase = validCb;
-            }
-        }
-        else {
-            errors.push("codebase must be an object");
-        }
-    }
     return { preferences: validated, errors, warnings };
 }

package/dist/resources/extensions/gsd/preferences.js

@@ -15,7 +15,6 @@ import { join } from "node:path";
 import { gsdRoot } from "./paths.js";
 import { parse as parseYaml } from "yaml";
 import { normalizeStringArray } from "../shared/format-utils.js";
-import { logWarning } from "./workflow-logger.js";
 import { resolveProfileDefaults as _resolveProfileDefaults } from "./preferences-models.js";
 import { KNOWN_PREFERENCE_KEYS, MODE_DEFAULTS, } from "./preferences-types.js";
 import { validatePreferences } from "./preferences-validation.js";
@@ -163,7 +162,7 @@ function parseFrontmatterBlock(frontmatter) {
         return parsed;
     }
     catch (e) {
-        logWarning("guided", `YAML parse error in frontmatter block: ${e.message}`);
+        console.error("[parseFrontmatterBlock] YAML parse error:", e);
         return {};
     }
 }
@@ -218,8 +217,8 @@ function parseHeadingListFormat(content) {
             }
             typed[targetSection] = value;
         }
-        catch (e) {
-            logWarning("guided", `preferences section parse failed: ${e.message}`);
+        catch {
+            /* malformed section — skip */
         }
     }
     return typed;
@@ -290,17 +289,6 @@ function mergePreferences(base, override) {
         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,
-        codebase: (base.codebase || override.codebase)
-            ? {
-                ...(base.codebase ?? {}),
-                ...(override.codebase ?? {}),
-                // Merge exclude_patterns arrays rather than overriding
-                exclude_patterns: [
-                    ...((base.codebase?.exclude_patterns) ?? []),
-                    ...((override.codebase?.exclude_patterns) ?? []),
-                ].filter(Boolean),
-            }
-            : undefined,
     };
 }
 function mergeStringLists(base, override) {

package/dist/resources/extensions/gsd/prompt-loader.js

@@ -21,7 +21,6 @@ import { GSDError, GSD_PARSE_ERROR } from "./errors.js";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 import { homedir } from "node:os";
-import { logWarning } from "./workflow-logger.js";
 /**
  * Resolve the GSD extension directory.
  *
@@ -70,7 +69,7 @@ function warmCache() {
         // prompts/ may not exist in test environments — lazy loading still works.
         // Emit a diagnostic when running outside tests so wrong-path bugs are visible.
         if (!process.env.VITEST && !process.env.NODE_TEST) {
-            logWarning("prompt", `warmCache: prompts dir not found: ${promptsDir}`);
+            process.stderr.write(`[gsd:prompt-loader] warmCache: prompts dir not found: ${promptsDir}\n`);
         }
     }
     try {
@@ -86,7 +85,7 @@ function warmCache() {
     catch {
         // templates/ may not exist in test environments — lazy loading still works.
         if (!process.env.VITEST && !process.env.NODE_TEST) {
-            logWarning("prompt", `warmCache: templates dir not found: ${templatesDir}`);
+            process.stderr.write(`[gsd:prompt-loader] warmCache: templates dir not found: ${templatesDir}\n`);
         }
     }
 }

package/dist/resources/extensions/gsd/prompts/rethink.md

@@ -48,7 +48,7 @@ Remove the `{ID}-PARKED.md` file from the milestone directory to reactivate it.
 ### Skip a slice
 Mark a slice as skipped so auto-mode advances past it without executing. Use the `gsd_skip_slice` tool:
 ```
-gsd_skip_slice({ milestoneId: "M003", sliceId: "S02", reason: "Descoped — feature moved to M005" })
+gsd_skip_slice({ milestone_id: "M003", slice_id: "S02", reason: "Descoped — feature moved to M005" })
 ```
 Skipped slices are treated as closed by the state machine (like "complete" but distinct). Use when a slice is no longer needed or has been superseded. The slice data is preserved for reference.