@dotdrelle/wiki-manager 0.15.40 → 0.15.42

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotdrelle/wiki-manager",
-  "version": "0.15.40",
+  "version": "0.15.42",
   "description": "Agentic shell and orchestration cockpit for llm-wiki workspaces.",
   "license": "PolyForm-Noncommercial-1.0.0",
   "author": "dotrelle",
@@ -11,7 +11,7 @@
   },
   "scripts": {
     "start": "bun ./bin/wiki-manager.js",
-    "test": "node --test src/cli/runtimeStartup.test.js src/cli/wiki-manager.test.js src/agent/graph.test.js src/contracts/schemas.test.js src/core/activity.test.js src/core/env.test.js src/core/agentsCompose.test.js src/core/profileServiceStatus.test.js src/core/buildInfo.test.js src/core/agentEvents.test.js src/core/runtimeLog.test.js src/activity/activityAggregator.test.js src/graph/runGraphProjector.test.js src/core/workflow.test.js src/core/planPatch.test.js src/core/agentLoop.test.js src/core/plan.test.js src/core/mcp.test.js src/core/toolLoop.test.js src/core/documentIntake.test.js src/core/dockerCompose.test.js src/core/wikiSetup.test.js src/core/wikiWorkspace.test.js src/core/wikirc.test.js src/core/cacert.test.js src/core/composeOverrides.test.js src/core/setEnvValue.test.js src/core/commandFailure.test.js src/core/googleGrants.test.js src/core/modelFetch.test.js src/core/startupCheck.test.js src/core/queueStore.test.js src/orchestrator/agentRegistry.test.js src/orchestrator/capabilityRegistry.test.js src/orchestrator/capabilityResolver.test.js src/orchestrator/planValidator.test.js src/orchestrator/planIntegrator.test.js src/orchestrator/scheduler.test.js src/orchestrator/attemptManager.test.js src/orchestrator/resultAggregator.test.js src/orchestrator/approvalPolicy.test.js src/orchestrator/dispatcher.test.js src/orchestrator/objectiveResolver.test.js src/commands/slash.test.js src/shell/repl.test.js src/shell/setupWizardPlaceholders.test.js src/shell/setupWizardSuggestions.test.js src/shell/setupWizardDiscovery.test.js src/shell/wrapText.test.js src/runtime/lifecycle.test.js src/runtime/store.test.js src/runtime/controlMessages.test.js src/runtime/recoveryManager.test.js src/runtime/server.test.js src/runtime/supervisor.test.js src/runtime/runner.test.js src/runtime/runner.e2e.test.js src/runtime/donna-contract.test.js src/runtime/auth.test.js",
+    "test": "node --test src/cli/runtimeStartup.test.js src/cli/wiki-manager.test.js src/agent/graph.test.js src/contracts/schemas.test.js src/core/activity.test.js src/core/env.test.js src/core/agentsCompose.test.js src/core/profileServiceStatus.test.js src/core/buildInfo.test.js src/core/agentEvents.test.js src/core/runtimeLog.test.js src/activity/activityAggregator.test.js src/graph/runGraphProjector.test.js src/core/workflow.test.js src/core/planPatch.test.js src/core/agentLoop.test.js src/core/plan.test.js src/core/mcp.test.js src/core/toolLoop.test.js src/core/documentIntake.test.js src/core/dockerCompose.test.js src/core/otherWorkspacesRunning.test.js src/core/wikiSetup.test.js src/core/wikiWorkspace.test.js src/core/wikirc.test.js src/core/workspaceInherit.test.js src/core/cacert.test.js src/core/composeOverrides.test.js src/core/setEnvValue.test.js src/core/commandFailure.test.js src/core/googleGrants.test.js src/core/modelFetch.test.js src/core/startupCheck.test.js src/core/queueStore.test.js src/orchestrator/agentRegistry.test.js src/orchestrator/capabilityRegistry.test.js src/orchestrator/capabilityResolver.test.js src/orchestrator/planValidator.test.js src/orchestrator/planIntegrator.test.js src/orchestrator/taskStatuses.test.js src/orchestrator/scheduler.test.js src/orchestrator/attemptManager.test.js src/orchestrator/resultAggregator.test.js src/orchestrator/approvalPolicy.test.js src/orchestrator/dispatcher.test.js src/orchestrator/objectiveResolver.test.js src/commands/slash.test.js src/shell/repl.test.js src/shell/setupWizardModality.test.js src/shell/setupWizardPlaceholders.test.js src/shell/setupWizardSuggestions.test.js src/shell/setupWizardDiscovery.test.js src/shell/wrapText.test.js src/runtime/lifecycle.test.js src/runtime/store.test.js src/runtime/controlMessages.test.js src/runtime/recoveryManager.test.js src/runtime/server.test.js src/runtime/supervisor.test.js src/runtime/delegation.test.js src/runtime/runner.test.js src/runtime/runner.e2e.test.js src/runtime/donna-contract.test.js src/runtime/auth.test.js",
     "check-versions": "node scripts/check-versions.js",
     "prepack": "node scripts/check-versions.js",
     "prepublishOnly": "node scripts/check-versions.js",

package/src/activity/activityAggregator.js

@@ -1,8 +1,8 @@
 import { calculateWeightedProgress } from './progressCalculator.js';
 import { deduplicateActivities } from './activityDeduplicator.js';
 import { initialSynthesisFromState } from './runSynthesis.js';
+import { isSuccessful } from '../orchestrator/taskStatuses.js';
 
-const DONE = new Set(['done', 'complete', 'completed', 'success', 'succeeded']);
 const ACTIVE = new Set(['running', 'starting', 'queued']);
 
 export function aggregateActivity(state = {}, events = []) {
@@ -67,7 +67,7 @@ function groupLabel(task) {
 
 function groupLine(group, activities) {
   const total = group.tasks.length;
-  const done = group.tasks.filter((task) => DONE.has(statusOf(task))).length;
+  const done = group.tasks.filter((task) => isSuccessful(statusOf(task))).length;
   const running = group.tasks.filter((task) => ACTIVE.has(statusOf(task)));
   const failed = group.tasks.find((task) => statusOf(task) === 'failed');
   const waitingApproval = group.tasks.some((task) => ['pending_approval', 'waiting_approval'].includes(statusOf(task)));
@@ -76,7 +76,7 @@ function groupLine(group, activities) {
   // the whole group as "validation 0%" while a worker visibly runs at 35%.
   const activePair = group.tasks
     .map((task) => ({ task, activity: activityForTask(task, activities) }))
-    .find(({ activity }) => activity && !activity.terminal && !DONE.has(statusOf(activity)));
+    .find(({ activity }) => activity && !activity.terminal && !isSuccessful(statusOf(activity)));
   const activeTask = activePair?.task ?? running[0] ?? null;
   const activeActivity = activePair?.activity
     ?? running.map((task) => activityForTask(task, activities)).find(Boolean);

package/src/activity/progressCalculator.js

@@ -1,5 +1,4 @@
-const TERMINAL_DONE = new Set(['done', 'complete', 'completed', 'success', 'succeeded']);
-const TERMINAL_ANY = new Set([...TERMINAL_DONE, 'failed', 'cancelled', 'canceled', 'error']);
+import { isSuccessful, isTerminal } from '../orchestrator/taskStatuses.js';
 
 export function calculateWeightedProgress(tasks = [], activities = []) {
   const items = Array.isArray(tasks) ? tasks : [];
@@ -10,10 +9,10 @@ export function calculateWeightedProgress(tasks = [], activities = []) {
   for (const task of items) {
     const weight = taskWeight(task);
     const status = normalizeStatus(task.status);
-    if (TERMINAL_DONE.has(status)) {
+    if (isSuccessful(status)) {
       completedWeight += weight;
       done += 1;
-    } else if (!TERMINAL_ANY.has(status)) {
+    } else if (!isTerminal(status)) {
       completedWeight += weight * taskProgressRatio(task, activities);
     }
   }

package/src/agent/graph.js

@@ -1,3 +1,13 @@
+/**
+ * @statuses-vocabulary
+ *
+ * JSON schema enumeration exposed to models. A schema declares what it
+ * accepts, including values the orchestrator no longer produces.
+ *
+ * Declared here rather than in a central exception list so the waiver
+ * travels with the code it excuses (see orchestrator/taskStatuses.test.js).
+ */
+import { isTerminal } from '../orchestrator/taskStatuses.js';
 import { join } from 'node:path';
 import { Annotation, END, START, StateGraph } from '@langchain/langgraph';
 import {
@@ -640,7 +650,7 @@ function rememberProductionProgress(session, payload, label) {
     jobId: jobId ?? session.productionActivity?.jobId ?? null,
     status,
     label: label ?? `Production: ${status}`,
-    terminal: ['done', 'failed', 'cancelled'].includes(String(status)),
+    terminal: isTerminal(status),
     updatedAt: new Date().toISOString(),
   };
 }
@@ -804,6 +814,35 @@ async function handleRuntimeControlTool(session, tool, args = {}) {
       if (connectorConfig) {
         return `Delegation rejected: ${connectorConfig.serverName} advertises no setup or authentication tool. Do not call an unrelated data tool and do not delegate to export. Explain conversationally that authentication must be completed outside MCP, using only configuration instructions already available in the current context.`;
       }
+      /*
+       Un run ne passe pas par le réseau pour se déléguer à lui-même.
+
+       Donna délègue DEPUIS l'intérieur du run conversationnel qui vient d'être
+       marqué actif. Passer par POST /delegate revenait à demander au runtime
+       l'autorisation de démarrer un run alors qu'un run tourne déjà — le sien —
+       et l'endpoint répondait 409, à juste titre de son point de vue. 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. Quand ce chemin interne existe (agent
+       exécuté dans le processus du runtime), on l'emprunte : même `runId`,
+       aucun run concurrent, aucun 409. Le chemin HTTP reste pour les appelants
+       réellement extérieurs — le Shell, un client tiers —, et c'est là que le
+       409 garde tout son sens.
+      */
+      if (typeof session?._delegateWithinRun === 'function') {
+        try {
+          const inRun = await session._delegateWithinRun(objective);
+          return JSON.stringify({
+            delegated: true,
+            runId: inRun.runId,
+            summary: inRun.summary ?? null,
+            message: `Action lancée (${String(inRun.runId).slice(0, 8)}) après validation du plan réel : ${inRun.summary?.tasks ?? 0} tâche(s), ${inRun.summary?.agent ?? 'agent résolu'}. Exécution en cours.`,
+          });
+        } catch (err) {
+          return `Délégation refusée : ${err instanceof Error ? err.message : String(err)}`;
+        }
+      }
       const result = await postRuntimeDelegate(objective, { url, workspace });
       return result?.runId
         ? JSON.stringify({

package/src/cli/wiki-manager.js

@@ -1,3 +1,12 @@
+/**
+ * @statuses-vocabulary
+ *
+ * JOB statuses as reported by headless polling, mapped to a process exit
+ * code — a different contract from the orchestrator's task vocabulary.
+ *
+ * Declared here rather than in a central exception list so the waiver
+ * travels with the code it excuses (see orchestrator/taskStatuses.test.js).
+ */
 import { randomUUID } from 'node:crypto';
 import { spawnSync } from 'node:child_process';
 import { readFileSync } from 'node:fs';
@@ -297,11 +306,28 @@ export function createInteractiveSession(context, { runtimeUrl, turnId, signal =
   return session;
 }
 
+/*
+ Un tour interactif se termine TOUJOURS par un assistant_message.
+
+ C'est la condition de fin que les deux interfaces attendent : côté `serve`, la
+ bulle « Request received · Donna is preparing… » n'est retirée que lorsqu'un
+ message assistant non vide arrive. La garde `!content` renvoyait donc `false`
+ en silence quand le tour ne produisait rien — modèle qui répond vide, boucle
+ d'outils qui s'arrête sans conclure — et le point d'attente tournait
+ indéfiniment, sans erreur nulle part.
+
+ Une réponse vide est un résultat, pas une raison de ne rien dire.
+*/
 export function ensureInteractiveAssistantMessage(session, response, { turnId, workspace } = {}) {
+  if (session.agentEvents.some((event) => event.type === 'assistant_message')) return false;
   const content = String(response ?? '').trim();
-  if (!content || session.agentEvents.some((event) => event.type === 'assistant_message')) return false;
   dispatchAgentEvent(session, createAgentEvent('assistant_message', {
-    origin: 'runtime_turn', turnId, workspace, payload: { content: String(response) },
+    origin: 'runtime_turn',
+    turnId,
+    workspace,
+    payload: {
+      content: content || 'No answer was produced for this turn. The model returned nothing — try rephrasing, or switch to /agent if the request needs an action.',
+    },
   }));
   return true;
 }
@@ -317,17 +343,7 @@ export async function forwardRuntimeApproval(getWorkspaceContext, request = {})
   return context.approvalManager?.approve(request) ?? { approved: false };
 }
 
-export function resolvePreparedDelegationApproval({
-  autoApprove = false,
-  approvalManager = null,
-  runId,
-} = {}) {
-  if (autoApprove !== true || typeof approvalManager?.approve !== 'function') {
-    return { approved: false, awaitingApproval: true };
-  }
-  const result = approvalManager.approve({ scope: 'run', runId });
-  return { approved: true, awaitingApproval: false, result };
-}
+export { resolvePreparedDelegationApproval } from '../runtime/delegation.js';
 
 function timestampForFile() {
   return new Date().toISOString().replace(/[:.]/g, '-');
@@ -1168,39 +1184,33 @@ async function runRuntime(argv, agent) {
         : undefined;
       supervisor?.setRunSignal(signal);
       session._onStep = (message) => emitRuntimeLog(session, message);
-      if (body.preparedDelegation?.fragment) {
-        const { integrate } = await import('../orchestrator/planIntegrator.js');
-        const prepared = body.preparedDelegation;
-        const integrated = integrate(runId, prepared.fragment, {
+      session._delegateWithinRun = async (objective) => {
+        const { delegateWithinRun } = await import('../runtime/delegation.js');
+        return delegateWithinRun(session, objective, {
+          prepare: ({ objective: goal }) => prepareDelegation(context, { objective: goal }),
           registry: capabilityRegistryForSession(session),
-          session,
           store,
-          workspace: session.workspace ?? null,
-          enforceApprovalCoverage: true,
+          approvalManager: context.approvalManager,
+          autoApprove: body.autoApprove === true,
         });
-        if (!integrated.ok) {
-          throw new Error(`Delegated plan integration failed: ${(integrated.errors ?? []).map((error) => error.message ?? error.code ?? String(error)).join('; ')}`);
-        }
-        emitRuntimeLog(session, `delegation: ${prepared.fragment.tasks.length} validated task(s) integrated from ${prepared.provider.serverName}.agent_plan (${prepared.capability}/${prepared.operation})`);
+      };
+      if (body.preparedDelegation?.fragment) {
+        const { integratePreparedDelegation } = await import('../runtime/delegation.js');
+        const prepared = body.preparedDelegation;
         // Real approval gate (opt-out): a directly-delegated run only skips the
         // human approval step when the caller explicitly opts in via
         // `autoApprove` (e.g. headless/CI, or a future "trust this run" toggle).
-        // By default the run WAITS: integrate() above created the per-task
-        // approval requests, and the scheduler's approvalCovered() filter blocks
-        // the mutating tasks until a run-scope grant arrives (/approve or
-        // "valide tout"). This keeps a visible pending_approval window instead of
-        // resolving it programmatically ~30ms after launch, which no polled UI
-        // could ever render.
-        const approval = resolvePreparedDelegationApproval({
-          autoApprove: body.autoApprove,
-          approvalManager: context.approvalManager,
+        // By default the run WAITS, so the pending_approval window stays
+        // visible instead of being resolved ~30ms after launch.
+        integratePreparedDelegation({
+          session,
+          store,
           runId,
+          prepared,
+          registry: capabilityRegistryForSession(session),
+          approvalManager: context.approvalManager,
+          autoApprove: body.autoApprove === true,
         });
-        if (approval.approved) {
-          emitRuntimeLog(session, `approval: run ${runId} auto-approved (autoApprove opt-in)`);
-        } else {
-          emitRuntimeLog(session, `approval: run ${runId} awaiting explicit approval before mutations (/approve or « valide tout »)`);
-        }
         body._planReady?.resolve?.({ runId, planRevision: session.agentProjection?.planRevision ?? 0 });
       }
       // Deterministic capability run (/ingest): ask the capable agent for its
@@ -1372,6 +1382,22 @@ async function runRuntime(argv, agent) {
       response = await runHeadlessChatTurn(ephemeral, input, {
         history,
         onStep: ephemeral._onStep,
+        // Fragments de réponse publiés au fil de l'eau. Le réducteur les
+        // agrège dans la dernière entrée de conversation (`assistant_delta`),
+        // que `assistant_message` vient ensuite figer : les deux interfaces
+        // voient la réponse s'écrire, au lieu d'attendre le tour complet.
+        onTextDelta: (delta) => dispatchAgentEvent(ephemeral, createAgentEvent('assistant_delta', {
+          origin: 'runtime_turn',
+          turnId,
+          workspace: context.workspace ?? null,
+          payload: { delta },
+        })),
+        onTextReset: () => dispatchAgentEvent(ephemeral, createAgentEvent('assistant_delta_reset', {
+          origin: 'runtime_turn',
+          turnId,
+          workspace: context.workspace ?? null,
+          payload: {},
+        })),
         // UI context from `wiki serve`: up to five selected wiki or raw
         // documents. Only paths are prompted; Donna reads through tools.
         openWikiPages: body.context?.openWikiPages ?? body.context?.openWikiPage,

package/src/commands/slash.js

@@ -1,8 +1,18 @@
+/**
+ * @statuses-vocabulary
+ *
+ * CONTROL QUEUE item statuses, which include `expired`. A control request
+ * is not a task and does not share its lifecycle.
+ *
+ * Declared here rather than in a central exception list so the waiver
+ * travels with the code it excuses (see orchestrator/taskStatuses.test.js).
+ */
+import { isTerminal } from '../orchestrator/taskStatuses.js';
 import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
 import { openExternalUrl } from '../shell/openExternal.js';
 import { classifyCommandFailure, failureHint, rawFailureText } from '../core/commandFailure.js';
 import { join, relative } from 'node:path';
-import { composeServices, listServices, runWikiCli, serviceLogs, serviceNames, serviceStates, startService, stopService } from '../core/compose.js';
+import { composeServices, listServices, otherWorkspacesRunning, runWikiCli, serviceLogs, serviceNames, serviceStates, startService, stopService } from '../core/compose.js';
 import { agentServiceNames, profileServiceStatus } from '../core/agentsCompose.js';
 import { GOOGLE_GRANTS, GOOGLE_GRANT_LABELS, defaultGoogleGrants } from '../core/googleGrants.js';
 import {
@@ -558,12 +568,23 @@ async function createWorkspaceCommand(context, workspaceName, targetPath) {
   try {
     context.onStep?.(`Workspace: creating ${workspaceName}…`);
     const output = await createWorkspace(workspaceName, targetPath, { timeout: 600_000 });
-    finalizeCreatedWorkspace(workspaceName);
+    // Seed the new workspace from the one in use: the LLM endpoint, key and
+    // model are almost always the same, and re-entering them by hand was the
+    // first thing to do after every /new.
+    const { inherited } = await finalizeCreatedWorkspace(workspaceName, {
+      inheritFrom: context.session?.workspace ?? null,
+    });
     return {
       output: [
         output,
         '',
         `Workspace created: ${workspaceName}`,
+        // State what was carried over. Inheriting silently would make a wrong
+        // endpoint look like a scaffold default and send the operator hunting
+        // in the wrong file.
+        inherited.length > 0
+          ? `Inherited from ${context.session.workspace}: ${inherited.join(', ')}`
+          : null,
         `Use /use ${workspaceName} to load it.`,
       ].filter(Boolean).join('\n'),
     };
@@ -715,7 +736,7 @@ ${helpPair('/use <workspace>', 'Use workspace', '/status', 'Session status')}
 ${helpPair('/config list', 'Config profiles', '/config use <n>', 'Use config')}
 ${helpPair('/config edit <n>', 'Edit config', '/workspace delete <n>', 'Delete workspace')}
 ${helpPair('/services', 'Services', '/start [all|agents|services]', 'all = services + agents')}
-${helpPair('/stop [all|service|agents]', 'Stop service(s)', '/logs <service>', 'Service logs')}
+${helpPair('/stop [all|everything|service|agents]', 'Stop service(s)', '/logs <service>', 'Service logs')}
 ${helpPair('/skills', 'List skills', '/skills show <n>', 'Show skill')}
 ${helpPair('/skills run <n>', 'Run skill guide', '/skills edit <n>', 'Edit skill')}
 ${helpPair('/mcp status', 'MCP status', '/mcp endpoints', 'MCP endpoints')}
@@ -850,7 +871,7 @@ function formatRuntimeRunStatus(state) {
     ? state.controlQueue.filter((item) => item.status === 'queued').length
     : 0;
   const tasks = Array.isArray(state?.workflow?.nodes)
-    ? state.workflow.nodes.filter((node) => node.type === 'task' && !['done', 'failed', 'cancelled'].includes(String(node.status))).length
+    ? state.workflow.nodes.filter((node) => node.type === 'task' && !isTerminal(node.status)).length
     : 0;
   return `runtime: ${status}${runId} · queued=${queued} · activeTasks=${tasks}`;
 }
@@ -1118,14 +1139,31 @@ export async function handleSlashCommand(line, context) {
       // compris. Il ne stoppait que les services du workspace et laissait les
       // agents debout — donc `/start all` puis `/stop all` ne revenait pas à
       // l'état de départ.
-      const stopsAgents = service === 'all';
-      const stopTarget = service === 'services' ? undefined : service;
+      //
+      // Cette symétrie ne tient que tant qu'un seul workspace tourne. Les
+      // agents externes sont UNE pile partagée : les arrêter depuis un
+      // workspace coupait les autres, qui n'avaient rien demandé et ne
+      // voyaient qu'une panne. « all » reste donc « toute ma pile », et les
+      // agents ne tombent que s'ils ne servent plus personne. `/stop
+      // everything` garde la coupure franche, explicitement demandée.
+      const stopsEverything = service === 'everything';
+      const stopsAgents = service === 'all' || stopsEverything;
+      const stopTarget = service === 'services' || stopsEverything ? undefined : service;
       try {
-        step(`Services: stopping ${service ?? 'workspace services'}…`);
+        step(`Services: stopping ${stopsEverything ? 'all workspaces and agents' : (service ?? 'workspace services')}…`);
         await stopService(context.session, stopTarget);
         if (stopsAgents) {
-          const agentsResult = await runAgentCommand(stopAgents, 'stop');
-          if (agentsResult?.failed) return agentsResult;
+          const busy = stopsEverything
+            ? []
+            : await otherWorkspacesRunning(context.session, listWorkspaces());
+          if (busy.length > 0) {
+            // Say who is holding them, and how to override. A silent skip
+            // would look exactly like the bug we just fixed.
+            step(`Services: agents left running for ${busy.join(', ')} — use /stop everything to stop them anyway.`);
+          } else {
+            const agentsResult = await runAgentCommand(stopAgents, 'stop');
+            if (agentsResult?.failed) return agentsResult;
+          }
         }
         step('Services: refreshing MCP runtime…');
         await refreshMcpRuntimeStatus(context.session);

package/src/core/activity.js

@@ -1,4 +1,5 @@
 import { validateContractInDev } from '../contracts/schemas.js';
+import { isTerminal, isUnsuccessfulTerminal } from '../orchestrator/taskStatuses.js';
 
 export function parseJsonText(text) {
   try {
@@ -13,7 +14,7 @@ function basename(value) {
 }
 
 function terminalStatus(status) {
-  return ['done', 'failed', 'cancelled', 'canceled', 'complete', 'completed', 'success', 'succeeded', 'error'].includes(String(status ?? '').toLowerCase());
+  return isTerminal(status);
 }
 
 export function activityKey(activity) {
@@ -251,7 +252,7 @@ export function newNonTerminalActivities(snapshotBefore, session) {
 
 export function terminalFailures(activities) {
   return activities.filter(
-    (a) => a.terminal && ['failed', 'error', 'cancelled', 'canceled'].includes(String(a.status).toLowerCase()),
+    (a) => a.terminal && isUnsuccessfulTerminal(a.status),
   );
 }
 

package/src/core/agentEvents.js

@@ -4,6 +4,7 @@ import { applyPlanPatch, normalizePlanPatch, normalizePlanRevision, rebasePlanPa
 import { formatRuntimeLogPayload } from './runtimeLog.js';
 import { projectWorkflow } from './workflow.js';
 import { validateContractInDev } from '../contracts/schemas.js';
+import { isTerminal, isSuccessful, isUnknownStatus, normalizeTaskStatus } from '../orchestrator/taskStatuses.js';
 
 const SESSION_PROJECTION_EVENTS = new Set([
   'run_started',
@@ -267,6 +268,9 @@ function applyEvent(state, event) {
     case 'assistant_delta':
       appendAssistantDelta(state, String(event.payload?.delta ?? ''));
       return;
+    case 'assistant_delta_reset':
+      discardStreamingAssistantMessage(state);
+      return;
     case 'tool_call_started':
       state.chain.push({
         type: 'tool',
@@ -343,7 +347,13 @@ function applyEvent(state, event) {
       state.planRevision = normalizePlanRevision(event.payload?.planRevision ?? state.planRevision + 1);
       return;
     case 'plan_step_updated':
-      updatePlanStep(state.plan, event.payload ?? {});
+      {
+        // L'anomalie remonte par la valeur de retour plutôt que par une
+        // référence au state : `updatePlanStep` reste une fonction sur un
+        // plan, et le journal reste la responsabilité de l'appelant.
+        const anomaly = updatePlanStep(state.plan, event.payload ?? {});
+        if (anomaly) state.logs.push(anomaly);
+      }
       return;
     case 'control_message_received':
       state.logs.push(`Control message: ${String(event.payload?.input ?? '')}`);
@@ -659,6 +669,26 @@ function appendAssistantDelta(state, delta) {
   }
 }
 
+/*
+ Jeter une réponse en cours d'écriture, sans retirer son entrée.
+
+ Une itération de la boucle d'outils peut produire du texte puis décider
+ d'appeler un outil : ce texte est un raisonnement intermédiaire que le tour
+ suivant remplace, il ne doit pas rester à l'écran.
+
+ L'entrée est vidée, jamais dépilée. La réconciliation de `serve`
+ (`chatHtml.ts`) suppose une conversation en ajout seul — « le serveur ne mute
+ que la dernière entrée, tout ce qui précède est acquis » — et n'indexe la
+ boucle que sur la longueur croissante. Un `pop` la ferait passer sous le
+ nombre de références déjà rendues : l'élément DOM en trop resterait affiché
+ avec le texte qu'on voulait justement effacer, et tous les messages suivants
+ se décaleraient d'un cran.
+*/
+function discardStreamingAssistantMessage(state) {
+  const last = state.conversation.at(-1);
+  if (last?.role === 'assistant' && last.streaming) last.content = '';
+}
+
 function finalizeAssistantMessage(state, content) {
   const last = state.conversation.at(-1);
   if (last?.role === 'assistant' && last.streaming) {
@@ -725,7 +755,7 @@ function markCoveredApprovalsApproved(approvals, grant, ts) {
 
 function cancelPendingPlanSteps(plan) {
   for (const step of plan ?? []) {
-    if (!['done', 'failed', 'cancelled'].includes(String(step.status ?? ''))) step.status = 'cancelled';
+    if (!isTerminal(step.status)) step.status = 'cancelled';
   }
 }
 
@@ -852,24 +882,51 @@ function normalizePlanTask(raw, index, { owner = 'orchestrator', ownerActivityKe
 }
 
 function updatePlanStep(plan, payload) {
-  if (!plan) return;
+  let anomaly = null;
+  if (!plan) return anomaly;
   const requestedTaskId = payload.taskId ?? payload.id ?? payload.targetTaskId;
   const step = requestedTaskId != null
     ? plan.find((item) => String(item.id ?? item.step) === String(requestedTaskId))
     : plan.find((item) => item.step === Number(payload.step));
-  if (!step) return;
-  if (payload.status === 'failed') step.status = 'failed';
-  else if (payload.status === 'running') step.status = 'running';
-  else if (payload.status === 'pending') step.status = 'pending';
-  else if (payload.status === 'pending_approval') step.status = 'pending_approval';
-  else if (payload.status === 'waiting_approval') step.status = 'waiting_approval';
-  else if (payload.status === 'cancelled') step.status = 'cancelled';
-  else step.status = 'done';
+  if (!step) return anomaly;
+  /*
+   Un statut inconnu ne vaut pas « réussi ».
+
+   La cascade se terminait par `else step.status = 'done'` : tout statut non
+   énuméré — `skipped`, par exemple — était projeté en succès. Le runner
+   marquait bien une tâche ignorée, la projection la déclarait faite, et le
+   résumé de run comptait une réussite qui n'a jamais eu lieu. Le défaut le
+   plus dangereux est celui qui transforme une inconnue en bonne nouvelle.
+
+   Trois cas, et un seul mène à `done` :
+
+   - un statut reconnu par le vocabulaire commun est repris tel quel, alias
+     compris (`succeeded` → `done`, `error` → `failed`) ;
+   - l'ABSENCE de statut garde le contrat historique — un événement de fin
+     sans précision signifie « terminé » ;
+   - un statut présent mais incompréhensible laisse l'étape dans l'état où
+     elle était, et signale une anomalie de projection. On ne sait pas ce qui
+     s'est passé : le dire est plus utile que d'inventer une réponse.
+  */
+  const canonical = normalizeTaskStatus(payload.status);
+  if (canonical) {
+    step.status = canonical;
+  } else if (isUnknownStatus(payload.status)) {
+    anomaly = `projection: unknown status "${String(payload.status)}" for plan step ${String(requestedTaskId ?? payload.step ?? '?')} — kept "${String(step.status ?? 'pending')}"`;
+  } else {
+    step.status = 'done';
+  }
+  // Le motif d'un abandon est la seule chose qui le rende actionnable :
+  // « ignorée » sans « parce que » n'apprend rien à qui relance.
+  if (step.status === 'skipped' && payload.reason && !step.error) {
+    step.error = { code: 'dependency_failed', message: String(payload.reason) };
+  }
   if (payload.activityKey) step.activityKey = payload.activityKey;
   if (Array.isArray(payload.outputRefs)) step.outputRefs = payload.outputRefs.map(cloneRef);
   if (payload.result) step.result = cloneJson(payload.result);
   if (payload.retryState) step.retryState = cloneJson(payload.retryState);
   if (payload.retryAssignment) step.retryAssignment = cloneJson(payload.retryAssignment);
+  return anomaly;
 }
 
 function formatPlanErrors(errors) {

package/src/core/agentEvents.test.js

@@ -547,3 +547,79 @@ test('run_error cancels pending plan steps and active activities (no ghosts at r
   assert.equal(activity.status, 'cancelled');
   assert.equal(activity.terminal, true);
 });
+
+/*
+ La cascade de statuts se terminait par `else step.status = 'done'` : un statut
+ non énuméré était projeté en succès. Le runner marquait une tâche `skipped`
+ faute de dépendance, la projection la déclarait faite, et le résumé comptait
+ une réussite qui n'avait jamais eu lieu — le pire des défauts, celui qui
+ transforme une inconnue en bonne nouvelle.
+*/
+test('reduceAgentEvents: un statut de plan inconnu ne devient pas un succès', () => {
+  const projection = reduceAgentEvents([
+    createAgentEvent('plan_set', { origin: 'tool', payload: { steps: ['Ingest a', 'Ingest b'] } }),
+    createAgentEvent('plan_step_updated', {
+      origin: 'runtime',
+      payload: { step: 1, status: 'skipped', reason: 'dependency_failed:convert' },
+    }),
+    createAgentEvent('plan_step_updated', {
+      origin: 'runtime',
+      payload: { step: 2, status: 'brouette' },
+    }),
+  ]);
+
+  assert.equal(projection.plan[0].status, 'skipped');
+  assert.equal(projection.plan[0].error?.code, 'dependency_failed');
+  assert.match(projection.plan[0].error.message, /convert/);
+  // Un statut incompréhensible laisse l'étape où elle était et se signale :
+  // on ne sait pas ce qui s'est passé, le dire vaut mieux que d'inventer.
+  assert.equal(projection.plan[1].status, 'pending');
+  assert.equal(projection.logs.some((line) => /unknown status "brouette"/.test(line)), true);
+});
+
+test('reduceAgentEvents: les alias de statut tombent sur le canonique', () => {
+  const projection = reduceAgentEvents([
+    createAgentEvent('plan_set', { origin: 'tool', payload: { steps: ['A', 'B', 'C'] } }),
+    createAgentEvent('plan_step_updated', { origin: 'runtime', payload: { step: 1, status: 'succeeded' } }),
+    createAgentEvent('plan_step_updated', { origin: 'runtime', payload: { step: 2, status: 'error' } }),
+    // Contrat historique : un événement de fin sans statut vaut « terminé ».
+    createAgentEvent('plan_step_updated', { origin: 'runtime', payload: { step: 3 } }),
+  ]);
+
+  assert.equal(projection.plan[0].status, 'done');
+  assert.equal(projection.plan[1].status, 'failed');
+  assert.equal(projection.plan[2].status, 'done');
+  assert.equal(projection.logs.some((line) => /unknown status/.test(line)), false);
+});
+
+// La bulle « Request received · Donna is preparing… » n'est retirée côté serve
+// que lorsqu'un message assistant NON VIDE arrive. Un tour sans réponse ne
+// publiait rien : le point d'attente tournait jusqu'au rechargement de la page.
+test('a discarded stream is emptied, never popped', () => {
+  const projection = reduceAgentEvents([
+    createAgentEvent('user_message', { origin: 'user', payload: { content: 'question' } }),
+    createAgentEvent('assistant_delta', { origin: 'runtime', payload: { delta: 'Je vais regarder…' } }),
+    createAgentEvent('assistant_delta_reset', { origin: 'runtime', payload: {} }),
+  ]);
+
+  // La réconciliation de serve suppose une conversation en ajout seul : dépiler
+  // la ferait passer sous le nombre d'éléments déjà rendus, laissant à l'écran
+  // le texte qu'on voulait effacer et décalant tous les messages suivants.
+  assert.equal(projection.conversation.length, 2);
+  assert.deepEqual(projection.conversation[1], { role: 'assistant', content: '', streaming: true });
+});
+
+test('a stream resumed after a discard carries only the final text', () => {
+  const projection = reduceAgentEvents([
+    createAgentEvent('user_message', { origin: 'user', payload: { content: 'question' } }),
+    createAgentEvent('assistant_delta', { origin: 'runtime', payload: { delta: 'Je vais regarder…' } }),
+    createAgentEvent('assistant_delta_reset', { origin: 'runtime', payload: {} }),
+    createAgentEvent('assistant_delta', { origin: 'runtime', payload: { delta: '12 ' } }),
+    createAgentEvent('assistant_delta', { origin: 'runtime', payload: { delta: 'pages.' } }),
+    createAgentEvent('assistant_message', { origin: 'runtime', payload: { content: '12 pages.' } }),
+  ]);
+
+  assert.equal(projection.conversation.length, 2);
+  assert.equal(projection.conversation[1].content, '12 pages.');
+  assert.equal(projection.conversation[1].streaming, undefined, 'le message doit être figé');
+});