@dotdrelle/wiki-manager 0.15.35 → 0.15.40

package/README.md

@@ -556,6 +556,48 @@ 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`.
 
+### Adding a connector from the served chat UI
+
+`mcp.endpoints.json` stays hand-editable, but the Connectors panel of
+`llm-wiki serve` can now write it. Connecting a card there upserts the endpoint
+through the runtime (`POST /mcp/endpoints`), and the runtime immediately
+re-reads the file and rediscovers tools and agents — no restart, and the new
+tools are usable in the same breath by `/chat`, `/agent` and any subsequent
+plan.
+
+Because a server absent from `chatAccess` gets **zero** tools in `/chat`, the
+upsert writes `"allow": "*"` for it. That is the deliberate difference between
+a connector declared by hand — where you choose the tool list — and one added
+from the UI, where the person adding it is the person who will use it. Narrow
+it afterwards by editing the file.
+
+Three origins are distinguished, and the UI labels each card:
+
+| origin | shown as | who owns it |
+| --- | --- | --- |
+| `wiki`, `production`, `llm-wiki`, `wiki-production` | `internal` | the workspace stack. Fields read-only, no delete — the runtime rejects any change to these names |
+| declared in `mcp.endpoints.json` by hand or by `agents up` | `global config` | the operator. CME, Documents, Mailer, Connectors, Exa… |
+| added from the UI | `added here` | carries `"managedBy": "serve-ui"` in the file |
+
+Removing a `global config` connector is a workspace-wide act — it leaves every
+chat, agent and future plan — so the UI says so before confirming. The
+container and its data are untouched; only the wiring is removed. The name is
+also pushed into `disabledMcpServers`, which the scaffold honours, so a
+connector you removed on purpose is not silently restored by the next
+`agents up` merging the packaged example back in.
+
+Renaming is atomic: the UI sends `previousName`, and the endpoint, its
+`Authorization` header and its `chatAccess` entry move together under the new
+key. A rename onto an existing name, or from a name that is not there, is
+rejected rather than half-applied.
+
+`POST /mcp/endpoints` returns **409 while a plan is running** — connector
+wiring must not change under a run that already resolved its agents. The chat
+UI treats that as what it is: the MCP handshake succeeded, so the card stays
+connected and usable in this browser, badged `local only` with
+"runtime synchronization pending", and the write is retried on the next
+reconnect. A busy runtime never presents itself as a broken connector.
+
 MCP `tools/call` requests retry transient HTTP/MCP failures before the run fails.
 They also share a per-endpoint outbound control budget (45 RPM by default,
 configurable with `WIKI_MANAGER_MCP_REQUESTS_PER_MINUTE`). This budget is
@@ -729,6 +771,11 @@ capabilityRouting:
     allowedAgents: [connectors]
 ```
 
+The production agent also advertises `workspace.restore` for Git-backed
+rollback. It is workspace-scoped and remains subject to the normal runtime
+approval and lock checks; it can be pinned in the same way when several agents
+provide that capability.
+
 #### Compose overrides — optional agents, proxies, local fixes
 
 Two override files sit under **`.wiki/compose/`**, one per stack:

package/docker-compose.yml

@@ -124,7 +124,7 @@ services:
       - WORKSPACE_NAME=${WORKSPACE_NAME:-workspace}
       - WIKI_WORKSPACE_PATH=/workspace
       - WIKI_CONFIG_PATH=${WIKI_CONFIG_PATH:-}
-      - PRODUCTION_ALLOWED_STEPS=${PRODUCTION_ALLOWED_STEPS:-doctor,ingest,ingest_plan,ingest_apply,build,export,polish,pipeline}
+      - PRODUCTION_ALLOWED_STEPS=${PRODUCTION_ALLOWED_STEPS:-doctor,ingest,ingest_plan,ingest_apply,build,export,polish,restore,pipeline}
       - PRODUCTION_REQUIRE_CONFIRMATION=${PRODUCTION_REQUIRE_CONFIRMATION:-false}
       # Parallelism levers — effective concurrency ≈ recommendedConcurrency.
       # Intermediate defaults (4/8). Low profile 2/4, high profile 8/16.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotdrelle/wiki-manager",
-  "version": "0.15.35",
+  "version": "0.15.40",
   "description": "Agentic shell and orchestration cockpit for llm-wiki workspaces.",
   "license": "PolyForm-Noncommercial-1.0.0",
   "author": "dotrelle",

package/src/cli/wiki-manager.js

@@ -14,6 +14,7 @@ import { refreshRunningContainers } from '../core/wikiSetup.js';
 import { applySessionWikircProfile } from '../core/sessionConfig.js';
 import { listWikircProfiles } from '../core/wikirc.js';
 import { callMcpTool, formatMcpToolResult, readChatAccessConfig } from '../core/mcp.js';
+import { deleteManagedMcpEndpoint, listManagedMcpEndpoints, upsertManagedMcpEndpoint } from '../core/mcpEndpoints.js';
 import { extractActivity, parseJsonText, sessionActivities, terminalFailures } from '../core/activity.js';
 import { syncActivitiesToPlan, formatPlanStatus } from '../core/plan.js';
 import { createAgentEvent, dispatchAgentEvent, reduceAgentEvents } from '../core/agentEvents.js';
@@ -740,6 +741,14 @@ async function runRuntime(argv, agent) {
   let serverHandle = null;
   const contexts = new Map();
 
+  async function refreshAllMcpContexts() {
+    const resolved = await Promise.all([...new Set(contexts.values())].map((value) => Promise.resolve(value)));
+    await Promise.all(resolved.map(async (context) => {
+      await refreshMcpRuntimeStatus(context.session);
+      await discoverAgentsOnce(context.session);
+    }));
+  }
+
   async function getWorkspaceContext(workspaceName = null) {
     const requestedWorkspace = workspaceName ? String(workspaceName).trim() : null;
     const key = requestedWorkspace ?? '__default__';
@@ -1222,9 +1231,11 @@ async function runRuntime(argv, agent) {
             ),
             requireApprovalForMutations: body.capabilityPlan.requireApproval !== false,
           },
-          ...(Array.isArray(body.capabilityPlan.inputs) && body.capabilityPlan.inputs.length > 0
-            ? { arguments: { inputs: body.capabilityPlan.inputs } }
-            : {}),
+          ...(body.capabilityPlan.arguments && typeof body.capabilityPlan.arguments === 'object'
+            ? { arguments: body.capabilityPlan.arguments }
+            : Array.isArray(body.capabilityPlan.inputs) && body.capabilityPlan.inputs.length > 0
+              ? { arguments: { inputs: body.capabilityPlan.inputs } }
+              : {}),
         })));
         if (!Array.isArray(fragment?.tasks) || fragment.tasks.length === 0) {
           dispatchAgentEvent(session, createAgentEvent('assistant_message', {
@@ -1416,6 +1427,17 @@ async function runRuntime(argv, agent) {
         config,
       };
     },
+    listMcpEndpoints: async () => ({ endpoints: listManagedMcpEndpoints() }),
+    upsertMcpEndpoint: async (_context, body) => {
+      const endpoint = upsertManagedMcpEndpoint(body);
+      await refreshAllMcpContexts();
+      return { ok: true, endpoint };
+    },
+    deleteMcpEndpoint: async (_context, body) => {
+      const endpoint = deleteManagedMcpEndpoint(body.name);
+      await refreshAllMcpContexts();
+      return { ok: true, endpoint };
+    },
     token: auth.token,
   });
   const recovery = await recoverRuntime();

package/src/commands/slash.js

@@ -338,7 +338,7 @@ function workspaceStatsColumns(stats, session) {
   };
 }
 
-function workspaceLoadedText(workspace, summary, session) {
+function workspaceLoadedText(workspace, summary, session, mcpError = null) {
   const profiles = listWikircProfiles(workspace.workspacePath);
   const profileLines = profiles.length > 0
     ? profiles.map((profile) => {
@@ -374,6 +374,7 @@ function workspaceLoadedText(workspace, summary, session) {
     '',
     `llm: ${session.llm ? 'configured' : 'missing config'}`,
     `mcp: ${Object.values(session.mcp ?? {}).filter((value) => value.status === 'connected').length} connected`,
+    ...(mcpError ? ['', `MCP discovery failed: ${mcpError}`] : []),
   ].join('\n');
 }
 
@@ -941,9 +942,17 @@ export async function handleSlashCommand(line, context) {
       context.session.workspaceEnv = workspace.env;
       context.session.workspaceEnvFile = workspace.envFile;
       context.session.systemPrompt = loadWorkspaceSystemPrompt(workspace.workspacePath);
+      let summary;
       try {
         step(`Workspace: loading ${workspace.name} config…`);
-        const { summary } = applySessionWikircProfile(context.session, 'default');
+        ({ summary } = applySessionWikircProfile(context.session, 'default'));
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+          output: workspaceLoadedWithoutConfigText(workspace, message),
+        };
+      }
+      try {
         step(`Workspace: discovering ${workspace.name} MCP tools…`);
         await refreshMcpRuntimeStatus(context.session);
         return {
@@ -952,7 +961,7 @@ export async function handleSlashCommand(line, context) {
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         return {
-          output: workspaceLoadedWithoutConfigText(workspace, message),
+          output: workspaceLoadedText(workspace, summary, context.session, message),
         };
       }
     }

package/src/commands/slash.test.js

@@ -345,6 +345,54 @@ test('/use loads only workspaces and /config use switches wikirc profiles', asyn
   }
 });
 
+test('/use keeps a loaded wikirc when MCP discovery fails', async () => {
+  const root = await mkdtemp(join(tmpdir(), 'wiki-manager-use-mcp-error-'));
+  const registryRoot = join(root, 'registry');
+  const workspacePath = join(root, 'workspace');
+  const registryPath = join(registryRoot, 'demo');
+  mkdirSync(registryPath, { recursive: true });
+  mkdirSync(workspacePath, { recursive: true });
+  mkdirSync(join(root, 'mcp.endpoints.json'));
+  writeFileSync(join(root, '.env'), '', 'utf8');
+  writeFileSync(join(registryPath, '.env'), [
+    'WORKSPACE_NAME=demo',
+    `WIKI_WORKSPACE_PATH=${workspacePath}`,
+    '',
+  ].join('\n'), 'utf8');
+  writeFileSync(join(workspacePath, '.wikirc.yaml'), [
+    'language: fr',
+    'llm:',
+    '  provider: openai-compatible',
+    '  engine: openai',
+    '  model: test-model',
+    '  apiKey: test-key',
+    '',
+  ].join('\n'), 'utf8');
+
+  const previousDir = process.env.WIKI_WORKSPACES_DIR;
+  const previousEnvFile = process.env.WIKI_MANAGER_ENV_FILE;
+  process.env.WIKI_WORKSPACES_DIR = registryRoot;
+  process.env.WIKI_MANAGER_ENV_FILE = join(root, '.env');
+  try {
+    const session = {};
+    const result = await handleSlashCommand('/use demo', {
+      packageJson: { version: 'test' },
+      session,
+    });
+
+    assert.equal(session.wikirc?.profile, 'default');
+    assert.equal(session.wikircConfig?.llm?.model, 'test-model');
+    assert.match(result.output ?? '', /profile: default/);
+    assert.match(result.output ?? '', /MCP discovery failed:.*EISDIR/s);
+    assert.doesNotMatch(result.output ?? '', /Wikirc not loaded/);
+  } finally {
+    if (previousDir === undefined) delete process.env.WIKI_WORKSPACES_DIR;
+    else process.env.WIKI_WORKSPACES_DIR = previousDir;
+    if (previousEnvFile === undefined) delete process.env.WIKI_MANAGER_ENV_FILE;
+    else process.env.WIKI_MANAGER_ENV_FILE = previousEnvFile;
+  }
+});
+
 test('/queue cancel refuses runtime-managed items instead of fake-cancelling locally', async () => {
   // syncRuntimeState replaces session.jobQueue with the runtime queue and tags
   // origin:'runtime' — a local cancel would be reverted by the next SSE sync,

package/src/core/agentEvents.js

@@ -556,6 +556,7 @@ function applyEvent(state, event) {
         status: 'queued',
         createdAt: event.payload?.createdAt ?? event.ts,
         updatedAt: event.ts,
+        ...(event.payload?.capabilityPlan !== undefined ? { capabilityPlan: event.payload.capabilityPlan } : {}),
       });
       return;
     case 'control_started':

package/src/core/agentEvents.test.js

@@ -364,6 +364,38 @@ test('reduceAgentEvents: control queue is event sourced and follows run status',
   assert.equal(projection.controlQueue[1].status, 'cancelled');
 });
 
+test('reduceAgentEvents: control_enqueued preserves a structured capabilityPlan across replay', () => {
+  const capabilityPlan = {
+    capability: 'workspace.restore',
+    operation: 'restore',
+    arguments: { run: 'abc123' },
+    requireApproval: true,
+  };
+  const projection = reduceAgentEvents([
+    createAgentEvent('control_enqueued', {
+      origin: 'runtime',
+      workspace: 'docs',
+      payload: {
+        id: 'control-restore',
+        workspace: 'docs',
+        input: 'restore',
+        createdAt: '2026-01-01T00:00:00.000Z',
+        capabilityPlan,
+      },
+    }),
+    createAgentEvent('control_started', {
+      origin: 'runtime',
+      runId: 'run-control-restore',
+      workspace: 'docs',
+      payload: { id: 'control-restore', runId: 'run-control-restore' },
+    }),
+  ]);
+
+  const item = projection.controlQueue.find((entry) => entry.id === 'control-restore');
+  assert.deepEqual(item.capabilityPlan, capabilityPlan);
+  assert.equal(item.status, 'running');
+});
+
 test('reduceAgentEvents: activity-owned plan is used when no orchestrator plan exists', () => {
   const projection = reduceAgentEvents([
     createAgentEvent('activity_upserted', {

package/src/core/buildInfo.json

@@ -1,4 +1,4 @@
 {
-  "version": "0.15.35",
-  "commit": "9bca2fd"
+  "version": "0.15.40",
+  "commit": "49ea8ff"
 }

package/src/core/dockerCompose.test.js

@@ -19,6 +19,14 @@ test('workspace compose does not start a per-workspace agent runtime', async ()
   );
 });
 
+test('workspace production agent enables restore by default', async () => {
+  const raw = await readFile(new URL('../../docker-compose.yml', import.meta.url), 'utf8');
+  const compose = YAML.parse(raw);
+  const allowed = compose.services['production-mcp'].environment
+    .find((entry) => String(entry).startsWith('PRODUCTION_ALLOWED_STEPS='));
+  assert.match(String(allowed), /(?:^|,)restore(?:,|})/);
+});
+
 test('shipped compose files never carry a build context', async () => {
   // Ces deux fichiers partent dans le paquet npm, où les dépôts frères
   // (`../agent-external/…`) n'existent pas : un `build:` y rend toute commande

package/src/core/env.js

@@ -121,9 +121,10 @@ export function ensureManagerScaffold({ log = () => {} } = {}) {
           const missing = Object.keys(example).filter((key) => !(key in current));
           const currentServers = current.mcpServers;
           const exampleServers = example.mcpServers;
+          const disabledServers = new Set(Array.isArray(current.disabledMcpServers) ? current.disabledMcpServers.map(String) : []);
           const missingServers = currentServers && typeof currentServers === 'object' && !Array.isArray(currentServers)
             && exampleServers && typeof exampleServers === 'object' && !Array.isArray(exampleServers)
-            ? Object.keys(exampleServers).filter((key) => !(key in currentServers))
+            ? Object.keys(exampleServers).filter((key) => !(key in currentServers) && !disabledServers.has(key))
             : [];
           if (missing.length > 0) {
             for (const key of missing) current[key] = example[key];

package/src/core/env.test.js

@@ -102,6 +102,20 @@ test('scaffold never overwrites an existing chatAccess, including explicit null'
   });
 });
 
+test('scaffold does not restore a packaged MCP explicitly removed in the UI', () => {
+  withTempManagerDir((dir) => {
+    const endpointsFile = join(dir, 'mcp.endpoints.json');
+    writeFileSync(endpointsFile, JSON.stringify({
+      mcpServers: {},
+      disabledMcpServers: ['cme'],
+    }, null, 2));
+    ensureManagerScaffold();
+    const after = JSON.parse(readFileSync(endpointsFile, 'utf8'));
+    assert.equal(after.mcpServers.cme, undefined);
+    assert.ok(after.mcpServers.documents);
+  });
+});
+
 test('scaffold leaves an invalid endpoints file strictly alone', () => {
   withTempManagerDir((dir) => {
     const endpointsFile = join(dir, 'mcp.endpoints.json');

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

package/src/core/mcp.test.js

@@ -1,5 +1,6 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
+import './mcpEndpoints.test.js';
 import { mkdtemp, writeFile } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';

package/src/core/mcpEndpoints.js

@@ -0,0 +1,96 @@
+import { chmodSync, existsSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { managerMcpEndpointsFile } from './env.js';
+
+const PROTECTED_SERVERS = new Set(['wiki', 'production', 'llm-wiki', 'wiki-production']);
+
+function readDocument() {
+  const filePath = managerMcpEndpointsFile();
+  const raw = existsSync(filePath) ? JSON.parse(readFileSync(filePath, 'utf8')) : {};
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+    throw new Error('mcp.endpoints.json must contain a JSON object.');
+  }
+  raw.mcpServers ??= {};
+  raw.disabledMcpServers = Array.isArray(raw.disabledMcpServers)
+    ? raw.disabledMcpServers.map(String).filter(Boolean)
+    : [];
+  raw.chatAccess ??= { maxToolIterations: 8, servers: {} };
+  raw.chatAccess.servers ??= {};
+  return { filePath, raw };
+}
+
+function writeDocument(filePath, raw) {
+  const temporary = `${filePath}.tmp.${process.pid}`;
+  writeFileSync(temporary, `${JSON.stringify(raw, null, 2)}\n`, { mode: 0o600 });
+  chmodSync(temporary, 0o600);
+  renameSync(temporary, filePath);
+}
+
+function normalizeName(value) {
+  const name = String(value ?? '').trim();
+  if (!name || name.length > 80 || !/^[A-Za-z0-9][A-Za-z0-9_.-]*$/.test(name)) {
+    throw new Error('MCP server name must use letters, numbers, dots, underscores or hyphens.');
+  }
+  if (PROTECTED_SERVERS.has(name)) throw new Error(`Built-in MCP server cannot be changed: ${name}`);
+  return name;
+}
+
+function normalizeUrl(value) {
+  const url = String(value ?? '').trim();
+  let parsed;
+  try { parsed = new URL(url); } catch { throw new Error('MCP server URL is invalid.'); }
+  if (!['http:', 'https:'].includes(parsed.protocol)) throw new Error('MCP server URL must use HTTP or HTTPS.');
+  return url;
+}
+
+export function listManagedMcpEndpoints() {
+  const { raw } = readDocument();
+  return Object.entries(raw.mcpServers).map(([name, endpoint]) => ({
+    name,
+    url: String(endpoint?.url ?? ''),
+    bearer: String(endpoint?.headers?.Authorization ?? endpoint?.headers?.authorization ?? '').replace(/^Bearer\s+/i, ''),
+    allow: raw.chatAccess?.servers?.[name]?.allow ?? null,
+  }));
+}
+
+export function upsertManagedMcpEndpoint({ name: rawName, previousName: rawPreviousName = null, url: rawUrl, bearer = '' } = {}) {
+  const name = normalizeName(rawName);
+  const previousName = rawPreviousName ? normalizeName(rawPreviousName) : name;
+  const url = normalizeUrl(rawUrl);
+  const { filePath, raw } = readDocument();
+  if (previousName !== name && !Object.hasOwn(raw.mcpServers, previousName)) {
+    throw new Error(`MCP server to rename was not found: ${previousName}`);
+  }
+  if (previousName !== name && Object.hasOwn(raw.mcpServers, name)) {
+    throw new Error(`MCP server already exists: ${name}`);
+  }
+  const previous = raw.mcpServers[previousName] && typeof raw.mcpServers[previousName] === 'object'
+    ? raw.mcpServers[previousName]
+    : {};
+  const headers = { ...(previous.headers ?? {}) };
+  delete headers.authorization;
+  delete headers.Authorization;
+  if (String(bearer).trim()) headers.Authorization = `Bearer ${String(bearer).trim()}`;
+  const managedBy = previous.managedBy === 'serve-ui' ? 'serve-ui' : (Object.keys(previous).length ? null : 'serve-ui');
+  raw.mcpServers[name] = { ...previous, url, ...(managedBy ? { managedBy } : {}), ...(Object.keys(headers).length ? { headers } : {}) };
+  if (!Object.keys(headers).length) delete raw.mcpServers[name].headers;
+  if (previousName !== name) {
+    delete raw.mcpServers[previousName];
+    delete raw.chatAccess.servers[previousName];
+    if (!raw.disabledMcpServers.includes(previousName)) raw.disabledMcpServers.push(previousName);
+  }
+  raw.chatAccess.servers[name] = { allow: '*' };
+  raw.disabledMcpServers = raw.disabledMcpServers.filter((item) => item !== name);
+  writeDocument(filePath, raw);
+  return { name, previousName, url, allow: '*', hasBearer: Boolean(String(bearer).trim()), origin: managedBy ? 'ui' : 'global' };
+}
+
+export function deleteManagedMcpEndpoint(rawName) {
+  const name = normalizeName(rawName);
+  const { filePath, raw } = readDocument();
+  const existed = Object.hasOwn(raw.mcpServers, name);
+  delete raw.mcpServers[name];
+  delete raw.chatAccess.servers[name];
+  if (!raw.disabledMcpServers.includes(name)) raw.disabledMcpServers.push(name);
+  writeDocument(filePath, raw);
+  return { name, deleted: existed };
+}

package/src/core/mcpEndpoints.test.js

@@ -0,0 +1,126 @@
+import assert from 'node:assert/strict';
+import { readFileSync, writeFileSync } from 'node:fs';
+import { mkdtemp } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test from 'node:test';
+import { deleteManagedMcpEndpoint, listManagedMcpEndpoints, upsertManagedMcpEndpoint } from './mcpEndpoints.js';
+import { buildMcpStatus, discoverMcpTools, resetMcpSessionsForTests } from './mcp.js';
+import { chatAllowedTools } from '../shell/repl.js';
+import { buildAgentSystemPrompt } from '../agent/graph.js';
+
+async function withEndpoints(fn) {
+  const root = await mkdtemp(join(tmpdir(), 'wiki-manager-mcp-endpoints-'));
+  const envFile = join(root, '.env');
+  writeFileSync(envFile, '', 'utf8');
+  writeFileSync(join(root, 'mcp.endpoints.json'), JSON.stringify({
+    mcpServers: { cme: { url: 'http://localhost:3336/mcp/' } },
+    chatAccess: { maxToolIterations: 8, servers: { cme: { allow: ['cme_status'] } } },
+  }), 'utf8');
+  const previous = process.env.WIKI_MANAGER_ENV_FILE;
+  process.env.WIKI_MANAGER_ENV_FILE = envFile;
+  try { await fn(root); } finally {
+    if (previous === undefined) delete process.env.WIKI_MANAGER_ENV_FILE;
+    else process.env.WIKI_MANAGER_ENV_FILE = previous;
+  }
+}
+
+test('UI-managed MCP endpoints persist with bearer auth and chat wildcard access', async () => {
+  await withEndpoints(async (root) => {
+    upsertManagedMcpEndpoint({ name: 'exa', url: 'https://mcp.exa.ai/mcp', bearer: 'secret' });
+    const raw = JSON.parse(readFileSync(join(root, 'mcp.endpoints.json'), 'utf8'));
+    assert.equal(raw.mcpServers.exa.url, 'https://mcp.exa.ai/mcp');
+    assert.equal(raw.mcpServers.exa.headers.Authorization, 'Bearer secret');
+    assert.equal(raw.chatAccess.servers.exa.allow, '*');
+    assert.deepEqual(listManagedMcpEndpoints().find((item) => item.name === 'exa'), {
+      name: 'exa', url: 'https://mcp.exa.ai/mcp', bearer: 'secret', allow: '*',
+    });
+  });
+});
+
+test('deleting an external MCP removes endpoint and chat access without touching others', async () => {
+  await withEndpoints(async (root) => {
+    upsertManagedMcpEndpoint({ name: 'exa', url: 'https://mcp.exa.ai/mcp' });
+    assert.equal(deleteManagedMcpEndpoint('cme').deleted, true);
+    const raw = JSON.parse(readFileSync(join(root, 'mcp.endpoints.json'), 'utf8'));
+    assert.equal(raw.mcpServers.cme, undefined);
+    assert.equal(raw.chatAccess.servers.cme, undefined);
+    assert.deepEqual(raw.disabledMcpServers, ['cme']);
+    assert.equal(raw.mcpServers.exa.url, 'https://mcp.exa.ai/mcp');
+    upsertManagedMcpEndpoint({ name: 'cme', url: 'http://localhost:3336/mcp/' });
+    const restored = JSON.parse(readFileSync(join(root, 'mcp.endpoints.json'), 'utf8'));
+    assert.deepEqual(restored.disabledMcpServers, []);
+  });
+});
+
+test('built-in workspace MCP endpoints cannot be changed from the connectors UI', async () => {
+  await withEndpoints(async () => {
+    assert.throws(() => deleteManagedMcpEndpoint('llm-wiki'), /cannot be changed/);
+    assert.throws(
+      () => upsertManagedMcpEndpoint({ name: 'wiki-production', url: 'https://example.test/mcp' }),
+      /cannot be changed/,
+    );
+  });
+});
+
+test('renaming a persisted MCP moves endpoint, chat access and deletion identity atomically', async () => {
+  await withEndpoints(async (root) => {
+    upsertManagedMcpEndpoint({ name: 'exa', url: 'https://mcp.exa.ai/mcp', bearer: 'first' });
+    const renamed = upsertManagedMcpEndpoint({
+      name: 'exa-search', previousName: 'exa', url: 'https://mcp.exa.ai/mcp', bearer: 'second',
+    });
+    assert.equal(renamed.previousName, 'exa');
+    const raw = JSON.parse(readFileSync(join(root, 'mcp.endpoints.json'), 'utf8'));
+    assert.equal(raw.mcpServers.exa, undefined);
+    assert.equal(raw.chatAccess.servers.exa, undefined);
+    assert.equal(raw.mcpServers['exa-search'].headers.Authorization, 'Bearer second');
+    assert.equal(raw.chatAccess.servers['exa-search'].allow, '*');
+    assert.ok(raw.disabledMcpServers.includes('exa'));
+  });
+});
+
+test('a UI-added MCP is rediscovered for both chat wildcard and direct agent tools', async () => {
+  await withEndpoints(async () => {
+    upsertManagedMcpEndpoint({ name: 'exa', url: 'https://mcp.exa.ai/mcp', bearer: 'secret' });
+    const originalFetch = globalThis.fetch;
+    const seenAuthorization = [];
+    resetMcpSessionsForTests();
+    globalThis.fetch = async (_url, init) => {
+      const body = JSON.parse(init.body);
+      seenAuthorization.push(init.headers.authorization);
+      if (body.method === 'initialize') {
+        return {
+          ok: true, status: 200,
+          headers: { get: (name) => name === 'mcp-session-id' ? 'exa-session' : null },
+          text: async () => '{"jsonrpc":"2.0","id":1,"result":{"protocolVersion":"2025-06-18"}}',
+        };
+      }
+      if (body.method === 'notifications/initialized') {
+        return { ok: true, status: 202, headers: { get: () => null }, text: async () => '' };
+      }
+      return {
+        ok: true, status: 200, headers: { get: () => null },
+        text: async () => JSON.stringify({
+          jsonrpc: '2.0', id: 2,
+          result: { tools: [
+            { name: 'web_search_exa', inputSchema: { type: 'object', properties: {} } },
+            { name: 'get_code_context_exa', inputSchema: { type: 'object', properties: {} } },
+          ] },
+        }),
+      };
+    };
+    try {
+      const session = { workspace: 'docs', workspaceEnv: {}, wikircConfig: {}, commands: [] };
+      session.mcp = await discoverMcpTools(buildMcpStatus(session));
+      const chatTools = chatAllowedTools(session).map((tool) => tool.function.name).sort();
+      assert.deepEqual(chatTools, ['exa__get_code_context_exa', 'exa__web_search_exa']);
+      const agentPrompt = buildAgentSystemPrompt({ session });
+      assert.match(agentPrompt, /exa__web_search_exa/);
+      assert.match(agentPrompt, /exa__get_code_context_exa/);
+      assert.ok(seenAuthorization.includes('Bearer secret'));
+    } finally {
+      globalThis.fetch = originalFetch;
+      resetMcpSessionsForTests();
+    }
+  });
+});

package/src/core/wikiWorkspace.test.js

@@ -88,6 +88,13 @@ test('workspace creation keeps mutable manager files outside the installed packa
   assert.match(source, /WIKI_MANAGER_ENDPOINTS_FILE: managerMcpEndpointsFile\(\)/);
 });
 
+test('wiki-workspace rejects an MCP endpoints directory instead of copying into it', async () => {
+  const script = await readFile(new URL('../../wiki-workspace', import.meta.url), 'utf8');
+
+  assert.match(script, /\[\[ -e "\$MANAGER_ENDPOINTS_FILE" && ! -f "\$MANAGER_ENDPOINTS_FILE" \]\]/);
+  assert.match(script, /MCP endpoints path is not a file/);
+});
+
 test('container refresh pulls and renews only services that are already running', async () => {
   const script = await readFile(new URL('../../wiki-workspace', import.meta.url), 'utf8');
 

package/src/orchestrator/agentRegistry.js

@@ -15,10 +15,22 @@ export function createAgentRegistry({
   return {
     async discover(session, { signal = null } = {}) {
       const discovered = [];
-      for (const [serverName, endpoint] of Object.entries(session?.mcp ?? {})) {
+      const endpoints = Object.entries(session?.mcp ?? {});
+      const activeServers = new Set(endpoints.map(([serverName]) => serverName));
+      for (const [serverName, endpoint] of endpoints) {
         const agent = await discoverServerAgent(session, serverName, endpoint, { callTool, signal, now });
         discovered.push(registerAgent(session, agent, { agentsByInstance, instanceByServer }));
       }
+      for (const [serverName, instanceId] of instanceByServer) {
+        if (activeServers.has(serverName)) continue;
+        const previous = agentsByInstance.get(instanceId);
+        instanceByServer.delete(serverName);
+        agentsByInstance.delete(instanceId);
+        if (previous) dispatchRegistryEvent(session, 'agent.unregistered', {
+          agentInstanceId: instanceId,
+          serverName,
+        });
+      }
       session.agentRegistry = this;
       session.agentRegistrySnapshot = this.snapshot();
       return discovered;

package/src/orchestrator/agentRegistry.test.js

@@ -85,6 +85,26 @@ test('agentRegistry records legacy visible agents when no contract tool exists',
   assert.equal(agent.health, 'available');
 });
 
+test('agentRegistry removes a server that disappeared during MCP refresh', async () => {
+  const events = [];
+  const session = {
+    mcp: {
+      cme: { status: 'connected', tools: [{ name: 'cme_status' }] },
+      exa: { status: 'connected', tools: [{ name: 'web_search_exa' }] },
+    },
+    _onAgentEvent: (event) => events.push(event),
+  };
+  const registry = createAgentRegistry({ callTool: async () => assert.fail('no contract tool expected') });
+  await registry.discover(session);
+  assert.deepEqual(registry.snapshot().map((agent) => agent.serverName), ['cme', 'exa']);
+
+  delete session.mcp.cme;
+  await registry.discover(session);
+
+  assert.deepEqual(registry.snapshot().map((agent) => agent.serverName), ['exa']);
+  assert.ok(events.some((event) => event.type === 'agent.unregistered' && event.payload.serverName === 'cme'));
+});
+
 test('agentRegistry marks unavailable boot agents and emits health changes on re-scan', async () => {
   const events = [];
   let health = 'unavailable';

package/src/orchestrator/dispatcher.js

@@ -53,7 +53,7 @@ export async function execute(task, assignment, {
       session.mcp,
       serverName,
       executeTool,
-      executeRequest(task, session),
+      executeRequest(task, session, runId),
       signal,
     ));
     if (accepted?.accepted === false || accepted?.ok === false) {
@@ -157,9 +157,11 @@ export async function execute(task, assignment, {
   }
 }
 
-function executeRequest(task, session) {
+function executeRequest(task, session, runId) {
   return {
     taskId: String(task.id ?? task.step),
+    ...(runId ? { runId: String(runId) } : {}),
+    ...(task.requiredCapability ? { capability: String(task.requiredCapability) } : {}),
     idempotencyKey: task.idempotencyKey ?? undefined,
     operation: task.operation,
     workspace: workspaceRequest(session),

package/src/orchestrator/dispatcher.test.js

@@ -33,6 +33,39 @@ test('dispatcher returns a retryable logical failure when agent_execute reports
   assert.equal(result.error.retryable, true);
 });
 
+test('dispatcher forwards the orchestration run and required capability to agent_execute', async () => {
+  let executeArgs;
+  const session = {
+    workspace: 'test',
+    mcp: {
+      production: {
+        tools: [{ name: 'agent_execute' }, { name: 'agent_status' }, { name: 'agent_cancel' }],
+      },
+    },
+    activities: {},
+  };
+  const dispatcher = createDispatcher({
+    session,
+    pollIntervalMs: 1,
+    callTool: async (_mcp, _server, tool, args) => {
+      if (tool === 'agent_execute') {
+        executeArgs = args;
+        return { accepted: true, jobId: 'job-build', status: 'queued' };
+      }
+      return { jobId: 'job-build', status: 'succeeded', terminal: true, result: { status: 'succeeded' } };
+    },
+  });
+
+  await dispatcher.execute(
+    { id: 'build-a', requiredCapability: 'document.build', operation: 'build', arguments: {} },
+    { serverName: 'production', agentInstanceId: 'production-main' },
+    { runId: 'run-donna-1', attempt: { attemptId: 'build-a:attempt-1', locks: [], release() {} } },
+  );
+
+  assert.equal(executeArgs.runId, 'run-donna-1');
+  assert.equal(executeArgs.capability, 'document.build');
+});
+
 test('dispatcher completes when an executor-only agent reports succeeded', async () => {
   const session = {
     workspace: 'test',

package/src/runtime/server.js

@@ -24,6 +24,9 @@ export function startRuntimeServer({
   approve,
   configProfiles,
   useConfigProfile,
+  listMcpEndpoints,
+  upsertMcpEndpoint,
+  deleteMcpEndpoint,
   listActiveRuns = null,
   exitOnShutdown = process.env.WIKI_MANAGER_RUNTIME_CHILD === '1',
 } = {}) {
@@ -230,6 +233,31 @@ export function startRuntimeServer({
         sendJson(response, 200, result);
         return;
       }
+      if (request.method === 'GET' && url.pathname === '/mcp/endpoints') {
+        const workspace = workspaceFromUrl(url);
+        const context = await resolveContext({ workspace });
+        const result = await listMcpEndpoints?.(context);
+        sendJson(response, 200, result ?? { endpoints: [] });
+        return;
+      }
+      if (request.method === 'POST' && url.pathname === '/mcp/endpoints') {
+        const activeRuns = typeof listActiveRuns === 'function' ? listActiveRuns() : [];
+        if (activeRuns.length > 0) {
+          sendJson(response, 409, { error: 'MCP connectors cannot be changed while a plan is running.' });
+          return;
+        }
+        const { body, context } = await resolveBodyContext(request, url);
+        const action = String(body.action ?? 'upsert').trim().toLowerCase();
+        const result = action === 'delete'
+          ? await deleteMcpEndpoint?.(context, body)
+          : await upsertMcpEndpoint?.(context, body);
+        if (!result) {
+          sendJson(response, 501, { error: 'MCP endpoint management is not supported.' });
+          return;
+        }
+        sendJson(response, 200, result);
+        return;
+      }
       if (request.method === 'GET' && url.pathname === '/events/stream') {
         const workspace = workspaceFromUrl(url);
         const context = workspace ? await resolveContext({ workspace }) : null;
@@ -255,6 +283,27 @@ export function startRuntimeServer({
           }
           validateContractInDev('runRequest', { ...body, input });
           if (context.running) {
+            // A structured capability plan must never degrade into a free-text
+            // control message: its exact arguments and approval policy would
+            // otherwise be discarded by the control lane. It can still be
+            // queued as a future run when the caller explicitly opts in via
+            // intent: 'enqueue' — the control queue carries capabilityPlan
+            // through untouched (see enqueueControlRequest/
+            // startNextControlRequest) instead of collapsing it to text.
+            if (body.capabilityPlan) {
+              if (body.intent === 'enqueue') {
+                const item = enqueueControlRequest(context, input, { capabilityPlan: body.capabilityPlan });
+                void startNextControlRequest(context);
+                sendJson(response, 202, {
+                  accepted: true,
+                  item,
+                  ...controlStatus(context, store),
+                });
+                return;
+              }
+              sendJson(response, 409, { error: 'run_active' });
+              return;
+            }
             // Blind enqueueing made every message typed during a run
             // invisible until the run ended (serve UI symptom: "no result
             // until the job finished or was stopped"). Classify instead:
@@ -602,6 +651,7 @@ export function startRuntimeServer({
     startRuntimeRun(context, {
       input: item.input,
       workspace: item.workspace ?? context.workspace ?? null,
+      ...(item.capabilityPlan !== undefined ? { capabilityPlan: item.capabilityPlan } : {}),
     }, { controlItemId: item.id });
     return true;
   }
@@ -815,7 +865,7 @@ async function handleControlMessage(context, store, input, { intent = null, star
     : controlMessage(context?.session, 'converse_while_idle'));
 }
 
-function enqueueControlRequest(context, input) {
+function enqueueControlRequest(context, input, { capabilityPlan } = {}) {
   const now = new Date().toISOString();
   const item = {
     id: `control-${randomUUID()}`,
@@ -825,6 +875,7 @@ function enqueueControlRequest(context, input) {
     status: 'queued',
     createdAt: now,
     updatedAt: now,
+    ...(capabilityPlan !== undefined ? { capabilityPlan } : {}),
   };
   dispatchAgentEvent(context.session, createAgentEvent('control_enqueued', {
     origin: 'runtime',

package/src/runtime/server.test.js

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

package/src/shell/LeftPane.tsx

@@ -139,20 +139,52 @@ function WelcomeHelpPanels(props: { width: number }) {
   );
 }
 
-const COPY_BTN = ' [ copy ]';
+const COPY_BTN = '  copy';
+
+/**
+ * Barre de gouttière, préfixée à chaque ligne d'un message.
+ *
+ * Remplace le filet horizontal pleine largeur qui ouvrait chaque message.
+ * Celui-ci était l'élément le plus encré de l'écran, répété à chaque tour, et
+ * il séparait là où il fallait grouper : rien n'indiquait où un bloc finissait,
+ * seulement où le suivant commençait. Une barre colorée porte la même
+ * information — à qui est le tour, où le bloc commence ET où il s'arrête — pour
+ * un caractère par ligne au lieu de toute la largeur.
+ */
+const GUTTER = '▌ ';
+
+function clockLabel(at?: number): string {
+  if (!Number.isFinite(at)) return '';
+  const date = new Date(at as number);
+  return `${String(date.getHours()).padStart(2, '0')}:${String(date.getMinutes()).padStart(2, '0')}`;
+}
 
-function messageHeaderSegments(role: string, columns: number): Segment[] {
-  const label = `[${roleLabel(role)}]`;
-  const left = '── ';
-  const actionsLength = COPY_BTN.length;
-  const rightLength = Math.max(2, columns - left.length - label.length - 1 - actionsLength);
+/**
+ * En-tête d'un message : gouttière, locuteur, heure, et `copy` à droite.
+ *
+ * Le bouton de copie était collé au libellé, précédé d'un filet de soixante-dix
+ * tirets. Poussé au bord droit et dégrisé, il reste atteignable sans peser sur
+ * la ligne. L'heure était reléguée dans une colonne latérale, détachée de ce
+ * qu'elle datait ; elle coûte cinq caractères ici et devient lisible.
+ */
+function messageHeaderSegments(role: string, columns: number, at?: number): Segment[] {
+  const time = clockLabel(at);
+  const label = roleLabel(role);
+  const used = GUTTER.length + label.length + (time ? time.length + 2 : 0);
+  const pad = Math.max(1, columns - used - COPY_BTN.length);
   return [
-    { text: left, color: '#4B5563' },
+    { text: GUTTER, color: roleColor(role) },
     { text: label, color: roleColor(role) },
-    { text: ' ' + '─'.repeat(rightLength), color: '#4B5563' },
+    ...(time ? [{ text: `  ${time}`, color: '#4B5563' }] : []),
+    { text: ' '.repeat(pad), color: '#4B5563' },
   ];
 }
 
+/** Préfixe la gouttière à une ligne de corps de message. */
+function withGutter(line: RenderedLine, role: string): RenderedLine {
+  return { ...line, segments: [{ text: GUTTER, color: roleColor(role) }, ...line.segments] };
+}
+
 // Split "  /cmd [<arg>...]  description" into two segments.
 // Uses non-greedy to stop at the first double-space separator.
 function splitCmdDesc(line: string): [string, string] | null {
@@ -413,21 +445,24 @@ function headerGroupKey(role: string) {
   return isDonnaRole(role) ? 'donna' : roleLabel(role);
 }
 
-function conversationLines(messages: Array<{ role: string; content: string }>, columns: number): RenderedLine[] {
+function conversationLines(messages: Array<{ role: string; content: string; at?: number }>, columns: number): RenderedLine[] {
   return messages.flatMap((message, index) => {
     const raw = String(message.content || '');
     const previous = index > 0 ? messages[index - 1] : null;
     const showHeader = !previous || headerGroupKey(previous.role) !== headerGroupKey(message.role);
+    // Plus de ligne vide sous l'en-tête : le filet et son rembourrage
+    // coûtaient deux lignes par message, en plus de la ligne de séparation.
+    // La gouttière rattache visuellement l'en-tête à son corps, la respiration
+    // entre tours suffit.
     const headerLines: RenderedLine[] = showHeader
-      ? [
-          {
-            segments: messageHeaderSegments(message.role, columns),
-            copyContent: raw,
-          },
-          { segments: [{ text: ' ', color: '#D6DEE8' }] },
-        ]
+      ? [{ segments: messageHeaderSegments(message.role, columns, message.at), copyContent: raw }]
       : [];
-    const contentColumns = message.role === 'user' ? Math.max(12, Math.floor(columns * 0.6) - 2) : columns;
+    // Les messages utilisateur étaient repliés à 60 % de la largeur pour tenir
+    // dans une bulle alignée à droite. Cela coupait les phrases en plein milieu
+    // et faisait repartir l'œil de deux colonnes différentes selon le locuteur.
+    // La couleur de gouttière distingue les tours ; la colonne de lecture reste
+    // unique. On retire aussi la largeur de la gouttière du texte disponible.
+    const contentColumns = Math.max(12, columns - GUTTER.length);
     if (isStatusOutput(message)) {
       const statusLines: RenderedLine[] = [
         ...headerLines,
@@ -454,15 +489,9 @@ function conversationLines(messages: Array<{ role: string; content: string }>, c
       lines.push({ text: line, isCode: inFence });
     }
     const renderedBody = renderMarkdownLines(lines, message.role, contentColumns);
-    const userBubbleWidth = message.role === 'user'
-      ? Math.min(
-          Math.max(1, ...renderedBody.map((line) => line.segments.reduce((sum, segment) => sum + segment.text.length, 0))) + 2,
-          Math.max(12, Math.floor(columns * 0.6)),
-        )
-      : undefined;
     const bodyLines: RenderedLine[] = [
       ...headerLines,
-      ...renderedBody.map((line) => ({ ...line, userBubbleWidth })),
+      ...renderedBody.map((line) => withGutter(line, message.role)),
       { segments: [{ text: ' ', color: '#D6DEE8' }] },
     ];
     return bodyLines.map((line) => ({ ...line, role: message.role }));
@@ -470,7 +499,7 @@ function conversationLines(messages: Array<{ role: string; content: string }>, c
 }
 
 export function ConversationView(props: {
-  messages: Array<{ role: string; content: string }>;
+  messages: Array<{ role: string; content: string; at?: number }>;
   rows: number;
   columns: number;
   scroll: number;
@@ -536,21 +565,6 @@ export function ConversationView(props: {
               </For>
               <text fg="#4B5563" content={COPY_BTN} onMouseUp={() => props.onCopy?.(line.copyContent!)} />
             </box>
-          ) : line.role === 'user' && line.userBubbleWidth ? (
-            <box height={1} flexDirection="row" overflow="hidden">
-              <box flexGrow={1} />
-              <box
-                width={line.userBubbleWidth}
-                height={1}
-                flexDirection="row"
-                flexShrink={1}
-                justifyContent="flex-start"
-                paddingX={1}
-                overflow="hidden"
-              >
-                <text>{styledSegments(line.segments)}</text>
-              </box>
-            </box>
           ) : line.status ? (
             <box height={1} flexDirection="row" gap={2} overflow="hidden">
               <box
@@ -786,7 +800,7 @@ export function LeftPane(props: {
   statusLine: string;
   hintLine?: string | null;
   showWelcome: boolean;
-  messages: Array<{ role: string; content: string }>;
+  messages: Array<{ role: string; content: string; at?: number }>;
   prompt: string;
   input: string;
   busy: boolean;

package/src/shell/repl.js

@@ -169,11 +169,34 @@ export function conversationKey(session) {
   return session.workspace || GLOBAL_CONVERSATION_KEY;
 }
 
+/**
+ * Horodate un message au moment où il entre dans la conversation.
+ *
+ * Posé sur le `push` du tableau plutôt qu'aux trente-deux endroits qui créent
+ * un message : un seul de ces endroits oublié, et la ligne perdrait son heure
+ * sans que rien ne le signale. Un message qui porte déjà `at` — rejoué depuis
+ * l'historique, par exemple — garde le sien.
+ */
+function stampConversation(messages) {
+  if (messages.__stamped) return messages;
+  Object.defineProperty(messages, '__stamped', { value: true });
+  const push = messages.push.bind(messages);
+  Object.defineProperty(messages, 'push', {
+    value: (...entries) =>
+      push(...entries.map((entry) =>
+        entry && typeof entry === 'object' && entry.at === undefined
+          ? Object.assign(entry, { at: Date.now() })
+          : entry,
+      )),
+  });
+  return messages;
+}
+
 export function conversationMessages(session) {
   const key = conversationKey(session);
   session.conversations ??= { [GLOBAL_CONVERSATION_KEY]: [] };
   session.conversations[key] ??= [];
-  return session.conversations[key];
+  return stampConversation(session.conversations[key]);
 }
 
 // Ordered from verifiable to hopeful. Mirrors tui.tsx's clipboardCommands():

package/src/shell/repl.test.js

@@ -31,28 +31,50 @@ test('ShellUI inserts StyledText as a child instead of stringifying it through c
   assert.match(source, /<text[^>]*>\{styledSegments\(line\.segments\)\}<\/text>/);
 });
 
-test('ShellUI renders the user header full-width before constraining only its body', async () => {
+test('every message line carries its speaker gutter, and no full-width rule', async () => {
   const source = await readFile(new URL('./LeftPane.tsx', import.meta.url), 'utf8');
-  const headerBranch = source.indexOf("line.copyContent !== undefined ? (");
-  const userBodyBranch = source.indexOf("line.role === 'user' && line.userBubbleWidth ? (", headerBranch);
-  assert.ok(headerBranch >= 0 && userBodyBranch > headerBranch);
-  assert.match(source, /const userBubbleWidth = message\.role === 'user'/);
-  assert.match(source, /Math\.floor\(columns \* 0\.6\)/);
-  assert.doesNotMatch(source, /Math\.floor\(columns \* 0\.5\)/);
-  assert.match(source.slice(userBodyBranch), /width=\{line\.userBubbleWidth\}/);
-  assert.match(source.slice(userBodyBranch), /justifyContent="flex-start"/);
-  assert.doesNotMatch(source.slice(userBodyBranch, source.indexOf(') : line.status ?', userBodyBranch)), /#12263A/);
-  assert.doesNotMatch(source, /messageHeaderSegments\(message\.role, contentColumns\)/);
-  assert.match(source, /messageHeaderSegments\(message\.role, columns\)/);
+  // Le filet pleine largeur ouvrait chaque message : l'élément le plus encré de
+  // l'écran, répété à chaque tour, et qui séparait au lieu de grouper. La
+  // gouttière dit la même chose — à qui est le tour, où le bloc commence et où
+  // il finit — pour un caractère par ligne.
+  assert.match(source, /const GUTTER = '▌ ';/);
+  assert.match(source, /function withGutter\(/);
+  assert.match(source, /renderedBody\.map\(\(line\) => withGutter\(line, message\.role\)\)/);
+  assert.doesNotMatch(source, /'─'\.repeat\(rightLength\)/);
+
+  // La bulle alignée à droite repliait les messages utilisateur à 60 % de la
+  // largeur : phrases coupées en plein milieu, et deux colonnes de lecture
+  // selon le locuteur.
+  assert.doesNotMatch(source, /userBubbleWidth\s*=/);
+  assert.doesNotMatch(source, /Math\.floor\(columns \* 0\.6\)/);
+  assert.match(source, /const contentColumns = Math\.max\(12, columns - GUTTER\.length\)/);
 });
 
-test('ShellUI exposes copy without a reply or redo action', async () => {
+test('the header carries the clock and the copy action, pushed to the right edge', async () => {
   const source = await readFile(new URL('./LeftPane.tsx', import.meta.url), 'utf8');
-  assert.match(source, /const COPY_BTN = ' \[ copy \]';/);
+  assert.match(source, /const COPY_BTN = '  copy';/);
+  assert.match(source, /messageHeaderSegments\(message\.role, columns, message\.at\)/);
+  // Le remplissage pousse `copy` au bord droit au lieu de le coller au libellé.
+  assert.match(source, /const pad = Math\.max\(1, columns - used - COPY_BTN\.length\)/);
   assert.doesNotMatch(source, /\[\s*(?:reply|redo)\s*\]/i);
   assert.doesNotMatch(source, /onRedo|redoContent|redoIndex|REDO_BTN/);
 });
 
+test('a message is stamped once, when it enters the conversation', async () => {
+  const { conversationMessages } = await import('./repl.js');
+  const session = { workspace: null };
+  const messages = conversationMessages(session);
+  // Posé sur le `push` du tableau : trente-deux endroits créent un message, et
+  // un seul oublié perdrait son heure sans que rien ne le signale.
+  messages.push({ role: 'user', content: 'bonjour' });
+  assert.ok(Number.isFinite(messages[0].at));
+  // Un message qui porte déjà son heure garde la sienne.
+  messages.push({ role: 'donna', content: 'rejoué', at: 42 });
+  assert.equal(messages[1].at, 42);
+  // Et le tableau n'est instrumenté qu'une fois.
+  assert.equal(conversationMessages(session), messages);
+});
+
 test('redo translates the local thread index into a runtime conversation index', async () => {
   const session = await readFile(new URL('./useSession.ts', import.meta.url), 'utf8');
   const redo = session.slice(
@@ -559,7 +581,10 @@ test('/agent <question> submits one runtime request and remains in chat mode', a
     assert.equal(session.chatMode, true);
     assert.equal(result.oneShotAgent, true);
     assert.equal(result.runtimeOutcome.kind, 'accepted');
-    assert.deepEqual(conversationMessages(session), [{ role: 'user', content: 'lance ingestion', _pending: true }]);
+    assert.deepEqual(
+      conversationMessages(session).map(({ at, ...rest }) => rest),
+      [{ role: 'user', content: 'lance ingestion', _pending: true }],
+    );
   } finally {
     restore();
   }
@@ -658,10 +683,14 @@ test('agent mode without runtime records a visible error instead of falling back
   const message = recordRuntimeUnavailableAgentInput(session, 'salut', { error: 'port 7788 already in use' });
 
   assert.equal(message, '⚠ Runtime indisponible : port 7788 already in use — /agent désactivé, /chat reste possible');
-  assert.deepEqual(conversationMessages(session), [
-    { role: 'user', content: 'salut' },
-    { role: 'command', content: message },
-  ]);
+  // `at` est posé à l'insertion : on compare le reste.
+  assert.deepEqual(
+    conversationMessages(session).map(({ at, ...rest }) => rest),
+    [
+      { role: 'user', content: 'salut' },
+      { role: 'command', content: message },
+    ],
+  );
 });
 
 test('runtime status exposes the disconnected reason', () => {

package/wiki-workspace

@@ -534,7 +534,11 @@ ensure_endpoints_file() {
   # Without mcp.endpoints.json the shell never connects to the agents it
   # just started (and `agents status` refuses to run). Seed it from the
   # packaged example; the \${VAR} placeholders resolve against the .env.
+  if [[ -e "$MANAGER_ENDPOINTS_FILE" && ! -f "$MANAGER_ENDPOINTS_FILE" ]]; then
+    die "MCP endpoints path is not a file: $MANAGER_ENDPOINTS_FILE"
+  fi
   if [[ ! -f "$MANAGER_ENDPOINTS_FILE" && -f "$ROOT_DIR/mcp.endpoints.example.json" ]]; then
+    mkdir -p "$(dirname "$MANAGER_ENDPOINTS_FILE")"
     cp "$ROOT_DIR/mcp.endpoints.example.json" "$MANAGER_ENDPOINTS_FILE"
     printf 'Created %s from packaged example\n' "$MANAGER_ENDPOINTS_FILE"
   fi
@@ -918,6 +922,9 @@ ensure_compose_override() {
 }
 
 ensure_manager_endpoints_file() {
+  if [[ -e "$MANAGER_ENDPOINTS_FILE" && ! -f "$MANAGER_ENDPOINTS_FILE" ]]; then
+    die "MCP endpoints path is not a file: $MANAGER_ENDPOINTS_FILE"
+  fi
   if [[ ! -f "$MANAGER_ENDPOINTS_FILE" && -f "$ROOT_DIR/mcp.endpoints.example.json" ]]; then
     mkdir -p "$(dirname "$MANAGER_ENDPOINTS_FILE")"
     cp "$ROOT_DIR/mcp.endpoints.example.json" "$MANAGER_ENDPOINTS_FILE"