gsd-pi 2.59.0 → 2.60.0-dev.2580e65

package/dist/resources/extensions/gsd/markdown-renderer.js

@@ -8,6 +8,7 @@
 // Critical invariant: rendered markdown must round-trip through
 // parseRoadmap(), parsePlan(), parseSummary() in files.ts.
 import { readFileSync, existsSync, mkdirSync } from "node:fs";
+import { logWarning } from "./workflow-logger.js";
 import { isClosedStatus } from "./status-guards.js";
 import { join, relative } from "node:path";
 import { createRequire } from "node:module";
@@ -56,7 +57,7 @@ function loadArtifactContent(artifactPath, absPath, opts) {
         content = readFileSync(absPath, "utf-8");
     }
     catch {
-        process.stderr.write(`markdown-renderer: cannot read file from disk: ${absPath}\n`);
+        logWarning("renderer", `cannot read file from disk: ${absPath}`);
         return null;
     }
     // Store in DB for future use (graceful degradation path)
@@ -72,7 +73,7 @@ function loadArtifactContent(artifactPath, absPath, opts) {
     }
     catch {
         // Non-fatal: we have the content, DB storage is best-effort
-        process.stderr.write(`markdown-renderer: warning — failed to store disk fallback in DB: ${artifactPath}\n`);
+        logWarning("renderer", `failed to store disk fallback in DB: ${artifactPath}`);
     }
     return content;
 }
@@ -93,7 +94,7 @@ async function writeAndStore(absPath, artifactPath, content, opts) {
     }
     catch {
         // Non-fatal: file is on disk, DB is best-effort
-        process.stderr.write(`markdown-renderer: warning — failed to update artifact in DB: ${artifactPath}\n`);
+        logWarning("renderer", `failed to update artifact in DB: ${artifactPath}`);
     }
     invalidateCaches();
 }
@@ -613,7 +614,8 @@ export function detectStaleRenders(basePath) {
         parseRoadmap = m.parseRoadmap;
         parsePlan = m.parsePlan;
     }
-    catch {
+    catch (e) {
+        logWarning("renderer", `parsers-legacy.ts require failed, falling back to .js: ${e.message}`);
         const m = _require("./parsers-legacy.js");
         parseRoadmap = m.parseRoadmap;
         parsePlan = m.parsePlan;
@@ -647,8 +649,8 @@ export function detectStaleRenders(basePath) {
                     }
                 }
             }
-            catch {
-                // Can't parse roadmap — skip silently
+            catch (e) {
+                logWarning("renderer", `roadmap parse failed: ${e.message}`);
             }
         }
         // ── Check plan checkbox state and summaries for each slice ────────
@@ -679,8 +681,8 @@ export function detectStaleRenders(basePath) {
                         }
                     }
                 }
-                catch {
-                    // Can't parse plan — skip silently
+                catch (e) {
+                    logWarning("renderer", `plan parse failed: ${e.message}`);
                 }
             }
             // Check missing task summary files
@@ -824,7 +826,7 @@ export async function repairStaleRenders(basePath) {
             }
         }
         catch (err) {
-            process.stderr.write(`markdown-renderer: repair failed for ${entry.path}: ${err.message}\n`);
+            logWarning("renderer", `repair failed for ${entry.path}: ${err.message}`);
         }
     }
     if (repairCount > 0) {

package/dist/resources/extensions/gsd/md-importer.js

@@ -10,6 +10,7 @@ import { resolveGsdRootFile, resolveMilestoneFile, resolveSliceFile, resolveTask
 import { findMilestoneIds } from './guided-flow.js';
 import { parseRoadmap, parsePlan } from './parsers-legacy.js';
 import { parseContextDependsOn } from './files.js';
+import { logWarning } from './workflow-logger.js';
 // ─── DECISIONS.md Parser ───────────────────────────────────────────────────
 const VALID_MADE_BY = new Set(['human', 'agent', 'collaborative']);
 /**
@@ -597,25 +598,25 @@ export function migrateFromMarkdown(gsdDir) {
             decisions = importDecisions(gsdDir);
         }
         catch (err) {
-            process.stderr.write(`gsd-migrate: skipping decisions import: ${err.message}\n`);
+            logWarning("migration", `skipping decisions import: ${err.message}`);
         }
         try {
             requirements = importRequirements(gsdDir);
         }
         catch (err) {
-            process.stderr.write(`gsd-migrate: skipping requirements import: ${err.message}\n`);
+            logWarning("migration", `skipping requirements import: ${err.message}`);
         }
         try {
             artifacts = importHierarchyArtifacts(gsdDir);
         }
         catch (err) {
-            process.stderr.write(`gsd-migrate: skipping artifacts import: ${err.message}\n`);
+            logWarning("migration", `skipping artifacts import: ${err.message}`);
         }
         try {
             hierarchy = migrateHierarchyToDb(gsdDir);
         }
         catch (err) {
-            process.stderr.write(`gsd-migrate: skipping hierarchy migration: ${err.message}\n`);
+            logWarning("migration", `skipping hierarchy migration: ${err.message}`);
         }
     });
     process.stderr.write(`gsd-migrate: imported ${decisions} decisions, ${requirements} requirements, ${artifacts} artifacts, ${hierarchy.milestones}M/${hierarchy.slices}S/${hierarchy.tasks}T hierarchy\n`);

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

@@ -16,6 +16,7 @@ import { resolveMilestonePath, resolveMilestoneFile, buildMilestoneFileName, } f
 import { invalidateAllCaches } from "./cache.js";
 import { loadQueueOrder, saveQueueOrder } from "./queue-order.js";
 import { isDbAvailable, updateMilestoneStatus } from "./gsd-db.js";
+import { logWarning } from "./workflow-logger.js";
 // ─── Park ──────────────────────────────────────────────────────────────────
 /**
  * Park a milestone — creates a PARKED.md marker file with reason and timestamp.
@@ -51,7 +52,7 @@ export function parkMilestone(basePath, milestoneId, reason) {
             updateMilestoneStatus(milestoneId, "parked");
         }
         catch (err) {
-            process.stderr.write(`gsd: parkMilestone DB sync failed for ${milestoneId}: ${err.message}\n`);
+            logWarning("engine", `parkMilestone DB sync failed for ${milestoneId}: ${err.message}`);
         }
     }
     invalidateAllCaches();
@@ -76,7 +77,7 @@ export function unparkMilestone(basePath, milestoneId) {
             updateMilestoneStatus(milestoneId, "active");
         }
         catch (err) {
-            process.stderr.write(`gsd: unparkMilestone DB sync failed for ${milestoneId}: ${err.message}\n`);
+            logWarning("engine", `unparkMilestone DB sync failed for ${milestoneId}: ${err.message}`);
         }
     }
     invalidateAllCaches();

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

@@ -5,6 +5,7 @@
  * Consumed by 15+ modules across the GSD extension. Zero side-effects.
  */
 import { randomInt } from "node:crypto";
+import { logWarning } from "./workflow-logger.js";
 import { readdirSync, existsSync } from "node:fs";
 import { milestonesDir } from "./paths.js";
 import { loadQueueOrder, sortByQueueOrder } from "./queue-order.js";
@@ -109,7 +110,7 @@ export function findMilestoneIds(basePath) {
     catch (err) {
         // Log why milestone scanning failed — silent [] here causes infinite loops (#456)
         if (existsSync(dir)) {
-            console.error(`[gsd] findMilestoneIds: .gsd/milestones/ exists but readdirSync failed — ${getErrorMessage(err)}`);
+            logWarning("engine", `findMilestoneIds: .gsd/milestones/ exists but readdirSync failed — ${getErrorMessage(err)}`);
         }
         return [];
     }

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

@@ -76,19 +76,177 @@ 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 },
+    "claude-haiku-4-5": { coding: 60, debugging: 50, research: 45, reasoning: 50, speed: 95, longContext: 50, instruction: 75 },
+    "gpt-4o": { coding: 80, debugging: 75, research: 70, reasoning: 75, speed: 65, longContext: 70, instruction: 80 },
+    "gpt-4o-mini": { coding: 55, debugging: 45, research: 40, reasoning: 45, speed: 90, longContext: 45, instruction: 70 },
+    "gemini-2.5-pro": { coding: 75, debugging: 70, research: 85, reasoning: 75, speed: 55, longContext: 90, instruction: 75 },
+    "gemini-2.0-flash": { coding: 50, debugging: 40, research: 50, reasoning: 40, speed: 95, longContext: 60, instruction: 65 },
+    "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 = {
+    "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 },
+    "plan-milestone": { reasoning: 0.9, coding: 0.5 },
+    "plan-slice": { reasoning: 0.9, coding: 0.5 },
+    "replan-slice": { reasoning: 0.9, debugging: 0.6, coding: 0.5 },
+    "reassess-roadmap": { reasoning: 0.9, research: 0.5 },
+    "complete-slice": { instruction: 0.8, speed: 0.7 },
+    "run-uat": { instruction: 0.7, speed: 0.8 },
+    "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.
+ */
+export function computeTaskRequirements(unitType, metadata) {
+    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 };
+        }
+        if (metadata.complexityKeywords?.some(k => k === "concurrency" || k === "compatibility")) {
+            return { ...base, debugging: 0.9, reasoning: 0.8 };
+        }
+        if (metadata.complexityKeywords?.some(k => k === "migration" || k === "architecture")) {
+            return { ...base, reasoning: 0.9, coding: 0.8 };
+        }
+        if ((metadata.fileCount ?? 0) >= 6 || (metadata.estimatedLines ?? 0) >= 500) {
+            return { ...base, coding: 0.9, reasoning: 0.7 };
+        }
+    }
+    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.
+ */
+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;
+        }
+    }
+    return result;
+}
 /**
  * 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.
  *
- * @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)
+ * 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)
  */
-export function resolveModelForComplexity(classification, phaseConfig, routingConfig, availableModelIds) {
+export function resolveModelForComplexity(classification, phaseConfig, routingConfig, availableModelIds, unitType, taskMetadata, capabilityOverrides) {
     // If no phase config or routing disabled, pass through
     if (!phaseConfig || !routingConfig.enabled) {
         return {
@@ -97,6 +255,7 @@ 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;
@@ -114,6 +273,7 @@ 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
@@ -124,11 +284,12 @@ export function resolveModelForComplexity(classification, phaseConfig, routingCo
             tier: requestedTier,
             wasDowngraded: false,
             reason: `tier ${requestedTier} >= configured ${configuredTier}`,
+            selectionMethod: "tier-only",
         };
     }
-    // Find the best model for the requested tier
-    const targetModelId = findModelForTier(requestedTier, routingConfig, availableModelIds, routingConfig.cross_provider !== false);
-    if (!targetModelId) {
+    // 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
         return {
             modelId: configuredPrimary,
@@ -136,19 +297,42 @@ export function resolveModelForComplexity(classification, phaseConfig, routingCo
             tier: requestedTier,
             wasDowngraded: false,
             reason: `no ${requestedTier}-tier model available`,
+            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);
+        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 = [
-        ...phaseConfig.fallbacks.filter(f => f !== targetModelId),
-        configuredPrimary,
-    ].filter(f => f !== targetModelId);
+    const fallbacks = buildFallbackChain(targetModelId, phaseConfig);
     return {
         modelId: targetModelId,
         fallbacks,
         tier: requestedTier,
         wasDowngraded: true,
         reason: classification.reason,
+        selectionMethod: "tier-only",
     };
 }
 /**
@@ -168,6 +352,7 @@ export function escalateTier(currentTier) {
 export function defaultRoutingConfig() {
     return {
         enabled: true,
+        capability_routing: true,
         escalate_on_failure: true,
         budget_pressure: true,
         cross_provider: true,
@@ -186,8 +371,8 @@ function getModelTier(modelId) {
         if (bareId.includes(knownId) || knownId.includes(bareId))
             return tier;
     }
-    // Unknown models are assumed heavy (safest assumption)
-    return "heavy";
+    // Unknown models are assumed standard (per D-15: avoids silently ignoring user config)
+    return "standard";
 }
 /** Check if a model ID has a known capability tier mapping. (#2192) */
 function isKnownModel(modelId) {
@@ -200,37 +385,6 @@ 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 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,6 +13,7 @@ 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.
@@ -27,7 +28,8 @@ 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 {
+    catch (e) {
+        logWarning("parallel", `spawnSync milestone completion check failed for ${mid}: ${e.message}`);
         return false;
     }
 }
@@ -45,8 +47,8 @@ function discoverDbCompletedMilestones(basePath) {
             }
         }
     }
-    catch {
-        // worktrees dir may not exist
+    catch (e) {
+        logWarning("parallel", `readdirSync for completed set failed: ${e.message}`);
     }
     return completed;
 }

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

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