@dotdrelle/wiki-manager 0.15.41 → 0.15.43

package/README.md

@@ -210,7 +210,7 @@ Slash primitives (shell):
 
 ```text
 /wiki                # inspect the wiki
-/skills              # bundled examples: pipeline, diagnose, status, wiki-sync
+/skills              # bundled examples: pipeline, wiki-sync, wiki-build, deliver, diagnose, status
 /skills run pipeline # run the shipped end-to-end example
 ```
 
@@ -273,7 +273,7 @@ just reopens the web page.)*
 The scaffold ships **ready-to-use examples**. In the shell, explore them:
 
 ```text
-/skills              list the bundled examples (diagnose, pipeline, status, wiki-sync…)
+/skills              list the bundled examples (pipeline, wiki-sync, wiki-build, deliver, diagnose, status…)
 /skills show <name>  see what an example does
 /skills run <name>   run it to see the result
 ```
@@ -329,8 +329,12 @@ At each step, either you **ask for it in plain language**, or you **run the skil
    rendering.
    → *"Export and polish the deliverables"*
 
-> 💡 Even simpler: `/skills run wiki-sync` chains export + ingestion, and
-> `/skills run pipeline` runs the whole chain end to end.
+> 💡 Even simpler: `/skills run wiki-sync` chains export + ingestion,
+> `/skills run wiki-build` regenerates the deliverables, `/skills run deliver`
+> publishes them (add `polish` to refine the rendering), and
+> `/skills run pipeline` runs the whole chain end to end. The three step skills
+> take an optional argument — a source name, or a template with or without its
+> `.md` extension.
 
 ### Entry point B — from a simple PDF (the fastest)
 
@@ -556,6 +560,14 @@ including under `"*"`. Multi-step work belongs to `/agent`.
 An `allowActions` key written by an older manager is folded into `allow` on
 read and removed on the next `agents up`.
 
+`chatAccess` is not how workspace context reaches chat. The workspace profile
+(`.wiki/profile.md`) is read from disk and injected into the system prompt of
+both modes, so durable preferences — tone, formatting, notification recipient —
+shape every reply without a tool call and without an allow-list entry. Adding
+`profile_read` here would help no existing install anyway: the scaffold's
+additive merge only fills missing top-level keys and never edits an allow-list
+you already have.
+
 ### Adding a connector from the served chat UI
 
 `mcp.endpoints.json` stays hand-editable, but the Connectors panel of
@@ -844,6 +856,38 @@ wiki-workspace wiki my-project build --plan
 wiki-workspace wiki my-project build
 ```
 
+### Resetting a workspace
+
+```bash
+wiki-workspace wiki my-project down            # the services must be stopped
+wiki-workspace wiki my-project reset --dry-run # what would go, what stays
+wiki-workspace wiki my-project reset
+```
+
+`reset` empties a workspace while keeping the **method**: `.wikirc*` (provider,
+model, retrieval, per-profile variants), `templates/` and `build-context/` —
+plus `.env`, which holds the workspace's ports and MCP tokens and without which
+nothing could be restarted.
+Everything the workspace produced, cached or logged goes — `wiki/`,
+`deliverables/`, `raw/untracked/`, `raw/ingested/`, `.wiki/` (vector index,
+cache, logs, tmp, build state, skills, profile, system prompt), `CLAUDE.md`,
+`.gitignore` — then `wiki init` puts the empty structure back.
+
+Three things worth knowing:
+
+- `.git/` is kept when present, so the state from before the reset stays
+  reachable through `wiki restore`. It is the only undo there is.
+- The command refuses to run while workspace services are up: a container
+  writing into the bind mount would recreate part of what was erased and leave
+  files owned by another UID behind.
+- It stops there. Nothing is re-synced and nothing is rebuilt — refilling the
+  workspace is a decision, not a side effect of emptying it.
+
+It is available **only** here: there is no `wiki reset` CLI subcommand, no
+production job type, no MCP tool and no skill for it. Nothing Donna can call
+may erase a workspace. Confirmation is interactive (retype the workspace name)
+unless you pass `--yes`.
+
 ## Services
 
 The shared `docker-compose.yml` starts one workspace stack:

package/package.json

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

@@ -18,18 +18,17 @@ import {
   resolveToolCallName,
   truncateToolResult,
 } from '../core/mcp.js';
-import { formatSkillsForAgent, readOptionalText } from '../core/skills.js';
+import { formatSkillsForAgent } from '../core/skills.js';
 import { handleSlashCommand } from '../commands/slash.js';
 import { extractActivity, formatActivitySummary, parseJsonText, sessionActivities } from '../core/activity.js';
 import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
 import { enqueueProductionJob, ensureJobQueue, formatQueue, productionLockBusy } from '../core/jobQueue.js';
-import { updateWorkspaceProfilePreference } from '../core/profile.js';
+import { loadWorkspaceProfile, updateWorkspaceProfilePreference } from '../core/profile.js';
 import { capabilityRegistryForSession } from '../orchestrator/capabilityRegistry.js';
 import { fetchRuntimeState, postRuntimeApprove, postRuntimeCancel, postRuntimeControl, postRuntimeDelegate, postRuntimeKill } from '../runtime/client.js';
 
 const MAX_TOOL_ITERATIONS = 80;
 const MAX_SPINNER_ARG_LENGTH = 96;
-const MAX_PROFILE_CHARS = 4000;
 
 // Pseudo-servers handled directly by the tool executor (not present in
 // session.mcp). Listed so unqualified names like "plan_set" resolve the same
@@ -1002,11 +1001,7 @@ function slugStepId(description, index) {
 // relying on the model proactively calling wiki__profile_read — profile
 // content (tutoiement, formatting preferences, etc.) is meant to shape every
 // reply, not just ones where the model happens to think to check it.
-function loadWorkspaceProfile(workspacePath) {
-  if (!workspacePath) return null;
-  const content = readOptionalText(join(workspacePath, '.wiki', 'profile.md'));
-  return content ? content.slice(0, MAX_PROFILE_CHARS) : null;
-}
+// Loader shared with chat mode — see core/profile.js.
 
 export function buildAgentSystemPrompt(state) {
   const workspace = state.session.workspace ?? 'no workspace selected';

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",
-  "commit": "d0180aa"
+  "version": "0.15.43",
+  "commit": "513dff5"
 }

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.43';
 
 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/profile.js

@@ -1,5 +1,8 @@
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
+import { readOptionalText } from './skills.js';
+
+export const MAX_PROFILE_CHARS = 4000;
 
 const DEFAULT_PROFILE = `# Workspace Profile
 
@@ -22,6 +25,22 @@ function profilePathForWorkspace(workspacePath) {
   return join(workspacePath, '.wiki', 'profile.md');
 }
 
+// Durable per-workspace user preferences, injected into the system prompt of
+// BOTH shell modes. Agent mode used to own this loader; chat mode had nothing,
+// so the same workspace answered with a different tone depending on the mode,
+// and a skill running in chat could not know who it was talking to. `serve`
+// already injects the profile the same way (llm-wiki chatRoutes), so this keeps
+// the three surfaces aligned. Injection is deliberately preferred over exposing
+// `profile_read` through `chatAccess`: no allow-list entry to migrate on
+// existing installs, and no tool round-trip for a file we can always read.
+// Returns null when there is no workspace or no readable profile — never throws,
+// since a missing profile must not degrade a reply.
+export function loadWorkspaceProfile(workspacePath) {
+  if (!workspacePath) return null;
+  const content = readOptionalText(profilePathForWorkspace(workspacePath));
+  return content ? content.slice(0, MAX_PROFILE_CHARS) : null;
+}
+
 function formatPreference(preference) {
   const clean = String(preference ?? '').trim();
   if (!clean) return '';

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 ?? '',