@dotdrelle/wiki-manager 0.14.13 → 0.14.16

package/src/core/wikiSetup.js

@@ -105,6 +105,41 @@ export async function stopAgents(options = {}) {
   }
 }
 
+export async function refreshRunningContainers(options = {}) {
+  if (process.env.WIKI_MANAGER_AUTO_UPDATE === '0') {
+    return { skipped: true, refreshed: [] };
+  }
+  const script = join(managerRoot(), 'wiki-workspace');
+  const common = {
+    cwd: dirname(managerEnvFile()),
+    env: {
+      ...process.env,
+      WIKI_WORKSPACES_DIR: workspacesDir(),
+      WIKI_MANAGER_ENV_FILE: managerEnvFile(),
+      WIKI_MANAGER_ENDPOINTS_FILE: managerMcpEndpointsFile(),
+      AGENTS_DATA_DIR: resolveAgentsDataDir(),
+    },
+    timeout: options.timeout ?? 600_000,
+    maxBuffer: options.maxBuffer ?? 1024 * 1024 * 8,
+  };
+  const targets = [['agents', 'refresh'], ...listWorkspaces().map((workspace) => ['wiki', workspace.name, 'refresh'])];
+  // Each target is an independent Compose project (its own agents/workspace
+  // stack) — refresh them concurrently instead of summing every target's
+  // pull/restart time into one sequential wait.
+  const results = await Promise.all(targets.map(async (args) => {
+    options.onStep?.(`Images: checking ${args[0] === 'agents' ? 'running agents' : `workspace ${args[1]}`}…`);
+    try {
+      const { stdout, stderr } = await execFileAsync(script, args, common);
+      return { ok: true, output: [stdout, stderr].filter(Boolean).join('\n').trim() };
+    } catch (err) {
+      return { ok: false, error: wrapDockerError(err).message };
+    }
+  }));
+  const refreshed = results.filter((result) => result.ok).map((result) => result.output).filter(Boolean);
+  const errors = results.filter((result) => !result.ok).map((result) => result.error);
+  return { skipped: false, refreshed, errors };
+}
+
 export async function createNewWorkspace(name, targetPath) {
   try {
     const output = await createWorkspace(name, targetPath, { timeout: 600_000 });

package/src/core/wikiWorkspace.test.js

@@ -31,3 +31,23 @@ test('wiki-workspace regenerates CA compose overrides instead of retaining remov
   assert.match(script, /mv "\$tmp_override" "\$override_path"/);
   assert.match(script, /Changes are overwritten on the next compose command/);
 });
+
+test('workspace creation keeps mutable manager files outside the installed package', async () => {
+  const source = await readFile(new URL('./workspaces.js', import.meta.url), 'utf8');
+
+  assert.match(source, /const stateDir = dirname\(managerEnvFile\(\)\)/);
+  assert.match(source, /cwd: stateDir/);
+  assert.match(source, /WIKI_MANAGER_ENV_FILE: managerEnvFile\(\)/);
+  assert.match(source, /WIKI_MANAGER_ENDPOINTS_FILE: managerMcpEndpointsFile\(\)/);
+});
+
+test('container refresh pulls and renews only services that are already running', async () => {
+  const script = await readFile(new URL('../../wiki-workspace', import.meta.url), 'utf8');
+
+  assert.match(script, /refresh_running_services\(\) \{/);
+  assert.match(script, /\[\[ -n "\$\{line\/\/\[\[:space:\]\]\/\}" \]\] \|\| continue/);
+  assert.match(script, /ps --status running --services/);
+  assert.match(script, /"\$@" pull "\$\{running_services\[@\]\}"/);
+  assert.match(script, /refresh_running_services 'No running external agent containers to refresh' 'Refreshed running agents: %s' _agents_dc/);
+  assert.match(script, /refresh_running_services "No running workspace containers to refresh: \$workspace" "Refreshed running workspace containers: \$workspace \(%s\)" compose_for_workspace "\$workspace"/);
+});

package/src/core/workspaces.js

@@ -3,7 +3,7 @@ import { existsSync, readdirSync, realpathSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { promisify } from 'node:util';
-import { managerEnvFile, readEnvFile, userManagerDir } from './env.js';
+import { managerEnvFile, managerMcpEndpointsFile, readEnvFile, userManagerDir } from './env.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const packageRoot = resolve(__dirname, '../..');
@@ -70,15 +70,23 @@ export async function createWorkspace(name, targetPath = null, options = {}) {
   }
   const args = ['config', name];
   if (targetPath) args.push(targetPath);
+  const stateDir = dirname(managerEnvFile());
   const { stdout, stderr } = await execFileAsync(
     join(managerRoot(), 'wiki-workspace'),
     args,
     {
-      cwd: managerRoot(),
+      // Relative Compose mounts and default scaffold paths must resolve from
+      // the user's manager state, never from the globally installed package.
+      cwd: stateDir,
       env: {
         ...process.env,
         WIKI_WORKSPACES_DIR: workspacesDir(),
         WIKI_MANAGER_ENV_FILE: managerEnvFile(),
+        // The script runs from the installed package directory so it can find
+        // its Compose templates. Pin mutable manager state to the user's
+        // launch directory; a global npm package is commonly owned by root
+        // and must never become the destination for this scaffold.
+        WIKI_MANAGER_ENDPOINTS_FILE: managerMcpEndpointsFile(),
       },
       maxBuffer: options.maxBuffer ?? 1024 * 1024 * 8,
       timeout: options.timeout ?? 600_000,

package/src/orchestrator/dependencyResolver.js

@@ -3,6 +3,9 @@ import { approvalCovered } from './approvalPolicy.js';
 
 const DONE_STATUSES = new Set(['done', 'completed', 'complete', 'success', 'succeeded']);
 const TERMINAL_STATUSES = new Set([...DONE_STATUSES, 'failed', 'cancelled', 'canceled', 'skipped']);
+// A task in one of these statuses hasn't run yet but could become ready —
+// shared with runner.js's scheduler-stall check so the two can't drift apart.
+export const PENDING_STATUSES = new Set(['pending', 'pending_approval', 'waiting_approval']);
 
 export function readyTasks(dag, {
   registry = null,
@@ -18,7 +21,7 @@ export function readyTasks(dag, {
     .filter((task) => {
       const status = statusOf(task);
       return status === 'pending'
-        || ((status === 'waiting_approval' || status === 'pending_approval')
+        || (PENDING_STATUSES.has(status)
           && approvalCovered(task, approvals, {
             runId: task?.runId ?? dag?.runId ?? null,
             workspaceId: dag?.workspace ?? null,
@@ -35,6 +38,21 @@ export function readyTasks(dag, {
     .sort(compareTaskPriority);
 }
 
+export function tasksAwaitingApproval(dag, { approvals = [] } = {}) {
+  const tasks = normalizeTasks(dag);
+  const done = new Set(tasks.filter((task) => DONE_STATUSES.has(statusOf(task))).map(taskId));
+  return tasks
+    .filter((task) => PENDING_STATUSES.has(statusOf(task)))
+    .filter((task) => task?.requiresApproval === true)
+    .filter((task) => !approvalCovered(task, approvals, {
+      runId: task?.runId ?? dag?.runId ?? null,
+      workspaceId: dag?.workspace ?? null,
+      planRevision: dag?.planRevision ?? null,
+    }))
+    .filter((task) => dependenciesDone(task, done))
+    .filter((task) => groupBarrierSatisfied(task, tasks));
+}
+
 function normalizeTasks(dag) {
   if (Array.isArray(dag)) return dag;
   if (Array.isArray(dag?.tasks)) return dag.tasks;

package/src/orchestrator/objectiveResolver.js

@@ -1,6 +1,8 @@
 export async function resolveObjective(objective, session) {
   const candidates = capabilityCandidates(session);
   if (candidates.length === 0) throw new Error('No orchestrable capability is currently available.');
+  const deterministic = resolveMentionedRegistryOperation(objective, candidates);
+  if (deterministic) return selectionWithProvider(session, deterministic, candidates);
   const llm = session?.llm;
   if (!llm?.completeWithTools) throw new Error('Objective resolution requires the configured workspace LLM.');
 
@@ -25,6 +27,28 @@ export async function resolveObjective(objective, session) {
   if (!candidate.operations.includes(operation)) {
     throw new Error(`Objective resolver selected unsupported operation "${operation}" for ${capability}.`);
   }
+  return selectionWithProvider(session, { capability, operation }, candidates);
+}
+
+// Prefer an operation explicitly named by the user when that name resolves to
+// exactly one entry in the live registry. This is deliberately generic: the
+// resolver knows neither capability ids nor business verbs. Prefix matching
+// covers natural inflections such as an operation name followed by a suffix.
+function resolveMentionedRegistryOperation(objective, candidates) {
+  const words = String(objective ?? '')
+    .normalize('NFKD')
+    .replace(/\p{Diacritic}/gu, '')
+    .toLowerCase()
+    .match(/[a-z0-9]+/g) ?? [];
+  const matches = candidates.flatMap((candidate) => candidate.operations
+    .filter((operation) => String(operation).split(/[._-]+/).some((token) =>
+      token.length >= 4 && words.some((word) => word.startsWith(token))))
+    .map((operation) => ({ capability: candidate.id, operation })));
+  return matches.length === 1 ? matches[0] : null;
+}
+
+function selectionWithProvider(session, selection, candidates) {
+  const { capability, operation } = selection;
   const providers = providersFor(session, capability)
     .filter((provider) => !operation || (provider.capability?.supportedOperations ?? []).includes(operation))
     .sort((a, b) => String(a.agentInstanceId).localeCompare(String(b.agentInstanceId)));

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.test.js

@@ -4,7 +4,7 @@ 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 {
   effectiveConcurrency,
@@ -60,6 +60,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']);

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,6 +7,8 @@ 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';
@@ -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,
@@ -328,7 +393,6 @@ export async function runRuntimeParallelPlan(agent, session, input, {
   sanitizeSessionPlanForExecution(session, runId);
   ensurePlanProjection(session, runId);
   emitRuntimeLog(session, `scheduler: parallel plan enabled (concurrency ${limit})`);
-  let approvalNoticeSent = false;
   // 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 +495,60 @@ 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,
+            }));
+          }
+          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 +567,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 +685,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 = {