@dotdrelle/wiki-manager 0.14.13 → 0.14.20

package/.env.example

@@ -63,10 +63,35 @@ DOCUMENTS_MCP_AUTH_TOKEN=
 # Add your own entries when you declare additional endpoints.
 
 # ── Orchestration (optional) ───────────────────────────────────────────────────
-# Parallel tasks dispatched at once for capability runs. Defaults to what the
-# agent itself declares (agent_describe limits); set only to constrain it.
-# Example constraint (never raises an agent's declared capacity):
-# WIKI_MANAGER_CAPABILITY_CONCURRENCY=3
+# The runtime runs on the host while `llm-wiki serve` runs in Docker and
+# reaches it through host.docker.internal. Listen on all host interfaces so
+# the container can connect; exposed runtimes are protected by the generated
+# WIKI_MANAGER_RUNTIME_TOKEN.
+#
+# WIKI_MANAGER_RUNTIME_PORT=7788
+# Set to 0 to skip pulling and renewing already-running containers at startup.
+# WIKI_MANAGER_AUTO_UPDATE=1
+# WIKI_MANAGER_RUNTIME_HOST=0.0.0.0
+
+
+# ── Parallelism & throughput ───────────────────────────────────────────────────
+# Effective concurrency = MIN(agent recommendedConcurrency, agent maxConcurrency,
+# this ceiling, per-task limits). So the PRIMARY levers live on the production
+# agent (PRODUCTION_RECOMMENDED_CONCURRENCY / PRODUCTION_MAX_CONCURRENCY); this
+# manager variable can only LOWER the result, never raise it. Full explanation
+# and low/high profiles in docs/configuration.md § "Parallelism & throughput".
+#
+# Manager ceiling — leave unset to let the agent decide. Set to constrain:
+# WIKI_MANAGER_CAPABILITY_CONCURRENCY=4
+#
+# Production agent capacity (passed through by docker-compose). Intermediate
+# defaults are 4/8 (effective ≈ 4 parallel). Profiles:
+#   low   → PRODUCTION_RECOMMENDED_CONCURRENCY=2  PRODUCTION_MAX_CONCURRENCY=4
+#   high  → PRODUCTION_RECOMMENDED_CONCURRENCY=8  PRODUCTION_MAX_CONCURRENCY=16
+# The wiki LLM backend must accept this many concurrent requests, and
+# ingest_apply stays serialized regardless (global workspace-write lock).
+# PRODUCTION_RECOMMENDED_CONCURRENCY=4
+# PRODUCTION_MAX_CONCURRENCY=8
 
 # ── MCP retry policy (optional) ────────────────────────────────────────────────
 

package/README.md

@@ -550,6 +550,25 @@ or the shell command `/approve item <id>`. The approval timeout defaults to 10
 minutes and can be changed with `WIKI_MANAGER_APPROVAL_TIMEOUT_MS` or
 `approvalTimeoutMs` in the `/run` body.
 
+Directly-launched capability runs (ingest, pipeline) now **wait for approval by
+default** before their mutating tasks: reply "valide tout", run `/approve`, or
+click Approve in either UI (Shell right-pane banner, or the `serve` banner above
+the composer). Auto-approval only happens when the run is started with
+`autoApprove: true` (headless/CI).
+
+### Parallelism & throughput
+
+The number of tasks that run at once is `MIN(agent recommendedConcurrency, agent
+maxConcurrency, WIKI_MANAGER_CAPABILITY_CONCURRENCY, per-task limits)` — a
+minimum, so the manager ceiling can only lower it. The production agent ships
+intermediate defaults (`PRODUCTION_RECOMMENDED_CONCURRENCY=4` /
+`PRODUCTION_MAX_CONCURRENCY=8`, ≈ 4 parallel); locks then cap real parallelism
+per phase (`ingest_apply` stays serial). The resolved value is shown in both
+UIs' run summary and on the run node of the execution graph, with an amber
+"(ceiling)" marker when the manager ceiling binds. Low/high profiles, the lock
+model and the LLM-backend caveat are in
+[docs/configuration.md § "Parallelism & throughput"](docs/configuration.md).
+
 While a run is active, `GET`/`POST /control` still answers without waiting for
 it to finish: `{"action":"status"}` returns the current run/plan/queue state,
 `{"action":"explain"}` adds a one-line plain-language summary, and

package/docker-compose.yml

@@ -59,7 +59,7 @@ services:
       - DOCUMENT_MAX_UPLOAD_BYTES=${DOCUMENT_MAX_UPLOAD_BYTES:-52428800}
       - WIKI_MCP_PROXY_URL=http://host.docker.internal:${WIKI_MCP_PORT:-3101}/mcp
       - PRODUCTION_MCP_PROXY_URL=http://host.docker.internal:${PRODUCTION_MCP_PORT:-3102}/mcp/
-      - WIKI_MANAGER_RUNTIME_URL=http://host.docker.internal:7788
+      - WIKI_MANAGER_RUNTIME_URL=http://host.docker.internal:${WIKI_MANAGER_RUNTIME_PORT:-7788}
       - WIKI_MANAGER_RUNTIME_TOKEN=${WIKI_MANAGER_RUNTIME_TOKEN:-}
       # HTTPS — set paths inside the container (e.g. /certs/server.crt) and uncomment the volume above
       #- WIKI_SERVE_TLS_CERT_PATH=/certs/server.crt
@@ -110,6 +110,11 @@ services:
       - WIKI_CONFIG_PATH=${WIKI_CONFIG_PATH:-}
       - PRODUCTION_ALLOWED_STEPS=${PRODUCTION_ALLOWED_STEPS:-doctor,ingest,ingest_plan,ingest_apply,build,export,polish,pipeline}
       - PRODUCTION_REQUIRE_CONFIRMATION=${PRODUCTION_REQUIRE_CONFIRMATION:-false}
+      # Parallelism levers — effective concurrency ≈ recommendedConcurrency.
+      # Intermediate defaults (4/8). Low profile 2/4, high profile 8/16.
+      # See docs/configuration.md § "Parallelism & throughput".
+      - PRODUCTION_RECOMMENDED_CONCURRENCY=${PRODUCTION_RECOMMENDED_CONCURRENCY:-4}
+      - PRODUCTION_MAX_CONCURRENCY=${PRODUCTION_MAX_CONCURRENCY:-8}
       - PRODUCTION_JOBS_DIR=${PRODUCTION_JOBS_DIR:-/workspace/.wiki/production-jobs}
       - PRODUCTION_LOCKS_DIR=${PRODUCTION_LOCKS_DIR:-/workspace/.wiki/production-jobs/locks}
     ports:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotdrelle/wiki-manager",
-  "version": "0.14.13",
+  "version": "0.14.20",
   "description": "Agentic shell and orchestration cockpit for llm-wiki workspaces.",
   "license": "PolyForm-Noncommercial-1.0.0",
   "author": "dotrelle",

package/src/activity/activityAggregator.js

@@ -71,23 +71,43 @@ function groupLine(group, activities) {
   const running = group.tasks.filter((task) => ACTIVE.has(statusOf(task)));
   const failed = group.tasks.find((task) => statusOf(task) === 'failed');
   const waitingApproval = group.tasks.some((task) => ['pending_approval', 'waiting_approval'].includes(statusOf(task)));
-  const activeAgents = new Set(running.map((task) => task.agentInstanceId).filter(Boolean)).size;
-  const activeProgress = running
-    .map((task) => progressForTask(task, activities))
-    .find((value) => value != null);
+  // Activity polling can advance before the persisted task projection catches
+  // up. Treat a live, linked activity as authoritative instead of rendering
+  // the whole group as "validation 0%" while a worker visibly runs at 35%.
+  const activePair = group.tasks
+    .map((task) => ({ task, activity: activityForTask(task, activities) }))
+    .find(({ activity }) => activity && !activity.terminal && !DONE.has(statusOf(activity)));
+  const activeTask = activePair?.task ?? running[0] ?? null;
+  const activeActivity = activePair?.activity
+    ?? running.map((task) => activityForTask(task, activities)).find(Boolean);
+  const activeAgents = new Set([
+    ...running.map((task) => task.agentInstanceId),
+    activeTask?.agentInstanceId,
+  ].filter(Boolean)).size;
+  const activeProgress = Number.isFinite(Number(activeActivity?.progress?.percent))
+    ? Number(activeActivity.progress.percent)
+    : running.map((task) => Number(task?.progress?.percent)).find(Number.isFinite);
   let icon = '[ ]';
   let status = 'en attente';
-  if (failed) {
-    icon = '[!]';
+  // A group may contain an earlier failure while another independent task is
+  // still progressing. Show the live worker as running; surface the group
+  // failure once no work remains. Otherwise its business label was rendered
+  // red even though that exact task was healthy and advancing.
+  // Glyphs mirror the Shell PlanPanel so the two never disagree: done is a
+  // check (not a cross — "[x]" read as a failure X), failure is a distinct
+  // cross, and an approval wait gets its own pause glyph instead of reusing the
+  // failure "[!]".
+  if (running.length > 0 || activeActivity) {
+    icon = '[...]';
+    status = activeProgress != null ? `${Math.round(activeProgress)} %` : `${done}/${total}`;
+  } else if (failed) {
+    icon = '[✗]';
     status = 'error';
   } else if (done === total) {
-    icon = '[x]';
+    icon = '[✓]';
     status = 'done';
-  } else if (running.length > 0) {
-    icon = '[...]';
-    status = activeProgress != null ? `${Math.round(activeProgress)} %` : `${done}/${total}`;
   } else if (waitingApproval) {
-    icon = '[!]';
+    icon = '[⏸]';
     status = 'validation';
   } else if (done > 0) {
     icon = '[...]';
@@ -100,12 +120,28 @@ function groupLine(group, activities) {
   // text. Fall back to the task-completion ratio when nothing is running.
   const percent = running.length > 0 && activeProgress != null
     ? Math.round(activeProgress)
+    : activeActivity && activeProgress != null
+      ? Math.round(activeProgress)
     : (total > 0 ? Math.round((done / total) * 100) : null);
+  const phaseTasks = activeTask
+    ? group.tasks.filter((task) => String(task.operation ?? '') === String(activeTask.operation ?? ''))
+    : [];
+  const taskIndex = activeTask ? phaseTasks.indexOf(activeTask) + 1 : null;
+  const taskTotal = phaseTasks.length || null;
   return {
     id: `group:${group.id}`,
     label: `${icon} ${group.label} - ${status}${agents}`,
     status,
-    progress: { done, total, percent },
+    // Preserve the active worker's business progress (source/template/
+    // deliverable, phase and detail). ShellUI can then show the same useful
+    // information as the direct wiki CLI instead of only "knowledge.update".
+    progress: {
+      ...(activeActivity?.progress ?? {}),
+      done,
+      total,
+      percent,
+      ...(taskIndex ? { taskIndex, taskTotal, taskOperation: activeTask?.operation ?? null } : {}),
+    },
     activeAgents,
   };
 }
@@ -121,15 +157,13 @@ function activityLine(activity) {
   };
 }
 
-function progressForTask(task, activities) {
+function activityForTask(task, activities) {
   const taskId = String(task.id ?? task.step ?? '');
   const activityKey = task.activityKey ?? task.ownerActivityKey ?? null;
-  const match = activities.find((activity) =>
+  return activities.find((activity) =>
     (activityKey && (activity.key === activityKey || activity.id === activityKey))
     || String(activity?.progress?.stepId ?? '') === taskId,
   );
-  const value = Number(match?.progress?.percent ?? task.progress?.percent);
-  return Number.isFinite(value) ? value : null;
 }
 
 function statusOf(task) {

package/src/activity/activityAggregator.test.js

@@ -5,6 +5,20 @@ import { aggregateActivity } from './activityAggregator.js';
 import { visibleActivityEvents } from './activityDeduplicator.js';
 import { calculateWeightedProgress } from './progressCalculator.js';
 
+test('a group awaiting approval renders a distinct pause glyph, not a failure', () => {
+  const aggregated = aggregateActivity({
+    plan: [
+      { id: 'publish', label: 'Publication', groupId: 'publish', status: 'pending_approval', progressWeight: 1 },
+    ],
+    activities: [],
+  });
+  const line = aggregated.lines.find((item) => /publish|Publication/.test(item.label));
+  assert.ok(line, 'the awaiting-approval group is present');
+  assert.match(line.label, /\[⏸\]/, 'uses the pause glyph');
+  assert.doesNotMatch(line.label, /\[!\]|\[✗\]/, 'never reuses the failure glyph');
+  assert.equal(line.status, 'validation');
+});
+
 test('activityDeduplicator keeps one visible entry for repeated 2 percent polls', () => {
   const events = Array.from({ length: 50 }, () => ({
     type: 'activity_upserted',
@@ -37,10 +51,10 @@ test('aggregateActivity exposes initial synthesis and grouped display lines', ()
   const activity = aggregateActivity({
     plan: [
       { id: 'collect', label: 'Collecte externe', groupId: 'collect', status: 'done', progressWeight: 1 },
-      { id: 'enrich', label: 'Enrichissement commercial', groupId: 'enrich', requiredCapability: 'customer-data.enrich', status: 'running', progressWeight: 1, activityKey: 'activity-enrich' },
+      { id: 'enrich', label: 'Enrichissement commercial', groupId: 'enrich', requiredCapability: 'customer-data.enrich', operation: 'export', status: 'running', progressWeight: 1, activityKey: 'activity-enrich' },
       { id: 'publish', label: 'Publication', groupId: 'publish', status: 'pending', progressWeight: 1 },
     ],
-    activities: [{ key: 'activity-enrich', label: 'Enrichissement commercial', status: 'running', progress: { percent: 63, stepId: 'enrich' } }],
+    activities: [{ key: 'activity-enrich', label: 'Enrichissement commercial', status: 'running', progress: { percent: 63, stepId: 'enrich', label: 'Export rapport.md', detail: 'Rendering PDF', currentStep: 'export' } }],
   }, [{
     type: 'plan.received',
     payload: {
@@ -54,8 +68,15 @@ test('aggregateActivity exposes initial synthesis and grouped display lines', ()
 
   assert.deepEqual(activity.initialSynthesis, ['120 sources detectees', '6 traitements simultanes recommandes']);
   assert.equal(activity.progress.percent, 54);
-  assert.ok(activity.lines.some((line) => /\[x\] collect - done/.test(line.label)));
+  assert.ok(activity.lines.some((line) => /\[✓\] collect - done/.test(line.label)));
   assert.ok(activity.lines.some((line) => /\[\.\.\.\] customer-data\.enrich - 63 %/.test(line.label)));
+  const enrichLine = activity.lines.find((line) => /customer-data\.enrich/.test(line.label));
+  assert.equal(enrichLine.progress.label, 'Export rapport.md');
+  assert.equal(enrichLine.progress.detail, 'Rendering PDF');
+  assert.equal(enrichLine.progress.currentStep, 'export');
+  assert.equal(enrichLine.progress.taskIndex, 1);
+  assert.equal(enrichLine.progress.taskTotal, 1);
+  assert.equal(enrichLine.progress.taskOperation, 'export');
   assert.ok(activity.lines.some((line) => /\[ \] publish - en attente/.test(line.label)));
 });
 
@@ -85,8 +106,50 @@ test('aggregateActivity keeps activities not attached to any plan task visible',
 
   const aggregated = aggregateActivity(state, []);
   const labels = aggregated.lines.map((line) => line.label).join('\n');
-  assert.match(labels, /\[x\] .* done/, 'the done plan group stays visible');
+  assert.match(labels, /\[✓\] .* done/, 'the done plan group stays visible');
   assert.match(labels, /Ingest b87acaf6/, 'the unattached running ingest must appear');
   const ingestLine = aggregated.lines.find((line) => /Ingest/.test(line.label));
   assert.equal(ingestLine.status, 'running');
 });
+
+test('aggregateActivity trusts live worker progress while the task projection lags', () => {
+  const aggregated = aggregateActivity({
+    plan: [
+      { id: 'plan-a', groupId: 'knowledge.update', operation: 'ingest_plan', status: 'pending_approval', activityKey: 'activity-plan-a' },
+      { id: 'plan-b', groupId: 'knowledge.update', operation: 'ingest_plan', status: 'pending' },
+    ],
+    activities: [{
+      key: 'activity-plan-a',
+      status: 'running',
+      terminal: false,
+      progress: { percent: 35, stepId: 'plan-a', label: 'Ingest source-a.md', stepIndex: 1, stepTotal: 1 },
+    }],
+  }, []);
+
+  const line = aggregated.lines.find((item) => /knowledge\.update/.test(item.label));
+  assert.match(line.label, /35 %/);
+  assert.equal(line.progress.percent, 35);
+  assert.equal(line.progress.label, 'Ingest source-a.md');
+  assert.equal(line.progress.taskIndex, 1);
+  assert.equal(line.progress.taskTotal, 2);
+});
+
+test('aggregateActivity keeps a healthy active task out of the error color when a sibling failed', () => {
+  const aggregated = aggregateActivity({
+    plan: [
+      { id: 'failed-a', groupId: 'ingest', operation: 'ingest_plan', status: 'failed' },
+      { id: 'running-b', groupId: 'ingest', operation: 'ingest_plan', status: 'running', activityKey: 'activity-b' },
+    ],
+    activities: [{
+      key: 'activity-b',
+      status: 'running',
+      terminal: false,
+      progress: { percent: 35, stepId: 'running-b', label: 'Ingest application-orea.md', detail: 'LLM running' },
+    }],
+  }, []);
+
+  const line = aggregated.lines[0];
+  assert.equal(line.status, '35 %');
+  assert.match(line.label, /^\[\.\.\.\]/);
+  assert.equal(line.progress.label, 'Ingest application-orea.md');
+});

package/src/agent/graph.js

@@ -274,6 +274,7 @@ const AgentState = Annotation.Root({
   invalidResponseRetries: Annotation({ default: () => 0 }),
   invalidToolCallRetries: Annotation({ default: () => 0 }),
   forceDelegation: Annotation({ default: () => false }),
+  terminalToolFailure: Annotation({ default: () => false }),
 });
 
 function invalidToolCalls(toolCalls) {
@@ -365,21 +366,62 @@ export function invalidUserFacingToolNames(content, session) {
   return [...new Set([...connected, ...syntactic])].sort();
 }
 
+function parseActionJson(text) {
+  const cleaned = String(text ?? '').trim().replace(/^```(?:json)?\s*/i, '').replace(/\s*```$/, '');
+  if (!cleaned) return null;
+  return JSON.parse(cleaned)?.action === true;
+}
+
 async function classifyRequestedAction(llm, input, signal) {
+  const system = [
+    'Classify whether the user explicitly requests a real state-changing action now.',
+    'Actions include starting, stopping, importing, ingesting, building, exporting, configuring, writing, deleting, or sending.',
+    'Questions, explanations, status questions, greetings, and hypothetical discussions are not actions.',
+    'Return JSON only: {"action":true} or {"action":false}.',
+  ].join('\n');
+  const messages = [{ role: 'user', content: String(input ?? '') }];
+
+  // Preferred path: a forced structured tool call, reliable on providers that
+  // honour tool_choice. But an OpenAI-compatible gateway (e.g. Albert / gpt-oss)
+  // may reject a forced tool_choice or return neither tool_calls nor parsable
+  // content. Without a fallback that made EVERY request classify as a non-action
+  // (catch → false), so Donna silently stopped delegating in agent mode. Fall
+  // back to a plain JSON-text completion, and only give up if both paths fail.
   try {
+    const classifier = {
+      type: 'function',
+      function: {
+        name: 'classify_action_request',
+        description: 'Classify whether the user explicitly requests a real state-changing action now.',
+        parameters: {
+          type: 'object',
+          additionalProperties: false,
+          properties: { action: { type: 'boolean' } },
+          required: ['action'],
+        },
+      },
+    };
     const result = await llm.completeWithTools({
-      system: [
-        'Classify whether the user explicitly requests a real state-changing action now.',
-        'Actions include starting, stopping, importing, ingesting, building, exporting, configuring, writing, deleting, or sending.',
-        'Questions, explanations, status questions, greetings, and hypothetical discussions are not actions.',
-        'Return JSON only: {"action":true} or {"action":false}.',
-      ].join('\n'),
-      tools: [],
-      messages: [{ role: 'user', content: String(input ?? '') }],
+      system,
+      tools: [classifier],
+      toolChoice: { type: 'function', function: { name: 'classify_action_request' } },
+      messages,
       signal,
     });
-    const text = String(result?.content ?? '').trim().replace(/^```(?:json)?\s*/i, '').replace(/\s*```$/, '');
-    return JSON.parse(text)?.action === true;
+    const call = (result?.tool_calls ?? []).find((item) => item?.function?.name === 'classify_action_request');
+    if (call) {
+      const parsed = JSON.parse(call.function.arguments ?? '{}')?.action;
+      if (typeof parsed === 'boolean') return parsed;
+    }
+    const fromText = parseActionJson(result?.content);
+    if (fromText !== null) return fromText;
+  } catch {
+    // Fall through to the toolless path below.
+  }
+
+  try {
+    const result = await llm.completeWithTools({ system, tools: [], messages, signal });
+    return parseActionJson(result?.content) === true;
   } catch {
     return false;
   }
@@ -1327,6 +1369,7 @@ export function createAgentGraph(options = {}) {
   async function toolExecutorNode(state) {
     const toolCalls = state.pendingToolCalls ?? [];
     const toolResultMessages = [];
+    let terminalFailure = null;
 
     for (const call of toolCalls) {
       const resolved = resolveToolCallName(state.session.mcp, call.function.name, INTERNAL_TOOL_SERVERS);
@@ -1415,6 +1458,12 @@ export function createAgentGraph(options = {}) {
           resultText = JSON.stringify(result, null, 2);
         } else if (server === 'runtime') {
           resultText = await handleRuntimeControlTool(state.session, tool, args);
+          if (tool === 'delegate' && /^Runtime control error \(delegate\):/i.test(resultText)) {
+            terminalFailure = resultText
+              .replace(/^Runtime control error \(delegate\):\s*/i, '')
+              .replace(/^Delegation failed during objective_resolution:\s*/i, '');
+            ok = false;
+          }
         } else if (server !== 'shell') {
           await awaitRunApproval(state.session, { runId, tool: toolName });
           await awaitToolApproval(state.session, {
@@ -1510,17 +1559,36 @@ export function createAgentGraph(options = {}) {
         tool_call_id: call.id,
         content: boundedResult,
       });
+      if (terminalFailure) break;
     }
 
+    if (terminalFailure) {
+      const response = `Action non lancée : ${terminalFailure}`;
+      emitAgentEvent(state.session, 'assistant_message', 'agent_guard', { content: response });
+      return {
+        response,
+        messages: toolResultMessages,
+        pendingToolCalls: null,
+        forceDelegation: false,
+        terminalToolFailure: true,
+        invalidToolCallRetries: 0,
+        invalidResponseRetries: 0,
+      };
+    }
     return {
       messages: toolResultMessages,
       pendingToolCalls: null,
       forceDelegation: false,
       invalidToolCallRetries: 0,
       invalidResponseRetries: 0,
+      terminalToolFailure: false,
     };
   }
 
+  function routeToolExecutor(state) {
+    return state.terminalToolFailure ? END : 'orchestrator';
+  }
+
   function routeOrchestrator(state) {
     if (state.pendingToolCalls?.length > 0) return 'tool_executor';
     if (state.retryWithoutTool) return 'orchestrator';
@@ -1534,7 +1602,7 @@ export function createAgentGraph(options = {}) {
     .addNode('tool_executor', toolExecutorNode)
     .addEdge(START, 'orchestrator')
     .addConditionalEdges('orchestrator', routeOrchestrator)
-    .addEdge('tool_executor', 'orchestrator')
+    .addConditionalEdges('tool_executor', routeToolExecutor)
     .compile();
 
   // LangGraph's default recursionLimit is 25 super-steps. Each tool round

package/src/agent/graph.test.js

@@ -25,7 +25,9 @@ test('Donna cannot answer an explicit action with manual instructions instead of
     runtime: { url: 'http://runtime.test' },
     llm: {
       async completeWithTools({ tools }) {
-        if (tools.length === 0) return { content: '{"action":true}', message: { role: 'assistant', content: '{"action":true}' }, tool_calls: null };
+        if (tools.some((tool) => tool.function?.name === 'classify_action_request')) {
+          return { content: null, message: { role: 'assistant', content: null }, tool_calls: [{ id: 'classify', type: 'function', function: { name: 'classify_action_request', arguments: '{"action":true}' } }] };
+        }
         mainCalls += 1;
         if (mainCalls === 1) {
           return {
@@ -910,8 +912,8 @@ test('forced delegation is cleared after one valid tool call and does not loop',
     commands: ['status'],
     llm: {
       async completeWithTools({ toolChoice, tools }) {
-        if (tools.length === 0) {
-          return { content: '{"action":true}', message: { role: 'assistant', content: '{"action":true}' }, tool_calls: null };
+        if (tools.some((tool) => tool.function?.name === 'classify_action_request')) {
+          return { content: null, message: { role: 'assistant', content: null }, tool_calls: [{ id: 'classify', type: 'function', function: { name: 'classify_action_request', arguments: '{"action":true}' } }] };
         }
         calls += 1;
         choices.push(toolChoice);
@@ -946,6 +948,44 @@ test('forced delegation is cleared after one valid tool call and does not loop',
   }
 });
 
+test('a rejected runtime delegation is terminal and never loops', async () => {
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = async () => ({
+    ok: false,
+    status: 422,
+    json: async () => ({
+      error: 'Delegation failed during objective_resolution: No orchestrable capability is currently available.',
+    }),
+  });
+  let calls = 0;
+  const session = sessionBase({
+    runtime: { url: 'http://runtime.test' },
+    llm: {
+      async completeWithTools() {
+        calls += 1;
+        return {
+          content: null,
+          message: { role: 'assistant', content: null },
+          tool_calls: [{
+            id: 'delegate-failure',
+            type: 'function',
+            function: { name: 'runtime__delegate', arguments: '{"objective":"Lance ingestion"}' },
+          }],
+        };
+      },
+    },
+  });
+
+  try {
+    const result = await createAgentGraph().invoke({ input: 'lance ingestion', session });
+    assert.equal(calls, 1);
+    assert.equal(result.response, 'Action non lancée : No orchestrable capability is currently available.');
+    assert.equal(result.terminalToolFailure, true);
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
 // Guard: the system prompt must never show a connected tool's bare name
 // outside its qualified server__tool form. Bare mentions are what teach the
 // model to emit unqualified tool calls (the cme_status incident). The bare