@dotdrelle/wiki-manager 0.12.11 → 0.14.0

package/src/runtime/client.js

@@ -52,6 +52,7 @@ export async function postRuntimeRun(input, {
   workspace = null,
   evaluate = undefined,
   replans = undefined,
+  capabilityPlan = undefined,
 } = {}) {
   const response = await fetch(runtimeEndpoint(url, '/run', workspace), {
     method: 'POST',
@@ -59,7 +60,7 @@ export async function postRuntimeRun(input, {
       ...runtimeHeaders(token),
       'Content-Type': 'application/json',
     },
-    body: JSON.stringify(Object.assign({ input, workspace }, evaluate !== undefined && { evaluate }, replans !== undefined && { replans })),
+    body: JSON.stringify(Object.assign({ input, workspace }, evaluate !== undefined && { evaluate }, replans !== undefined && { replans }, capabilityPlan !== undefined && { capabilityPlan })),
   });
   if (!response.ok) {
     const err = new Error(`Runtime run failed: HTTP ${response.status}`);
@@ -69,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(),
@@ -151,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);
@@ -159,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/lifecycle.js

@@ -109,7 +109,7 @@ export async function runtimeHealthOrNull(url = runtimeUrlFromEnv(), token = run
 // 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 = () => {} } = {}) {
+export async function shutdownOwnedRuntime(runtime, { log = (_message) => {} } = {}) {
   if (!runtime?.url || !runtime?.started) return { action: 'kept', reason: 'not_owned' };
   try {
     const health = await runtimeHealthOrNull(runtime.url, runtime.token);

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

@@ -9,10 +9,16 @@ import { createBudgetManager, BudgetExceededError } from '../orchestrator/budget
 import { createDispatcher } from '../orchestrator/dispatcher.js';
 import { assertValidatedFragment } from '../orchestrator/planValidator.js';
 import { createResultAggregator } from '../orchestrator/resultAggregator.js';
-import { drainActive, resolveSchedulerConcurrency, startReadyTasks } from '../orchestrator/scheduler.js';
+import { drainActive, resolvePlanConcurrency, startReadyTasks } from '../orchestrator/scheduler.js';
 import { emitRuntimeLog, pollActivitiesOnce } from './supervisor.js';
 
-const DEFAULT_MAX_REPLANS = 2;
+// 0 by default: automatic replans turn evaluator/replanner TEXT into
+// executable pseudo-tasks (no capability, no operation) that stall at 0%
+// and pile up as replan-1/2/3 ghost work — the same disease as the removed
+// text-plan extraction. Failures now end with an honest report; the user
+// (or a stronger model) decides what to do next. Re-enable explicitly with
+// WIKI_MANAGER_REPLANNER_MAX_REPLANS if desired.
+const DEFAULT_MAX_REPLANS = 0;
 
 async function waitForRuntimeActivities(session, startedActivities, { timeoutMs, signal, pollBusy }) {
   const deadline = Date.now() + timeoutMs;
@@ -43,13 +49,35 @@ async function waitForRuntimeActivities(session, startedActivities, { timeoutMs,
   return { ok: false, timedOut: true, completed: tracked };
 }
 
-export async function runRuntimeAgenticLoop(agent, session, initialInput, { signal, timeoutMs, maxTurns, runId, pollBusy, parallelHandoff = false }) {
+// Last chat exchanges (user/assistant) that preceded this run, so the run's
+// LLM knows WHAT was agreed before acting. Long messages are clipped: the
+// context is for grounding, not for re-reading novels.
+// Env knobs (documented in .env.example): every tunable introduced by the
+// grounding/orchestration work is overridable — nothing business-critical
+// is frozen in code.
+export function conversationSeed(session, currentInput, { limit = 12, maxChars = 2000 } = {}) {
+  const conversation = Array.isArray(session.agentProjection?.conversation)
+    ? session.agentProjection.conversation
+    : [];
+  const seed = conversation
+    .filter((message) => ['user', 'assistant'].includes(message?.role) && String(message?.content ?? '').trim())
+    .slice(-limit)
+    .map((message) => ({ role: message.role, content: String(message.content).slice(0, maxChars) }));
+  // The run's own triggering user message is appended by the loop itself —
+  // drop it from the seed to avoid sending it twice.
+  const last = seed.at(-1);
+  if (last && last.role === 'user' && last.content === String(currentInput ?? '').slice(0, maxChars)) seed.pop();
+  return seed;
+}
+
+export async function runRuntimeAgenticLoop(agent, session, initialInput, { signal, timeoutMs, maxTurns, runId, pollBusy, parallelHandoff = false, initialMessages = [] }) {
   return runAgenticLoop(agent, session, initialInput, {
     signal,
     timeoutMs,
     maxTurns,
     runId,
     parallelHandoff,
+    initialMessages,
     deterministicTerminalSummary: true,
     abortMessage: 'Runtime run cancelled.',
     waitForActivities: (turnSession, startedActivities, waitOptions) =>
@@ -103,10 +131,13 @@ 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));
+  // Computed ONCE at run start: the pre-run chat. Re-computing inside the
+  // loop would re-ingest this run's own turns and duplicate them.
+  const runConversationSeed = conversationSeed(session, currentInput);
 
   while (true) {
     sanitizeSessionPlanForExecution(session, runId);
@@ -127,6 +158,7 @@ export async function runRuntimeAgenticWorkflow(agent, session, input, {
         runId,
         pollBusy,
         parallelHandoff: true,
+        initialMessages: runConversationSeed,
       });
     if (result.ok && result.handoff) continue;
     if (!result.ok) {
@@ -212,6 +244,16 @@ export async function runRuntimeAgenticWorkflow(agent, session, input, {
             continue;
           }
         }
+        // Surface the verdict in the CHAT: the work that ran stays done, the
+        // user sees why the evaluator was unsatisfied and decides — no
+        // self-generated follow-up tasks.
+        dispatchAgentEvent(session, createAgentEvent('assistant_message', {
+          origin: 'runtime',
+          runId,
+          payload: {
+            content: `Le run est terminé mais l'évaluation le juge incomplet : ${evaluation.reason}`,
+          },
+        }));
         dispatchAgentEvent(session, createAgentEvent('run_error', {
           origin: 'runtime',
           runId,
@@ -240,7 +282,7 @@ export async function runRuntimeParallelPlan(agent, session, input, {
   maxTurns,
   runId = null,
   pollBusy,
-  concurrency = resolveSchedulerConcurrency(),
+  concurrency = null,
   fragment = null,
   assignmentManager = null,
   attemptManager = null,
@@ -249,10 +291,18 @@ export async function runRuntimeParallelPlan(agent, session, input, {
   budgetManager = null,
   budgets = {},
   callTool = null,
-  dispatcherPollIntervalMs = 250,
+  dispatcherPollIntervalMs = 2500,
 } = {}) {
   if (fragment != null) assertValidatedFragment(fragment);
-  const limit = Math.max(1, Math.floor(Number(concurrency) || 1));
+  const agents = session.agentRegistry?.snapshot?.() ?? session.agentRegistrySnapshot ?? [];
+  const configuredConcurrency = Number(concurrency) > 0
+    ? Number(concurrency)
+    : Number(process.env.WIKI_MANAGER_CAPABILITY_CONCURRENCY || process.env.WIKI_MANAGER_SCHEDULER_CONCURRENCY);
+  const limit = resolvePlanConcurrency({
+    plan: session.headlessPlan ?? [],
+    agents,
+    configured: configuredConcurrency,
+  });
   const active = new Map();
   const attempts = attemptManager ?? createAttemptManager();
   const assigner = assignmentManager ?? createAssignmentManager({ session });
@@ -278,6 +328,15 @@ 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
+  // runs, CI) via the session or the env escape hatch.
+  const configuredApprovalWait = Number(session._approvalTimeoutMs) > 0
+    ? Number(session._approvalTimeoutMs)
+    : (Number(process.env.WIKI_MANAGER_APPROVAL_TIMEOUT_MS) > 0 ? Number(process.env.WIKI_MANAGER_APPROVAL_TIMEOUT_MS) : null);
+  const approvalDeadline = configuredApprovalWait ? Date.now() + configuredApprovalWait : Infinity;
 
   try {
     while (true) {
@@ -336,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,
@@ -371,6 +431,44 @@ 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);
+        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;
+            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,
+                  '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))`);
+          }
+          if (Date.now() < approvalDeadline) {
+            await new Promise((resolveDelay) => setTimeout(resolveDelay, 500));
+            continue;
+          }
+          // Configured timeout (headless/CI) reached: say it PLAINLY in the
+          // chat and let run_error clean the plan/activities so nothing
+          // lingers in the panels.
+          emitRuntimeLog(session, 'scheduler: approval wait timed out');
+          dispatchAgentEvent(session, createAgentEvent('assistant_message', {
+            origin: 'runtime',
+            runId,
+            payload: {
+              content: `⏱ Approbation non reçue dans le délai imparti — run arrêté, ${needingApproval.length} tâche(s) annulée(s). Relance la demande quand tu veux.`,
+            },
+          }));
+          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';
         emitRuntimeLog(session, `scheduler: stalled (${reason})`);
         return { ok: false, stalled: true, reason, completed: sessionActivities(session), failures };
@@ -428,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);
@@ -603,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 });
@@ -623,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, {
@@ -718,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.');
@@ -741,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();
@@ -860,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).`,
@@ -872,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;
@@ -889,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',
@@ -1016,7 +1216,7 @@ function formatRecentConversation(session, n = 12) {
     .join('\n');
 }
 
-function resolveMaxReplans(value = process.env.WIKI_MANAGER_REPLANNER_MAX_REPLANS) {
+function resolveMaxReplans(value) {
   const parsed = Number(value);
   return Number.isFinite(parsed) ? Math.max(0, Math.floor(parsed)) : DEFAULT_MAX_REPLANS;
 }

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 = [];
@@ -713,7 +776,9 @@ test('runRuntimeParallelPlan fails cleanly when scheduler budget is exceeded', a
   assert.equal(result.budgetExceeded, true);
   assert.equal(result.reason, 'max_tasks_exceeded');
   assert.ok(session.agentEvents.some((event) => event.type === 'run_error' && event.payload?.budget?.reason === 'max_tasks_exceeded'));
-  assert.equal(session.headlessPlan[0].status, 'pending');
+  // run_error now cancels leftover pending steps: a dead run must not leave
+  // ghost work in the panels or reappear at the next relaunch.
+  assert.equal(session.headlessPlan[0].status, 'cancelled');
 });
 
 test('runRuntimeParallelPlan retries a retryable task on a fallback agent', async () => {
@@ -915,3 +980,36 @@ async function waitFor(predicate, timeoutMs = 500) {
   }
   assert.fail('condition was not met before timeout');
 }
+
+test('runtime runs are seeded with the chat that preceded them', async () => {
+  // "Donna n'a pas de contexte" was literally true: runs started with an
+  // empty history, so the model reinvented the missing context. The seed
+  // carries the prior exchanges, minus the run's own triggering message.
+  const { conversationSeed } = await import('./runner.js');
+  const session = {
+    agentProjection: {
+      conversation: [
+        { role: 'user', content: 'peux-tu configurer le CME ?' },
+        { role: 'assistant', content: 'CME configuré sur confluent.meteo.fr. Veux-tu ingérer les documents en attente ?' },
+        { role: 'user', content: 'oui lance l\'ingestion' },
+      ],
+    },
+  };
+
+  const seed = conversationSeed(session, "oui lance l'ingestion");
+  assert.deepEqual(seed.map((message) => message.role), ['user', 'assistant']);
+  assert.match(seed[1].content, /confluent\.meteo\.fr/);
+
+  // Long entries are clipped, empty/technical roles dropped.
+  const noisy = {
+    agentProjection: {
+      conversation: [
+        { role: 'command', content: 'Runtime is idle.' },
+        { role: 'assistant', content: 'x'.repeat(5000) },
+      ],
+    },
+  };
+  const clipped = conversationSeed(noisy, 'autre demande');
+  assert.equal(clipped.length, 1);
+  assert.equal(clipped[0].content.length, 2000);
+});