@dotdrelle/wiki-manager 0.15.41 → 0.15.42

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotdrelle/wiki-manager",
-  "version": "0.15.41",
+  "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/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/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",
+    "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/cli/wiki-manager.js

@@ -306,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;
 }
@@ -1365,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

@@ -12,7 +12,7 @@ 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 {
@@ -568,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'),
     };
@@ -725,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')}
@@ -1128,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/agentEvents.js

@@ -268,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',
@@ -666,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) {

package/src/core/agentEvents.test.js

@@ -591,3 +591,35 @@ test('reduceAgentEvents: les alias de statut tombent sur le canonique', () => {
   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é');
+});

package/src/core/buildInfo.json

@@ -1,4 +1,4 @@
 {
-  "version": "0.15.41",
+  "version": "0.15.42",
   "commit": "d0180aa"
 }

package/src/core/compose.js

@@ -321,6 +321,38 @@ export async function serviceStates(session) {
   return states;
 }
 
+/**
+ * Names of OTHER registered workspaces that still have containers running.
+ *
+ * The external agents (cme, documents, connectors, mailer) are a single
+ * stack shared by every workspace — one Compose project, one set of
+ * containers. `/stop all` took them down unconditionally, so stopping one
+ * workspace silently cut the agents out from under all the others.
+ *
+ * Best effort by design: a workspace whose Compose project cannot be queried
+ * (registry entry pointing at a path that no longer exists, docker refusing)
+ * is reported as NOT running. Erring the other way would make the agents
+ * impossible to stop as soon as one stale registry entry existed.
+ */
+export async function otherWorkspacesRunning(session, workspaces = []) {
+  const current = session?.workspace ?? null;
+  const others = workspaces.filter((workspace) => workspace?.name && workspace.name !== current);
+  const results = await Promise.all(others.map(async (workspace) => {
+    try {
+      const states = await serviceStates({
+        workspace: workspace.name,
+        workspacePath: workspace.workspacePath,
+        workspaceEnvFile: workspace.envFile,
+        workspaceEnv: workspace.env,
+      });
+      return Object.values(states).some((state) => state.running) ? workspace.name : null;
+    } catch {
+      return null;
+    }
+  }));
+  return results.filter(Boolean);
+}
+
 export async function missingServiceImages(service) {
   const aliases = serviceAliases();
   const targets = service ? (aliases[service] ?? [service]) : COMPOSE_SERVICES;

package/src/core/dockerCompose.test.js

@@ -150,3 +150,35 @@ test('missing-image checks ignore agents behind inactive Compose profiles', () =
     ['example/cme:latest', 'example/connectors:latest'],
   );
 });
+
+// Trois variables DOCUMENT_* pour deux conteneurs, chacun n'en déclarant que
+// deux : la question « à quoi ça sert » revient à chaque lecture. Ce test fige
+// le partage pour que la doc reste vraie.
+test('the document handoff keeps input shared and the rest separate', async () => {
+  const workspace = YAML.parse(await readFile(new URL('../../docker-compose.yml', import.meta.url), 'utf8'));
+  const agents = YAML.parse(await readFile(new URL('../../agents.docker-compose.yml', import.meta.url), 'utf8'));
+  const envOf = (service) => Object.fromEntries(
+    (service.environment ?? []).map((entry) => String(entry).split('=', 2)),
+  );
+
+  const serve = envOf(workspace.services.serve);
+  const documents = envOf(agents.services.documents);
+
+  // `input` est le point de passage : serve y écrit, l'agent y lit.
+  assert.equal(serve.DOCUMENT_INPUT_DIR, '/documents/input');
+  assert.equal(documents.DOCUMENT_INPUT_DIR, '/documents/input');
+  assert.ok(workspace.services.serve.volumes.some((v) => String(v).endsWith(':/documents/input')));
+  assert.ok(agents.services.documents.volumes.some((v) => String(v).endsWith(':/documents/input')));
+
+  // Le manifeste des téléversements n'appartient qu'à serve ; la sortie de
+  // conversion n'appartient qu'à l'agent. Déclarer l'un chez l'autre laisserait
+  // croire à un partage qui n'existe pas.
+  assert.equal(serve.DOCUMENT_UPLOADS_DIR, '/documents/uploads');
+  assert.equal(documents.DOCUMENT_UPLOADS_DIR, undefined);
+  assert.equal(documents.DOCUMENT_OUTPUT_DIR, '/documents/output');
+  assert.equal(serve.DOCUMENT_OUTPUT_DIR, undefined);
+
+  // Le plafond est vérifié des deux côtés, donc déclaré des deux côtés.
+  assert.ok(serve.DOCUMENT_MAX_UPLOAD_BYTES);
+  assert.ok(documents.DOCUMENT_MAX_UPLOAD_BYTES);
+});

package/src/core/mcp.js

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { managerEnvFile, managerMcpEndpointsFile, readEnvFile } from './env.js';
 
-const WIKI_MANAGER_VERSION = '0.15.41';
+const WIKI_MANAGER_VERSION = '0.15.42';
 
 function envValue(key) {
   const filePath = managerEnvFile();

package/src/core/otherWorkspacesRunning.test.js

@@ -0,0 +1,51 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { otherWorkspacesRunning } from './compose.js';
+
+// `otherWorkspacesRunning` shells out to `docker compose ps` per workspace.
+// Docker is not available in the test environment, so every probe throws —
+// which is itself the behaviour worth pinning: a workspace that cannot be
+// queried must read as NOT running, or one stale registry entry would make
+// the shared agents impossible to stop for good.
+
+function workspaceEntry(root, name) {
+  const registryPath = join(root, name);
+  mkdirSync(registryPath, { recursive: true });
+  const envFile = join(registryPath, '.env');
+  writeFileSync(envFile, `WORKSPACE_NAME=${name}\nWIKI_WORKSPACE_PATH=${registryPath}\n`, 'utf8');
+  return {
+    name,
+    registryPath,
+    envFile,
+    workspacePath: registryPath,
+    env: { WORKSPACE_NAME: name, WIKI_WORKSPACE_PATH: registryPath },
+  };
+}
+
+test('the current workspace is never counted as another one', async () => {
+  const root = mkdtempSync(join(tmpdir(), 'ws-running-self-'));
+  const acpi = workspaceEntry(root, 'acpi');
+
+  const busy = await otherWorkspacesRunning({ workspace: 'acpi' }, [acpi]);
+
+  assert.deepEqual(busy, [], 'stopping a workspace must not be blocked by itself');
+});
+
+test('an unqueryable workspace does not hold the shared agents hostage', async () => {
+  const root = mkdtempSync(join(tmpdir(), 'ws-running-unknown-'));
+  const workspaces = [workspaceEntry(root, 'acpi'), workspaceEntry(root, 'stale')];
+
+  const busy = await otherWorkspacesRunning({ workspace: 'acpi' }, workspaces);
+
+  assert.deepEqual(busy, []);
+});
+
+test('a single workspace, or none at all, never blocks', async () => {
+  assert.deepEqual(await otherWorkspacesRunning({ workspace: 'acpi' }, []), []);
+  assert.deepEqual(await otherWorkspacesRunning({}, []), []);
+  // Entries without a name are registry noise, not workspaces.
+  assert.deepEqual(await otherWorkspacesRunning({ workspace: 'acpi' }, [{}, null]), []);
+});

package/src/core/profileServiceStatus.test.js

@@ -82,8 +82,32 @@ test('"all" means the same thing to start and to stop', () => {
   // `/start all` démarrait les agents, `/stop all` ne les arrêtait pas : la
   // séquence start/stop ne revenait donc pas à l'état de départ.
   assert.match(slash, /const startsAgents = service === 'all';/);
-  assert.match(slash, /const stopsAgents = service === 'all';/);
-  assert.match(slash, /if \(stopsAgents\) \{\s*\n\s*const agentsResult = await runAgentCommand\(stopAgents, 'stop'\);/);
+  assert.match(slash, /const stopsAgents = service === 'all' \|\| stopsEverything;/);
+});
+
+test('stopping one workspace never takes the shared agents from another', () => {
+  const slash = readFileSync(fileURLToPath(new URL('../commands/slash.js', import.meta.url)), 'utf8');
+  // Les agents externes sont UNE pile partagée. `/stop all` les arrêtait sans
+  // condition : couper un workspace coupait tous les autres, qui ne voyaient
+  // qu'une panne.
+  assert.match(slash, /await otherWorkspacesRunning\(context\.session, listWorkspaces\(\)\)/);
+  assert.match(slash, /if \(busy\.length > 0\) \{/);
+  // Le renoncement doit se dire : un saut silencieux ressemble exactement au
+  // bug d'origine.
+  assert.match(slash, /agents left running for \$\{busy\.join\(', '\)\}/);
+  assert.match(slash, /use \/stop everything to stop them anyway/);
+  // `everything` court-circuite la garde, et c'est son seul intérêt.
+  assert.match(slash, /const busy = stopsEverything\s*\n\s*\? \[\]/);
+});
+
+test('the everything escape hatch is discoverable', () => {
+  const slash = readFileSync(fileURLToPath(new URL('../commands/slash.js', import.meta.url)), 'utf8');
+  const repl = readFileSync(fileURLToPath(new URL('../shell/repl.js', import.meta.url)), 'utf8');
+  // Une porte de sortie qui n'apparaît ni dans l'aide ni dans la complétion
+  // n'existe pas pour l'opérateur qui en a besoin.
+  assert.match(slash, /\/stop \[all\|everything\|service\|agents\]/);
+  assert.match(repl, /command === '\/stop' && tokenIndex === 1\) return \['all', 'everything'/);
+  assert.match(repl, /if \(value === 'everything'\)/);
 });
 
 test('the addressable agents are read from the compose file, never hard-coded', async () => {

package/src/core/toolLoop.js

@@ -12,6 +12,13 @@
 //
 // `executeCall` may throw to abort the whole loop (e.g. an AbortError on
 // cancel); anything it returns is treated as the tool result for that call.
+/**
+ * @param onTextDelta appelé au fil de la génération. Une itération qui finit
+ *   par des appels d'outils ne produit pas de réponse lisible : ses fragments
+ *   sont donc rejetés a posteriori via `onTextReset`, pour ne pas afficher un
+ *   raisonnement intermédiaire que le tour suivant remplacera.
+ * @param onTextReset appelé quand les fragments déjà émis sont à jeter.
+ */
 export async function runBoundedToolLoop({
   llm,
   system,
@@ -21,19 +28,37 @@ export async function runBoundedToolLoop({
   maxIterations = 4,
   signal,
   onStep,
+  onTextDelta,
+  onTextReset,
 } = {}) {
   const cap = Math.max(1, Math.floor(maxIterations) || 1);
   const convo = [...(messages ?? [])];
+  // `streamWithTools` accumule les appels d'outils exactement comme
+  // `completeWithTools` et renvoie la même forme : le seul écart est qu'il
+  // livre le texte au fil de l'eau. Sans lui, la réponse finale n'apparaissait
+  // qu'une fois complète — le tour paraissait figé pendant toute sa durée.
+  const canStream = typeof onTextDelta === 'function' && typeof llm?.streamWithTools === 'function';
   for (let i = 0; i < cap; i += 1) {
     onStep?.(i + 1, cap);
-    const result = await llm.completeWithTools({
-      system,
-      tools,
-      messages: convo,
-      toolChoice: 'auto',
-      signal,
-    });
+    let streamedText = false;
+    const result = canStream
+      ? await llm.streamWithTools({
+          system,
+          tools,
+          messages: convo,
+          toolChoice: 'auto',
+          onTextDelta: (delta) => { streamedText = true; onTextDelta(delta); },
+          signal,
+        })
+      : await llm.completeWithTools({
+          system,
+          tools,
+          messages: convo,
+          toolChoice: 'auto',
+          signal,
+        });
     const calls = result?.tool_calls ?? [];
+    if (calls.length > 0 && streamedText) onTextReset?.();
     if (calls.length === 0) {
       return {
         content: result?.content ?? result?.message?.content ?? '',

package/src/core/toolLoop.test.js

@@ -86,3 +86,98 @@ test('propagates an abort thrown by executeCall', async () => {
     /aborted/,
   );
 });
+
+// Le tour paraissait figé pendant toute sa durée : la réponse n'apparaissait
+// qu'une fois complète, parce que la boucle n'appelait que completeWithTools.
+test('streams the answer when the caller asks for deltas', async () => {
+  const deltas = [];
+  const llm = {
+    async completeWithTools() { throw new Error('streamWithTools devait être préféré'); },
+    async streamWithTools({ onTextDelta }) {
+      onTextDelta('Le wiki ');
+      onTextDelta('contient 12 pages.');
+      return { content: 'Le wiki contient 12 pages.', tool_calls: [] };
+    },
+  };
+
+  const out = await runBoundedToolLoop({
+    llm,
+    tools: [],
+    executeCall: async () => 'unused',
+    onTextDelta: (delta) => deltas.push(delta),
+  });
+
+  assert.deepEqual(deltas, ['Le wiki ', 'contient 12 pages.']);
+  assert.equal(out.content, 'Le wiki contient 12 pages.');
+});
+
+test('keeps the non-streaming path when no delta callback is given', async () => {
+  let streamed = false;
+  const llm = {
+    async completeWithTools() { return { content: 'plain', tool_calls: [] }; },
+    async streamWithTools() { streamed = true; return { content: 'streamed', tool_calls: [] }; },
+  };
+
+  const out = await runBoundedToolLoop({ llm, tools: [], executeCall: async () => 'unused' });
+
+  assert.equal(streamed, false, 'sans onTextDelta, rien ne doit changer');
+  assert.equal(out.content, 'plain');
+});
+
+test('discards text emitted by an iteration that ends in tool calls', async () => {
+  // Un modèle peut écrire un raisonnement puis décider d'appeler un outil. Ce
+  // texte est remplacé par le tour suivant : le laisser afficherait des
+  // paragraphes qui disparaissent, pire que pas de streaming du tout.
+  let round = 0;
+  const deltas = [];
+  let resets = 0;
+  const llm = {
+    async streamWithTools({ onTextDelta }) {
+      round += 1;
+      if (round === 1) {
+        onTextDelta('Je vais regarder…');
+        const calls = [toolCall('c1', 'wiki__wiki_list_pages')];
+        return { message: { role: 'assistant', content: '', tool_calls: calls }, tool_calls: calls };
+      }
+      onTextDelta('12 pages.');
+      return { content: '12 pages.', tool_calls: [] };
+    },
+  };
+
+  const out = await runBoundedToolLoop({
+    llm,
+    tools: [],
+    executeCall: async () => 'ok',
+    onTextDelta: (delta) => deltas.push(delta),
+    onTextReset: () => { resets += 1; },
+  });
+
+  assert.deepEqual(deltas, ['Je vais regarder…', '12 pages.']);
+  assert.equal(resets, 1, 'le texte intermédiaire doit être annulé, une fois');
+  assert.equal(out.content, '12 pages.');
+});
+
+test('never asks to discard text that was never emitted', async () => {
+  let resets = 0;
+  let round = 0;
+  const llm = {
+    async streamWithTools() {
+      round += 1;
+      if (round === 1) {
+        const calls = [toolCall('c1', 'wiki__wiki_list_pages')];
+        return { message: { role: 'assistant', content: '', tool_calls: calls }, tool_calls: calls };
+      }
+      return { content: 'fini', tool_calls: [] };
+    },
+  };
+
+  await runBoundedToolLoop({
+    llm,
+    tools: [],
+    executeCall: async () => 'ok',
+    onTextDelta: () => {},
+    onTextReset: () => { resets += 1; },
+  });
+
+  assert.equal(resets, 0);
+});

package/src/core/wikiSetup.js

@@ -5,7 +5,8 @@ import { dirname, join } from 'node:path';
 import { promisify } from 'node:util';
 import YAML from 'yaml';
 import { checkMissingDockerImages } from './dockerImages.js';
-import { patchWikircProfile } from './wikirc.js';
+import { loadWikircProfile, patchWikircProfile } from './wikirc.js';
+import { buildInheritedWikircPatch, copyCmeCredentials } from './workspaceInherit.js';
 import { resolveAgentsComposeContext } from './agentsCompose.js';
 import { managerEnvFile, managerMcpEndpointsFile, resolveAgentsDataDir } from './env.js';
 import { createWorkspace, findWorkspace, isValidWorkspaceName, listWorkspaces, managerRoot, workspacesDir } from './workspaces.js';
@@ -208,20 +209,62 @@ export async function refreshRunningContainers(options = {}) {
   return { skipped: false, refreshed, errors };
 }
 
-export async function createNewWorkspace(name, targetPath) {
+export async function createNewWorkspace(name, targetPath, options = {}) {
   try {
     const output = await createWorkspace(name, targetPath, { timeout: 600_000 });
-    const workspace = finalizeCreatedWorkspace(name);
-    return { output, workspace };
+    const { workspace, inherited } = await finalizeCreatedWorkspace(name, options);
+    return { output, workspace, inherited };
   } catch (err) {
     throw wrapDockerError(err);
   }
 }
 
-export function finalizeCreatedWorkspace(name) {
+/**
+ * @param options.inheritFrom name of the workspace to copy LLM config and CME
+ *   credentials from — normally the session's current workspace. Omitted, or
+ *   unknown, means "scaffold defaults only", the previous behaviour.
+ */
+export async function finalizeCreatedWorkspace(name, options = {}) {
   const workspace = findWorkspace(name);
-  if (workspace) initializeWorkspaceWikirc(workspace);
-  return workspace;
+  if (!workspace) return { workspace: null, inherited: [] };
+  // Order matters: the access key is this workspace's own credential and must
+  // land before anything else touches the file.
+  initializeWorkspaceWikirc(workspace);
+  const inherited = await inheritWorkspaceSetup(workspace, options.inheritFrom ?? null);
+  return { workspace, inherited };
+}
+
+/**
+ * Carry an existing workspace's proven setup over to a new one. Best effort by
+ * design: a workspace that exists and works must never fail to be created
+ * because the workspace next door has an unreadable config.
+ */
+export async function inheritWorkspaceSetup(workspace, sourceName) {
+  if (!workspace?.workspacePath || !sourceName || sourceName === workspace.name) return [];
+  const source = findWorkspace(sourceName);
+  if (!source?.workspacePath) return [];
+
+  const inherited = [];
+  try {
+    const { config: sourceConfig } = loadWikircProfile(source.workspacePath, 'default');
+    const { config: targetConfig } = loadWikircProfile(workspace.workspacePath, 'default');
+    const { patch, inherited: keys } = buildInheritedWikircPatch(sourceConfig, targetConfig);
+    if (keys.length > 0) {
+      patchWikircProfile(workspace.workspacePath, 'default', patch);
+      inherited.push(...keys);
+    }
+  } catch {
+    // Unreadable or absent profile on either side — nothing to inherit.
+  }
+
+  try {
+    const copied = await copyCmeCredentials(resolveAgentsDataDir(), source.name, workspace.name);
+    if (copied) inherited.push('cme.app_data.json');
+  } catch {
+    // Credentials are a convenience, not a prerequisite.
+  }
+
+  return inherited;
 }
 
 export function initializeWorkspaceWikirc(workspace) {