@dotdrelle/wiki-manager 0.14.13 → 0.14.20

package/src/orchestrator/objectiveResolver.test.js

@@ -42,9 +42,31 @@ test('resolveObjective selects and validates one real provider', async () => {
   assert.equal(result.provider.agentInstanceId, 'production-1');
 });
 
+test('resolveObjective uses an unambiguously mentioned registry operation without asking the LLM', async () => {
+  const session = sessionWithSelection({ capability: 'external-source.export', operation: 'export' });
+  session.capabilityRegistry.snapshot = () => ({
+    'knowledge.update@1': [sessionWithSelection({}).capabilityRegistry.snapshot()['knowledge.update@1'][0]],
+    'external-source.export@1': [{
+      agentInstanceId: 'cme-1',
+      serverName: 'cme',
+      capability: { id: 'external-source.export', version: '1', supportedOperations: ['export'] },
+    }],
+  });
+  session.capabilityRegistry.providersFor = (capability) =>
+    session.capabilityRegistry.snapshot()[`${capability}@1`] ?? [];
+  session.llm.completeWithTools = async () => {
+    throw new Error('the explicit operation must not depend on LLM selection');
+  };
+
+  const result = await resolveObjective("lance l'ingestion", session);
+  assert.equal(result.capability, 'knowledge.update');
+  assert.equal(result.operation, 'ingest');
+  assert.equal(result.provider.agentInstanceId, 'production-1');
+});
+
 test('resolveObjective rejects invented capability and operation', async () => {
   await assert.rejects(
-    resolveObjective('Ingère tout', sessionWithSelection({ capability: 'ingest', operation: 'ingest_all_pending' })),
+    resolveObjective('Traite tout', sessionWithSelection({ capability: 'ingest', operation: 'ingest_all_pending' })),
     /unknown capability "ingest"/,
   );
 });

package/src/orchestrator/scheduler.js

@@ -9,7 +9,11 @@ export function resolveSchedulerConcurrency(value = process.env.WIKI_MANAGER_SCH
     : DEFAULT_SCHEDULER_CONCURRENCY;
 }
 
-export function resolvePlanConcurrency({ plan = [], agents = [], configured = null } = {}) {
+// Display-only breakdown of the SAME computation resolvePlanConcurrency uses.
+// resolvePlanConcurrency delegates to this so the number surfaced to the UIs can
+// never diverge from the number the scheduler actually enforces. Never used to
+// gate scheduling — only `.limit` feeds startReadyTasks.
+export function describePlanConcurrency({ plan = [], agents = [], configured = null } = {}) {
   const capabilities = new Set(plan.map((task) => task?.requiredCapability).filter(Boolean).map(String));
   const assignedAgents = new Set(plan.map((task) => task?.agentInstanceId).filter(Boolean).map(String));
   const relevantAgents = agents.filter((agent) => {
@@ -17,12 +21,28 @@ export function resolvePlanConcurrency({ plan = [], agents = [], configured = nu
     if (id && assignedAgents.has(id)) return true;
     return (agent?.description?.capabilities ?? []).some((capability) => capabilities.has(String(capability?.id ?? '')));
   });
-  const values = [
-    positiveInteger(configured),
-    ...plan.flatMap(concurrencyValues),
-    ...relevantAgents.flatMap(concurrencyValues),
-  ].filter(Boolean);
-  return values.length > 0 ? Math.max(1, Math.min(...values)) : DEFAULT_SCHEDULER_CONCURRENCY;
+  const ceiling = positiveInteger(configured);
+  const agentValues = relevantAgents.flatMap(concurrencyValues).filter(Boolean);
+  const taskValues = plan.flatMap(concurrencyValues).filter(Boolean);
+  const values = [ceiling, ...taskValues, ...agentValues].filter(Boolean);
+  const limit = values.length > 0 ? Math.max(1, Math.min(...values)) : DEFAULT_SCHEDULER_CONCURRENCY;
+  const otherMin = [...taskValues, ...agentValues].length > 0
+    ? Math.min(...taskValues, ...agentValues)
+    : null;
+  // The manager ceiling "bit" when it is the (uniquely) binding constraint: it
+  // is set, equals the resolved limit, and is strictly below every other input.
+  const cappedByCeiling = ceiling != null && limit === ceiling && (otherMin == null || ceiling < otherMin);
+  return {
+    limit,
+    ceiling: ceiling ?? null,
+    agentLimit: agentValues.length > 0 ? Math.min(...agentValues) : null,
+    taskLimit: taskValues.length > 0 ? Math.min(...taskValues) : null,
+    cappedByCeiling,
+  };
+}
+
+export function resolvePlanConcurrency(options = {}) {
+  return describePlanConcurrency(options).limit;
 }
 
 export function resolveCapabilityConcurrency(agent = null, ...constraints) {

package/src/orchestrator/scheduler.test.js

@@ -4,9 +4,10 @@ import { join } from 'node:path';
 import test from 'node:test';
 
 import { createBudgetManager } from './budgetManager.js';
-import { readyTasks } from './dependencyResolver.js';
+import { readyTasks, tasksAwaitingApproval } from './dependencyResolver.js';
 import { createLockManager } from './lockManager.js';
 import {
+  describePlanConcurrency,
   effectiveConcurrency,
   resolveCapabilityConcurrency,
   resolvePlanConcurrency,
@@ -60,6 +61,27 @@ test('dependencyResolver releases a waiting task when a run grant covers it', ()
   }).map((item) => item.id), ['ingest']);
 });
 
+test('dependencyResolver does not request approval for a task blocked by a failed dependency', () => {
+  const plan = {
+    runId: 'run-1',
+    workspace: 'test4',
+    planRevision: 1,
+    tasks: [
+      task('plan', { status: 'failed' }),
+      task('apply', {
+        status: 'waiting_approval',
+        dependsOn: ['plan'],
+        requiresApproval: true,
+        approvalClass: 'mutation',
+      }),
+    ],
+  };
+
+  assert.deepEqual(tasksAwaitingApproval(plan), []);
+  plan.tasks[0].status = 'done';
+  assert.deepEqual(tasksAwaitingApproval(plan).map((item) => item.id), ['apply']);
+});
+
 test('dependencyResolver skips tasks whose locks are not free and keeps other ready work moving', () => {
   const lockManager = createLockManager();
   const held = lockManager.acquire(['deliverable:a.md']);
@@ -120,6 +142,28 @@ test('scheduler uses the relevant agent declaration instead of hard-capping plan
   assert.equal(resolvePlanConcurrency({ plan, agents, configured: 20 }), 10);
 });
 
+test('describePlanConcurrency mirrors resolvePlanConcurrency and flags the ceiling', () => {
+  const plan = [{ id: 'task-1', requiredCapability: 'ingest' }];
+  const agents = [{ description: { capabilities: [{ id: 'ingest' }], limits: { recommendedConcurrency: 10, maxConcurrency: 12 } } }];
+
+  // The number must never diverge from what the scheduler enforces.
+  for (const configured of [undefined, 3, 20]) {
+    const opts = configured === undefined ? { plan, agents } : { plan, agents, configured };
+    assert.equal(describePlanConcurrency(opts).limit, resolvePlanConcurrency(opts));
+  }
+
+  // Ceiling binds → flagged.
+  const capped = describePlanConcurrency({ plan, agents, configured: 3 });
+  assert.equal(capped.limit, 3);
+  assert.equal(capped.ceiling, 3);
+  assert.equal(capped.cappedByCeiling, true);
+
+  // Ceiling above the agent declaration → does not bind, not flagged.
+  const loose = describePlanConcurrency({ plan, agents, configured: 20 });
+  assert.equal(loose.limit, 10);
+  assert.equal(loose.cappedByCeiling, false);
+});
+
 test('scheduler ignores unrelated agents and falls back to three without declarations', () => {
   const plan = [{ id: 'task-1', requiredCapability: 'ingest' }];
   const agents = [{

package/src/runtime/auth.test.js

@@ -4,7 +4,7 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import test from 'node:test';
 import { resolveRuntimeAuthToken } from './auth.js';
-import { assertRuntimeNode, runtimeNodeExecutable } from './lifecycle.js';
+import { assertRuntimeNode, runtimeNodeExecutable, shutdownOwnedRuntime } from './lifecycle.js';
 
 test('resolveRuntimeAuthToken: loopback host does not require token', () => {
   const result = resolveRuntimeAuthToken({ host: '127.0.0.1', explicitToken: null });
@@ -27,3 +27,67 @@ test('runtime lifecycle uses a Node executable with node:sqlite support', async
   assert.ok(runtimeNode.executable);
   assert.ok(Number(runtimeNode.version.split('.')[0]) >= 22);
 });
+
+test('shutdownOwnedRuntime reports progress and stops an idle owned runtime', async () => {
+  const originalFetch = globalThis.fetch;
+  const calls = [];
+  const logs = [];
+  globalThis.fetch = async (url, options = {}) => {
+    calls.push({ url: String(url), method: options.method ?? 'GET' });
+    return new Response(JSON.stringify(calls.length === 1 ? { activeRuns: [] } : { shutdown: true }), {
+      status: calls.length === 1 ? 200 : 202,
+      headers: { 'content-type': 'application/json' },
+    });
+  };
+  try {
+    const result = await shutdownOwnedRuntime(
+      { url: 'http://127.0.0.1:7788', started: true, token: null },
+      { log: (message) => logs.push(message), timeoutMs: 100 },
+    );
+    assert.equal(result.action, 'shutdown');
+    assert.deepEqual(calls.map((call) => call.method), ['GET', 'POST']);
+    assert.match(logs.join('\n'), /runtime arrêté/);
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test('shutdownOwnedRuntime also stops an idle reused runtime', async () => {
+  const originalFetch = globalThis.fetch;
+  const calls = [];
+  globalThis.fetch = async (_url, options = {}) => {
+    calls.push(options.method ?? 'GET');
+    return new Response(JSON.stringify(calls.length === 1 ? { activeRuns: [] } : { shutdown: true }), {
+      status: calls.length === 1 ? 200 : 202,
+      headers: { 'content-type': 'application/json' },
+    });
+  };
+  try {
+    const result = await shutdownOwnedRuntime(
+      { url: 'http://127.0.0.1:7788', started: false, token: null },
+      { timeoutMs: 100 },
+    );
+    assert.equal(result.action, 'shutdown');
+    assert.deepEqual(calls, ['GET', 'POST']);
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test('shutdownOwnedRuntime bounds an unresponsive shutdown', async () => {
+  const originalFetch = globalThis.fetch;
+  const logs = [];
+  globalThis.fetch = async (_url, { signal } = {}) => new Promise((_resolve, reject) => {
+    signal?.addEventListener('abort', () => reject(new DOMException('aborted', 'AbortError')), { once: true });
+  });
+  try {
+    const result = await shutdownOwnedRuntime(
+      { url: 'http://127.0.0.1:7788', started: true, token: null },
+      { log: (message) => logs.push(message), timeoutMs: 5 },
+    );
+    assert.equal(result.action, 'timeout');
+    assert.match(logs.join('\n'), /délai de fermeture/);
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});

package/src/runtime/client.js

@@ -38,9 +38,11 @@ export async function checkRuntimeHealth({
   url = runtimeUrlFromEnv(),
   token = runtimeToken(),
   workspace = null,
+  signal = null,
 } = {}) {
   const response = await fetch(runtimeEndpoint(url, '/health', workspace), {
     headers: runtimeHeaders(token),
+    signal,
   });
   if (!response.ok) return null;
   return response.json();
@@ -143,10 +145,12 @@ export async function postRuntimeKill({
 export async function postRuntimeShutdown({
   url = runtimeUrlFromEnv(),
   token = runtimeToken(),
+  signal = null,
 } = {}) {
   const response = await fetch(runtimeEndpoint(url, '/shutdown'), {
     method: 'POST',
     headers: runtimeHeaders(token),
+    signal,
   });
   if (!response.ok) throw new Error(`Runtime shutdown failed: HTTP ${response.status}`);
   return response.json();

package/src/runtime/donna-contract.test.js

@@ -259,6 +259,8 @@ test('CME export is dispatched only from an approved DAG task', async () => {
   assert.equal(result.reason, 'awaiting_approval');
   assert.equal(executeCalls, 0);
   assert.equal(session.headlessPlan[0].status, 'waiting_approval');
+  assert.ok(session.agentEvents.some((event) => event.type === 'approval.requested'
+    && event.taskId === session.headlessPlan[0].id));
 });
 
 function buildSingleTaskAgent({ taskId, description, finalResponse }) {

package/src/runtime/lifecycle.js

@@ -127,22 +127,25 @@ async function waitForRuntimeShutdown(url, token, timeoutMs) {
   }
 }
 
-export async function runtimeHealthOrNull(url = runtimeUrlFromEnv(), token = runtimeTokenFromEnv()) {
+export async function runtimeHealthOrNull(url = runtimeUrlFromEnv(), token = runtimeTokenFromEnv(), signal = null) {
   try {
-    return await checkRuntimeHealth({ url, token });
-  } catch {
+    return await checkRuntimeHealth({ url, token, signal });
+  } catch (err) {
+    if (signal?.aborted) throw err;
     return null;
   }
 }
 
-// Contract with the user: the shell OWNS the runtime it started — leaving it
-// alive after exit produced zombie runtimes running yesterday's code and
-// yesterday's endpoints. Nuance preserved: if a run is active anywhere, the
-// runtime is left alive so the run survives the shell (that promise stays).
-export async function shutdownOwnedRuntime(runtime, { log = (_message) => {} } = {}) {
-  if (!runtime?.url || !runtime?.started) return { action: 'kept', reason: 'not_owned' };
+// Close the runtime attached to the shell when it is idle, including a process
+// reused at startup. Restricting cleanup to `started: true` left ownerless
+// runtimes occupying port 7788 with another manager directory/token.
+// An active run still survives the shell.
+export async function shutdownOwnedRuntime(runtime, { log = (_message) => {}, timeoutMs = 3000 } = {}) {
+  if (!runtime?.url) return { action: 'kept', reason: 'unavailable' };
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), Math.max(1, Number(timeoutMs) || 3000));
   try {
-    const health = await runtimeHealthOrNull(runtime.url, runtime.token);
+    const health = await runtimeHealthOrNull(runtime.url, runtime.token, controller.signal);
     if (!health) return { action: 'kept', reason: 'unreachable' };
     const activeRuns = Array.isArray(health.activeRuns) ? health.activeRuns : [];
     if (activeRuns.length > 0) {
@@ -152,10 +155,16 @@ export async function shutdownOwnedRuntime(runtime, { log = (_message) => {} } =
       log(`runtime laissé actif : run en cours (${labels}) — il survivra à ce shell ; relance wiki-manager pour le retrouver.`);
       return { action: 'kept', reason: 'run_active', activeRuns };
     }
-    await postRuntimeShutdown({ url: runtime.url, token: runtime.token });
-    log('runtime arrêté (démarré par ce shell, aucun run en cours).');
+    await postRuntimeShutdown({ url: runtime.url, token: runtime.token, signal: controller.signal });
+    log('runtime arrêté (aucun run en cours).');
     return { action: 'shutdown' };
   } catch (err) {
+    if (controller.signal.aborted) {
+      log('délai de fermeture du runtime dépassé — le shell termine sans attendre davantage.');
+      return { action: 'timeout', reason: 'shutdown_timeout' };
+    }
     return { action: 'error', reason: err instanceof Error ? err.message : String(err) };
+  } finally {
+    clearTimeout(timeout);
   }
 }

package/src/runtime/runner.js

@@ -7,9 +7,11 @@ import { createAssignmentManager } from '../orchestrator/assignmentManager.js';
 import { createAttemptManager } from '../orchestrator/attemptManager.js';
 import { createBudgetManager, BudgetExceededError } from '../orchestrator/budgetManager.js';
 import { createDispatcher } from '../orchestrator/dispatcher.js';
+import { approvalRequestForTask } from '../orchestrator/approvalPolicy.js';
+import { PENDING_STATUSES, tasksAwaitingApproval } from '../orchestrator/dependencyResolver.js';
 import { assertValidatedFragment } from '../orchestrator/planValidator.js';
 import { createResultAggregator } from '../orchestrator/resultAggregator.js';
-import { drainActive, resolvePlanConcurrency, startReadyTasks } from '../orchestrator/scheduler.js';
+import { describePlanConcurrency, drainActive, startReadyTasks } from '../orchestrator/scheduler.js';
 import { emitRuntimeLog, pollActivitiesOnce } from './supervisor.js';
 
 // 0 by default: automatic replans turn evaluator/replanner TEXT into
@@ -139,9 +141,14 @@ export async function runRuntimeAgenticWorkflow(agent, session, input, {
   // loop would re-ingest this run's own turns and duplicate them.
   const runConversationSeed = conversationSeed(session, currentInput);
 
+  // The conversational loop path ends with the agent's own natural-language
+  // reply; the deterministic parallel scheduler has no agent voice, so only
+  // that path gets a synthesized outcome summary (announceRunOutcome).
+  let usedParallelScheduler = false;
   while (true) {
     sanitizeSessionPlanForExecution(session, runId);
-    const result = shouldUseParallelScheduler(session.headlessPlan)
+    usedParallelScheduler = shouldUseParallelScheduler(session.headlessPlan);
+    const result = usedParallelScheduler
       ? await runRuntimeParallelPlan(agent, session, input, {
         signal,
         timeoutMs,
@@ -188,6 +195,7 @@ export async function runRuntimeAgenticWorkflow(agent, session, input, {
         emitRuntimeLog(session, 'runtime: run ended by user cancellation (no replan)');
         return { ok: false, result, cancelled: true };
       }
+      if (usedParallelScheduler) await announceRunOutcome(session, { runId, ok: false, signal });
       dispatchAgentEvent(session, createAgentEvent('run_error', {
         origin: 'runtime',
         runId,
@@ -267,6 +275,7 @@ export async function runRuntimeAgenticWorkflow(agent, session, input, {
       }
     }
 
+    if (usedParallelScheduler) await announceRunOutcome(session, { runId, ok: true, signal });
     dispatchAgentEvent(session, createAgentEvent('run_done', {
       origin: 'runtime',
       runId,
@@ -276,6 +285,62 @@ export async function runRuntimeAgenticWorkflow(agent, session, input, {
   }
 }
 
+// Emit ONE natural-language Donna message summarizing how the run finished,
+// instead of the client streaming a per-job line for every task. Uses the
+// workspace LLM to phrase it, degrading to a plain templated fact line if the
+// LLM is unavailable or errors — the run must never block on this summary.
+async function announceRunOutcome(session, { runId, ok, signal = null } = {}) {
+  const plan = Array.isArray(session.headlessPlan) ? session.headlessPlan : [];
+  if (plan.length === 0) return;
+  let failed = 0;
+  let cancelled = 0;
+  let completed = 0;
+  let firstError = null;
+  for (const step of plan) {
+    const status = String(step?.status ?? '').toLowerCase();
+    if (['failed', 'error', 'stalled'].includes(status)) {
+      failed += 1;
+      firstError ??= String(
+        step?.error?.message ?? step?.error?.code ?? step?.error
+        ?? step?.result?.error?.message ?? step?.result?.error?.code ?? '',
+      ).trim() || null;
+    } else if (['cancelled', 'canceled'].includes(status)) {
+      cancelled += 1;
+    } else if (['done', 'complete', 'completed', 'success', 'succeeded'].includes(status)) {
+      completed += 1;
+    }
+  }
+  const total = plan.length;
+  const factLine = ok && failed === 0
+    ? `Plan terminé avec succès — ${completed}/${total} tâche(s) réussie(s).`
+    : `Plan terminé en erreur — ${completed}/${total} tâche(s) réussie(s), ${failed} en erreur${cancelled ? `, ${cancelled} annulée(s)` : ''}.${firstError ? ` Première erreur : ${firstError}.` : ''}`;
+  let content = factLine;
+  const llm = session.llm;
+  if (llm && typeof llm.completeWithTools === 'function') {
+    try {
+      const result = await llm.completeWithTools({
+        system: [
+          'You are Donna, an orchestration assistant reporting a run result to the user.',
+          'Rephrase the outcome facts in ONE short, natural sentence, in the same language as the facts.',
+          'No lists, no headers, no raw job ids — just a concise human summary.',
+        ].join('\n'),
+        tools: [],
+        messages: [{ role: 'user', content: `Run outcome facts:\n${factLine}` }],
+        signal,
+      });
+      const phrased = String(result?.content ?? '').trim();
+      if (phrased) content = phrased;
+    } catch {
+      // Degrade to the templated fact line — never fail the run on the summary.
+    }
+  }
+  dispatchAgentEvent(session, createAgentEvent('assistant_message', {
+    origin: 'runtime',
+    runId,
+    payload: { content },
+  }));
+}
+
 export async function runRuntimeParallelPlan(agent, session, input, {
   signal = null,
   timeoutMs,
@@ -298,11 +363,24 @@ export async function runRuntimeParallelPlan(agent, session, input, {
   const configuredConcurrency = Number(concurrency) > 0
     ? Number(concurrency)
     : Number(process.env.WIKI_MANAGER_CAPABILITY_CONCURRENCY || process.env.WIKI_MANAGER_SCHEDULER_CONCURRENCY);
-  const limit = resolvePlanConcurrency({
+  const concurrencyDetail = describePlanConcurrency({
     plan: session.headlessPlan ?? [],
     agents,
     configured: configuredConcurrency,
   });
+  const limit = concurrencyDetail.limit;
+  // Publish the RESOLVED concurrency so both UIs show the real dispatch cap
+  // (not a value re-derived from the fragment). Display-only: scheduling still
+  // uses `limit` exactly as before. NOTE: this is a plain field assignment — do
+  // NOT emit a runtime_log here (it runs before ensurePlanProjection and would
+  // clobber session.headlessPlan via applyAgentProjectionToSession). The audit
+  // line is folded into the existing "parallel plan enabled" log below.
+  session._runConcurrency = {
+    limit,
+    ceiling: concurrencyDetail.ceiling,
+    agentLimit: concurrencyDetail.agentLimit,
+    cappedByCeiling: concurrencyDetail.cappedByCeiling,
+  };
   const active = new Map();
   const attempts = attemptManager ?? createAttemptManager();
   const assigner = assignmentManager ?? createAssignmentManager({ session });
@@ -327,8 +405,7 @@ export async function runRuntimeParallelPlan(agent, session, input, {
   };
   sanitizeSessionPlanForExecution(session, runId);
   ensurePlanProjection(session, runId);
-  emitRuntimeLog(session, `scheduler: parallel plan enabled (concurrency ${limit})`);
-  let approvalNoticeSent = false;
+  emitRuntimeLog(session, `scheduler: parallel plan enabled (concurrency ${limit}; agent=${concurrencyDetail.agentLimit ?? 'n/a'}, ceiling=${concurrencyDetail.ceiling ?? 'none'}${concurrencyDetail.cappedByCeiling ? ' → capped by manager ceiling' : ''})`);
   // Interactive approvals do NOT expire: the user has /approve, "valide
   // tout", /cancel and /run kill — an arbitrary timer only created mystery
   // failures. A deadline exists only when explicitly configured (headless
@@ -431,26 +508,74 @@ export async function runRuntimeParallelPlan(agent, session, input, {
           emitRuntimeLog(session, `scheduler: budget exceeded (${exceeded.reason})`);
           return { ok: false, budgetExceeded: true, reason: exceeded.reason, budget: exceeded, completed: sessionActivities(session), failures };
         }
-        const needingApproval = pending.filter((step) => step.requiresApproval === true);
+        // Only wait for a human when approval is the sole remaining blocker.
+        // A task whose dependency failed cannot become runnable by approving
+        // it; treating it as an approval wait leaves the run alive forever.
+        const approvalContext = {
+          runId,
+          workspace: session.workspace ?? null,
+          planRevision: session.planRevision ?? session.agentProjection?.planRevision ?? null,
+          tasks: session.headlessPlan ?? [],
+        };
+        // One snapshot of the approvals list, reused for both the
+        // awaiting-approval computation and the per-task dedup below so the two
+        // can never diverge mid-iteration.
+        const approvals = session.agentProjection?.approvals ?? session.approvals ?? [];
+        const needingApproval = tasksAwaitingApproval(approvalContext, { approvals });
         if (needingApproval.length > 0) {
           // The plan is only blocked on a HUMAN decision — wait for it
           // (bounded) instead of declaring the run stalled. Announce once in
           // the chat: users cannot approve what they never saw asked.
-          if (!approvalNoticeSent) {
-            approvalNoticeSent = true;
+          const newlyRequested = [];
+          for (const task of needingApproval) {
+            const taskId = String(task.id ?? task.taskId ?? task.step ?? '');
+            const alreadyRequested = approvals.some((approval) =>
+              approval.status === 'pending_approval'
+              && String(approval.taskId ?? approval.itemId ?? '') === taskId
+              && Number(approval.planRevision ?? approvalContext.planRevision) === Number(approvalContext.planRevision));
+            if (alreadyRequested) continue;
+            newlyRequested.push(task);
+            const request = approvalRequestForTask(task, {
+              runId,
+              workspaceId: session.workspace ?? null,
+              planRevision: approvalContext.planRevision,
+            });
+            dispatchAgentEvent(session, createAgentEvent('approval.requested', {
+              origin: 'runtime',
+              runId,
+              taskId: request.taskId,
+              workspace: session.workspace ?? null,
+              payload: request,
+            }));
+            // Reflect the block on the task's plan step so the UIs can render it
+            // distinctly (amber "[⏸]" in the Shell, banner/badge in serve)
+            // instead of leaving it as a neutral "pending" indistinguishable
+            // from a not-started step. Only promote a plain pending task — never
+            // overwrite a status the planner already set (e.g. waiting_approval).
+            const currentStatus = String(task.status ?? '').toLowerCase();
+            if (!['pending_approval', 'waiting_approval'].includes(currentStatus)) {
+              dispatchAgentEvent(session, createAgentEvent('plan_step_updated', {
+                origin: 'runtime',
+                runId,
+                taskId,
+                payload: { taskId, status: 'pending_approval' },
+              }));
+            }
+          }
+          if (newlyRequested.length > 0) {
             dispatchAgentEvent(session, createAgentEvent('assistant_message', {
               origin: 'runtime',
               runId,
               payload: {
                 content: [
-                  `⏸ Approbation requise avant exécution : ${needingApproval.length} tâche(s) mutante(s) en attente.`,
-                  ...needingApproval.slice(0, 5).map((step) => `  - ${step.description ?? step.id}`),
-                  needingApproval.length > 5 ? `  … et ${needingApproval.length - 5} autre(s).` : null,
+                  `⏸ Approbation requise avant exécution : ${newlyRequested.length} tâche(s) mutante(s) en attente.`,
+                  ...newlyRequested.slice(0, 5).map((step) => `  - ${step.description ?? step.id}`),
+                  newlyRequested.length > 5 ? `  … et ${newlyRequested.length - 5} autre(s).` : null,
                   'Réponds « valide tout » (ou tape /approve) pour lancer, « annule » pour abandonner.',
                 ].filter(Boolean).join('\n'),
               },
             }));
-            emitRuntimeLog(session, `scheduler: waiting for approval (${needingApproval.length} task(s))`);
+            emitRuntimeLog(session, `scheduler: waiting for approval (${newlyRequested.length} new task(s))`);
           }
           if (Date.now() < approvalDeadline) {
             await new Promise((resolveDelay) => setTimeout(resolveDelay, 500));
@@ -469,7 +594,9 @@ export async function runRuntimeParallelPlan(agent, session, input, {
           }));
           return { ok: false, stalled: true, reason: 'awaiting_approval', completed: sessionActivities(session), failures };
         }
-        const reason = pending.every((step) => approvalWaitingStatus(step.status)) ? 'awaiting_approval' : 'no_ready_plan_task';
+        // Any genuine approval-only block returned above. Remaining tasks are
+        // unschedulable for another reason (most commonly a failed dependency).
+        const reason = 'no_ready_plan_task';
         emitRuntimeLog(session, `scheduler: stalled (${reason})`);
         return { ok: false, stalled: true, reason, completed: sessionActivities(session), failures };
       }
@@ -585,11 +712,7 @@ function abortCancelledActiveTasks(session, active) {
 }
 
 function pendingSchedulerStatus(status) {
-  return ['pending', 'pending_approval', 'waiting_approval'].includes(String(status ?? ''));
-}
-
-function approvalWaitingStatus(status) {
-  return ['pending_approval', 'waiting_approval'].includes(String(status ?? ''));
+  return PENDING_STATUSES.has(String(status ?? ''));
 }
 
 // Scope the evaluator/replanner's view of "completed" activities to the

package/src/runtime/runner.test.js

@@ -812,6 +812,36 @@ test('runRuntimeParallelPlan fails cleanly when scheduler budget is exceeded', a
   assert.equal(session.headlessPlan[0].status, 'cancelled');
 });
 
+test('runRuntimeParallelPlan does not wait for approval behind a failed dependency', async () => {
+  const session = {
+    workspace: 'demo-workspace',
+    mcp: { tools: {} },
+    agentEvents: [],
+    headlessPlan: [
+      { ...plannedDoctorTask('a', []), status: 'failed' },
+      {
+        ...plannedDoctorTask('b', ['a']),
+        status: 'waiting_approval',
+        requiresApproval: true,
+        approvalClass: 'mutation',
+      },
+    ],
+  };
+
+  const result = await runRuntimeParallelPlan(
+    { invoke: async () => assert.fail('blocked work must not invoke an agent') },
+    session,
+    'Apply after failed plan',
+    { runId: 'run-failed-dependency', timeoutMs: 1000, maxTurns: 1 },
+  );
+
+  assert.equal(result.ok, false);
+  assert.equal(result.stalled, true);
+  assert.equal(result.reason, 'no_ready_plan_task');
+  assert.equal(session.agentEvents.some((event) => event.type === 'assistant_message'
+    && /Approbation requise/.test(event.payload?.content ?? '')), false);
+});
+
 test('runRuntimeParallelPlan retries a retryable task on a fallback agent', async () => {
   const executeServers = [];
   const session = {

package/src/runtime/server.js

@@ -6,6 +6,8 @@ import { normalizePlanPatch, rebasePlanPatch } from '../core/planPatch.js';
 import { validateContractInDev } from '../contracts/schemas.js';
 import { runtimeTokenFromEnv } from './auth.js';
 import { controlMessage } from './controlMessages.js';
+import { tasksAwaitingApproval } from '../orchestrator/dependencyResolver.js';
+import { approvalClassForTask } from '../orchestrator/approvalPolicy.js';
 
 export function startRuntimeServer({
   host = '127.0.0.1',
@@ -679,10 +681,19 @@ function readOnlyControlResponse(kind, classification, status, explanation, { ac
   };
 }
 
-function approvalRequestFromStatus(status) {
+export function approvalRequestFromStatus(status) {
   const runId = status.runId ?? status.runs?.find((run) => run.status === 'running' || run.status === 'pending_approval')?.id ?? null;
   const pending = (status.approvals ?? []).filter((approval) => approval.status === 'pending_approval');
-  const classes = [...new Set(pending.flatMap((approval) => readOptionalList(approval.approvalClasses ?? approval.approvalClass)))];
+  const waitingTasks = tasksAwaitingApproval({
+    runId,
+    workspace: status.workspace ?? null,
+    planRevision: status.planRevision ?? null,
+    tasks: status.plan ?? [],
+  }, { approvals: status.approvals ?? [] });
+  const classes = [...new Set([
+    ...pending.flatMap((approval) => readOptionalList(approval.approvalClasses ?? approval.approvalClass)),
+    ...waitingTasks.map((task) => approvalClassForTask(task)),
+  ].filter(Boolean))];
   return {
     workspace: status.workspace ?? null,
     workspaceId: status.workspace ?? null,