@dotdrelle/wiki-manager 0.15.40 → 0.15.42

package/src/runtime/delegation.test.js

@@ -0,0 +1,281 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { delegateWithinRun, integratePreparedDelegation } from './delegation.js';
+import { isTerminal } from '../orchestrator/taskStatuses.js';
+
+function task(id) {
+  return {
+    id,
+    label: `Task ${id}`,
+    requiredCapability: 'knowledge.update',
+    operation: 'ingest',
+    arguments: { inputs: [`raw/untracked/${id}.md`] },
+    groupId: 'ingest',
+    dependsOn: [],
+    parallelizable: true,
+    inputRefs: [{ type: 'file', ref: `raw/untracked/${id}.md` }],
+    expectedOutputRefs: [{ type: 'file', ref: `.wiki/ingest-plans/${id}.json` }],
+    locks: ['workspace-write'],
+    requiresApproval: true,
+    idempotencyKey: `idem-${id}`,
+    progressWeight: 1,
+  };
+}
+
+function fragment(taskId = 'build-1') {
+  return {
+    contractVersion: '1',
+    agentInstanceId: 'production-main',
+    capability: 'knowledge.update',
+    summary: { label: 'Update knowledge', initialSynthesis: ['Build.'], estimatedTasks: 1 },
+    groups: [{ id: 'ingest', label: 'Ingest sources', recommendedConcurrency: 2, progressWeight: 1 }],
+    tasks: [task(taskId)],
+    expectedOutputs: [{ type: 'directory', ref: 'wiki' }],
+  };
+}
+
+function preparedDelegation(taskId) {
+  return {
+    capability: 'knowledge.update',
+    operation: 'ingest',
+    provider: { serverName: 'production' },
+    fragment: fragment(taskId),
+    summary: { agent: 'production', capability: 'knowledge.update', operation: 'ingest', tasks: 1 },
+  };
+}
+
+function runningSession(runId = 'run-conversational') {
+  return {
+    workspace: 'juno',
+    activities: {},
+    agentEvents: [],
+    headlessPlan: null,
+    _currentRunIdentity: { runId, workspace: 'juno' },
+  };
+}
+
+// Le registre est un double minimal : la question posée ici n'est pas la
+// validation du plan (couverte par planIntegrator.test.js) mais l'identité du
+// run auquel la délégation appartient.
+function registryDouble() {
+  return {
+    providersFor(capability) {
+      if (capability !== 'knowledge.update') return [];
+      return [{
+        serverName: 'production',
+        agentInstanceId: 'production-main',
+        health: 'available',
+        capability: {
+          id: 'knowledge.update',
+          version: '1',
+          description: 'Knowledge update',
+          inputSchema: {
+            type: 'object',
+            required: ['inputs'],
+            additionalProperties: true,
+            properties: { inputs: { type: 'array', items: { type: 'string' } } },
+          },
+          outputSchema: {},
+          supportedOperations: ['ingest'],
+          mutationClass: 'workspace',
+          defaultRequiresApproval: true,
+        },
+        description: { contractVersion: '1' },
+      }];
+    },
+    isCompatible: (contractVersion) => String(contractVersion) === '1',
+  };
+}
+
+test('une demande de build délègue dans le run courant, sans en démarrer un second', async () => {
+  /*
+   Le run conversationnel se marquait actif AVANT que Donna appelle delegate.
+   L'appel repartait alors vers POST /delegate, qui refusait par 409 : le run
+   refusait sa propre délégation. Déléguer n'est pas démarrer un second run,
+   c'est faire passer celui-ci de la décision à l'exécution.
+  */
+  const session = runningSession('run-fr-build');
+  const started = [];
+
+  const result = await delegateWithinRun(session, 'construis les livrables du workspace juno', {
+    prepare: async ({ objective }) => {
+      assert.match(objective, /construis les livrables/);
+      return preparedDelegation('build-fr');
+    },
+    registry: registryDouble(),
+    startRun: (...args) => started.push(args),
+  });
+
+  assert.equal(result.delegated, true);
+  // Identité unique : le runId rendu est celui du run en cours.
+  assert.equal(result.runId, 'run-fr-build');
+  assert.equal(result.summary.tasks, 1);
+  // Aucun second run concurrent n'a été démarré par la bande.
+  assert.deepEqual(started, []);
+});
+
+test('la délégation interne exige un run actif', async () => {
+  // Hors run, il n'y a pas d'exécution à transformer : c'est un vrai démarrage
+  // de run, et il doit passer par le chemin normal plutôt que par ici.
+  const session = { workspace: 'juno', agentEvents: [] };
+
+  await assert.rejects(
+    () => delegateWithinRun(session, 'construis les livrables', {
+      prepare: async () => preparedDelegation(),
+      registry: registryDouble(),
+    }),
+    /in-run delegation requires a running run/,
+  );
+});
+
+test('un fragment non intégrable est refusé explicitement, sans plan à moitié posé', async () => {
+  const session = runningSession();
+
+  await assert.rejects(
+    () => delegateWithinRun(session, 'objectif', {
+      prepare: async () => ({ ...preparedDelegation(), fragment: null }),
+      registry: registryDouble(),
+    }),
+    /carries no validated fragment/,
+  );
+  assert.equal(session.headlessPlan, null);
+});
+
+test('l’approbation reste requise par défaut, et n’est levée que sur opt-in', () => {
+  const approvals = [];
+  const approvalManager = { approve: (request) => { approvals.push(request); return { ok: true }; } };
+  const session = runningSession('run-approval');
+
+  const waiting = integratePreparedDelegation({
+    session,
+    runId: 'run-approval',
+    prepared: preparedDelegation('build-waiting'),
+    registry: registryDouble(),
+    approvalManager,
+  });
+  assert.equal(waiting.approval.awaitingApproval, true);
+  assert.deepEqual(approvals, []);
+
+  const auto = integratePreparedDelegation({
+    session,
+    runId: 'run-approval',
+    prepared: preparedDelegation('build-auto'),
+    registry: registryDouble(),
+    approvalManager,
+    autoApprove: true,
+  });
+  assert.equal(auto.approval.approved, true);
+  assert.deepEqual(approvals, [{ scope: 'run', runId: 'run-approval' }]);
+});
+
+/*
+ Test d'INTÉGRATION, pas de délégation isolée.
+
+ Les tests unitaires de `delegateWithinRun` passaient tous pendant que le run
+ dupliquait son plan à chaud : 5 tâches, puis 10, 15, 20, 35. Ils vérifiaient
+ la délégation ; personne ne vérifiait ce que la boucle en faisait ensuite.
+
+ Le parcours complet est donc rejoué ici : demande française → délégation →
+ intégration → bascule → planificateur. Le seul chiffre qui compte est le
+ dernier : toujours exactement cinq tâches.
+*/
+test('une demande française délègue une fois et bascule, sans jamais dupliquer le plan', async () => {
+  const { runRuntimeAgenticWorkflow } = await import('./runner.js');
+  const runId = 'run-fr-integration';
+  const session = {
+    workspace: 'juno',
+    activities: {},
+    agentEvents: [],
+    headlessPlan: null,
+    // Posée par executeRun avant l'appel au workflow, comme en production.
+    _currentRunIdentity: { runId, workspace: 'juno' },
+    llm: { async completeWithTools() { assert.fail('aucune évaluation ne doit avoir lieu ici'); } },
+  };
+  const fiveTasks = {
+    ...fragment('build-a'),
+    summary: { label: 'Update knowledge', initialSynthesis: ['Build.'], estimatedTasks: 5 },
+    groups: [{ id: 'ingest', label: 'Ingest sources', recommendedConcurrency: 4, progressWeight: 5 }],
+    tasks: ['a', 'b', 'c', 'd', 'e'].map((suffix) => ({ ...task(`build-${suffix}`), requiresApproval: false })),
+  };
+
+  let delegations = 0;
+  let conversationalTurns = 0;
+  const agent = {
+    async invoke({ session: turnSession }) {
+      conversationalTurns += 1;
+      // Le tour conversationnel appelle l'outil de délégation, comme Donna.
+      const result = await delegateWithinRun(turnSession, 'construis les livrables du workspace juno', {
+        prepare: async () => {
+          delegations += 1;
+          return { ...preparedDelegation(), fragment: fiveTasks };
+        },
+        registry: registryDouble(),
+      });
+      assert.equal(result.runId, runId);
+      return { response: 'Action lancée.' };
+    },
+  };
+
+  const jobs = new Map();
+  const callTool = async (_mcp, _serverName, toolName, args) => {
+    const text = (payload) => ({ content: [{ type: 'text', text: JSON.stringify(payload) }] });
+    if (toolName === 'agent_execute') {
+      const jobId = `job-${args.taskId}`;
+      jobs.set(jobId, args.taskId);
+      return text({ accepted: true, jobId, status: 'queued' });
+    }
+    if (toolName === 'agent_status') {
+      return text({
+        jobId: args.jobId,
+        taskId: jobs.get(args.jobId),
+        operation: 'ingest',
+        status: 'done',
+        progress: { percent: 100 },
+        result: { status: 'succeeded', outputRefs: [], metrics: { durationMs: 1 } },
+      });
+    }
+    if (toolName === 'agent_cancel') return text({ ok: true });
+    throw new Error(`unexpected tool: ${toolName}`);
+  };
+
+  // Borne l'attente d'approbation comme en headless : un test ne doit jamais
+  // pouvoir se figer sur une décision humaine qui ne viendra pas.
+  session._approvalTimeoutMs = 200;
+  await runRuntimeAgenticWorkflow(agent, session, 'construis les livrables du workspace juno', {
+    runId,
+    timeoutMs: 2000,
+    maxTurns: 4,
+    maxReplans: 2,
+    evaluate: false,
+    callTool,
+    dispatcherPollIntervalMs: 1,
+  });
+
+  // Une seule délégation, un seul tour conversationnel : la bascule a eu lieu
+  // immédiatement après l'intégration.
+  assert.equal(delegations, 1);
+  assert.equal(conversationalTurns, 1);
+  // Et surtout : cinq tâches, pas dix, pas trente-cinq.
+  assert.equal(session.headlessPlan.length, 5);
+  // Toutes sont passées par le planificateur : plus aucune n'attend. Le double
+  // d'agent ne rejoue pas une exécution réelle — ce que ce test garantit est
+  // qu'une seule décision a eu lieu et qu'aucune tâche n'a été dupliquée.
+  assert.equal(session.headlessPlan.every((step) => isTerminal(step.status)), true);
+  assert.deepEqual([...new Set(session.headlessPlan.map((step) => step.id))].length, 5);
+});
+
+test('un run qui porte déjà un plan validé refuse une seconde délégation', async () => {
+  // Garde-fou défensif : c'est ce qui transforme une bascule ratée en erreur
+  // lisible plutôt qu'en plan qui double à chaque tour.
+  const session = runningSession('run-guard');
+  session.headlessPlan = [task('build-a')];
+
+  await assert.rejects(
+    () => delegateWithinRun(session, 'construis les livrables', {
+      prepare: async () => preparedDelegation(),
+      registry: registryDouble(),
+    }),
+    /already carries a validated plan/,
+  );
+});

package/src/runtime/recoveryManager.js

@@ -3,9 +3,9 @@ import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
 import { formatMcpToolResult, callMcpTool as defaultCallMcpTool } from '../core/mcp.js';
 import { createCapabilityRegistry } from '../orchestrator/capabilityRegistry.js';
 import { accept as acceptResult } from '../orchestrator/resultAggregator.js';
+import { isSuccessful, isTerminal } from '../orchestrator/taskStatuses.js';
 
 const ACTIVE_TASK_STATUSES = new Set(['running', 'queued', 'starting', 'assigned']);
-const TERMINAL_STATUSES = new Set(['done', 'failed', 'cancelled', 'canceled', 'completed', 'complete', 'success', 'succeeded']);
 
 export async function recoverActiveRuns({
   store,
@@ -169,9 +169,6 @@ function latestAssignment(assignments, attemptId) {
   return [...assignments].sort((a, b) => String(b.assignedAt ?? b.attemptId).localeCompare(String(a.assignedAt ?? a.attemptId)))[0] ?? null;
 }
 
-function isTerminal(status) {
-  return TERMINAL_STATUSES.has(String(status ?? '').toLowerCase());
-}
 
 function capabilityResolvable(session, capability) {
   const registry = session.capabilityRegistry
@@ -195,7 +192,7 @@ function parseToolPayload(result) {
 function taskResultFromStatus(task, assignment, jobId, statusPayload, attempt) {
   const result = statusPayload?.result ?? {};
   const status = String(result.status ?? statusPayload?.status ?? '').toLowerCase();
-  const ok = ['succeeded', 'success', 'done', 'complete', 'completed'].includes(status);
+  const ok = isSuccessful(status);
   return {
     ok,
     taskId: task.id,

package/src/runtime/recoveryManager.test.js

@@ -167,6 +167,11 @@ test('recoveryManager fails unresolvable-capability tasks and interrupts the run
   // A registry that DOES know capabilities, but not the task's one: the plan
   // came from a hallucinated capability (the 0.12.1 incident) — re-attaching
   // it would recreate a forever-waiting queue on every boot.
+  store.hydrateSession(session, { workspace: 'docs' });
+  // Le registre vivant se pose APRÈS l'hydratation : c'est l'ordre réel
+  // (hydrate → invalidate → discover). Le poser avant faisait passer un
+  // instantané frais pour une restauration, et masquait le fait que les agents
+  // persistés doivent être invalidés.
   session.agentRegistrySnapshot = [{
     agentInstanceId: 'production-main',
     serverName: 'production',
@@ -177,7 +182,6 @@ test('recoveryManager fails unresolvable-capability tasks and interrupts the run
       capabilities: [{ id: 'knowledge.pipeline', version: '1' }],
     },
   }];
-  store.hydrateSession(session, { workspace: 'docs' });
   const statusCalls = [];
 
   try {

package/src/runtime/runner.js

@@ -8,7 +8,8 @@ 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 { blockedByFailedDependency, tasksAwaitingApproval } from '../orchestrator/dependencyResolver.js';
+import { isFailed, isPending, isSkipped, isSuccessful, isTerminal, isUnknownStatus } from '../orchestrator/taskStatuses.js';
 import { assertValidatedFragment } from '../orchestrator/planValidator.js';
 import { createResultAggregator } from '../orchestrator/resultAggregator.js';
 import { describePlanConcurrency, drainActive, startReadyTasks } from '../orchestrator/scheduler.js';
@@ -298,7 +299,7 @@ async function announceRunOutcome(session, { runId, ok, signal = null } = {}) {
   let firstError = null;
   for (const step of plan) {
     const status = String(step?.status ?? '').toLowerCase();
-    if (['failed', 'error', 'stalled'].includes(status)) {
+    if (isFailed(status)) {
       failed += 1;
       firstError ??= String(
         step?.error?.message ?? step?.error?.code ?? step?.error
@@ -306,7 +307,7 @@ async function announceRunOutcome(session, { runId, ok, signal = null } = {}) {
       ).trim() || null;
     } else if (['cancelled', 'canceled'].includes(status)) {
       cancelled += 1;
-    } else if (['done', 'complete', 'completed', 'success', 'succeeded'].includes(status)) {
+    } else if (isSuccessful(status)) {
       completed += 1;
     }
   }
@@ -594,8 +595,25 @@ export async function runRuntimeParallelPlan(agent, session, input, {
           }));
           return { ok: false, stalled: true, reason: 'awaiting_approval', completed: sessionActivities(session), failures };
         }
+        /*
+         Une dépendance en échec n'est pas un blocage : c'est une réponse.
+
+         On arrivait ici avec des tâches en attente dont une dépendance avait
+         échoué, et on déclarait le plan bloqué — ce qui déclenchait une
+         replanification et laissait le run vivant indéfiniment. Ces tâches ne
+         deviendront jamais exécutables : les marquer `skipped` avec le nom de
+         la dépendance fautive fait avancer la boucle, laisse les branches
+         indépendantes finir, et termine le run sur un résultat partiel
+         explicite au lieu d'une panne muette.
+        */
+        const skippedCount = skipImpossibleTasks(session, runId);
+        if (skippedCount > 0) {
+          // La boucle reprend : d'autres tâches peuvent être devenues prêtes,
+          // notamment derrière une barrière de groupe désormais terminale.
+          continue;
+        }
         // Any genuine approval-only block returned above. Remaining tasks are
-        // unschedulable for another reason (most commonly a failed dependency).
+        // unschedulable for another reason.
         const reason = 'no_ready_plan_task';
         emitRuntimeLog(session, `scheduler: stalled (${reason})`);
         return { ok: false, stalled: true, reason, completed: sessionActivities(session), failures };
@@ -653,6 +671,56 @@ export async function runRuntimeParallelPlan(agent, session, input, {
   }
 }
 
+/*
+ Propagation d'un échec jusqu'au point fixe.
+
+ Marquer les seules tâches directement bloquées ne suffisait pas : `A failed`
+ rendait `B` impossible, mais `C` — qui dépend de `B` — restait en attente
+ d'une tâche désormais `skipped`, donc terminale sans succès. Il fallait un
+ second passage pour l'atteindre, un troisième pour la suivante, et la boucle
+ du planificateur ne les aurait découvertes qu'au prix d'un aller-retour par
+ tour. On itère donc ici jusqu'à ce que plus rien ne change.
+
+ Le garde-fou n'est pas décoratif : si une passe ne produit aucune transition
+ effective — une tâche déjà `skipped` que l'on retrouverait bloquée, par
+ exemple —, on s'arrête. Sans lui, une incohérence de statut se paierait en
+ boucle infinie, c'est-à-dire en run figé : exactement ce qu'on répare.
+*/
+export function skipImpossibleTasks(session, runId, { maxPasses = 50 } = {}) {
+  let total = 0;
+  for (let pass = 0; pass < maxPasses; pass += 1) {
+    // Le plan est relu à chaque passe, jamais capturé : `dispatchAgentEvent`
+    // reprojette la session et REMPLACE `headlessPlan` par un nouveau tableau.
+    // Une référence prise avant la première dépêche deviendrait orpheline, et
+    // les passes suivantes muteraient un plan que plus personne ne lit.
+    const plan = session.headlessPlan ?? [];
+    const blocked = blockedByFailedDependency(plan);
+    if (blocked.length === 0) break;
+    let changed = 0;
+    for (const { task, dependencies } of blocked) {
+      const skippedId = String(task.id ?? task.taskId ?? task.step ?? '');
+      const step = plan.find((candidate) => String(candidate?.id ?? candidate?.step ?? '') === skippedId);
+      // Déjà terminale : la repasser en `skipped` ne changerait rien et
+      // ferait tourner la boucle pour rien.
+      if (!step || isSkipped(step.status) || isTerminal(step.status)) continue;
+      const because = dependencies.join(', ');
+      step.status = 'skipped';
+      step.error = { code: 'dependency_failed', message: `Dependency failed: ${because}` };
+      changed += 1;
+      dispatchAgentEvent(session, createAgentEvent('plan_step_updated', {
+        origin: 'runtime',
+        runId,
+        taskId: skippedId,
+        payload: { taskId: skippedId, status: 'skipped', reason: `dependency_failed:${because}` },
+      }));
+      emitRuntimeLog(session, `scheduler: skipping ${skippedId} (dependency failed: ${because})`);
+    }
+    total += changed;
+    if (changed === 0) break;
+  }
+  return total;
+}
+
 export function materializeTaskInputs(task, plan = []) {
   const dependencies = new Set(Array.isArray(task?.dependsOn) ? task.dependsOn.map(String) : []);
   const replacements = new Map();
@@ -712,7 +780,7 @@ function abortCancelledActiveTasks(session, active) {
 }
 
 function pendingSchedulerStatus(status) {
-  return PENDING_STATUSES.has(String(status ?? ''));
+  return isPending(status);
 }
 
 // Scope the evaluator/replanner's view of "completed" activities to the
@@ -1031,31 +1099,77 @@ export async function evaluateRuntimeRun(session, input, {
   }
 }
 
-function structuredPlanEvaluation(plan) {
+export 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) {
+  /*
+   Compteurs séparés, jamais de fraction.
+
+   « 9/10 » suppose un dénominateur qui veut dire quelque chose. Le plan mêle
+   des tâches métier (un fichier ingéré) et des étapes techniques (une
+   barrière, une agrégation) : la même fraction aurait dit tantôt « 9 fichiers
+   sur 10 », tantôt « 9 étapes sur 10 », sans que le lecteur puisse savoir
+   laquelle. Trois compteurs qui s'additionnent se vérifient d'un coup d'œil et
+   ne mentent sur rien.
+
+   Et l'inverse compte autant : le message ne listait que les échecs, si bien
+   qu'un run où l'essentiel du travail avait abouti se lisait comme une panne.
+  */
+  const done = plan.filter((step) => isSuccessful(step?.status));
+  const failed = plan.filter((step) => isFailed(step?.status) || isCancelledStatus(step?.status));
+  const skipped = plan.filter((step) => isSkipped(step?.status));
+  const unfinished = plan.filter((step) => !isTerminal(step?.status));
+  const label = (step) => step.label ?? step.description ?? step.id ?? step.step;
+  /*
+   Les compteurs sont rendus tels quels, en plus de la phrase.
+
+   Une phrase est faite pour être lue, pas analysée : tout consommateur qui
+   voudrait savoir « combien ont réussi » devrait la découper, donc dépendre de
+   sa formulation — et casser à la première reformulation. Les nombres sont la
+   donnée, la phrase n'en est qu'un rendu.
+  */
+  const counts = {
+    total: plan.length,
+    done: done.length,
+    failed: failed.length,
+    skipped: skipped.length,
+    unfinished: unfinished.length,
+  };
+  const summary = [
+    `${done.length} réussie(s)`,
+    failed.length > 0 ? `${failed.length} en échec` : null,
+    skipped.length > 0 ? `${skipped.length} ignorée(s) faute de dépendance` : null,
+    unfinished.length > 0 ? `${unfinished.length} non terminée(s)` : null,
+  ].filter(Boolean).join(', ');
+
+  if (failed.length > 0 || skipped.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(', ')}.`,
+      counts,
+      reason: [
+        `${summary}.`,
+        failed.length > 0 ? `Échecs : ${failed.map(label).join(', ')}.` : null,
+        skipped.length > 0 ? `Ignorées : ${skipped.map(label).join(', ')}.` : null,
+      ].filter(Boolean).join(' '),
       suggestedAction: null,
     };
   }
-  if (incomplete.length > 0) {
+  // Un statut actif ou inconnu ne peut jamais valoir un succès : le plan n'est
+  // pas fini, on le dit, on ne le suppose pas terminé.
+  if (unfinished.length > 0) {
     return {
       ok: false,
-      reason: `${incomplete.length} tâche(s) du plan ne sont pas terminées.`,
+      counts,
+      reason: `${summary}. Le plan n'est pas terminé.`,
       suggestedAction: null,
     };
   }
   return {
-    ok: statuses.length > 0,
-    reason: `${statuses.length} tâche(s) du plan terminées avec succès.`,
+    ok: plan.length > 0,
+    counts,
+    reason: `${plan.length} tâche(s) du plan terminées avec succès.`,
     suggestedAction: null,
   };
 }