agentic-qe 3.14.7 → 3.15.0

package/dist/planning/goap-planner.js

@@ -157,6 +157,7 @@ export class GOAPPlanner {
         // for databases seeded before this feature existed, or before a given
         // action's binding was added to the library.
         this.backfillActionMethodBindings();
+        this.backfillActionDurationEstimates();
         await this.loadActions();
         this.initialized = true;
         console.log(`[GOAPPlanner] Initialized: ${this.persistence.getDbPath()}`);
@@ -170,12 +171,12 @@ export class GOAPPlanner {
         const allActions = getAllQEActions();
         const db = this.ensureDb();
         const insertAction = db.prepare(`
-      INSERT INTO goap_actions (id, name, description, category, preconditions, effects, cost, qe_domain, agent_type, method, params, implemented)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      INSERT INTO goap_actions (id, name, description, category, preconditions, effects, cost, qe_domain, agent_type, method, params, implemented, estimated_duration_ms)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `);
         for (const action of allActions) {
             const id = `action-${Date.now()}-${randomUUID().slice(0, 8)}`;
-            insertAction.run(id, action.name, action.description, action.category, JSON.stringify(action.preconditions), JSON.stringify(action.effects), action.cost, action.qeDomain ?? null, action.agentType ?? null, action.method ?? null, action.params ? JSON.stringify(action.params) : null, action.implemented ? 1 : 0);
+            insertAction.run(id, action.name, action.description, action.category, JSON.stringify(action.preconditions), JSON.stringify(action.effects), action.cost, action.qeDomain ?? null, action.agentType ?? null, action.method ?? null, action.params ? JSON.stringify(action.params) : null, action.implemented ? 1 : 0, action.estimatedDurationMs ?? null);
         }
         // Seed QE goals using direct insertion
         const insertGoal = db.prepare(`
@@ -212,6 +213,21 @@ export class GOAPPlanner {
             update.run(action.method, action.params ? JSON.stringify(action.params) : '{}', action.name);
         }
     }
+    /** Restore missing estimates only for unchanged legacy library definitions. */
+    backfillActionDurationEstimates() {
+        const update = this.ensureDb().prepare(`
+      UPDATE goap_actions SET estimated_duration_ms = ?
+      WHERE estimated_duration_ms IS NULL AND name = ?
+        AND agent_type IS ? AND category = ? AND qe_domain IS ?
+        AND preconditions = ? AND effects = ?
+        AND method IS ? AND params IS ? AND implemented = ?
+    `);
+        for (const action of getAllQEActions()) {
+            if (action.estimatedDurationMs === undefined)
+                continue;
+            update.run(action.estimatedDurationMs, action.name, action.agentType ?? null, action.category, action.qeDomain ?? null, JSON.stringify(action.preconditions), JSON.stringify(action.effects), action.method ?? null, action.params ? JSON.stringify(action.params) : null, action.implemented ? 1 : 0);
+        }
+    }
     // ==========================================================================
     // Core Planning - A* Search
     // ==========================================================================
@@ -242,6 +258,7 @@ export class GOAPPlanner {
                 this.recordPlanReuse(reusedPlan.id, true);
                 const clonedPlan = {
                     ...reusedPlan,
+                    estimatedDurationMs: reusedPlan.actions.reduce((sum, action) => sum + (action.estimatedDurationMs ?? 0), 0),
                     id: `plan-${Date.now()}-${randomUUID().slice(0, 8)}`,
                     initialState: this.cloneState(currentState),
                     reusedFrom: reusedPlan.id,
@@ -306,6 +323,9 @@ export class GOAPPlanner {
         // Entries are added on insert, updated when a better path is found, and
         // removed when the node is popped (moved to the closed set).
         const openSetCosts = new Map();
+        // Under a duration budget, cheaper paths can be slower or deeper. Keep
+        // nondominated labels rather than closing the entire state at its first cost.
+        const durationLabels = new Map();
         // Issue #535: cost-unit heuristic built once per search from the
         // actions that can actually move each goal key (see buildHeuristic).
         const heuristic = this.buildHeuristic(goal, availableActions);
@@ -322,34 +342,39 @@ export class GOAPPlanner {
             h: startH,
             f: 0,
             depth: 0,
+            estimatedDurationMs: 0,
         };
         startNode.f = startNode.g + startNode.h;
         openHeap.push(startNode);
         openSetCosts.set(this.hashState(start), 0);
+        durationLabels.set(this.hashState(start), [startNode]);
         // Constraint defaults
         const maxIterations = 10000;
         // Issue #535: constraints.maxSteps caps the search depth (= plan length).
         const maxPlanLength = constraints?.maxSteps ?? DEFAULT_MAX_PLAN_STEPS;
         const maxCost = constraints?.maxCost ?? Infinity;
         const maxDuration = constraints?.maxDurationMs ?? Infinity;
+        const boundedDuration = Number.isFinite(maxDuration);
         let iterations = 0;
         while (openHeap.length > 0 && iterations < maxIterations) {
             iterations++;
             // Get node with lowest f score — O(log n)
             const current = openHeap.pop();
+            const stateKey = this.hashState(current.state);
+            if (boundedDuration && !durationLabels.get(stateKey)?.includes(current)) {
+                continue; // a later label dominates this queued path
+            }
             // Check if goal reached
             if (this.meetsConditions(current.state, goal)) {
                 return this.reconstructPlan(current);
             }
-            // Generate state hash for closed set
-            const stateKey = this.hashState(current.state);
-            if (closedSet.has(stateKey)) {
-                // Lazy deletion: skip stale duplicate nodes
-                continue;
+            if (!boundedDuration) {
+                if (closedSet.has(stateKey)) {
+                    continue; // lazy deletion for the existing cost-only search
+                }
+                closedSet.add(stateKey);
+                openSetCosts.delete(stateKey);
             }
-            closedSet.add(stateKey);
-            // Node is now closed — remove from open set cost tracker
-            openSetCosts.delete(stateKey);
             // Check depth limit
             if (current.depth >= maxPlanLength) {
                 continue;
@@ -364,7 +389,7 @@ export class GOAPPlanner {
                 const newState = this.applyAction(current.state, action);
                 const newStateKey = this.hashState(newState);
                 // Skip if already visited
-                if (closedSet.has(newStateKey)) {
+                if (!boundedDuration && closedSet.has(newStateKey)) {
                     continue;
                 }
                 // Calculate costs
@@ -379,26 +404,33 @@ export class GOAPPlanner {
                     continue;
                 }
                 // Check duration constraints
-                const estimatedDuration = current.depth * 1000 + (action.estimatedDurationMs ?? 0);
+                const estimatedDuration = current.estimatedDurationMs + (action.estimatedDurationMs ?? 0);
                 if (estimatedDuration > maxDuration) {
                     continue;
                 }
-                // Only push if this is a better path than any previously seen in the open set
-                const prevG = openSetCosts.get(newStateKey);
-                if (prevG !== undefined && g >= prevG) {
-                    continue;
+                const next = {
+                    state: newState, action, parent: current, g, h, f,
+                    depth: current.depth + 1, estimatedDurationMs: estimatedDuration,
+                };
+                if (boundedDuration) {
+                    const labels = durationLabels.get(newStateKey) ?? [];
+                    if (labels.some((label) => label.g <= g &&
+                        label.estimatedDurationMs <= estimatedDuration && label.depth <= next.depth)) {
+                        continue;
+                    }
+                    durationLabels.set(newStateKey, [
+                        ...labels.filter((label) => !(g <= label.g &&
+                            estimatedDuration <= label.estimatedDurationMs && next.depth <= label.depth)),
+                        next,
+                    ]);
+                }
+                else {
+                    const prevG = openSetCosts.get(newStateKey);
+                    if (prevG !== undefined && g >= prevG)
+                        continue;
+                    openSetCosts.set(newStateKey, g);
                 }
-                openSetCosts.set(newStateKey, g);
-                // Add new node — O(log n)
-                openHeap.push({
-                    state: newState,
-                    action,
-                    parent: current,
-                    g,
-                    h,
-                    f,
-                    depth: current.depth + 1,
-                });
+                openHeap.push(next);
             }
         }
         // No plan found
@@ -896,20 +928,30 @@ export class GOAPPlanner {
       ORDER BY created_at DESC, id DESC
       LIMIT ?
     `).all(...args, boundedLimit);
-        const plans = rows.map((row) => {
-            const actionIds = safeJsonParse(row.action_sequence);
-            if (!Array.isArray(actionIds)) {
-                throw new Error(`Invalid action sequence in GOAP plan ${row.id}`);
+        const plans = [];
+        const invalidPlanIds = [];
+        for (const row of rows) {
+            let actionIds;
+            try {
+                actionIds = safeJsonParse(row.action_sequence);
+            }
+            catch {
+                invalidPlanIds.push(row.id);
+                continue;
+            }
+            if (!Array.isArray(actionIds) || !actionIds.every((id) => typeof id === 'string')) {
+                invalidPlanIds.push(row.id);
+                continue;
             }
-            return {
+            plans.push({
                 id: row.id,
                 status: row.status,
                 stepCount: actionIds.length,
                 totalCost: row.total_cost,
                 createdAt: row.created_at,
-            };
-        });
-        return { plans, count };
+            });
+        }
+        return { plans, count, ...(invalidPlanIds.length ? { invalidPlanIds } : {}) };
     }
     /**
      * Find a similar plan by goal conditions
@@ -998,7 +1040,8 @@ export class GOAPPlanner {
         if (plan.actions.length > maxSteps)
             return false;
         if (constraints?.maxDurationMs !== undefined &&
-            plan.estimatedDurationMs > constraints.maxDurationMs) {
+            plan.actions.reduce((sum, action) => sum + (action.estimatedDurationMs ?? 0), 0)
+                > constraints.maxDurationMs) {
             return false;
         }
         const allowed = new Set(this.getAvailableActions(constraints).map((a) => a.id));

package/dist/plugins/cache.js

@@ -51,9 +51,16 @@ export class PluginCache {
         }
         // Copy source to cache
         fs.mkdirSync(dir, { recursive: true });
-        this.copyDir(sourceDir, dir);
-        // Write the manifest (ensure it's present even if source didn't have it at root)
-        fs.writeFileSync(path.join(dir, 'qe-plugin.json'), JSON.stringify(manifest, null, 2));
+        try {
+            this.copyDir(sourceDir, dir);
+            // Write the manifest (ensure it's present even if source didn't have it at root)
+            fs.writeFileSync(path.join(dir, 'qe-plugin.json'), JSON.stringify(manifest, null, 2));
+        }
+        catch (error) {
+            // A partial directory must not satisfy the immutable-cache fast path on retry.
+            fs.rmSync(dir, { recursive: true, force: true });
+            throw error;
+        }
         // Cleanup old versions
         this.pruneOldVersions(manifest.name);
         return dir;

package/dist/shared/embeddings/embedding-cache.js

@@ -22,7 +22,7 @@ export class EmbeddingCache {
      */
     hashContent(content, model) {
         return createHash('sha256')
-            .update(`${model}:${content}`)
+            .update(JSON.stringify([model, content]))
             .digest('hex');
     }
     /**
@@ -36,7 +36,7 @@ export class EmbeddingCache {
             // Move to end (LRU update)
             this.cache.delete(key);
             this.cache.set(key, entry);
-            return entry.embedding;
+            return [...entry.embedding];
         }
         this.misses++;
         return null;
@@ -54,7 +54,7 @@ export class EmbeddingCache {
             }
         }
         const entry = {
-            embedding,
+            embedding: [...embedding],
             timestamp: Date.now(),
             model,
         };
@@ -118,7 +118,7 @@ export class EmbeddingCache {
     export() {
         return Array.from(this.cache.entries()).map(([key, entry]) => ({
             key,
-            entry,
+            entry: { ...entry, embedding: [...entry.embedding] },
         }));
     }
     /**
@@ -128,7 +128,7 @@ export class EmbeddingCache {
         this.cache.clear();
         for (const { key, entry } of data) {
             if (this.cache.size < this.maxSize) {
-                this.cache.set(key, entry);
+                this.cache.set(key, { ...entry, embedding: [...entry.embedding] });
             }
         }
     }

package/dist/shared/embeddings/nomic-embedder.js

@@ -14,6 +14,7 @@ import { OllamaClient } from './ollama-client.js';
 import { EmbeddingCache } from './embedding-cache.js';
 import { toErrorMessage } from '../error-utils.js';
 import { EMBEDDING_CONFIG, } from './types.js';
+const PSEUDO_EMBEDDING_MODEL = 'pseudo-embedding';
 /**
  * Nomic Embedder for generating code embeddings via Ollama
  */
@@ -50,17 +51,23 @@ export class NomicEmbedder {
      * Generate embedding for a single text string
      */
     async embed(text) {
-        // Check cache first
-        const cached = this.cache.get(text, EMBEDDING_CONFIG.MODEL);
+        // Prefer genuine cached vectors, then select the active backend before a
+        // single counted lookup so alternate namespaces do not inflate misses.
+        let model = this.cache.has(text, EMBEDDING_CONFIG.MODEL) ||
+            await this.isOllamaAvailable() || !this.enableFallback
+            ? EMBEDDING_CONFIG.MODEL : PSEUDO_EMBEDDING_MODEL;
+        const cached = this.cache.get(text, model);
         if (cached) {
             return cached;
         }
         // Try Ollama first, fall back to pseudo-embedding if unavailable
         let embedding;
         if (await this.isOllamaAvailable()) {
+            model = EMBEDDING_CONFIG.MODEL;
             embedding = await this.client.generateEmbedding(text);
         }
         else if (this.enableFallback) {
+            model = PSEUDO_EMBEDDING_MODEL;
             embedding = this.generatePseudoEmbedding(text);
         }
         else {
@@ -68,7 +75,7 @@ export class NomicEmbedder {
                 `Please run: ollama pull ${EMBEDDING_CONFIG.MODEL}`);
         }
         // Cache result
-        this.cache.set(text, EMBEDDING_CONFIG.MODEL, embedding);
+        this.cache.set(text, model, embedding);
         return embedding;
     }
     /**
@@ -181,12 +188,14 @@ export class NomicEmbedder {
             const formattedText = this.formatForEmbedding(chunk);
             const chunkStartTime = Date.now();
             // Check cache
-            const cachedEmbedding = this.cache.get(formattedText, EMBEDDING_CONFIG.MODEL);
+            const cachedModel = useOllama || this.cache.has(formattedText, EMBEDDING_CONFIG.MODEL)
+                ? EMBEDDING_CONFIG.MODEL : PSEUDO_EMBEDDING_MODEL;
+            const cachedEmbedding = this.cache.get(formattedText, cachedModel);
             if (cachedEmbedding) {
                 return {
                     chunkId: chunk.id,
                     embedding: cachedEmbedding,
-                    model: EMBEDDING_CONFIG.MODEL,
+                    model: cachedModel,
                     cached: true,
                     computeTimeMs: Date.now() - chunkStartTime,
                 };
@@ -201,11 +210,12 @@ export class NomicEmbedder {
                     embedding = this.generatePseudoEmbedding(formattedText);
                 }
                 // Cache the result
-                this.cache.set(formattedText, EMBEDDING_CONFIG.MODEL, embedding);
+                const model = useOllama ? EMBEDDING_CONFIG.MODEL : PSEUDO_EMBEDDING_MODEL;
+                this.cache.set(formattedText, model, embedding);
                 return {
                     chunkId: chunk.id,
                     embedding,
-                    model: useOllama ? EMBEDDING_CONFIG.MODEL : 'pseudo-embedding',
+                    model,
                     cached: false,
                     computeTimeMs: Date.now() - chunkStartTime,
                 };

package/dist/shared/embeddings/ollama-client.js

@@ -34,10 +34,12 @@ export class OllamaClient {
             }
             const data = await response.json();
             // Check if configured embedding model is available
-            // Model names may include tags like ":latest", so use startsWith for matching
+            // Match the configured model exactly, allowing its existing tag suffix.
             if (data.models) {
-                return data.models.some((model) => model.name?.startsWith(EMBEDDING_CONFIG.MODEL) ||
-                    model.model?.startsWith(EMBEDDING_CONFIG.MODEL));
+                return data.models.some((model) => model.name === EMBEDDING_CONFIG.MODEL ||
+                    model.name?.startsWith(`${EMBEDDING_CONFIG.MODEL}:`) ||
+                    model.model === EMBEDDING_CONFIG.MODEL ||
+                    model.model?.startsWith(`${EMBEDDING_CONFIG.MODEL}:`));
             }
             return false;
         }

package/dist/shared/git/git-analyzer.js

@@ -66,10 +66,11 @@ export class GitAnalyzer {
             return 0.4; // Default when not in git repo
         }
         try {
-            const relativePath = sanitizeGitArg(this.getRelativePath(filePath));
-            // Use execFileSync with argument array to prevent injection
+            const relativePath = this.getRelativePath(filePath);
+            // Literal pathspecs preserve route filenames such as app/[id].tsx.
+            // execFileSync passes arguments directly without shell interpretation.
             const output = execFileSync('git', [
-                'log', '--oneline', '--since=90 days ago', '--', relativePath
+                '--literal-pathspecs', 'log', '--oneline', '--since=90 days ago', '--', relativePath
             ], {
                 cwd: this.config.repoRoot,
                 encoding: 'utf-8',
@@ -97,10 +98,10 @@ export class GitAnalyzer {
             return 0.5; // Default when not in git repo
         }
         try {
-            const relativePath = sanitizeGitArg(this.getRelativePath(filePath));
+            const relativePath = this.getRelativePath(filePath);
             // Get blame info using execFileSync with argument array
             const blameOutput = execFileSync('git', [
-                'blame', '--line-porcelain', '--', relativePath
+                '--literal-pathspecs', 'blame', '--line-porcelain', '--', relativePath
             ], {
                 cwd: this.config.repoRoot,
                 encoding: 'utf-8',
@@ -143,12 +144,12 @@ export class GitAnalyzer {
             return 0.4; // Default when not in git repo
         }
         try {
-            const relativePath = sanitizeGitArg(this.getRelativePath(filePath));
+            const relativePath = this.getRelativePath(filePath);
             // Get first commit date using execFileSync with argument array
             let firstCommitTimestamp = NaN;
             try {
                 const firstCommitOutput = execFileSync('git', [
-                    'log', '--format=%at', '--follow', '--diff-filter=A', '--', relativePath
+                    '--literal-pathspecs', 'log', '--format=%at', '--follow', '--diff-filter=A', '--', relativePath
                 ], {
                     cwd: this.config.repoRoot,
                     encoding: 'utf-8',
@@ -167,7 +168,7 @@ export class GitAnalyzer {
             let lastCommitTimestamp = NaN;
             try {
                 const lastCommitOutput = execFileSync('git', [
-                    'log', '-1', '--format=%at', '--', relativePath
+                    '--literal-pathspecs', 'log', '-1', '--format=%at', '--', relativePath
                 ], {
                     cwd: this.config.repoRoot,
                     encoding: 'utf-8',
@@ -216,7 +217,7 @@ export class GitAnalyzer {
             return 0.2; // Default when not in git repo
         }
         try {
-            const relativePath = sanitizeGitArg(this.getRelativePath(filePath));
+            const relativePath = this.getRelativePath(filePath);
             // Search for each keyword separately and count unique commits
             // This avoids shell injection from keywords config
             let bugCommits = 0;
@@ -225,7 +226,7 @@ export class GitAnalyzer {
                 const sanitizedKeyword = sanitizeGitArg(keyword);
                 try {
                     const output = execFileSync('git', [
-                        'log', '--oneline', '--grep', sanitizedKeyword, '-i', '--', relativePath
+                        '--literal-pathspecs', 'log', '--oneline', '--grep', sanitizedKeyword, '-i', '--', relativePath
                     ], {
                         cwd: this.config.repoRoot,
                         encoding: 'utf-8',
@@ -267,12 +268,12 @@ export class GitAnalyzer {
             return this.getDefaultFileHistory(filePath);
         }
         try {
-            const relativePath = sanitizeGitArg(this.getRelativePath(filePath));
+            const relativePath = this.getRelativePath(filePath);
             // Get commit count using execFileSync with argument array
             let totalCommits = 0;
             try {
                 const commitCountOutput = execFileSync('git', [
-                    'log', '--oneline', '--', relativePath
+                    '--literal-pathspecs', 'log', '--oneline', '--', relativePath
                 ], {
                     cwd: this.config.repoRoot,
                     encoding: 'utf-8',
@@ -287,7 +288,7 @@ export class GitAnalyzer {
             let uniqueAuthors = 0;
             try {
                 const authorsOutput = execFileSync('git', [
-                    'log', '--format=%ae', '--', relativePath
+                    '--literal-pathspecs', 'log', '--format=%ae', '--', relativePath
                 ], {
                     cwd: this.config.repoRoot,
                     encoding: 'utf-8',
@@ -305,7 +306,7 @@ export class GitAnalyzer {
             let firstCommit = null;
             try {
                 const firstCommitOutput = execFileSync('git', [
-                    'log', '--format=%at', '--follow', '--', relativePath
+                    '--literal-pathspecs', 'log', '--format=%at', '--follow', '--', relativePath
                 ], {
                     cwd: this.config.repoRoot,
                     encoding: 'utf-8',
@@ -328,7 +329,7 @@ export class GitAnalyzer {
             let lastCommit = null;
             try {
                 const lastCommitOutput = execFileSync('git', [
-                    'log', '-1', '--format=%at', '--', relativePath
+                    '--literal-pathspecs', 'log', '-1', '--format=%at', '--', relativePath
                 ], {
                     cwd: this.config.repoRoot,
                     encoding: 'utf-8',
@@ -361,7 +362,7 @@ export class GitAnalyzer {
                 const sanitizedKeyword = sanitizeGitArg(keyword);
                 try {
                     const bugFixOutput = execFileSync('git', [
-                        'log', '--oneline', '--grep', sanitizedKeyword, '-i', '--', relativePath
+                        '--literal-pathspecs', 'log', '--oneline', '--grep', sanitizedKeyword, '-i', '--', relativePath
                     ], {
                         cwd: this.config.repoRoot,
                         encoding: 'utf-8',
@@ -410,19 +411,19 @@ export class GitAnalyzer {
         }
         try {
             const sinceDate = since || new Date(Date.now() - 24 * 60 * 60 * 1000);
-            const sinceStr = sinceDate.toISOString().split('T')[0];
+            const sinceStr = sinceDate.toISOString();
             // Get files changed since the date using execFileSync with argument array
             const output = execFileSync('git', [
-                'log', `--since=${sinceStr}`, '--name-only', '--pretty=format:'
+                'log', `--since=${sinceStr}`, '--name-only', '-z', '--format='
             ], {
                 cwd: this.config.repoRoot,
                 encoding: 'utf-8',
                 stdio: ['pipe', 'pipe', 'pipe'],
-            }).trim();
+            });
             if (!output)
                 return [];
-            // Deduplicate and filter empty lines manually (instead of sort -u | grep -v)
-            const files = output.split('\n').filter(Boolean);
+            // NUL records preserve whitespace, newlines and Git-quoted Unicode paths.
+            const files = output.split('\0').filter(Boolean);
             return Array.from(new Set(files));
         }
         catch {
@@ -442,15 +443,15 @@ export class GitAnalyzer {
             // Sanitize commit hash to prevent injection
             const sanitizedHash = sanitizeGitArg(commitHash);
             const output = execFileSync('git', [
-                'diff-tree', '--no-commit-id', '--name-only', '-r', sanitizedHash
+                'diff-tree', '--no-commit-id', '--name-only', '-z', '-r', sanitizedHash
             ], {
                 cwd: this.config.repoRoot,
                 encoding: 'utf-8',
                 stdio: ['pipe', 'pipe', 'pipe'],
-            }).trim();
+            });
             if (!output)
                 return [];
-            return output.split('\n').filter(Boolean);
+            return output.split('\0').filter(Boolean);
         }
         catch {
             return [];
@@ -469,14 +470,14 @@ export class GitAnalyzer {
             // Get unstaged changes using execFileSync with argument array
             try {
                 const unstagedOutput = execFileSync('git', [
-                    'diff', '--name-only', 'HEAD'
+                    'diff', '--name-only', '-z', 'HEAD'
                 ], {
                     cwd: this.config.repoRoot,
                     encoding: 'utf-8',
                     stdio: ['pipe', 'pipe', 'pipe'],
-                }).trim();
+                });
                 if (unstagedOutput) {
-                    files.push(...unstagedOutput.split('\n').filter(Boolean));
+                    files.push(...unstagedOutput.split('\0').filter(Boolean));
                 }
             }
             catch {
@@ -485,14 +486,14 @@ export class GitAnalyzer {
             // Get staged changes using execFileSync with argument array
             try {
                 const stagedOutput = execFileSync('git', [
-                    'diff', '--name-only', '--cached'
+                    'diff', '--name-only', '-z', '--cached'
                 ], {
                     cwd: this.config.repoRoot,
                     encoding: 'utf-8',
                     stdio: ['pipe', 'pipe', 'pipe'],
-                }).trim();
+                });
                 if (stagedOutput) {
-                    files.push(...stagedOutput.split('\n').filter(Boolean));
+                    files.push(...stagedOutput.split('\0').filter(Boolean));
                 }
             }
             catch {

package/dist/shared/http/http-client.js

@@ -74,8 +74,9 @@ class CircuitBreaker {
             }
             return false;
         }
-        // half-open: allow one request through
-        return true;
+        // The open -> half-open transition already admitted the recovery probe.
+        // Keep further requests out until that probe records success or failure.
+        return false;
     }
     reset(url) {
         if (url) {
@@ -253,17 +254,23 @@ export class HttpClient {
         if (!error) {
             return 'UNKNOWN_ERROR';
         }
-        if (error.name === 'AbortError') {
-            return 'TIMEOUT';
-        }
-        if (error.message.includes('ECONNREFUSED')) {
-            return 'CONNECTION_REFUSED';
-        }
-        if (error.message.includes('ENOTFOUND')) {
-            return 'DNS_ERROR';
-        }
-        if (error.message.includes('ETIMEDOUT')) {
-            return 'NETWORK_TIMEOUT';
+        // Native fetch wraps transport errors in a TypeError whose cause carries
+        // the socket/DNS code. Retain message-based handling for existing callers.
+        const visited = new Set();
+        let current = error;
+        while (typeof current === 'object' && current !== null && !visited.has(current)) {
+            visited.add(current);
+            const detail = current;
+            if (detail.name === 'AbortError')
+                return 'TIMEOUT';
+            const message = typeof detail.message === 'string' ? detail.message : '';
+            if (detail.code === 'ECONNREFUSED' || message.includes('ECONNREFUSED'))
+                return 'CONNECTION_REFUSED';
+            if (detail.code === 'ENOTFOUND' || message.includes('ENOTFOUND'))
+                return 'DNS_ERROR';
+            if (detail.code === 'ETIMEDOUT' || message.includes('ETIMEDOUT'))
+                return 'NETWORK_TIMEOUT';
+            current = detail.cause;
         }
         return 'REQUEST_FAILED';
     }