@dotdrelle/wiki-manager 0.12.12 → 0.14.1

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 = [];

package/src/runtime/server.js

@@ -15,6 +15,7 @@ export function startRuntimeServer({
   session = null,
   getContext,
   run,
+  delegate,
   cancel,
   resume,
   approve,
@@ -24,6 +25,9 @@ export function startRuntimeServer({
   exitOnShutdown = process.env.WIKI_MANAGER_RUNTIME_CHILD === '1',
 } = {}) {
   const clients = new Set();
+  // When this runtime process started — used by ensureRuntime to detect that
+  // the manager source has been edited since (dev staleness) and auto-restart.
+  const runtimeStartedAtMs = Date.now();
   const defaultContext = { workspace: null, session, running: false, currentAbortController: null, currentRunId: null };
   const resolvedGetContext = getContext ?? (() => defaultContext);
 
@@ -61,6 +65,7 @@ export function startRuntimeServer({
           status: context?.running ? 'running' : 'idle',
           workspace: context?.workspace ?? workspace ?? null,
           activeRuns,
+          startedAtMs: runtimeStartedAtMs,
           dbPath: store.dbPath,
           cacertPath: activeCacertPath(),
           nodeExtraCaCerts: process.env.NODE_EXTRA_CA_CERTS ?? null,
@@ -271,6 +276,36 @@ export function startRuntimeServer({
         }
         return;
       }
+      if (request.method === 'POST' && url.pathname === '/delegate') {
+        const { body, context } = await resolveBodyContext(request, url);
+        const objective = String(body.objective ?? '').trim();
+        if (!objective) {
+          sendJson(response, 400, { error: 'Missing objective.' });
+          return;
+        }
+        if (context.running) {
+          sendJson(response, 409, { error: 'A runtime run is already active.' });
+          return;
+        }
+        if (typeof delegate !== 'function') {
+          sendJson(response, 501, { error: 'Runtime delegation is unavailable.' });
+          return;
+        }
+        try {
+          const prepared = await delegate(context, { objective, workspace: body.workspace ?? context.workspace ?? null });
+          const started = startRuntimeRun(context, {
+            input: objective,
+            workspace: body.workspace ?? context.workspace ?? null,
+            preparedDelegation: prepared,
+            evaluate: false,
+          }, { waitForPlan: true });
+          await started.ready;
+          sendJson(response, 202, { accepted: true, runId: started.runId, workspace: started.workspace, delegation: prepared.summary ?? null });
+        } catch (err) {
+          sendJson(response, 422, { error: err instanceof Error ? err.message : String(err) });
+        }
+        return;
+      }
       if (request.method === 'POST' && url.pathname === '/cancel') {
         const workspace = workspaceFromUrl(url);
         const context = await resolveContext({ workspace });
@@ -391,14 +426,22 @@ export function startRuntimeServer({
     return { killed: true, workspace: targetWorkspace, runId: targetRunId, runs, tasks, queued };
   }
 
-  function startRuntimeRun(context, body, { controlItemId = null } = {}) {
+  function startRuntimeRun(context, body, { controlItemId = null, waitForPlan = false } = {}) {
     const runId = randomUUID();
     const runWorkspace = context.workspace ?? body.workspace ?? null;
     context.running = true;
     context.currentAbortController = new AbortController();
     context.currentRunId = runId;
     context.currentRunWorkspace = runWorkspace;
-    const runBody = { ...body, workspace: runWorkspace, runId };
+    let resolveReady;
+    let rejectReady;
+    const ready = waitForPlan ? new Promise((resolve, reject) => { resolveReady = resolve; rejectReady = reject; }) : null;
+    const runBody = {
+      ...body,
+      workspace: runWorkspace,
+      runId,
+      ...(waitForPlan ? { _planReady: { resolve: resolveReady, reject: rejectReady } } : {}),
+    };
     if (controlItemId) {
       dispatchAgentEvent(context.session, createAgentEvent('control_started', {
         origin: 'runtime',
@@ -410,6 +453,7 @@ export function startRuntimeServer({
     const runPromise = run(context, runBody, { signal: context.currentAbortController.signal, runId });
     runPromise
       .catch((err) => {
+        rejectReady?.(err);
         context.session?._onRuntimeError?.(err);
       })
       .finally(() => {
@@ -420,7 +464,7 @@ export function startRuntimeServer({
         publishState(runWorkspace, context);
         void startNextControlRequest(context);
       });
-    return { accepted: true, runId, workspace: runWorkspace };
+    return { accepted: true, runId, workspace: runWorkspace, ...(ready ? { ready } : {}) };
   }
 
   function startNextControlRequest(context) {

package/src/runtime/supervisor.js

@@ -119,7 +119,10 @@ export async function pollActivitiesOnce(session, {
         const retry = progress.retryAt
           ? `retry ${progress.retryAt}`
           : (progress.waitMs ? `wait ${progress.waitMs}ms` : null);
-        const progressKey = `${polledActivity.status}:${Number.isFinite(percent) ? Math.round(percent) : ''}:${detail}:${batch ?? ''}:${lastEvent ?? ''}:${retry ?? ''}`;
+        // retryAt/waitMs are scheduling metadata and may be recomputed on every
+        // status poll. They must remain visible in the first log line, but must
+        // not turn an unchanged quota/backoff state into a new trace event.
+        const progressKey = `${polledActivity.status}:${Number.isFinite(percent) ? Math.round(percent) : ''}:${detail}:${batch ?? ''}:${lastEvent ?? ''}`;
         session._activityLogKeys ??= {};
         if (session._activityLogKeys[key] !== progressKey) {
           session._activityLogKeys[key] = progressKey;

package/src/runtime/supervisor.test.js

@@ -41,6 +41,55 @@ test('pollActivitiesOnce updates activity through the event reducer', async () =
   assert.ok(session.agentProjection.logs.some((line) => line.includes('activity:')));
 });
 
+test('pollActivitiesOnce does not repeat an unchanged retry state when retryAt moves', async () => {
+  const session = {
+    mcp: { production: { status: 'connected' } },
+    activities: {},
+    headlessPlan: null,
+    jobQueue: [],
+  };
+  dispatchAgentEvent(session, createAgentEvent('activity_upserted', {
+    payload: {
+      activity: {
+        id: 'job-quota',
+        source: 'production',
+        label: 'Production · ingest',
+        status: 'running',
+        poll: { server: 'production', tool: 'production_job_status', args: { jobId: 'job-quota' }, intervalMs: 0 },
+      },
+    },
+  }));
+
+  let poll = 0;
+  const callTool = async () => {
+    poll += 1;
+    return {
+      content: [{ type: 'text', text: JSON.stringify({
+        _activity: {
+          id: 'job-quota',
+          source: 'production',
+          label: 'Production · ingest',
+          status: 'running',
+          terminal: false,
+          progress: {
+            percent: 15,
+            detail: 'LLM quota wait',
+            lastEvent: 'llm:rate-limit-wait',
+            retryAt: `2026-07-10T20:31:5${poll}.000Z`,
+          },
+        },
+      }) }],
+    };
+  };
+
+  await pollActivitiesOnce(session, { callTool });
+  await pollActivitiesOnce(session, { callTool });
+
+  const lines = session.agentProjection.logs.filter((line) => line.includes('activity: Production · ingest'));
+  assert.equal(lines.length, 1);
+  assert.match(lines[0], /retry 2026-07-10T20:31:51\.000Z/);
+});
+
 test('pollActivitiesOnce retries transient MCP poll failures', async () => {
   const originalFetch = globalThis.fetch;
   let attempts = 0;