@dotdrelle/wiki-manager 0.15.38 → 0.15.41

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,
   };
 }

package/src/runtime/runner.test.js

@@ -1,7 +1,10 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
-import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
-import { ensurePlanProjection, evaluateRuntimeRun, finishRuntimeRun, materializeTaskInputs, replanRuntimeRun, runRuntimeAgenticWorkflow, runRuntimeParallelPlan, shouldUseParallelScheduler } from './runner.js';
+import { createAgentEvent, dispatchAgentEvent, reduceAgentEvents } from '../core/agentEvents.js';
+import { tasksAwaitingApproval } from '../orchestrator/dependencyResolver.js';
+import { isTerminal } from '../orchestrator/taskStatuses.js';
+import { readyPlanTasks } from '../core/planPatch.js';
+import { skipImpossibleTasks, structuredPlanEvaluation, ensurePlanProjection, evaluateRuntimeRun, finishRuntimeRun, materializeTaskInputs, replanRuntimeRun, runRuntimeAgenticWorkflow, runRuntimeParallelPlan, shouldUseParallelScheduler } from './runner.js';
 
 test('ensurePlanProjection re-projects when the chained plan changes shape (step 2)', () => {
   const session = { agentEvents: [], agentProjection: null };
@@ -821,7 +824,17 @@ test('runRuntimeParallelPlan fails cleanly when scheduler budget is exceeded', a
   assert.equal(session.headlessPlan[0].status, 'cancelled');
 });
 
-test('runRuntimeParallelPlan does not wait for approval behind a failed dependency', async () => {
+/*
+ Ce test gardait l'ancien comportement : la tâche bloquée derrière un échec
+ laissait le run « stalled ». Ne pas attendre d'approbation était déjà acquis,
+ mais s'arrêter là déclenchait une replanification et laissait le run vivant.
+
+ Cas observé le 2026-08-04 (workspace juno) : dix fichiers à ingérer, neuf
+ réussis, un en échec sur du JSON malformé — le run n'est jamais retombé.
+ Une tâche qui ne deviendra jamais exécutable est donc marquée `skipped` avec
+ le nom de la dépendance fautive, et le run se termine sur un résultat partiel.
+*/
+test('runRuntimeParallelPlan skips work stuck behind a failed dependency instead of stalling', async () => {
   const session = {
     workspace: 'demo-workspace',
     mcp: { tools: {} },
@@ -844,11 +857,17 @@ test('runRuntimeParallelPlan does not wait for approval behind a failed dependen
     { runId: 'run-failed-dependency', timeoutMs: 1000, maxTurns: 1 },
   );
 
-  assert.equal(result.ok, false);
-  assert.equal(result.stalled, true);
-  assert.equal(result.reason, 'no_ready_plan_task');
+  // Plus de blocage : le run retombe au lieu de rester actif indéfiniment.
+  assert.notEqual(result.stalled, true);
+  assert.equal(session.headlessPlan[1].status, 'skipped');
+  assert.equal(session.headlessPlan[1].error?.code, 'dependency_failed');
+  // Le motif nomme la dépendance fautive : sans lui, l'utilisateur voit une
+  // tâche disparaître sans savoir pourquoi.
+  assert.match(session.headlessPlan[1].error.message, /\ba\b/);
   assert.equal(session.agentEvents.some((event) => event.type === 'assistant_message'
     && /Approbation requise/.test(event.payload?.content ?? '')), false);
+  assert.equal(session.agentEvents.some((event) => event.type === 'plan_step_updated'
+    && event.payload?.status === 'skipped'), true);
 });
 
 test('runRuntimeParallelPlan retries a retryable task on a fallback agent', async () => {
@@ -1083,3 +1102,131 @@ test('runtime runs are seeded with the chat that preceded them', async () => {
   assert.equal(clipped.length, 1);
   assert.equal(clipped[0].content.length, 2000);
 });
+
+test('skipImpossibleTasks propage un échec jusqu’au point fixe', () => {
+  /*
+   Marquer les seules tâches directement bloquées laissait un résidu : A en
+   échec rend B impossible, mais C dépend de B et serait resté en attente
+   d'une tâche désormais terminale sans succès. La propagation doit descendre
+   toute la chaîne en une fois.
+  */
+  const session = { workspace: 'demo-workspace', agentEvents: [] };
+  const steps = [
+    { id: 'a', step: 1, status: 'failed' },
+    { id: 'b', step: 2, status: 'pending', dependsOn: ['a'] },
+    { id: 'c', step: 3, status: 'pending', dependsOn: ['b'] },
+    { id: 'independent', step: 4, status: 'pending', dependsOn: [] },
+  ];
+  // Le plan passe par la projection, comme en production : chaque dépêche
+  // remplace session.headlessPlan, et c'est précisément ce qui rendait une
+  // référence capturée orpheline.
+  dispatchAgentEvent(session, createAgentEvent('plan_set', { origin: 'tool', payload: { steps } }));
+
+  const skipped = skipImpossibleTasks(session, 'run-fixpoint');
+
+  assert.equal(skipped, 2);
+  assert.equal(session.headlessPlan[1].status, 'skipped');
+  assert.equal(session.headlessPlan[2].status, 'skipped');
+  // La branche indépendante n'est pas touchée : c'est tout l'objet du
+  // correctif, laisser finir ce qui peut finir.
+  assert.equal(session.headlessPlan[3].status, 'pending');
+  assert.equal(session.agentEvents.filter((event) => event.payload?.status === 'skipped').length, 2);
+});
+
+test('skipImpossibleTasks s’arrête au lieu de tourner sans rien changer', () => {
+  // Sans garde-fou, une incohérence de statut se paierait en boucle infinie,
+  // c'est-à-dire en run figé — exactement ce que l'on répare.
+  const session = { workspace: 'demo-workspace', agentEvents: [] };
+  dispatchAgentEvent(session, createAgentEvent('plan_set', {
+    origin: 'tool',
+    payload: {
+      steps: [
+        { id: 'a', step: 1, status: 'failed' },
+        { id: 'b', step: 2, status: 'skipped', dependsOn: ['a'] },
+      ],
+    },
+  }));
+  const eventsBefore = session.agentEvents.length;
+
+  assert.equal(skipImpossibleTasks(session, 'run-guard', { maxPasses: 3 }), 0);
+  assert.equal(session.agentEvents.length, eventsBefore);
+});
+
+test('structuredPlanEvaluation compte séparément, sans fraction trompeuse', () => {
+  const task = (id, status) => ({
+    id, status, label: `Task ${id}`, requiredCapability: 'knowledge.update', operation: 'ingest',
+  });
+
+  const allDone = structuredPlanEvaluation([task('a', 'done'), task('b', 'succeeded')]);
+  assert.equal(allDone.ok, true);
+
+  const partial = structuredPlanEvaluation([
+    task('a', 'done'), task('b', 'failed'), task('c', 'skipped'),
+  ]);
+  assert.equal(partial.ok, false);
+  // Trois compteurs qui s'additionnent, pas un « 1/3 » dont le dénominateur
+  // mêlerait tâches métier et étapes techniques.
+  assert.match(partial.reason, /1 réussie\(s\)/);
+  assert.match(partial.reason, /1 en échec/);
+  assert.match(partial.reason, /1 ignorée\(s\)/);
+  assert.doesNotMatch(partial.reason, /\d+\/\d+/);
+
+  // Uniquement des ignorées : jamais un succès.
+  const onlySkipped = structuredPlanEvaluation([task('a', 'skipped')]);
+  assert.equal(onlySkipped.ok, false);
+
+  // Succès + ignorée sans échec : toujours pas un succès.
+  const doneAndSkipped = structuredPlanEvaluation([task('a', 'done'), task('b', 'skipped')]);
+  assert.equal(doneAndSkipped.ok, false);
+
+  // Statut actif ou inconnu : incomplet, jamais réussi.
+  for (const status of ['running', 'brouette']) {
+    const pending = structuredPlanEvaluation([task('a', 'done'), task('b', status)]);
+    assert.equal(pending.ok, false, status);
+    assert.match(pending.reason, /non terminée/);
+  }
+});
+
+test('une tâche ignorée est terminale pour la reprise et pour les approbations', () => {
+  /*
+   Vérifications transversales sur le nouveau statut : il ne suffit pas que
+   l'ordonnanceur le comprenne. S'il n'est pas terminal pour la reprise, le
+   redémarrage réattache un run fantôme ; s'il n'est pas terminal pour la
+   politique d'approbation, on demande un accord pour une tâche qui ne sera
+   jamais exécutée.
+  */
+  const skippedTask = {
+    id: 'ingest-b',
+    status: 'skipped',
+    requiresApproval: true,
+    requiredCapability: 'knowledge.update',
+    operation: 'ingest_apply',
+  };
+
+  assert.equal(isTerminal(skippedTask.status), true);
+  assert.deepEqual(tasksAwaitingApproval([skippedTask], { approvals: [] }), []);
+  assert.deepEqual(readyPlanTasks([skippedTask]).map((task) => task.id), []);
+});
+
+test('rejouer les événements redonne exactement les mêmes statuts', () => {
+  // La projection est reconstruite au démarrage à partir du journal : si le
+  // rejeu ne rendait pas le même état, une tâche ignorée pourrait réapparaître
+  // en attente et relancer un travail déjà abandonné.
+  const events = [
+    createAgentEvent('plan_set', { origin: 'tool', payload: { steps: ['A', 'B'] } }),
+    createAgentEvent('plan_step_updated', { origin: 'runtime', payload: { step: 1, status: 'failed' } }),
+    createAgentEvent('plan_step_updated', {
+      origin: 'runtime',
+      payload: { step: 2, status: 'skipped', reason: 'dependency_failed:A' },
+    }),
+  ];
+
+  const first = reduceAgentEvents(events);
+  const replayed = reduceAgentEvents(events);
+
+  assert.deepEqual(
+    replayed.plan.map((step) => step.status),
+    first.plan.map((step) => step.status),
+  );
+  assert.deepEqual(replayed.plan.map((step) => step.status), ['failed', 'skipped']);
+});

package/src/runtime/server.js

@@ -283,6 +283,27 @@ export function startRuntimeServer({
           }
           validateContractInDev('runRequest', { ...body, input });
           if (context.running) {
+            // A structured capability plan must never degrade into a free-text
+            // control message: its exact arguments and approval policy would
+            // otherwise be discarded by the control lane. It can still be
+            // queued as a future run when the caller explicitly opts in via
+            // intent: 'enqueue' — the control queue carries capabilityPlan
+            // through untouched (see enqueueControlRequest/
+            // startNextControlRequest) instead of collapsing it to text.
+            if (body.capabilityPlan) {
+              if (body.intent === 'enqueue') {
+                const item = enqueueControlRequest(context, input, { capabilityPlan: body.capabilityPlan });
+                void startNextControlRequest(context);
+                sendJson(response, 202, {
+                  accepted: true,
+                  item,
+                  ...controlStatus(context, store),
+                });
+                return;
+              }
+              sendJson(response, 409, { error: 'run_active' });
+              return;
+            }
             // Blind enqueueing made every message typed during a run
             // invisible until the run ended (serve UI symptom: "no result
             // until the job finished or was stopped"). Classify instead:
@@ -630,6 +651,7 @@ export function startRuntimeServer({
     startRuntimeRun(context, {
       input: item.input,
       workspace: item.workspace ?? context.workspace ?? null,
+      ...(item.capabilityPlan !== undefined ? { capabilityPlan: item.capabilityPlan } : {}),
     }, { controlItemId: item.id });
     return true;
   }
@@ -843,7 +865,7 @@ async function handleControlMessage(context, store, input, { intent = null, star
     : controlMessage(context?.session, 'converse_while_idle'));
 }
 
-function enqueueControlRequest(context, input) {
+function enqueueControlRequest(context, input, { capabilityPlan } = {}) {
   const now = new Date().toISOString();
   const item = {
     id: `control-${randomUUID()}`,
@@ -853,6 +875,7 @@ function enqueueControlRequest(context, input) {
     status: 'queued',
     createdAt: now,
     updatedAt: now,
+    ...(capabilityPlan !== undefined ? { capabilityPlan } : {}),
   };
   dispatchAgentEvent(context.session, createAgentEvent('control_enqueued', {
     origin: 'runtime',

package/src/runtime/server.test.js

@@ -347,6 +347,119 @@ test('runtime server accepts only one active run', async (t) => {
   }
 });
 
+test('runtime server rejects a structured capability plan while a run is active', async (t) => {
+  let releaseRun;
+  let handle;
+  try {
+    handle = await startRuntimeServer({
+      host: '127.0.0.1',
+      port: 0,
+      store: {
+        dbPath: ':memory:',
+        getState: () => ({ status: 'idle' }),
+        listEvents: () => [],
+      },
+      session: {},
+      run: async () => new Promise((resolve) => { releaseRun = resolve; }),
+    });
+  } catch (err) {
+    if (err?.code === 'EPERM') {
+      t.skip('network listen is not permitted in this sandbox');
+      return;
+    }
+    throw err;
+  }
+
+  try {
+    const url = `http://127.0.0.1:${handle.port}/run`;
+    const first = await fetch(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ input: 'active build' }),
+    });
+    assert.equal(first.status, 202);
+
+    const restore = await fetch(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        input: 'restore',
+        capabilityPlan: {
+          capability: 'workspace.restore',
+          operation: 'restore',
+          arguments: { run: 'abc123' },
+          requireApproval: true,
+        },
+      }),
+    });
+    assert.equal(restore.status, 409);
+    assert.deepEqual(await restore.json(), { error: 'run_active' });
+  } finally {
+    releaseRun?.();
+    await handle.close();
+  }
+});
+
+test('runtime server queues a structured capability plan when intent is enqueue', async (t) => {
+  let releaseRun;
+  let handle;
+  try {
+    handle = await startRuntimeServer({
+      host: '127.0.0.1',
+      port: 0,
+      store: {
+        dbPath: ':memory:',
+        getState: () => ({ status: 'idle' }),
+        listEvents: () => [],
+      },
+      session: {},
+      run: async () => new Promise((resolve) => { releaseRun = resolve; }),
+    });
+  } catch (err) {
+    if (err?.code === 'EPERM') {
+      t.skip('network listen is not permitted in this sandbox');
+      return;
+    }
+    throw err;
+  }
+
+  try {
+    const url = `http://127.0.0.1:${handle.port}/run`;
+    const first = await fetch(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ input: 'active build' }),
+    });
+    assert.equal(first.status, 202);
+
+    const capabilityPlan = {
+      capability: 'workspace.restore',
+      operation: 'restore',
+      arguments: { run: 'abc123' },
+      requireApproval: true,
+    };
+    const restore = await fetch(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ input: 'restore', intent: 'enqueue', capabilityPlan }),
+    });
+    assert.equal(restore.status, 202);
+    const restoreBody = await restore.json();
+    assert.equal(restoreBody.accepted, true);
+    assert.deepEqual(restoreBody.item.capabilityPlan, capabilityPlan);
+    assert.equal(restoreBody.item.status, 'queued');
+
+    const status = await fetch(`http://127.0.0.1:${handle.port}/control`);
+    const statusBody = await status.json();
+    const queued = statusBody.controlQueue.find((item) => item.id === restoreBody.item.id);
+    assert.ok(queued, 'queued item should be visible in control status');
+    assert.deepEqual(queued.capabilityPlan, capabilityPlan);
+  } finally {
+    releaseRun?.();
+    await handle.close();
+  }
+});
+
 test('runtime server returns the accepted run id and passes it to the runner', async (t) => {
   let receivedBody = null;
   let handle;

package/src/runtime/store.js

@@ -1,3 +1,12 @@
+/**
+ * @statuses-vocabulary
+ *
+ * RUN lifecycle statuses, not task statuses: a run can be `interrupted`,
+ * a task never is.
+ *
+ * Declared here rather than in a central exception list so the waiver
+ * travels with the code it excuses (see orchestrator/taskStatuses.test.js).
+ */
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { DatabaseSync } from 'node:sqlite';
@@ -6,6 +15,8 @@ import { defaultRuntimeStateDir } from '../core/env.js';
 import { projectQueue } from '../core/jobQueue.js';
 import { projectWorkflow } from '../core/workflow.js';
 import { createCapabilityRegistry } from '../orchestrator/capabilityRegistry.js';
+import { isSuccessful } from '../orchestrator/taskStatuses.js';
+import { markPersistedAgentsStale } from '../orchestrator/agentRegistry.js';
 
 export { defaultRuntimeStateDir };
 
@@ -1121,7 +1132,7 @@ export function openRuntimeStore({ stateDir = defaultRuntimeStateDir(), fileName
 
   function attemptStatusForResult(status, eventType) {
     const normalized = String(status ?? '').toLowerCase();
-    if (['succeeded', 'success', 'done', 'complete', 'completed'].includes(normalized)) return 'done';
+    if (isSuccessful(normalized)) return 'done';
     if (['cancelled', 'canceled'].includes(normalized)) return 'cancelled';
     if (eventType === 'task.failed') return 'failed';
     return normalized || 'finished';
@@ -1265,6 +1276,10 @@ export function openRuntimeStore({ stateDir = defaultRuntimeStateDir(), fileName
   function hydrateSession(session, { workspace = null } = {}) {
     const projection = replayEvents(session, { workspace });
     applyAgentProjectionToSession(session, projection);
+    // Le journal restitue les agents avec la santé qu'ils avaient à l'écriture
+    // de l'événement. Les reprendre tels quels les faisait réapparaître
+    // « disponibles » après un redémarrage, endpoint éteint compris.
+    markPersistedAgentsStale(session);
     session.jobQueue = listQueue({ workspace });
     return projection;
   }

package/src/runtime/store.test.js

@@ -6,6 +6,7 @@ import { DatabaseSync } from 'node:sqlite';
 import test from 'node:test';
 import { conversationEventSequences, createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
 import { openRuntimeStore } from './store.js';
+import { capabilityRegistryForSession } from '../orchestrator/capabilityRegistry.js';
 
 function runtimeStateDir() {
   return join(mkdtempSync(join(tmpdir(), 'wiki-manager-runtime-')), '.wiki', 'runtime');
@@ -1106,3 +1107,52 @@ test('deleteEventsAfter removes bookkeeping only for runs entirely produced by t
   assert.equal(store.db.prepare('SELECT COUNT(*) AS n FROM task_attempts').get().n, 1);
   store.close();
 });
+
+test('un agent restauré par hydrateSession n’est plus routable tant qu’aucun scan n’a réussi', () => {
+  /*
+   Validation à chaud du 2026-08-04 : après redémarrage, `cme-main` restait
+   `available` et `external-source.export` gardait un fournisseur, alors que
+   l'endpoint CME était arrêté. Le test précédent construisait `session.agents`
+   à la main et ratait donc le vrai chemin — celui où l'état vient du journal.
+
+   On hydrate ici depuis de véritables événements persistés, comme au
+   démarrage : hydrate → invalidate → discover, sans scan entre les deux
+   premiers.
+  */
+  const store = openRuntimeStore({ stateDir: mkdtempSync(join(tmpdir(), 'wiki-manager-agent-staleness-')) });
+  const writer = { agentEvents: [], workspace: 'juno' };
+  dispatchAgentEvent(writer, createAgentEvent('agent.registered', {
+    origin: 'runtime',
+    workspace: 'juno',
+    payload: {
+      agent: {
+        agentInstanceId: 'cme-main',
+        serverName: 'cme',
+        health: 'available',
+        description: {
+          agentType: 'cme',
+          contractVersion: '1',
+          agentInstanceId: 'cme-main',
+          capabilities: [{ id: 'external-source.export', version: '1' }],
+        },
+      },
+    },
+  }));
+  for (const event of writer.agentEvents) store.persistEvent(event);
+
+  // Redémarrage : une session neuve, aucun scan encore effectué.
+  const rebooted = { agentEvents: [], workspace: 'juno' };
+  store.hydrateSession(rebooted, { workspace: 'juno' });
+
+  const restored = [...(rebooted.agents ?? []), ...(rebooted.agentRegistrySnapshot ?? [])];
+  assert.ok(restored.length > 0, 'the agent must be restored, only not trusted');
+  for (const agent of restored) {
+    assert.equal(agent.health, 'unknown');
+    assert.equal(agent.stale, true);
+  }
+  // Le seul point qui compte vraiment : plus aucun fournisseur sélectionnable.
+  assert.deepEqual(
+    capabilityRegistryForSession(rebooted).providersFor('external-source.export'),
+    [],
+  );
+});