@claude-flow/cli 3.55.0 → 3.56.1

package/dist/src/mcp-tools/agent-execute-core.js

@@ -101,7 +101,9 @@ export async function callAnthropicMessages(input) {
     // key-presence inference, kept below as the last-resort fallback.
     const explicitProvider = (input.provider || process.env.RUFLO_PROVIDER || '').toLowerCase();
     const ollamaKey = process.env.OLLAMA_API_KEY;
-    const anthropicKey = process.env.ANTHROPIC_API_KEY;
+    const anthropicAuthToken = process.env.ANTHROPIC_AUTH_TOKEN;
+    // A gateway bearer token is also an Anthropic credential for provider inference.
+    const anthropicKey = process.env.ANTHROPIC_API_KEY || anthropicAuthToken;
     // #2042 — OpenRouter is an OpenAI-compat endpoint that fronts dozens of
     // providers. Reporter (@ummcke00) had `providers.openrouter.apiKey` in
     // their config.yaml but agent_execute hardcoded Anthropic. Detect via
@@ -109,7 +111,7 @@ export async function callAnthropicMessages(input) {
     // when no Anthropic key is available (same precedence as the Ollama
     // branch above).
     const openrouterKey = process.env.OPENROUTER_API_KEY;
-    const useOpenRouter = explicitProvider === 'openrouter' || (!anthropicKey && !!openrouterKey);
+    const useOpenRouter = explicitProvider === 'openrouter' || (!explicitProvider && !anthropicKey && !!openrouterKey);
     // #2962 — only consult the persisted config when a candidate is actually
     // relevant (explicit choice, or no env key found anywhere), so a normal
     // ANTHROPIC_API_KEY-only setup never pays a config-file read.
@@ -117,7 +119,7 @@ export async function callAnthropicMessages(input) {
         ? getPersistedProviderConfig('ollama')
         : undefined;
     const persistedOpenRouter = explicitProvider === 'openrouter' && !openrouterKey ? getPersistedProviderConfig('openrouter') : undefined;
-    const useOllama = explicitProvider === 'ollama' || (!anthropicKey && !openrouterKey && (!!ollamaKey || !!persistedOllama));
+    const useOllama = explicitProvider === 'ollama' || (!explicitProvider && !anthropicKey && !openrouterKey && (!!ollamaKey || !!persistedOllama));
     if (useOpenRouter) {
         const apiKey = openrouterKey || persistedOpenRouter?.apiKey;
         if (apiKey) {
@@ -133,6 +135,7 @@ export async function callAnthropicMessages(input) {
                 defaultModel: process.env.OPENROUTER_DEFAULT_MODEL || persistedOpenRouter?.model || 'anthropic/claude-sonnet-4-6',
             });
         }
+        return { success: false, error: 'OpenRouter was selected but no API key is configured.' };
     }
     if (useOllama) {
         // #2962 — retire the undocumented OLLAMA_API_KEY=local sentinel
@@ -151,22 +154,26 @@ export async function callAnthropicMessages(input) {
                 model: input.model || persistedOllama?.model,
             });
         }
+        return { success: false, error: 'Ollama was selected but no API key or self-hosted endpoint is configured.' };
     }
     if (!anthropicKey) {
         return {
             success: false,
-            error: 'No LLM provider configured. Set ANTHROPIC_API_KEY (Tier-3), OPENROUTER_API_KEY (#2042), or OLLAMA_API_KEY (Tier-2 — #1725).',
+            error: 'No LLM provider configured. Set ANTHROPIC_API_KEY or ANTHROPIC_AUTH_TOKEN (Tier-3), OPENROUTER_API_KEY (#2042), or OLLAMA_API_KEY (Tier-2 — #1725).',
         };
     }
     const model = input.model || DEFAULT_ANTHROPIC_MODEL;
     const startedAt = Date.now();
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), input.timeoutMs || 60000);
     try {
-        const controller = new AbortController();
-        const timer = setTimeout(() => controller.abort(), input.timeoutMs || 60000);
-        const res = await fetch('https://api.anthropic.com/v1/messages', {
+        const baseUrl = (process.env.ANTHROPIC_BASE_URL || 'https://api.anthropic.com').replace(/\/+$/, '');
+        const res = await fetch(`${baseUrl}/v1/messages`, {
             method: 'POST',
             headers: {
-                'x-api-key': anthropicKey,
+                ...(anthropicAuthToken
+                    ? { Authorization: `Bearer ${anthropicAuthToken}` }
+                    : { 'x-api-key': anthropicKey }),
                 'anthropic-version': '2023-06-01',
                 'content-type': 'application/json',
             },
@@ -191,7 +198,6 @@ export async function callAnthropicMessages(input) {
             }),
             signal: controller.signal,
         });
-        clearTimeout(timer);
         if (!res.ok) {
             const errText = await res.text().catch(() => '<unreadable error body>');
             return { success: false, model, error: `Anthropic API error ${res.status}: ${errText.slice(0, 400)}` };
@@ -223,6 +229,9 @@ export async function callAnthropicMessages(input) {
             durationMs: Date.now() - startedAt,
         };
     }
+    finally {
+        clearTimeout(timer);
+    }
 }
 /**
  * Ollama Cloud / OpenAI-compat provider — Tier-2 routing per ADR-026 + #1725.
@@ -252,9 +261,9 @@ async function callOllamaCompat(input) {
     // (the daemon binds to 11434 with no auth by default), but Ollama Cloud
     // does. Send the bearer when the key is non-empty AND looks cloud-shaped.
     const sendAuth = !!input.apiKey && input.apiKey !== 'local';
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), input.timeoutMs || 60000);
     try {
-        const controller = new AbortController();
-        const timer = setTimeout(() => controller.abort(), input.timeoutMs || 60000);
         const res = await fetch(url, {
             method: 'POST',
             headers: {
@@ -274,7 +283,6 @@ async function callOllamaCompat(input) {
             }),
             signal: controller.signal,
         });
-        clearTimeout(timer);
         if (!res.ok) {
             const errText = await res.text().catch(() => '<unreadable error body>');
             return { success: false, model, error: `Ollama API error ${res.status} at ${url}: ${errText.slice(0, 400)}` };
@@ -304,6 +312,9 @@ async function callOllamaCompat(input) {
             durationMs: Date.now() - startedAt,
         };
     }
+    finally {
+        clearTimeout(timer);
+    }
 }
 /**
  * Generic OpenAI-compat caller for OpenRouter and other OpenAI-shaped
@@ -319,9 +330,9 @@ async function callOpenAICompat(input) {
     const startedAt = Date.now();
     const base = input.baseUrl.replace(/\/+$/, '');
     const url = `${base}/v1/chat/completions`;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), input.timeoutMs || 60000);
     try {
-        const controller = new AbortController();
-        const timer = setTimeout(() => controller.abort(), input.timeoutMs || 60000);
         const messages = [];
         if (input.systemPrompt)
             messages.push({ role: 'system', content: input.systemPrompt });
@@ -344,7 +355,6 @@ async function callOpenAICompat(input) {
             }),
             signal: controller.signal,
         });
-        clearTimeout(timer);
         if (!res.ok) {
             const errText = await res.text().catch(() => '<unreadable error body>');
             return { success: false, model, error: `${input.providerLabel} API error ${res.status}: ${errText.slice(0, 400)}` };
@@ -374,6 +384,9 @@ async function callOpenAICompat(input) {
             durationMs: Date.now() - startedAt,
         };
     }
+    finally {
+        clearTimeout(timer);
+    }
 }
 function resolveOpenAICompatModel(input, fallback) {
     if (!input)
@@ -418,6 +431,8 @@ export function resolveAnthropicModel(input) {
         return input.slice('anthropic:'.length);
     return input;
 }
+// Tracks overlapping calls in this process; persisted state remains authoritative.
+const activeExecutions = new Map();
 export async function executeAgentTask(input) {
     const store = loadAgentStore();
     const agent = store.agents[input.agentId];
@@ -465,194 +480,235 @@ export async function executeAgentTask(input) {
         `You are a ${agent.agentType} agent operating as part of a Ruflo swarm. ` +
             `Agent ID: ${input.agentId}. Domain: ${agent.domain ?? 'general'}. ` +
             `Respond directly and stay focused on the task. If you need information you don't have, state that explicitly.`;
+    const initialModelId = agent.modelId;
+    const initialModel = agent.model;
     agent.status = 'busy';
     agent.taskCount = (agent.taskCount || 0) + 1;
     saveAgentStore(store);
-    const startedAt = Date.now();
-    // #2042 — delegate to callAnthropicMessages so the v3 provider router
-    // (Anthropic / Ollama / OpenRouter) governs which backend is hit.
-    // #2962 — forward the agent's own explicit provider (set at spawn time
-    // from --provider / persisted config) so it outranks env-var inference.
-    // Only the first-attempt call; the ADR-149 fallback-retry call below is
-    // driven by the cost-optimal neural router picking model-id alternatives,
-    // an orthogonal mechanism left as-is to avoid unintended interaction.
-    let result = await callAnthropicMessages({
-        model: anthropicModel,
-        prompt: input.prompt,
-        systemPrompt,
-        maxTokens: input.maxTokens,
-        temperature: input.temperature,
-        timeoutMs: input.timeoutMs,
-        provider: agent.provider,
-    });
-    // ADR-149 iter 7 — fallback chain on retryable failures (429, 5xx,
-    // timeout). When the cost-optimal neural backend picked a specific
-    // model id and that model fails for a transient reason, fall back to
-    // the next-cheapest candidate that clears the quality bar. Budget is
-    // bounded by CLAUDE_FLOW_ROUTER_FALLBACK_MAX_RETRIES (default 1) so
-    // upstream outages don't cause retry storms.
-    const fallbackBudget = Math.max(0, parseInt(process.env.CLAUDE_FLOW_ROUTER_FALLBACK_MAX_RETRIES ?? '1', 10) || 1);
-    const fallbackHistory = [];
-    if (!result.success && agent.modelId && fallbackBudget > 0) {
-        const isRetryable = /\b(429|500|502|503|504|timeout|ECONNRESET|ETIMEDOUT)\b/i.test(result.error ?? '');
-        if (isRetryable) {
-            try {
-                const { nextCostOptimalAlternative } = await import('../ruvector/neural-router.js');
-                // ADR-149 iter 9 — delegate to the shared task-embedder LRU. The
-                // pipeline + cache are shared with agent-tools.ts, so the embedding
-                // for this prompt is almost always already cached from the initial
-                // routing decision (no extra inference cost in steady state).
-                const { embedTaskWithCache } = await import('../ruvector/task-embedder.js');
-                const embedding = await embedTaskWithCache(input.prompt);
-                if (embedding) {
-                    const excludeIds = [agent.modelId];
-                    for (let attempt = 0; attempt < fallbackBudget && !result.success; attempt++) {
-                        fallbackHistory.push({ modelId: excludeIds[excludeIds.length - 1], error: result.error ?? '' });
-                        const alt = await nextCostOptimalAlternative(embedding, excludeIds);
-                        if (!alt || !alt.modelId)
-                            break;
-                        excludeIds.push(alt.modelId);
-                        const altResult = await callAnthropicMessages({
-                            model: alt.modelId,
-                            prompt: input.prompt,
-                            systemPrompt,
-                            maxTokens: input.maxTokens,
-                            temperature: input.temperature,
-                            timeoutMs: input.timeoutMs,
-                        });
-                        // Record the model that ACTUALLY answered (or errored). On success,
-                        // update agent.modelId so downstream observers see the retry winner.
-                        agent.modelId = alt.modelId;
-                        result = altResult;
+    const executionKey = JSON.stringify([getAgentPath(), input.agentId, agent.createdAt]);
+    activeExecutions.set(executionKey, (activeExecutions.get(executionKey) || 0) + 1);
+    try {
+        const startedAt = Date.now();
+        // #2042 — delegate to callAnthropicMessages so the v3 provider router
+        // (Anthropic / Ollama / OpenRouter) governs which backend is hit.
+        // #2962 — forward the agent's own explicit provider (set at spawn time
+        // from --provider / persisted config) so it outranks env-var inference.
+        // Only the first-attempt call; the ADR-149 fallback-retry call below is
+        // driven by the cost-optimal neural router picking model-id alternatives,
+        // an orthogonal mechanism left as-is to avoid unintended interaction.
+        let result = await callAnthropicMessages({
+            model: anthropicModel,
+            prompt: input.prompt,
+            systemPrompt,
+            maxTokens: input.maxTokens,
+            temperature: input.temperature,
+            timeoutMs: input.timeoutMs,
+            provider: agent.provider,
+        });
+        // ADR-149 iter 7 — fallback chain on retryable failures (429, 5xx,
+        // timeout). When the cost-optimal neural backend picked a specific
+        // model id and that model fails for a transient reason, fall back to
+        // the next-cheapest candidate that clears the quality bar. Budget is
+        // bounded by CLAUDE_FLOW_ROUTER_FALLBACK_MAX_RETRIES (default 1) so
+        // upstream outages don't cause retry storms.
+        const configuredFallbackBudget = parseInt(process.env.CLAUDE_FLOW_ROUTER_FALLBACK_MAX_RETRIES ?? '1', 10);
+        const fallbackBudget = Number.isNaN(configuredFallbackBudget) ? 1 : Math.max(0, configuredFallbackBudget);
+        const fallbackHistory = [];
+        // Keep feedback for each completed attempt before switching model identity.
+        const failedAttempts = [];
+        if (!result.success && agent.modelId && fallbackBudget > 0) {
+            const isRetryable = /\b(429|500|502|503|504|timeout|ECONNRESET|ETIMEDOUT)\b/i.test(result.error ?? '');
+            if (isRetryable) {
+                try {
+                    const { nextCostOptimalAlternative } = await import('../ruvector/neural-router.js');
+                    // ADR-149 iter 9 — delegate to the shared task-embedder LRU. The
+                    // pipeline + cache are shared with agent-tools.ts, so the embedding
+                    // for this prompt is almost always already cached from the initial
+                    // routing decision (no extra inference cost in steady state).
+                    const { embedTaskWithCache } = await import('../ruvector/task-embedder.js');
+                    const embedding = await embedTaskWithCache(input.prompt);
+                    if (embedding) {
+                        const excludeIds = [agent.modelId];
+                        for (let attempt = 0; attempt < fallbackBudget && !result.success; attempt++) {
+                            fallbackHistory.push({ modelId: excludeIds[excludeIds.length - 1], error: result.error ?? '' });
+                            const alt = await nextCostOptimalAlternative(embedding, excludeIds);
+                            if (!alt || !alt.modelId)
+                                break;
+                            excludeIds.push(alt.modelId);
+                            const altResult = await callAnthropicMessages({
+                                model: alt.modelId,
+                                prompt: input.prompt,
+                                systemPrompt,
+                                maxTokens: input.maxTokens,
+                                temperature: input.temperature,
+                                timeoutMs: input.timeoutMs,
+                            });
+                            // Record the model that ACTUALLY answered (or errored). On success,
+                            // update agent.modelId so downstream observers see the retry winner.
+                            failedAttempts.push({ model: agent.model ?? 'sonnet', modelId: agent.modelId });
+                            agent.modelId = alt.modelId;
+                            agent.model = alt.model;
+                            result = altResult;
+                        }
                     }
                 }
-            }
-            catch {
-                // Fallback chain is best-effort — preserve the original error result.
+                catch {
+                    // Fallback chain is best-effort — preserve the original error result.
+                }
             }
         }
-    }
-    agent.status = 'idle';
-    // ADR-149 — close the bandit feedback loop. `recordModelOutcome` updates
-    // the Beta(α,β) prior for the agent's tier so the Thompson sampler learns
-    // from production traffic instead of staying frozen at install-day priors.
-    // This is best-effort: any error here must NOT break the agent execution.
-    // For now, "success" = the model returned a response without an API error.
-    // A finer-grained signal (user-accepted output / regression-detected) is a
-    // follow-up; this commit closes the bandit's basic learning loop.
-    try {
-        const { recordModelOutcome, recordModelOutcomeByModelId } = await import('../ruvector/model-router.js');
-        // Bandit priors are keyed on the 3 canonical tiers (haiku/sonnet/opus/inherit);
-        // collapse opus-4.7 → opus before recording so the bandit's per-tier Beta
-        // updates correctly.
-        const tier = agent.model === 'opus-4.7' ? 'opus' :
-            agent.model ?? 'sonnet';
-        const outcome = result.success ? 'success' : 'failure';
-        recordModelOutcome(input.prompt, tier, outcome);
-        // ADR-149 — also write to the shadow per-modelId priors when the cost-
-        // optimal neural backend picked a concrete model id. Selection logic
-        // still uses tier priors, but the per-modelId data accumulates so a
-        // future refactor can switch the selector over.
-        if (agent.modelId) {
-            recordModelOutcomeByModelId(input.prompt, agent.modelId, outcome);
-        }
-        // ADR-149 iter 17 — close the production-data side of the feedback loop.
-        // The trajectory recorder (CLAUDE_FLOW_ROUTER_TRAJECTORY=1) writes
-        // per-decision rows to .swarm/model-router-trajectories.jsonl from the
-        // model-router itself. Now we ALSO write outcome rows here so future
-        // training (scripts/train-from-trajectories.mjs, follow-up) can pair
-        // decision+outcome by task_hash and produce DRACO-shaped retraining
-        // rows from real production traffic. quality = 1.0 on success, 0.0 on
-        // failure (coarse signal; finer-grained quality from user ratings or
-        // regression-detection is a separate hook).
-        if (process.env.CLAUDE_FLOW_ROUTER_TRAJECTORY === '1') {
-            try {
-                const { recordTrajectoryOutcome } = await import('../ruvector/router-trajectory.js');
-                const scores = agent.modelId
-                    ? { [agent.modelId]: outcome === 'success' ? 1.0 : 0.0 }
-                    : undefined;
-                // iter 31 — pass token usage + modelId so the recorder can compute
-                // USD spend at write time. Consumers (`router decisions`, cost-
-                // savings reports) get cost without their own price table.
-                recordTrajectoryOutcome({
-                    task: input.prompt,
-                    quality: outcome === 'success' ? 1.0 : 0.0,
-                    scores,
-                    source: 'agent-execute',
-                    tokens: result.usage ? { input: result.usage.inputTokens, output: result.usage.outputTokens } : undefined,
-                    modelId: agent.modelId,
-                });
+        // ADR-149 — close the bandit feedback loop. `recordModelOutcome` updates
+        // the Beta(α,β) prior for the agent's tier so the Thompson sampler learns
+        // from production traffic instead of staying frozen at install-day priors.
+        // This is best-effort: any error here must NOT break the agent execution.
+        // For now, "success" = the model returned a response without an API error.
+        // A finer-grained signal (user-accepted output / regression-detected) is a
+        // follow-up; this commit closes the bandit's basic learning loop.
+        try {
+            const { recordModelOutcome, recordModelOutcomeByModelId } = await import('../ruvector/model-router.js');
+            // Bandit priors are keyed on the 3 canonical tiers (haiku/sonnet/opus/inherit);
+            // collapse opus-4.7 → opus before recording so the bandit's per-tier Beta
+            // updates correctly.
+            const tier = agent.model === 'opus-4.7' ? 'opus' :
+                agent.model ?? 'sonnet';
+            const outcome = result.success ? 'success' : 'failure';
+            for (const attempt of failedAttempts) {
+                recordModelOutcome(input.prompt, attempt.model === 'opus-4.7' ? 'opus' : attempt.model, 'failure');
+                recordModelOutcomeByModelId(input.prompt, attempt.modelId, 'failure');
             }
-            catch { /* never break execution */ }
-        }
-        // ADR-150 weight-eft capture seam — the ONLY place a run's full outcome is
-        // known here: prompt (issue), assistant transcript, model, tier, and a
-        // resolved PROXY. Gated behind CLAUDE_FLOW_RUN_TRANSCRIPTS=1 (off by
-        // default; PII/retention surface, mirrors the router trajectory recorder).
-        // HONESTY: `resolved` here is the WEAKEST proxy — 'api-success' means only
-        // that the model returned without an API error, NOT that the output is
-        // correct (ruflo has no SWE-bench gold oracle). model_patch is '' because
-        // this single-shot execute path produces no unified diff. Both facts are
-        // stamped so no downstream weight-eft export mistakes this for gold data.
-        if (process.env.CLAUDE_FLOW_RUN_TRANSCRIPTS === '1') {
-            try {
-                const { recordRunTranscript, tierForModel } = await import('../ruvector/run-transcript-recorder.js');
-                const modelId = agent.modelId ?? String(agent.model ?? 'unknown');
-                const messages = [];
-                if (systemPrompt)
-                    messages.push({ role: 'system', content: systemPrompt });
-                messages.push({ role: 'user', content: input.prompt });
-                if (result.success && typeof result.output === 'string') {
-                    messages.push({ role: 'assistant', content: result.output });
+            recordModelOutcome(input.prompt, tier, outcome);
+            // ADR-149 — also write to the shadow per-modelId priors when the cost-
+            // optimal neural backend picked a concrete model id. Selection logic
+            // still uses tier priors, but the per-modelId data accumulates so a
+            // future refactor can switch the selector over.
+            if (agent.modelId) {
+                recordModelOutcomeByModelId(input.prompt, agent.modelId, outcome);
+            }
+            // ADR-149 iter 17 — close the production-data side of the feedback loop.
+            // The trajectory recorder (CLAUDE_FLOW_ROUTER_TRAJECTORY=1) writes
+            // per-decision rows to .swarm/model-router-trajectories.jsonl from the
+            // model-router itself. Now we ALSO write outcome rows here so future
+            // training (scripts/train-from-trajectories.mjs, follow-up) can pair
+            // decision+outcome by task_hash and produce DRACO-shaped retraining
+            // rows from real production traffic. quality = 1.0 on success, 0.0 on
+            // failure (coarse signal; finer-grained quality from user ratings or
+            // regression-detection is a separate hook).
+            if (process.env.CLAUDE_FLOW_ROUTER_TRAJECTORY === '1') {
+                try {
+                    const { recordTrajectoryOutcome } = await import('../ruvector/router-trajectory.js');
+                    const scores = agent.modelId
+                        ? { [agent.modelId]: outcome === 'success' ? 1.0 : 0.0 }
+                        : undefined;
+                    // iter 31 — pass token usage + modelId so the recorder can compute
+                    // USD spend at write time. Consumers (`router decisions`, cost-
+                    // savings reports) get cost without their own price table.
+                    recordTrajectoryOutcome({
+                        task: input.prompt,
+                        quality: outcome === 'success' ? 1.0 : 0.0,
+                        scores,
+                        source: 'agent-execute',
+                        tokens: result.usage ? { input: result.usage.inputTokens, output: result.usage.outputTokens } : undefined,
+                        modelId: agent.modelId,
+                    });
                 }
-                recordRunTranscript({
-                    task: input.prompt,
-                    model: modelId,
-                    tier: tierForModel(modelId),
-                    resolved: outcome === 'success',
-                    resolvedSource: 'api-success',
-                    messages,
-                    source: 'agent-execute',
-                    tokens: result.usage ? { input: result.usage.inputTokens, output: result.usage.outputTokens } : undefined,
-                });
+                catch { /* never break execution */ }
+            }
+            // ADR-150 weight-eft capture seam — the ONLY place a run's full outcome is
+            // known here: prompt (issue), assistant transcript, model, tier, and a
+            // resolved PROXY. Gated behind CLAUDE_FLOW_RUN_TRANSCRIPTS=1 (off by
+            // default; PII/retention surface, mirrors the router trajectory recorder).
+            // HONESTY: `resolved` here is the WEAKEST proxy — 'api-success' means only
+            // that the model returned without an API error, NOT that the output is
+            // correct (ruflo has no SWE-bench gold oracle). model_patch is '' because
+            // this single-shot execute path produces no unified diff. Both facts are
+            // stamped so no downstream weight-eft export mistakes this for gold data.
+            if (process.env.CLAUDE_FLOW_RUN_TRANSCRIPTS === '1') {
+                try {
+                    const { recordRunTranscript, tierForModel } = await import('../ruvector/run-transcript-recorder.js');
+                    const modelId = agent.modelId ?? String(agent.model ?? 'unknown');
+                    const messages = [];
+                    if (systemPrompt)
+                        messages.push({ role: 'system', content: systemPrompt });
+                    messages.push({ role: 'user', content: input.prompt });
+                    if (result.success && typeof result.output === 'string') {
+                        messages.push({ role: 'assistant', content: result.output });
+                    }
+                    recordRunTranscript({
+                        task: input.prompt,
+                        model: modelId,
+                        tier: tierForModel(modelId),
+                        resolved: outcome === 'success',
+                        resolvedSource: 'api-success',
+                        messages,
+                        source: 'agent-execute',
+                        tokens: result.usage ? { input: result.usage.inputTokens, output: result.usage.outputTokens } : undefined,
+                    });
+                }
+                catch { /* never break execution */ }
             }
-            catch { /* never break execution */ }
         }
-    }
-    catch {
-        // Silent — bandit feedback must never block routing.
-    }
-    if (result.success) {
-        const out = {
-            success: true,
+        catch {
+            // Silent — bandit feedback must never block routing.
+        }
+        const remaining = (activeExecutions.get(executionKey) || 1) - 1;
+        const persistCompletion = (out) => {
+            // Awaited provider/feedback work may have overlapped registration, updates,
+            // termination or deletion. Never replace that newer registry snapshot.
+            const latest = loadAgentStore();
+            const current = latest.agents[input.agentId];
+            if (!current || current.createdAt !== agent.createdAt)
+                return;
+            if (current.status === 'busy')
+                current.status = remaining > 0 ? 'busy' : 'idle';
+            if (agent.modelId !== initialModelId && current.modelId === initialModelId) {
+                // A fallback may also change its tier. Carry that change with the model
+                // ID, but preserve any selection the user edited during the request.
+                if (agent.model !== initialModel && current.model === initialModel)
+                    current.model = agent.model;
+                current.modelId = agent.modelId;
+            }
+            if (out)
+                current.lastResult = out;
+            saveAgentStore(latest);
+        };
+        if (result.success) {
+            const out = {
+                success: true,
+                agentId: input.agentId,
+                messageId: result.messageId,
+                model: result.model,
+                stopReason: result.stopReason,
+                output: result.output,
+                usage: result.usage,
+                durationMs: result.durationMs ?? Date.now() - startedAt,
+                ...(fallbackHistory.length > 0 ? { fallbackHistory } : {}),
+            };
+            persistCompletion(out);
+            return out;
+        }
+        persistCompletion();
+        // No-provider-configured error → surface the same actionable message
+        // the router built, with a #2042-aware remediation pointer.
+        const noProvider = (result.error || '').includes('No LLM provider configured');
+        return {
+            success: false,
             agentId: input.agentId,
-            messageId: result.messageId,
-            model: result.model,
-            stopReason: result.stopReason,
-            output: result.output,
-            usage: result.usage,
+            model: anthropicModel,
+            error: result.error || 'agent_execute failed',
             durationMs: result.durationMs ?? Date.now() - startedAt,
             ...(fallbackHistory.length > 0 ? { fallbackHistory } : {}),
+            ...(noProvider && {
+                remediation: 'Set one of ANTHROPIC_API_KEY, OPENROUTER_API_KEY (+ optional OPENROUTER_BASE_URL), or OLLAMA_API_KEY. ' +
+                    'Or set RUFLO_PROVIDER=openrouter|ollama to force a specific provider.',
+            }),
         };
-        agent.lastResult = out;
-        saveAgentStore(store);
-        return out;
     }
-    saveAgentStore(store);
-    // No-provider-configured error → surface the same actionable message
-    // the router built, with a #2042-aware remediation pointer.
-    const noProvider = (result.error || '').includes('No LLM provider configured');
-    return {
-        success: false,
-        agentId: input.agentId,
-        model: anthropicModel,
-        error: result.error || 'agent_execute failed',
-        durationMs: result.durationMs ?? Date.now() - startedAt,
-        ...(fallbackHistory.length > 0 ? { fallbackHistory } : {}),
-        ...(noProvider && {
-            remediation: 'Set one of ANTHROPIC_API_KEY, OPENROUTER_API_KEY (+ optional OPENROUTER_BASE_URL), or OLLAMA_API_KEY. ' +
-                'Or set RUFLO_PROVIDER=openrouter|ollama to force a specific provider.',
-        }),
-    };
+    finally {
+        const pending = (activeExecutions.get(executionKey) || 1) - 1;
+        if (pending > 0)
+            activeExecutions.set(executionKey, pending);
+        else
+            activeExecutions.delete(executionKey);
+    }
 }
 //# sourceMappingURL=agent-execute-core.js.map