@dotdrelle/wiki-manager 0.12.12 → 0.14.0

package/src/orchestrator/dispatcher.js

@@ -8,7 +8,7 @@ const TERMINAL_STATUSES = new Set(['done', 'failed', 'cancelled', 'canceled', 'c
 export function createDispatcher({
   session = null,
   callTool = callMcpTool,
-  pollIntervalMs = 250,
+  pollIntervalMs = 2500,
 } = {}) {
   return {
     execute(task, assignment, options = {}) {
@@ -30,7 +30,7 @@ export async function execute(task, assignment, {
   attempt = null,
   timeoutMs = null,
   pollBusy = new Set(),
-  pollIntervalMs = 250,
+  pollIntervalMs = 2500,
 } = {}) {
   if (!session) throw new Error('dispatcher.execute requires session.');
   if (!assignment?.serverName) throw new Error(`No MCP server found for agent ${assignment?.agentInstanceId ?? '(unknown)'}.`);
@@ -57,7 +57,7 @@ export async function execute(task, assignment, {
       signal,
     ));
     if (accepted?.accepted === false || accepted?.ok === false) {
-      throw new Error(String(accepted.error ?? 'agent_execute rejected task'));
+      return rejectedTaskResult(task, assignment, accepted, attempt);
     }
     jobId = String(accepted.jobId ?? '');
     if (!jobId) throw new Error('agent_execute did not return jobId.');
@@ -218,6 +218,37 @@ function taskResultFromStatus(task, assignment, jobId, statusPayload, attempt =
   };
 }
 
+function rejectedTaskResult(task, assignment, payload, attempt = null) {
+  const rawError = payload?.error;
+  const error = rawError && typeof rawError === 'object'
+    ? { ...rawError }
+    : {
+        code: String(rawError ?? 'execution_rejected'),
+        message: String(payload?.message ?? rawError ?? 'agent_execute rejected task'),
+        retryable: transientError(rawError ?? payload?.message),
+      };
+  return {
+    ok: false,
+    taskId: String(task.id ?? task.step),
+    attemptId: attempt?.attemptId ?? null,
+    jobId: payload?.activeJobId ?? null,
+    agentInstanceId: assignment.agentInstanceId,
+    status: 'failed',
+    outputRefs: [],
+    metrics: {},
+    error: {
+      code: String(error.code ?? 'execution_rejected'),
+      message: String(error.message ?? error.code ?? 'agent_execute rejected task'),
+      retryable: error.retryable === true || transientError(error.code) || transientError(error.message),
+    },
+    rawStatus: payload,
+  };
+}
+
+function transientError(value) {
+  return /(?:429|timeout|temporar|throttl|rate.?limit|quota|busy|unavailable)/i.test(String(value ?? ''));
+}
+
 function toolNameFor(session, serverName, baseName) {
   const tools = session.mcp?.[serverName]?.tools ?? [];
   const names = tools.map((tool) => String(tool.name ?? '')).filter(Boolean);

package/src/orchestrator/dispatcher.test.js

@@ -0,0 +1,34 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { createDispatcher } from './dispatcher.js';
+
+test('dispatcher returns a retryable logical failure when agent_execute reports workspace_busy', async () => {
+  const session = {
+    workspace: 'test',
+    mcp: {
+      production: {
+        tools: [
+          { name: 'agent_execute' },
+          { name: 'agent_status' },
+          { name: 'agent_cancel' },
+        ],
+      },
+    },
+  };
+  const dispatcher = createDispatcher({
+    session,
+    callTool: async () => ({ accepted: false, error: 'workspace_busy', activeJobId: 'job-old' }),
+  });
+
+  const result = await dispatcher.execute(
+    { id: 'ingest-a', requiredCapability: 'knowledge.update', operation: 'ingest_plan', arguments: {} },
+    { serverName: 'production', agentInstanceId: 'production-main' },
+    { attempt: { attemptId: 'ingest-a:attempt-1', locks: [], release() {} } },
+  );
+
+  assert.equal(result.ok, false);
+  assert.equal(result.taskId, 'ingest-a');
+  assert.equal(result.attemptId, 'ingest-a:attempt-1');
+  assert.equal(result.error.code, 'workspace_busy');
+  assert.equal(result.error.retryable, true);
+});

package/src/orchestrator/objectiveResolver.js

@@ -0,0 +1,79 @@
+export async function resolveObjective(objective, session) {
+  const candidates = capabilityCandidates(session);
+  if (candidates.length === 0) throw new Error('No orchestrable capability is currently available.');
+  const llm = session?.llm;
+  if (!llm?.completeWithTools) throw new Error('Objective resolution requires the configured workspace LLM.');
+
+  const result = await llm.completeWithTools({
+    system: [
+      'You resolve one user objective against a closed capability registry.',
+      'Select exactly one listed capability and one of its supported operations.',
+      'Never invent identifiers. Return JSON only: {"capability":"...","operation":"..."}.',
+    ].join('\n'),
+    tools: [],
+    messages: [{
+      role: 'user',
+      content: `Objective:\n${String(objective)}\n\nRegistry:\n${JSON.stringify(candidates, null, 2)}`,
+    }],
+    signal: session?._abortSignal,
+  });
+  const selection = parseJson(result?.content);
+  const capability = String(selection?.capability ?? '');
+  const operation = String(selection?.operation ?? '');
+  const candidate = candidates.find((item) => item.id === capability);
+  if (!candidate) throw new Error(`Objective resolver selected unknown capability "${capability}".`);
+  if (!candidate.operations.includes(operation)) {
+    throw new Error(`Objective resolver selected unsupported operation "${operation}" for ${capability}.`);
+  }
+  const providers = providersFor(session, capability)
+    .filter((provider) => !operation || (provider.capability?.supportedOperations ?? []).includes(operation))
+    .sort((a, b) => String(a.agentInstanceId).localeCompare(String(b.agentInstanceId)));
+  if (providers.length === 0) throw new Error(`No healthy agent provides ${capability}/${operation}.`);
+  return { capability, operation, provider: providers[0], candidates };
+}
+
+export function capabilityCandidates(session) {
+  const snapshot = registrySnapshot(session);
+  const byId = new Map();
+  for (const [versionedId, providers] of Object.entries(snapshot)) {
+    const id = versionedId.includes('@') ? versionedId.slice(0, versionedId.lastIndexOf('@')) : versionedId;
+    const operations = [...new Set((providers ?? []).flatMap((provider) => provider?.capability?.supportedOperations ?? []))].sort();
+    const description = (providers ?? []).map((provider) => provider?.capability?.description).find(Boolean) ?? '';
+    byId.set(id, { id, description, operations });
+  }
+  return [...byId.values()].filter((item) => item.operations.length > 0).sort((a, b) => a.id.localeCompare(b.id));
+}
+
+function providersFor(session, capability) {
+  if (session?.capabilityRegistry?.providersFor) return session.capabilityRegistry.providersFor(capability) ?? [];
+  return Object.entries(registrySnapshot(session))
+    .filter(([key]) => key === capability || key.startsWith(`${capability}@`))
+    .flatMap(([, providers]) => providers ?? []);
+}
+
+function registrySnapshot(session) {
+  const registry = session?.capabilityRegistry;
+  if (registry?.snapshot) return registry.snapshot();
+  if (registry && typeof registry === 'object') return registry;
+  const agents = session?.agentRegistry?.snapshot?.() ?? session?.agentRegistrySnapshot ?? [];
+  const snapshot = {};
+  for (const agent of agents) {
+    for (const capability of agent?.description?.capabilities ?? []) {
+      const key = `${capability.id}@${capability.version ?? '1'}`;
+      (snapshot[key] ??= []).push({
+        agentInstanceId: agent.agentInstanceId,
+        serverName: agent.serverName,
+        capability,
+        description: agent.description,
+        health: agent.health,
+      });
+    }
+  }
+  return snapshot;
+}
+
+function parseJson(content) {
+  const text = String(content ?? '').trim();
+  const fenced = text.match(/^```(?:json)?\s*([\s\S]*?)\s*```$/i);
+  return JSON.parse(fenced ? fenced[1] : text);
+}

package/src/orchestrator/objectiveResolver.test.js

@@ -0,0 +1,50 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { capabilityCandidates, resolveObjective } from './objectiveResolver.js';
+
+function sessionWithSelection(selection) {
+  const provider = {
+    agentInstanceId: 'production-1',
+    serverName: 'production',
+    capability: {
+      id: 'knowledge.update',
+      version: '1',
+      description: 'Update knowledge from pending sources.',
+      supportedOperations: ['ingest'],
+    },
+  };
+  return {
+    capabilityRegistry: {
+      snapshot: () => ({ 'knowledge.update@1': [provider] }),
+      providersFor: () => [provider],
+    },
+    llm: {
+      completeWithTools: async () => ({ content: JSON.stringify(selection) }),
+    },
+  };
+}
+
+test('capabilityCandidates exposes only the closed live registry', () => {
+  assert.deepEqual(capabilityCandidates(sessionWithSelection({})), [{
+    id: 'knowledge.update',
+    description: 'Update knowledge from pending sources.',
+    operations: ['ingest'],
+  }]);
+});
+
+test('resolveObjective selects and validates one real provider', async () => {
+  const result = await resolveObjective('Ingère tous les fichiers en attente', sessionWithSelection({
+    capability: 'knowledge.update',
+    operation: 'ingest',
+  }));
+  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' })),
+    /unknown capability "ingest"/,
+  );
+});

package/src/orchestrator/scheduler.test.js

@@ -35,6 +35,31 @@ test('dependencyResolver orders ready tasks by priority before step', () => {
   assert.deepEqual(readyTasks(plan).map((item) => item.id), ['high', 'low', 'none']);
 });
 
+test('dependencyResolver releases a waiting task when a run grant covers it', () => {
+  const plan = {
+    runId: 'run-1',
+    workspace: 'test4',
+    planRevision: 1,
+    tasks: [task('ingest', {
+      status: 'waiting_approval',
+      requiresApproval: true,
+      approvalClass: 'mutation',
+    })],
+  };
+
+  assert.deepEqual(readyTasks(plan), []);
+  assert.deepEqual(readyTasks(plan, {
+    approvals: [{
+      status: 'approved',
+      scope: 'run',
+      runId: 'run-1',
+      workspaceId: 'test4',
+      planRevision: 1,
+      approvalClasses: ['mutation'],
+    }],
+  }).map((item) => item.id), ['ingest']);
+});
+
 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/client.js

@@ -70,6 +70,25 @@ export async function postRuntimeRun(input, {
   return response.json();
 }
 
+export async function postRuntimeDelegate(objective, {
+  url = runtimeUrlFromEnv(),
+  token = runtimeToken(),
+  workspace = null,
+} = {}) {
+  const response = await fetch(runtimeEndpoint(url, '/delegate', workspace), {
+    method: 'POST',
+    headers: { ...runtimeHeaders(token), 'Content-Type': 'application/json' },
+    body: JSON.stringify({ objective, workspace }),
+  });
+  const payload = await response.json().catch(() => ({}));
+  if (!response.ok) {
+    const err = new Error(payload.error ?? `Runtime delegation failed: HTTP ${response.status}`);
+    err.status = response.status;
+    throw err;
+  }
+  return payload;
+}
+
 export async function postRuntimeControl(action, {
   url = runtimeUrlFromEnv(),
   token = runtimeToken(),
@@ -152,6 +171,9 @@ export async function postRuntimeApprove({
   runId = null,
   itemId = null,
   approvalId = null,
+  scope = null,
+  planRevision = null,
+  approvalClasses = null,
 } = {}) {
   const endpoint = runtimeEndpoint(url, '/approve', workspace);
   const parsed = new URL(endpoint);
@@ -160,7 +182,16 @@ export async function postRuntimeApprove({
   if (approvalId) parsed.searchParams.set('approvalId', approvalId);
   const response = await fetch(parsed.toString(), {
     method: 'POST',
-    headers: runtimeHeaders(token),
+    headers: { ...runtimeHeaders(token), 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      workspace,
+      runId,
+      itemId,
+      approvalId,
+      scope,
+      planRevision,
+      approvalClasses,
+    }),
   });
   if (!response.ok) throw new Error(`Runtime approve failed: HTTP ${response.status}`);
   return response.json();

package/src/runtime/recoveryManager.js

@@ -37,18 +37,25 @@ export async function recoverActiveRuns({
         errors.push({ runId: run.id, taskId: task.id, error: error instanceof Error ? error.message : String(error) });
       }
     }
-    // A run in which nothing was recovered or rescheduled can never progress:
-    // leaving it 'running' in the store would re-attach it as a zombie on
-    // every subsequent boot. Close it for good.
-    if (activeTasks.length > 0 && runOutcomes.length === activeTasks.length
-      && runOutcomes.every((outcome) => outcome?.status === 'interrupted')) {
-      const changed = store.interruptRuns?.({ workspace: run.workspace ?? null, runId: run.id, reason: 'Recovery found no recoverable task.' }) ?? 0;
+    // A run that recovery cannot move forward must be closed for good, or it
+    // re-attaches as a blocking "a runtime run is already active" zombie on
+    // every boot. This covers BOTH cases that can never resume on a fresh boot:
+    //  - runs whose active tasks were all interrupted, and
+    //  - runs with no active task to recover at all (e.g. left waiting for
+    //    approval, or with only un-started pending tasks). Nothing here will
+    //    ever progress, so finalize it now.
+    const progressed = runOutcomes.some((outcome) => outcome?.status === 'recovered' || outcome?.status === 'rescheduled');
+    if (!progressed) {
+      const reason = activeTasks.length > 0
+        ? 'Recovery found no recoverable task.'
+        : 'Recovery found no active task to resume.';
+      const changed = store.interruptRuns?.({ workspace: run.workspace ?? null, runId: run.id, reason }) ?? 0;
       if (changed > 0) {
         dispatch(session, store, 'runtime_log', {
           origin: 'recovery_manager',
           runId: run.id,
           workspace: run.workspace ?? workspaceFromSession(session),
-          payload: { message: `recovery: run ${run.id} interrupted (no recoverable task)` },
+          payload: { message: `recovery: run ${run.id} interrupted (${reason})` },
         });
       }
     }

package/src/runtime/runner.js

@@ -131,7 +131,7 @@ export async function runRuntimeAgenticWorkflow(agent, session, input, {
   evaluate = true,
   maxReplans = resolveMaxReplans(),
   callTool = null,
-  dispatcherPollIntervalMs = 250,
+  dispatcherPollIntervalMs = 2500,
 } = {}) {
   let currentInput = initialInput ?? input;
   let replansLeft = Math.max(0, Math.floor(Number(maxReplans) || 0));
@@ -251,11 +251,7 @@ export async function runRuntimeAgenticWorkflow(agent, session, input, {
           origin: 'runtime',
           runId,
           payload: {
-            content: [
-              `Le run est terminé mais l'évaluation le juge incomplet : ${evaluation.reason}`,
-              evaluation.suggestedAction ? `Piste suggérée : ${evaluation.suggestedAction}` : null,
-              'Aucune tâche supplémentaire n\'a été créée automatiquement — dis-moi si tu veux poursuivre.',
-            ].filter(Boolean).join('\n'),
+            content: `Le run est terminé mais l'évaluation le juge incomplet : ${evaluation.reason}`,
           },
         }));
         dispatchAgentEvent(session, createAgentEvent('run_error', {
@@ -295,7 +291,7 @@ export async function runRuntimeParallelPlan(agent, session, input, {
   budgetManager = null,
   budgets = {},
   callTool = null,
-  dispatcherPollIntervalMs = 250,
+  dispatcherPollIntervalMs = 2500,
 } = {}) {
   if (fragment != null) assertValidatedFragment(fragment);
   const agents = session.agentRegistry?.snapshot?.() ?? session.agentRegistrySnapshot ?? [];
@@ -399,8 +395,9 @@ export async function runRuntimeParallelPlan(agent, session, input, {
           emitRuntimeLog(session, taskLogPayload('task.starting', task, { runId, detail: `starting task ${taskId}` }));
         },
         startTask: (task, attempt) => {
+          const executableTask = materializeTaskInputs(task, session.headlessPlan ?? []);
           const taskAbort = createTaskAbortSignal(signal);
-          const promise = runDispatchedTask(task, {
+          const promise = runDispatchedTask(executableTask, {
             session,
             assignmentManager: assigner,
             dispatcher: executor,
@@ -529,6 +526,41 @@ export async function runRuntimeParallelPlan(agent, session, input, {
   }
 }
 
+export function materializeTaskInputs(task, plan = []) {
+  const dependencies = new Set(Array.isArray(task?.dependsOn) ? task.dependsOn.map(String) : []);
+  const replacements = new Map();
+  for (const dependency of plan ?? []) {
+    if (!dependencies.has(String(dependency?.id ?? dependency?.step))) continue;
+    const expected = Array.isArray(dependency?.expectedOutputRefs) ? dependency.expectedOutputRefs : [];
+    const actual = Array.isArray(dependency?.outputRefs) ? dependency.outputRefs : [];
+    for (let index = 0; index < Math.min(expected.length, actual.length); index += 1) {
+      const expectedRef = refValue(expected[index]);
+      const actualRef = refValue(actual[index]);
+      if (expectedRef && actualRef && expectedRef !== actualRef) replacements.set(expectedRef, actualRef);
+    }
+  }
+  if (replacements.size === 0) return task;
+  return {
+    ...task,
+    arguments: replaceRefValues(task?.arguments, replacements),
+    inputRefs: replaceRefValues(task?.inputRefs, replacements),
+  };
+}
+
+function replaceRefValues(value, replacements) {
+  if (typeof value === 'string') return replacements.get(value) ?? value;
+  if (Array.isArray(value)) return value.map((item) => replaceRefValues(item, replacements));
+  if (value && typeof value === 'object') {
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, replaceRefValues(item, replacements)]));
+  }
+  return value;
+}
+
+function refValue(value) {
+  if (typeof value === 'string') return value;
+  return value && typeof value === 'object' ? String(value.ref ?? '') : '';
+}
+
 function sanitizeSessionPlanForExecution(session, runId = null) {
   if (!session.headlessPlan) return;
   const sanitized = sanitizePlanForExecution(session.headlessPlan);
@@ -704,7 +736,7 @@ async function runDispatchedTask(task, {
       error: {
         code: 'dispatcher_error',
         message: err instanceof Error ? err.message : String(err),
-        retryable: false,
+        retryable: transientRuntimeError(err),
       },
     };
     await resultAggregator.accept(result, { task, assignment });
@@ -724,8 +756,16 @@ async function runDispatchedTask(task, {
   }
 }
 
-function shouldUseParallelScheduler(plan) {
-  return readyPlanTasks(plan).some((task) => task.requiredCapability && task.operation);
+export function shouldUseParallelScheduler(plan) {
+  // A validated provider plan enters the scheduler even while every task is
+  // waiting for approval. Looking only at readyPlanTasks() made an all-
+  // approval plan fall through to the conversational Donna loop; that loop
+  // then ignored the integrated TaskGraph and marked the run done.
+  return (plan ?? []).some((task) =>
+    task?.requiredCapability
+    && task?.operation
+    && pendingSchedulerStatus(task.status),
+  );
 }
 
 function taskLogPayload(event, task, {
@@ -819,6 +859,11 @@ export async function evaluateRuntimeRun(session, input, {
   evaluate = true,
 } = {}) {
   if (!shouldEvaluate(evaluate)) return null;
+  const structured = structuredPlanEvaluation(session.headlessPlan);
+  if (structured) {
+    emitRuntimeLog(session, 'runtime: evaluating completed structured plan');
+    return structured;
+  }
   const llm = session.llm;
   if (!llm || typeof llm.completeWithTools !== 'function') {
     return fallbackEvaluation('Evaluator unavailable: no LLM completeWithTools client.');
@@ -842,6 +887,40 @@ export async function evaluateRuntimeRun(session, input, {
   }
 }
 
+function structuredPlanEvaluation(plan) {
+  if (!Array.isArray(plan) || plan.length === 0) return null;
+  // Only provider TaskGraph tasks are authoritative. Legacy conversational
+  // plans contain prose/tool labels and still use the compatibility evaluator.
+  if (!plan.every((step) => step?.requiredCapability && step?.operation)) return null;
+  const statuses = plan.map((step) => String(step?.status ?? '').toLowerCase());
+  const failed = plan.filter((step) => ['failed', 'error', 'cancelled', 'canceled', 'stalled'].includes(String(step?.status ?? '').toLowerCase()));
+  const incomplete = plan.filter((step) => !['done', 'complete', 'completed', 'success', 'succeeded'].includes(String(step?.status ?? '').toLowerCase()));
+  if (failed.length > 0) {
+    return {
+      ok: false,
+      reason: `${failed.length} tâche(s) du plan ont échoué : ${failed.map((step) => step.label ?? step.description ?? step.id ?? step.step).join(', ')}.`,
+      suggestedAction: null,
+    };
+  }
+  if (incomplete.length > 0) {
+    return {
+      ok: false,
+      reason: `${incomplete.length} tâche(s) du plan ne sont pas terminées.`,
+      suggestedAction: null,
+    };
+  }
+  return {
+    ok: statuses.length > 0,
+    reason: `${statuses.length} tâche(s) du plan terminées avec succès.`,
+    suggestedAction: null,
+  };
+}
+
+function transientRuntimeError(error) {
+  const value = error instanceof Error ? error.message : String(error ?? '');
+  return /(?:429|timeout|temporar|throttl|rate.?limit|quota|busy|unavailable)/i.test(value);
+}
+
 function shouldEvaluate(value) {
   if (value === false) return false;
   const env = String(process.env.WIKI_MANAGER_EVALUATOR ?? '').trim().toLowerCase();
@@ -961,10 +1040,30 @@ export async function replanRuntimeRun(session, input, trigger, {
   }
 }
 
+function isBusyFailure(failure) {
+  const fields = [
+    failure?.error,
+    failure?.status,
+    failure?.result?.error?.code,
+    failure?.result?.error?.message,
+    failure?.result?.status,
+  ].map((value) => String(value ?? '').toLowerCase());
+  return fields.some((value) => value.includes('busy') || value.includes('locked'));
+}
+
 function replanTriggerFromLoopResult(result) {
   // 'awaiting_approval' is not a dead end — it means to wait for a human
   // decision, not to replan around it.
   if (result.stalled && result.reason !== 'awaiting_approval') {
+    // A stall caused only by transient lock contention (target_busy /
+    // workspace_busy) must NOT be replanned: the plan is correct, the
+    // workspace was momentarily locked. Replanning around it re-runs the same
+    // tasks, hits the lock again and spins the run into a zombie. Fail cleanly
+    // so the run finalizes instead of lingering 'running'.
+    const blocking = [...(result.failures ?? []), ...terminalFailures(result.completed ?? [])];
+    if (blocking.length > 0 && blocking.every(isBusyFailure)) {
+      return null;
+    }
     return {
       kind: 'plan_stalled',
       reason: `Plan is stalled: ${result.reason ?? 'no ready task'} (pending steps exist but none have their dependencies satisfied).`,
@@ -973,7 +1072,7 @@ function replanTriggerFromLoopResult(result) {
     };
   }
   const failures = terminalFailures(result.completed ?? []);
-  const technical = failures.filter((failure) => !isCancelledStatus(failure.status));
+  const technical = failures.filter((failure) => !isCancelledStatus(failure.status) && !isBusyFailure(failure));
   const cancelled = failures.filter((failure) => isCancelledStatus(failure.status));
   if (cancelled.length > 0 && technical.length === 0 && (result.failures ?? []).every(isCancelledTaskFailure)) {
     return null;
@@ -990,7 +1089,7 @@ function replanTriggerFromLoopResult(result) {
   // The parallel scheduler can fail a task before it ever produces an
   // _activity (e.g. a thrown error on the first turn) — that failure lives
   // in result.failures, not in any activity, so it must be checked too.
-  const taskFailure = (result.failures ?? []).find((failure) => !isCancelledTaskFailure(failure));
+  const taskFailure = (result.failures ?? []).find((failure) => !isCancelledTaskFailure(failure) && !isBusyFailure(failure));
   if (!taskFailure) return null;
   return {
     kind: 'task_error',

package/src/runtime/runner.test.js

@@ -1,7 +1,70 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
 import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
-import { finishRuntimeRun, replanRuntimeRun, runRuntimeAgenticWorkflow, runRuntimeParallelPlan } from './runner.js';
+import { evaluateRuntimeRun, finishRuntimeRun, materializeTaskInputs, replanRuntimeRun, runRuntimeAgenticWorkflow, runRuntimeParallelPlan, shouldUseParallelScheduler } from './runner.js';
+
+test('validated tasks waiting for approval stay in the scheduler instead of falling back to Donna', () => {
+  assert.equal(shouldUseParallelScheduler([
+    {
+      id: 'ingest-plan',
+      requiredCapability: 'knowledge.update',
+      operation: 'ingest_plan',
+      status: 'waiting_approval',
+    },
+    {
+      id: 'ingest-apply',
+      requiredCapability: 'knowledge.update',
+      operation: 'ingest_apply',
+      status: 'waiting_approval',
+    },
+  ]), true);
+  assert.equal(shouldUseParallelScheduler([
+    { id: 'finished', requiredCapability: 'knowledge.update', operation: 'ingest', status: 'done' },
+  ]), false);
+});
+
+test('downstream tasks consume actual dependency outputs instead of planned placeholder refs', () => {
+  const plannedRef = '.wiki/ingest-plans/planned.json';
+  const actualRef = '.wiki/ingest-plans/ingest-2026-07-10.json';
+  const plan = [{
+    id: 'ingest-plan',
+    expectedOutputRefs: [{ type: 'file', ref: plannedRef }],
+    outputRefs: [{ type: 'file', ref: actualRef }],
+  }];
+  const apply = {
+    id: 'ingest-apply',
+    dependsOn: ['ingest-plan'],
+    arguments: { inputs: [plannedRef] },
+    inputRefs: [{ type: 'file', ref: plannedRef }],
+  };
+
+  const executable = materializeTaskInputs(apply, plan);
+  assert.deepEqual(executable.arguments.inputs, [actualRef]);
+  assert.equal(executable.inputRefs[0].ref, actualRef);
+  assert.deepEqual(apply.arguments.inputs, [plannedRef], 'the validated plan declaration remains immutable');
+});
+
+test('evaluateRuntimeRun trusts a completed provider TaskGraph without asking an LLM to reinterpret it', async () => {
+  const session = {
+    headlessPlan: [{
+      id: 'ingest-a',
+      label: 'Ingest A.md',
+      requiredCapability: 'knowledge.update',
+      operation: 'ingest_plan',
+      status: 'done',
+    }],
+    llm: {
+      async completeWithTools() {
+        assert.fail('a structured terminal TaskGraph must not be reinterpreted by an LLM');
+      },
+    },
+  };
+
+  const evaluation = await evaluateRuntimeRun(session, 'ingère A.md');
+
+  assert.equal(evaluation.ok, true);
+  assert.match(evaluation.reason, /1 tâche/);
+});
 
 test('runRuntimeAgenticWorkflow completes conversational turns without evaluation or replan', async () => {
   const events = [];