@dotdrelle/wiki-manager 0.11.4 → 0.11.7

package/agents.docker-compose.yml

@@ -95,7 +95,7 @@ services:
       - MAILER_REQUIRE_CONFIRMATION=${MAILER_REQUIRE_CONFIRMATION:-true}
       - MAILER_DRY_RUN=${MAILER_DRY_RUN:-false}
       - MCP_AUTH_TOKEN=${MAILER_MCP_AUTH_TOKEN:-}
-    volumes:
-      # Optional: mount a CA bundle and set MAILERSEND_CA_CERT to its container path.
-      #- ${AGENTS_DATA_DIR:-./.agents-data}/certs:/certs:ro
+    # Optional: mount a CA bundle and set MAILERSEND_CA_CERT to its container path.
+    # volumes:
+    #   - ${AGENTS_DATA_DIR:-./.agents-data}/certs:/certs:ro
     restart: unless-stopped

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotdrelle/wiki-manager",
-  "version": "0.11.4",
+  "version": "0.11.7",
   "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/agent/graph.test.js src/contracts/schemas.test.js src/core/activity.test.js src/core/agentEvents.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/documentIntake.test.js src/core/dockerCompose.test.js src/core/wikiWorkspace.test.js src/core/wikirc.test.js src/core/modelFetch.test.js src/core/startupCheck.test.js src/core/queueStore.test.js src/commands/slash.test.js src/shell/repl.test.js src/runtime/store.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/auth.test.js",
+    "test": "node --test src/agent/graph.test.js src/contracts/schemas.test.js src/core/activity.test.js src/core/agentEvents.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/documentIntake.test.js src/core/dockerCompose.test.js src/core/wikiWorkspace.test.js src/core/wikirc.test.js src/core/modelFetch.test.js src/core/startupCheck.test.js src/core/queueStore.test.js src/commands/slash.test.js src/shell/repl.test.js src/runtime/store.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",
     "check-versions": "node scripts/check-versions.js",
     "prepack": "node scripts/check-versions.js",
     "prepublishOnly": "node scripts/check-versions.js",

package/src/agent/graph.js

@@ -1,3 +1,4 @@
+import { join } from 'node:path';
 import { Annotation, END, START, StateGraph } from '@langchain/langgraph';
 import {
   buildLlmTools,
@@ -6,14 +7,17 @@ import {
   formatMcpToolsForAgent,
   parseToolCallName,
 } from '../core/mcp.js';
-import { formatSkillsForAgent } from '../core/skills.js';
+import { formatSkillsForAgent, readOptionalText } from '../core/skills.js';
 import { handleSlashCommand } from '../commands/slash.js';
 import { extractActivity, formatActivitySummary, parseJsonText } 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';
 
 const MAX_TOOL_ITERATIONS = 80;
 const MAX_SPINNER_ARG_LENGTH = 96;
+const MAX_PROFILE_CHARS = 4000;
+
 const AGENT_SLASH_COMMANDS = new Set([
   'help',
   'version',
@@ -51,6 +55,51 @@ const SHELL_RUN_COMMAND_TOOL = {
   },
 };
 
+const SHELL_READ_COMMAND_TOOL = {
+  type: 'function',
+  function: {
+    name: 'shell__read_command',
+    description: [
+      'Run a read-only deterministic wiki-manager slash command inside the current shell session.',
+      'Allowed commands: /help, /version, /config, /config list, /config status, /status, /services, /skills, /skills list, /skills show <name>, /uploads, /uploads list, /queue.',
+      'Do not use for workspace creation/deletion, uploads conversion, service start/stop, MCP calls, wiki runs, or any mutation.',
+    ].join(' '),
+    parameters: {
+      type: 'object',
+      additionalProperties: false,
+      properties: {
+        command: {
+          type: 'string',
+          description: 'Read-only slash command to run, for example "/status", "/config status", or "/services".',
+        },
+      },
+      required: ['command'],
+    },
+  },
+};
+
+const SHELL_PROFILE_UPDATE_TOOL = {
+  type: 'function',
+  function: {
+    name: 'shell__profile_update',
+    description: [
+      'Append one explicit durable user preference to the current workspace .wiki/profile.md.',
+      'Use when the user explicitly asks to remember, persist, note, or update profile information and wiki__profile_update is not available.',
+    ].join(' '),
+    parameters: {
+      type: 'object',
+      additionalProperties: false,
+      properties: {
+        preference: {
+          type: 'string',
+          description: 'The durable preference to append, without Markdown bullet syntax.',
+        },
+      },
+      required: ['preference'],
+    },
+  },
+};
+
 const WIKI_PLAN_SET_TOOL = {
   type: 'function',
   function: {
@@ -238,6 +287,24 @@ function assertAgentSlashCommandAllowed(commandLine) {
   }
 }
 
+function assertAgentReadSlashCommandAllowed(commandLine) {
+  const parts = commandLine.slice(1).trim().split(/\s+/).filter(Boolean);
+  const command = parts[0] ?? '';
+  const subcommand = parts[1] ?? '';
+  const allowed =
+    command === 'help' ||
+    command === 'version' ||
+    command === 'status' ||
+    command === 'services' ||
+    command === 'queue' ||
+    (command === 'config' && ['', 'list', 'status'].includes(subcommand)) ||
+    (command === 'skills' && ['', 'list', 'show'].includes(subcommand)) ||
+    (command === 'uploads' && ['', 'list'].includes(subcommand));
+  if (!allowed) {
+    throw new Error(`Read-only command is not available to the agent: /${parts.join(' ')}`);
+  }
+}
+
 function withActiveWorkspaceForExternalTool(session, server, tool, args) {
   const needsWorkspace =
     (server === 'documents' && tool.startsWith('documents_') && tool !== 'documents_status') ||
@@ -269,6 +336,21 @@ async function runShellCommandTool(session, commandLine) {
   return result.output ?? 'Command completed.';
 }
 
+async function runShellReadCommandTool(session, commandLine) {
+  const command = normalizeShellCommand(commandLine);
+  assertAgentReadSlashCommandAllowed(command);
+  session._onStep?.(`Shell: ${command}`);
+  const result = await handleSlashCommand(command, {
+    packageJson: session.packageJson ?? { version: '0.0.0' },
+    session,
+    onStep: session._onStep,
+  });
+  if (result.exit) {
+    throw new Error('/exit is not available to the agent.');
+  }
+  return result.output ?? 'Command completed.';
+}
+
 function rememberProductionProgress(session, payload, label) {
   const job = payload?.job;
   const jobId = payload?.jobId ?? job?.jobId;
@@ -423,6 +505,18 @@ function selectExecutorForStep(description, session) {
   return fallback;
 }
 
+// The manager runs on the same host filesystem as the workspace directory
+// (this is the same local file wiki__profile_update writes to via its
+// volume-mounted container), so read it fresh on every turn instead of
+// 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;
+}
+
 export function buildAgentSystemPrompt(state) {
   const workspace = state.session.workspace ?? 'no workspace selected';
   const wikirc = state.session.wikirc?.profile ?? 'no profile loaded';
@@ -430,10 +524,12 @@ export function buildAgentSystemPrompt(state) {
   const mcpTools = formatMcpToolsForAgent(state.session.mcp);
   const skills = formatSkillsForAgent(state.session);
   const customPrompt = state.session.systemPrompt ?? null;
+  const workspaceProfile = loadWorkspaceProfile(state.session.workspacePath);
 
   const agentContext = [
     'You are Donna, the terminal orchestrator agent for llm-wiki-manager.',
     'The shell is agent-first: every input without a leading slash is routed to you.',
+    'Default to a plain conversational reply with no tool call. Only call a tool, create a plan, or start a job when the user\'s message clearly requests an action (ingest, build, export, configure, run a skill, check a concrete status, etc.). Greetings, small talk, thanks, and general questions do not warrant starting a job or calling a tool — just answer in text.',
     'Commands starting with / are deterministic primitives. You may run a safe subset through shell__run_command.',
     `Reply language: ${language}.`,
     `Current workspace: ${workspace}.`,
@@ -488,7 +584,11 @@ export function buildAgentSystemPrompt(state) {
     'If production_start_job is returned as queued/waiting by the manager, report that it is waiting in the local queue and return control. Do not continue as if the production job has started.',
     'For diagnostics, use /wiki run doctor when the user asks for doctor. Use /workspace init <name> [path] for low-level non-interactive workspace creation. In the interactive TUI, /new <name> opens the setup wizard. Use /wiki for index, or /wiki run index through the explicit backup hatch. Use /wiki run init only for explicit current-workspace llm-wiki init.',
     'If an action requires tools or skills not available yet, explain the limitation and name the expected primitive.',
-  ].join('\n');
+    workspaceProfile
+      ? `Workspace profile (.wiki/profile.md) — durable user preferences, apply these to every reply (tone, tutoiement/vouvoiement, formatting, etc.):\n${workspaceProfile}`
+      : null,
+    'When the user explicitly asks you to remember, persist, or update durable preference/profile information, call wiki__profile_update when it is available; otherwise call shell__profile_update. Do not just acknowledge in text without calling a profile update tool.',
+  ].filter(Boolean).join('\n');
 
   return customPrompt ? `${customPrompt}\n\n${agentContext}` : agentContext;
 }
@@ -512,12 +612,17 @@ export function buildLimitedAgentResponse(state, reason = 'no workspace loaded w
   ].join('\n');
 }
 
+export function formatLlmUnavailableMessage(reason) {
+  const clean = String(reason ?? 'raison inconnue').replace(/\s+/g, ' ').trim();
+  return `⚠ LLM injoignable : ${clean || 'raison inconnue'}`;
+}
+
 export function createAgentGraph(options = {}) {
   async function orchestratorNode(state) {
     const llm = state.session.llm ?? options.llm ?? null;
 
     if (!llm) {
-      return { response: buildLimitedAgentResponse(state), pendingToolCalls: null, readyToStream: false };
+      return { response: formatLlmUnavailableMessage('aucun client LLM configure'), pendingToolCalls: null, readyToStream: false };
     }
 
     const iterations = state.toolIterations ?? 0;
@@ -535,12 +640,15 @@ export function createAgentGraph(options = {}) {
       state.session._onStep?.('Agent: planning next action…');
     }
 
-    const tools = [
+    const allTools = [
       SHELL_RUN_COMMAND_TOOL,
+      SHELL_READ_COMMAND_TOOL,
+      SHELL_PROFILE_UPDATE_TOOL,
       WIKI_PLAN_SET_TOOL,
       WIKI_PLAN_DONE_TOOL,
       ...buildLlmTools(state.session.mcp),
     ];
+    const tools = allTools;
     const system = buildAgentSystemPrompt(state);
 
     // On iteration 0: prior history is in state.messages, user input must be appended.
@@ -619,7 +727,7 @@ export function createAgentGraph(options = {}) {
     } catch (err) {
       if (err.name === 'AbortError') throw err;
       const message = err instanceof Error ? err.message : String(err);
-      return { response: buildLimitedAgentResponse(state, `LLM unavailable: ${message}`), pendingToolCalls: null, readyToStream: false };
+      return { response: formatLlmUnavailableMessage(message), pendingToolCalls: null, readyToStream: false };
     }
   }
 
@@ -663,6 +771,11 @@ export function createAgentGraph(options = {}) {
         } else if (server === 'shell' && tool === 'run_command') {
           await awaitRunApproval(state.session, { runId, tool: toolName });
           resultText = await runShellCommandTool(state.session, args.command);
+        } else if (server === 'shell' && tool === 'read_command') {
+          resultText = await runShellReadCommandTool(state.session, args.command);
+        } else if (server === 'shell' && tool === 'profile_update') {
+          const result = await updateWorkspaceProfilePreference(state.session, args.preference);
+          resultText = JSON.stringify(result, null, 2);
         } else if (server !== 'shell') {
           await awaitRunApproval(state.session, { runId, tool: toolName });
           await awaitToolApproval(state.session, {

package/src/agent/graph.test.js

@@ -1,6 +1,9 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
-import { createAgentGraph } from './graph.js';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { buildAgentSystemPrompt, createAgentGraph } from './graph.js';
 
 function sessionBase(overrides = {}) {
   return {
@@ -99,6 +102,160 @@ test('agent graph waits for run-level approval before first MCP action', async (
   }
 });
 
+test('agent graph reports LLM unavailable without Donna active boilerplate', async () => {
+  const agent = createAgentGraph();
+  const result = await agent.invoke({ input: 'salut', session: sessionBase({ llm: null }) });
+
+  assert.equal(result.response, '⚠ LLM injoignable : aucun client LLM configure');
+  assert.doesNotMatch(result.response, /Donna is active/);
+});
+
+test('agent graph binds the full toolset and lets Donna decide whether to call tools', async () => {
+  const seenTools = [];
+  const session = sessionBase({
+    llm: {
+      async completeWithTools({ tools }) {
+        seenTools.push(...tools.map((tool) => tool.function.name));
+        return {
+          content: 'Salut, je suis là.',
+          message: { role: 'assistant', content: 'Salut, je suis là.' },
+          tool_calls: null,
+        };
+      },
+    },
+  });
+
+  const agent = createAgentGraph();
+  const result = await agent.invoke({ input: 'salut', session });
+
+  assert.equal(result.response, 'Salut, je suis là.');
+  assert.ok(seenTools.length > 0);
+  assert.ok(seenTools.includes('shell__read_command'));
+  assert.ok(seenTools.includes('shell__run_command'));
+  assert.ok(seenTools.includes('shell__profile_update'));
+  assert.ok(seenTools.includes('wiki__plan_set'));
+  assert.ok(seenTools.includes('wiki__plan_done'));
+  assert.equal(session.headlessPlan ?? null, null);
+  assert.equal(Object.keys(session.activities ?? {}).length, 0);
+});
+
+test('agent graph does not pre-filter mutating MCP tools for config questions', async () => {
+  const seenTools = [];
+  const session = sessionBase({
+    mcp: {
+      production: {
+        status: 'connected',
+        url: 'http://127.0.0.1:3000/mcp/',
+        tools: [
+          {
+            name: 'production_start_job',
+            description: 'Start production job',
+            inputSchema: { type: 'object', properties: { type: { type: 'string' } } },
+          },
+          {
+            name: 'production_job_status',
+            description: 'Read production job status',
+            inputSchema: { type: 'object', properties: { jobId: { type: 'string' } } },
+          },
+        ],
+      },
+    },
+    llm: {
+      async completeWithTools({ tools }) {
+        seenTools.push(...tools.map((tool) => tool.function.name));
+        return {
+          content: 'Le profil actif est docs.',
+          message: { role: 'assistant', content: 'Le profil actif est docs.' },
+          tool_calls: null,
+        };
+      },
+    },
+  });
+
+  const agent = createAgentGraph();
+  const result = await agent.invoke({ input: 'quel est le profil actif ?', session });
+
+  assert.equal(result.response, 'Le profil actif est docs.');
+  assert.ok(seenTools.includes('shell__read_command'));
+  assert.ok(seenTools.includes('production__production_job_status'));
+  assert.ok(seenTools.includes('wiki__plan_set'));
+  assert.ok(seenTools.includes('production__production_start_job'));
+  assert.ok(seenTools.includes('shell__run_command'));
+});
+
+test('agent graph binds the full toolset for a "remember my preference" request, not just read-only tools', async () => {
+  const seenTools = [];
+  const session = sessionBase({
+    mcp: {
+      wiki: {
+        status: 'connected',
+        url: 'http://127.0.0.1:3001/mcp/',
+        tools: [
+          {
+            name: 'profile_read',
+            description: 'Read the workspace profile from .wiki/profile.md.',
+            inputSchema: { type: 'object', properties: {} },
+          },
+          {
+            name: 'profile_update',
+            description: 'Write the workspace profile to .wiki/profile.md.',
+            inputSchema: { type: 'object', properties: { content: { type: 'string' } } },
+          },
+        ],
+      },
+    },
+    llm: {
+      async completeWithTools({ tools }) {
+        seenTools.push(...tools.map((tool) => tool.function.name));
+        return {
+          content: 'Noté, je retiens cette préférence.',
+          message: { role: 'assistant', content: 'Noté, je retiens cette préférence.' },
+          tool_calls: null,
+        };
+      },
+    },
+  });
+
+  const agent = createAgentGraph();
+  const result = await agent.invoke({ input: 'retiens que je préfère des réponses courtes', session });
+
+  assert.equal(result.response, 'Noté, je retiens cette préférence.');
+  // profile_update is a write tool (doesn't match the read-only name pattern)
+  // and "retiens" doesn't appear in the config/status read-only phrasing —
+  // without action-intent coverage for remember/save/update requests, this
+  // tool would silently never be offered to the LLM at all.
+  assert.ok(seenTools.includes('wiki__profile_update'));
+  assert.ok(seenTools.includes('wiki__profile_read'));
+  assert.ok(seenTools.includes('shell__profile_update'));
+});
+
+test('buildAgentSystemPrompt includes .wiki/profile.md content so preferences apply without a tool call', () => {
+  const workspacePath = mkdtempSync(join(tmpdir(), 'donna-profile-'));
+  mkdirSync(join(workspacePath, '.wiki'), { recursive: true });
+  writeFileSync(
+    join(workspacePath, '.wiki', 'profile.md'),
+    '# Workspace Profile\n\n## User Preferences\n\n- Tutoiement : me tutoyer\n',
+  );
+  try {
+    const prompt = buildAgentSystemPrompt({
+      session: sessionBase({ workspacePath }),
+    });
+    assert.match(prompt, /Tutoiement : me tutoyer/);
+  } finally {
+    rmSync(workspacePath, { recursive: true, force: true });
+  }
+});
+
+test('buildAgentSystemPrompt omits the profile section when profile.md is missing or empty', () => {
+  const workspacePath = mkdtempSync(join(tmpdir(), 'donna-profile-empty-'));
+  try {
+    const prompt = buildAgentSystemPrompt({ session: sessionBase({ workspacePath }) });
+    assert.doesNotMatch(prompt, /Workspace profile \(\.wiki\/profile\.md\)/);
+  } finally {
+    rmSync(workspacePath, { recursive: true, force: true });
+  }
+});
+
 test('agent graph waits for tool-level approval configured on endpoint', async () => {
   const originalFetch = globalThis.fetch;
   globalThis.fetch = async () => ({

package/src/cli/wiki-manager.js

@@ -29,6 +29,11 @@ function valueAfter(argv, flag) {
   return argv[index + 1];
 }
 
+function unavailableRuntime(err) {
+  const reason = err instanceof Error ? err.message : String(err);
+  return { url: null, error: reason };
+}
+
 function createSession() {
   return {
     workspace: null,
@@ -745,7 +750,8 @@ export async function runCli(argv) {
       const { ensureRuntime } = await import('../runtime/lifecycle.js');
       runtime = await ensureRuntime();
     } catch (err) {
-      console.error(`Runtime unavailable: ${err instanceof Error ? err.message : String(err)}`);
+      runtime = unavailableRuntime(err);
+      console.error(`Runtime unavailable: ${runtime.error}`);
     }
     await runOpenTuiShell({ agent, packageJson, runtime });
     return;
@@ -757,7 +763,8 @@ export async function runCli(argv) {
       const { ensureRuntime } = await import('../runtime/lifecycle.js');
       runtime = await ensureRuntime();
     } catch (err) {
-      console.error(`Runtime unavailable: ${err instanceof Error ? err.message : String(err)}`);
+      runtime = unavailableRuntime(err);
+      console.error(`Runtime unavailable: ${runtime.error}`);
     }
   }
   await runShell({ agent, packageJson, runtime });

package/src/commands/slash.js

@@ -655,15 +655,38 @@ export function printHelp(packageJson) {
   console.log(helpText(packageJson));
 }
 
+function rawCommandAgentPrompt(command, output) {
+  return [
+    `L'utilisateur a lancé la commande shell ${command}.`,
+    'Voici la sortie brute collectée par la commande déterministe. Ne relance pas la commande et ne modifie pas les données.',
+    'Réponds à l’utilisateur à partir de ces faits, en appliquant le profil workspace et les préférences de présentation déjà chargés dans ton prompt système.',
+    '',
+    'Sortie brute:',
+    '```text',
+    output || '(empty)',
+    '```',
+  ].join('\n');
+}
+
+function rawCommandResult(command, output) {
+  return {
+    output,
+    rawOutput: true,
+    agentTrigger: rawCommandAgentPrompt(command, output),
+  };
+}
+
 export async function handleSlashCommand(line, context) {
   const args = line.slice(1).trim().split(/\s+/).filter(Boolean);
   const [command] = args;
   const step = context.onStep ?? (() => {});
-  const runAgentCommand = async (fn, verb) => {
+  const runAgentCommand = async (fn, verb, commandLabel) => {
     try {
       step(`Agents: ${verb}ing external agents…`);
       const output = await fn();
-      return { output: output || `Agents ${verb}ed.` };
+      return output
+        ? rawCommandResult(commandLabel, output)
+        : { output: `Agents ${verb}ed.` };
     } catch (err) {
       step(formatActivityError('agents', verb, err));
       return { output: err instanceof Error ? err.message : String(err) };
@@ -808,7 +831,8 @@ export async function handleSlashCommand(line, context) {
       try {
         step('Services: reading compose state…');
         await refreshMcpRuntimeStatus(context.session);
-        return { output: await listServices(context.session) };
+        const output = await listServices(context.session);
+        return rawCommandResult('/services', output);
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         step(formatActivityError('services', 'list', err));
@@ -821,13 +845,13 @@ export async function handleSlashCommand(line, context) {
       // do not remap it to undefined, that bypasses any custom "all" target list and always
       // falls back to the hardcoded COMPOSE_SERVICES constant instead.
       const service = args[1];
-      if (service === 'agents') return runAgentCommand(startAgents, 'start');
+      if (service === 'agents') return runAgentCommand(startAgents, 'start', '/start agents');
       try {
         step(`Services: starting ${service ?? 'workspace services'}…`);
         const output = await startService(context.session, service);
         step('Services: refreshing MCP runtime…');
         await refreshMcpRuntimeStatus(context.session);
-        return { output };
+        return rawCommandResult(`/start${service ? ` ${service}` : ''}`, output);
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         step(formatActivityError('services', 'stop', err));
@@ -836,13 +860,13 @@ export async function handleSlashCommand(line, context) {
     }
     case 'stop': {
       const service = args[1];
-      if (service === 'agents') return runAgentCommand(stopAgents, 'stop');
+      if (service === 'agents') return runAgentCommand(stopAgents, 'stop', '/stop agents');
       try {
         step(`Services: stopping ${service ?? 'workspace services'}…`);
         const output = await stopService(context.session, service);
         step('Services: refreshing MCP runtime…');
         await refreshMcpRuntimeStatus(context.session);
-        return { output };
+        return rawCommandResult(`/stop${service ? ` ${service}` : ''}`, output);
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         step(formatActivityError('services', 'logs', err));
@@ -854,7 +878,8 @@ export async function handleSlashCommand(line, context) {
       const tail = args[2] ? Number(args[2]) : 120;
       try {
         step(`Services: reading logs for ${service ?? 'service'}…`);
-        return { output: await serviceLogs(context.session, service, { tail }) };
+        const output = await serviceLogs(context.session, service, { tail });
+        return rawCommandResult(`/logs ${[service, args[2]].filter(Boolean).join(' ')}`.trim(), output);
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         return { output: message };
@@ -903,7 +928,7 @@ export async function handleSlashCommand(line, context) {
           }
           const activity = formatMcpCallActivity(serverName, toolName, output);
           if (activity) step(activity);
-          return { output };
+          return rawCommandResult(`/mcp call ${serverName} ${toolName}`, output);
         } catch (err) {
           const message = err instanceof Error ? err.message : String(err);
           step(formatActivityError(serverName, toolName, err));
@@ -1056,7 +1081,7 @@ export async function handleSlashCommand(line, context) {
           });
           const activity = formatActivitySummary('wiki', 'index', output);
           if (activity) step(activity);
-          return { output };
+          return rawCommandResult('/wiki', output);
         } catch (err) {
           const message = err instanceof Error ? err.message : String(err);
           step(formatActivityError('wiki', 'index', err));
@@ -1073,7 +1098,7 @@ export async function handleSlashCommand(line, context) {
           });
           const activity = formatActivitySummary('wiki', wikiArgs[0] ?? 'run', output);
           if (activity) step(activity);
-          return { output };
+          return rawCommandResult(`/wiki run ${wikiArgs.join(' ')}`, output);
         }
         return {
           output: [

package/src/core/agentLoop.js

@@ -1,8 +1,8 @@
-import { buildAgentSystemPrompt, buildLimitedAgentResponse } from '../agent/graph.js';
+import { buildAgentSystemPrompt, formatLlmUnavailableMessage } from '../agent/graph.js';
 import { createAgentEvent, dispatchAgentEvent } from './agentEvents.js';
 import { activitySnapshot, newNonTerminalActivities } from './activity.js';
 import { extractHeadlessPlan, formatCompletedActivities, formatPlanStatus } from './plan.js';
-import { formatReadyTaskPrompt, nextReadyPlanTask, readyPlanTasks } from './planPatch.js';
+import { formatReadyTaskPrompt, nextReadyPlanTask, readyPlanTasks, sanitizePlanForExecution } from './planPatch.js';
 
 export function abortError(message = 'Agent run cancelled.') {
   const err = new Error(message);
@@ -31,7 +31,7 @@ export async function runAgentTurn(agent, session, input, {
     if (session._abortSignal === signal) delete session._abortSignal;
   }
   if (result.streamedInline) {
-    return streamedContent.trim() || buildLimitedAgentResponse({ input, session }, 'LLM stream ended without content');
+    return streamedContent.trim() || formatLlmUnavailableMessage('flux vide');
   }
   if (result.response != null) return result.response;
   if (result.readyToStream && session.llm?.stream) {
@@ -44,9 +44,9 @@ export async function runAgentTurn(agent, session, input, {
     })) {
       content += delta;
     }
-    return content.trim() || buildLimitedAgentResponse({ input, session }, 'LLM stream ended without content');
+    return content.trim() || formatLlmUnavailableMessage('flux vide');
   }
-  return buildLimitedAgentResponse({ input, session });
+  return formatLlmUnavailableMessage('reponse vide');
 }
 
 export async function runAgenticLoop(agent, session, initialInput, {
@@ -109,6 +109,7 @@ export async function runAgenticLoop(agent, session, initialInput, {
         onPlanAlreadySet?.({ steps: session.headlessPlan });
       }
     }
+    sanitizeSessionPlan(session, { runId });
 
     const newPending = newNonTerminalActivities(snapshot, session);
     if (newPending.length === 0) {
@@ -158,6 +159,20 @@ export async function runAgenticLoop(agent, session, initialInput, {
   return { ok: false, maxTurns: true };
 }
 
+function sanitizeSessionPlan(session, { runId = null } = {}) {
+  if (!session.headlessPlan) return;
+  const sanitized = sanitizePlanForExecution(session.headlessPlan);
+  if (sanitized.warnings.length === 0) return;
+  session.headlessPlan = sanitized.plan;
+  dispatchAgentEvent(session, createAgentEvent('runtime_log', {
+    origin: 'runtime',
+    runId,
+    payload: {
+      message: `plan warning: ${sanitized.warnings.join('; ')}`,
+    },
+  }));
+}
+
 function pendingStepsPrompt(initialInput, plan, readyTask) {
   return [
     'Original task:',

package/src/core/agentLoop.test.js

@@ -1,7 +1,25 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
 import { createAgentEvent, dispatchAgentEvent } from './agentEvents.js';
-import { runAgenticLoop } from './agentLoop.js';
+import { runAgentTurn, runAgenticLoop } from './agentLoop.js';
+
+test('runAgentTurn returns a one-line LLM error on empty stream', async () => {
+  const session = {
+    commands: [],
+    llm: {
+      async *stream() {},
+    },
+  };
+  const agent = {
+    async invoke() {
+      return { readyToStream: true, streamContext: { messages: [] } };
+    },
+  };
+
+  const response = await runAgentTurn(agent, session, 'salut');
+
+  assert.equal(response, '⚠ LLM injoignable : flux vide');
+});
 
 test('runAgenticLoop waits for new activities and continues with a completion summary', async () => {
   const session = {

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.11.4';
+const WIKI_MANAGER_VERSION = '0.11.7';
 
 function envValue(key) {
   const filePath = managerEnvFile();