@dotdrelle/wiki-manager 0.12.11 → 0.14.0

package/src/runtime/server.js

@@ -15,6 +15,7 @@ export function startRuntimeServer({
   session = null,
   getContext,
   run,
+  delegate,
   cancel,
   resume,
   approve,
@@ -271,6 +272,36 @@ export function startRuntimeServer({
         }
         return;
       }
+      if (request.method === 'POST' && url.pathname === '/delegate') {
+        const { body, context } = await resolveBodyContext(request, url);
+        const objective = String(body.objective ?? '').trim();
+        if (!objective) {
+          sendJson(response, 400, { error: 'Missing objective.' });
+          return;
+        }
+        if (context.running) {
+          sendJson(response, 409, { error: 'A runtime run is already active.' });
+          return;
+        }
+        if (typeof delegate !== 'function') {
+          sendJson(response, 501, { error: 'Runtime delegation is unavailable.' });
+          return;
+        }
+        try {
+          const prepared = await delegate(context, { objective, workspace: body.workspace ?? context.workspace ?? null });
+          const started = startRuntimeRun(context, {
+            input: objective,
+            workspace: body.workspace ?? context.workspace ?? null,
+            preparedDelegation: prepared,
+            evaluate: false,
+          }, { waitForPlan: true });
+          await started.ready;
+          sendJson(response, 202, { accepted: true, runId: started.runId, workspace: started.workspace, delegation: prepared.summary ?? null });
+        } catch (err) {
+          sendJson(response, 422, { error: err instanceof Error ? err.message : String(err) });
+        }
+        return;
+      }
       if (request.method === 'POST' && url.pathname === '/cancel') {
         const workspace = workspaceFromUrl(url);
         const context = await resolveContext({ workspace });
@@ -391,14 +422,22 @@ export function startRuntimeServer({
     return { killed: true, workspace: targetWorkspace, runId: targetRunId, runs, tasks, queued };
   }
 
-  function startRuntimeRun(context, body, { controlItemId = null } = {}) {
+  function startRuntimeRun(context, body, { controlItemId = null, waitForPlan = false } = {}) {
     const runId = randomUUID();
     const runWorkspace = context.workspace ?? body.workspace ?? null;
     context.running = true;
     context.currentAbortController = new AbortController();
     context.currentRunId = runId;
     context.currentRunWorkspace = runWorkspace;
-    const runBody = { ...body, workspace: runWorkspace, runId };
+    let resolveReady;
+    let rejectReady;
+    const ready = waitForPlan ? new Promise((resolve, reject) => { resolveReady = resolve; rejectReady = reject; }) : null;
+    const runBody = {
+      ...body,
+      workspace: runWorkspace,
+      runId,
+      ...(waitForPlan ? { _planReady: { resolve: resolveReady, reject: rejectReady } } : {}),
+    };
     if (controlItemId) {
       dispatchAgentEvent(context.session, createAgentEvent('control_started', {
         origin: 'runtime',
@@ -410,6 +449,7 @@ export function startRuntimeServer({
     const runPromise = run(context, runBody, { signal: context.currentAbortController.signal, runId });
     runPromise
       .catch((err) => {
+        rejectReady?.(err);
         context.session?._onRuntimeError?.(err);
       })
       .finally(() => {
@@ -420,7 +460,7 @@ export function startRuntimeServer({
         publishState(runWorkspace, context);
         void startNextControlRequest(context);
       });
-    return { accepted: true, runId, workspace: runWorkspace };
+    return { accepted: true, runId, workspace: runWorkspace, ...(ready ? { ready } : {}) };
   }
 
   function startNextControlRequest(context) {

package/src/runtime/supervisor.js

@@ -1,3 +1,5 @@
+import { openSync, readSync, closeSync, fstatSync } from 'node:fs';
+import { isAbsolute, join, normalize, resolve } from 'node:path';
 import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
 import { extractActivity, parseJsonText, sessionActivities } from '../core/activity.js';
 import { callMcpTool, formatMcpToolResult } from '../core/mcp.js';
@@ -117,7 +119,10 @@ export async function pollActivitiesOnce(session, {
         const retry = progress.retryAt
           ? `retry ${progress.retryAt}`
           : (progress.waitMs ? `wait ${progress.waitMs}ms` : null);
-        const progressKey = `${polledActivity.status}:${Number.isFinite(percent) ? Math.round(percent) : ''}:${detail}:${batch ?? ''}:${lastEvent ?? ''}:${retry ?? ''}`;
+        // retryAt/waitMs are scheduling metadata and may be recomputed on every
+        // status poll. They must remain visible in the first log line, but must
+        // not turn an unchanged quota/backoff state into a new trace event.
+        const progressKey = `${polledActivity.status}:${Number.isFinite(percent) ? Math.round(percent) : ''}:${detail}:${batch ?? ''}:${lastEvent ?? ''}`;
         session._activityLogKeys ??= {};
         if (session._activityLogKeys[key] !== progressKey) {
           session._activityLogKeys[key] = progressKey;
@@ -144,9 +149,19 @@ export async function pollActivitiesOnce(session, {
           }
           session._activityLogCursors[key] = logTail.at(-1);
         }
+        // The job log is terse — the actual narrative (per-document plans,
+        // LLM calls with token counts, apply operations) lives in the
+        // engine's trace file, whose path the status exposes. Tail it from
+        // the host and surface the significant events.
+        if (progress.traceFile) {
+          for (const line of readNewTraceLines(session, key, progress.traceFile)) {
+            emitRuntimeLog(session, `trace: ${line}`);
+          }
+        }
         if (polledActivity.terminal) {
           delete session._activityLogKeys[key];
           delete session._activityLogCursors?.[key];
+          delete session._activityTraceCursors?.[key];
           await startNextQueuedJob(session, {
             addLog: (message) => emitRuntimeLog(session, message),
           });
@@ -210,3 +225,52 @@ export async function cancelActiveActivityJobs(session, { callTool = callMcpTool
   }
   return cancelled;
 }
+
+// Trace events worth surfacing in the chat-side log: plan/apply milestones,
+// LLM calls (with token counts), warnings and errors. The raw trace is far
+// chattier — streaming everything would recreate the noise the dedupe killed.
+const TRACE_EVENT_PATTERN = /\b(llm:start|llm:end|llm:json|llm:error|ingest:plan|ingest:operations|ingest:apply|ingest:source|build:template|retrieval:|embedding:|WARN|ERROR)\b/;
+const TRACE_MAX_BYTES_PER_POLL = 64 * 1024;
+const TRACE_MAX_LINES_PER_POLL = 12;
+
+export function readNewTraceLines(session, key, traceFile) {
+  const workspacePath = session?.workspacePath;
+  if (!workspacePath) return [];
+  // The trace path comes from an agent payload: never let it escape the
+  // workspace directory.
+  const resolved = resolve(workspacePath, normalize(String(traceFile)));
+  if (isAbsolute(String(traceFile)) || !resolved.startsWith(resolve(workspacePath))) return [];
+  let fd;
+  try {
+    fd = openSync(resolved, 'r');
+    const size = fstatSync(fd).size;
+    session._activityTraceCursors ??= {};
+    let offset = session._activityTraceCursors[key];
+    // First sighting (or file rotation): start near the end, not at byte 0 —
+    // replaying a long history would flood the panel.
+    if (offset == null || offset > size) offset = Math.max(0, size - 4096);
+    if (size <= offset) return [];
+    const length = Math.min(size - offset, TRACE_MAX_BYTES_PER_POLL);
+    const buffer = Buffer.alloc(length);
+    readSync(fd, buffer, 0, length, offset);
+    const chunk = buffer.toString('utf8');
+    // Only advance past COMPLETE lines so a partially-written line is
+    // re-read whole on the next poll.
+    const lastNewline = chunk.lastIndexOf('\n');
+    if (lastNewline === -1) return [];
+    session._activityTraceCursors[key] = offset + Buffer.byteLength(chunk.slice(0, lastNewline + 1), 'utf8');
+    return chunk
+      .slice(0, lastNewline)
+      .split('\n')
+      .map((line) => line.trim())
+      .filter((line) => line && TRACE_EVENT_PATTERN.test(line))
+      .slice(0, TRACE_MAX_LINES_PER_POLL)
+      // Strip the ISO timestamp + elapsed prefix: the runtime log adds its
+      // own clock, and the double timestamp ate half the panel width.
+      .map((line) => line.replace(/^\S+\s+\+[\d.]+(?:ms|s|m|h)\s+(INFO|WARN|ERROR)\s+/, (_m, level) => (level === 'INFO' ? '' : `${level} `)));
+  } catch {
+    return [];
+  } finally {
+    if (fd !== undefined) closeSync(fd);
+  }
+}

package/src/runtime/supervisor.test.js

@@ -41,6 +41,55 @@ test('pollActivitiesOnce updates activity through the event reducer', async () =
   assert.ok(session.agentProjection.logs.some((line) => line.includes('activity:')));
 });
 
+test('pollActivitiesOnce does not repeat an unchanged retry state when retryAt moves', async () => {
+  const session = {
+    mcp: { production: { status: 'connected' } },
+    activities: {},
+    headlessPlan: null,
+    jobQueue: [],
+  };
+  dispatchAgentEvent(session, createAgentEvent('activity_upserted', {
+    payload: {
+      activity: {
+        id: 'job-quota',
+        source: 'production',
+        label: 'Production · ingest',
+        status: 'running',
+        poll: { server: 'production', tool: 'production_job_status', args: { jobId: 'job-quota' }, intervalMs: 0 },
+      },
+    },
+  }));
+
+  let poll = 0;
+  const callTool = async () => {
+    poll += 1;
+    return {
+      content: [{ type: 'text', text: JSON.stringify({
+        _activity: {
+          id: 'job-quota',
+          source: 'production',
+          label: 'Production · ingest',
+          status: 'running',
+          terminal: false,
+          progress: {
+            percent: 15,
+            detail: 'LLM quota wait',
+            lastEvent: 'llm:rate-limit-wait',
+            retryAt: `2026-07-10T20:31:5${poll}.000Z`,
+          },
+        },
+      }) }],
+    };
+  };
+
+  await pollActivitiesOnce(session, { callTool });
+  await pollActivitiesOnce(session, { callTool });
+
+  const lines = session.agentProjection.logs.filter((line) => line.includes('activity: Production · ingest'));
+  assert.equal(lines.length, 1);
+  assert.match(lines[0], /retry 2026-07-10T20:31:51\.000Z/);
+});
+
 test('pollActivitiesOnce retries transient MCP poll failures', async () => {
   const originalFetch = globalThis.fetch;
   let attempts = 0;
@@ -284,3 +333,34 @@ async function waitFor(predicate, timeoutMs = 250) {
   }
   assert.fail('Timed out waiting for condition.');
 }
+
+test('readNewTraceLines streams significant trace events with a per-activity cursor', async () => {
+  const { readNewTraceLines } = await import('./supervisor.js');
+  const { mkdtempSync, writeFileSync, appendFileSync, rmSync } = await import('node:fs');
+  const { tmpdir } = await import('node:os');
+  const { join } = await import('node:path');
+  const workspacePath = mkdtempSync(join(tmpdir(), 'trace-tail-'));
+  try {
+    const rel = '.wiki/logs/ingest-test.log';
+    const abs = join(workspacePath, rel);
+    (await import('node:fs')).mkdirSync(join(workspacePath, '.wiki/logs'), { recursive: true });
+    writeFileSync(abs, '2026-07-10T13:00:00.000Z +10ms INFO llm:start label=ingest_plan promptChars=42000\n');
+    const session = { workspacePath };
+
+    const first = readNewTraceLines(session, 'k1', rel);
+    assert.deepEqual(first, ['llm:start label=ingest_plan promptChars=42000']);
+
+    // No new content → nothing re-emitted.
+    assert.deepEqual(readNewTraceLines(session, 'k1', rel), []);
+
+    appendFileSync(abs, '2026-07-10T13:01:00.000Z +70s INFO noise: irrelevant heartbeat\n2026-07-10T13:02:00.000Z +130s WARN embedding:neutralized-input status=413\n');
+    const second = readNewTraceLines(session, 'k1', rel);
+    assert.deepEqual(second, ['WARN embedding:neutralized-input status=413']);
+
+    // Path traversal attempts are refused.
+    assert.deepEqual(readNewTraceLines(session, 'k1', '../../etc/passwd'), []);
+    assert.deepEqual(readNewTraceLines(session, 'k1', '/etc/passwd'), []);
+  } finally {
+    rmSync(workspacePath, { recursive: true, force: true });
+  }
+});

package/src/shell/LeftPane.tsx

@@ -272,9 +272,16 @@ function renderMarkdownLines(lines: Array<{ text: string; isCode: boolean }>, ro
   for (let index = 0; index < lines.length; index += 1) {
     const { text, isCode } = lines[index];
     if (isCode) {
-      output.push(...wrapLine(text || ' ', columns).map((piece) => ({
-        segments: [{ text: piece || ' ', color: '#D6DEE8', bg: '#1A2235' }],
+      const blockStarts = index === 0 || !lines[index - 1].isCode;
+      const blockEnds = index === lines.length - 1 || !lines[index + 1].isCode;
+      // Blank line before/after the block + 2-space inner padding: fenced
+      // blocks used to render as a dense background slab glued to the text.
+      if (blockStarts) output.push({ segments: [{ text: ' ', color: '#D6DEE8' }] });
+      const innerWidth = Math.max(8, columns - 4);
+      output.push(...wrapLine(text || ' ', innerWidth).map((piece) => ({
+        segments: [{ text: `  ${(piece || ' ').padEnd(innerWidth)}  `, color: '#D6DEE8', bg: '#1A2235' }],
       })));
+      if (blockEnds) output.push({ segments: [{ text: ' ', color: '#D6DEE8' }] });
       continue;
     }
 

package/src/shell/repl.js

@@ -5,7 +5,7 @@ import { execFileSync } from 'node:child_process';
 import { stdin as input, stdout as output } from 'node:process';
 import { marked } from 'marked';
 import { markedTerminal } from 'marked-terminal';
-import { buildAgentSystemPrompt, classifyAgentInput, formatLlmUnavailableMessage } from '../agent/graph.js';
+import { buildAgentSystemPrompt, formatLlmUnavailableMessage } from '../agent/graph.js';
 import { handleSlashCommand } from '../commands/slash.js';
 import { serviceDescription, serviceNames as composeServiceNames } from '../core/compose.js';
 import { extractActivity, parseJsonText, sessionActivities } from '../core/activity.js';
@@ -18,7 +18,15 @@ import { listWorkspaces } from '../core/workspaces.js';
 import { fetchRuntimeState, postRuntimeApprove, postRuntimeCancel, postRuntimeControl, postRuntimeRun, postRuntimeShutdown, streamRuntimeEvents } from '../runtime/client.js';
 import { versionWithBuild } from '../core/buildInfo.js';
 
-marked.use(markedTerminal());
+// Code blocks: marked-terminal's default paints a dense background block
+// glued to the surrounding text. Indent the content, keep a plain style and
+// guarantee a blank line before/after so fenced blocks breathe in the chat.
+const CODE_INDENT = '  ';
+const CODE_TINT = '\u001b[38;5;152m'; // soft blue-grey, readable on dark bg
+const CODE_RESET = '\u001b[0m';
+marked.use(markedTerminal({
+  code: (code) => `\n${String(code).split('\n').map((line) => `${CODE_INDENT}${CODE_TINT}${line}${CODE_RESET}`).join('\n')}\n`,
+}));
 // marked-terminal's text renderer extracts token.text (raw string) instead of
 // calling parseInline(token.tokens), so inline Markdown inside list items is
 // silently dropped. Patch it to call parseInline when tokens are available.
@@ -75,7 +83,7 @@ const COMMAND_COMPLETION_DESCRIPTIONS = {
   '/chat': 'Switch free text to direct LLM chat without tools.',
   '/agent': 'Switch free text to the LangGraph agent with tools.',
   '/openui': 'Open the workspace web UI in the browser.',
-  '/run': 'Inspect, cancel, or kill runtime runs.',
+  '/run': 'Inspect, cancel, kill runtime runs, or start a capability run.',
   '/approve': 'Approve a pending runtime run or tool.',
 };
 
@@ -141,7 +149,7 @@ export function createSession() {
     wikircConfig: null,
     language: null,
     mcp: null,
-    commands: ['help', 'version', 'exit', 'workspace', 'new', 'use', 'config', 'status', 'services', 'start', 'stop', 'logs', 'mcp', 'wiki', 'skills', 'upload', 'uploads', 'clear', 'chat', 'agent', 'openui', 'run', 'queue', 'approve'],
+    commands: ['help', 'version', 'exit', 'workspace', 'new', 'use', 'config', 'status', 'services', 'start', 'stop', 'logs', 'mcp', 'wiki', 'skills', 'upload', 'uploads', 'clear', 'chat', 'agent', 'openui', 'run', 'cancel', 'queue', 'approve'],
     chatMode: true,
     llm: null,
     activities: {},
@@ -246,7 +254,7 @@ function completionValuesFor(parts, inputBuffer, session) {
   if (command === '/upload' && parts[1] === 'convert' && tokenIndex === 2) return ['pending'];
   if (command === '/uploads' && tokenIndex === 1) return ['clean', 'list'];
   if (command === '/uploads' && previousToken === 'clean') return ['--older-than'];
-  if (command === '/run' && tokenIndex === 1) return ['status', 'cancel', 'kill'];
+  if (command === '/run' && tokenIndex === 1) return ['status', 'cancel', 'kill', 'capability'];
   if (command === '/queue' && tokenIndex === 1) return ['cancel', 'clear'];
   if (command === '/queue' && previousToken === 'cancel') {
     return (session.jobQueue ?? [])
@@ -284,6 +292,7 @@ function buildDirectChatSystemPrompt(session) {
   return [
     'You are Donna, the llm-wiki-manager chat assistant.',
     'Answer directly and concisely. Do not claim to have called tools or changed files.',
+    'Never add a "Next steps", "Prochaines étapes", "À suivre", options, or suggestions section unless the user explicitly asks what to do next. End after answering the question.',
     'If the user asks for an action that needs workspace commands, MCP tools, services, files, or mutations, say to ask as an agent action instead of pretending to execute it.',
     `Reply language: ${language}.`,
     `Current workspace: ${workspace}.`,
@@ -766,18 +775,21 @@ function rememberProductionActivity(session, payload) {
 
 export function applyRuntimeStateToShellSession(session, state) {
   if (!state || typeof state !== 'object') return false;
+  const displayState = sanitizeRuntimeStateForDisplay(state);
   session.agentProjection = {
-    conversation: Array.isArray(state.conversation) ? state.conversation.map((message) => ({ ...message })) : [],
-    chain: Array.isArray(state.chain) ? state.chain.map((step) => ({ ...step })) : [],
-    plan: Array.isArray(state.plan) ? state.plan.map((step) => ({ ...step })) : null,
-    activities: Array.isArray(state.activities) ? state.activities.map((activity) => ({ ...activity })) : [],
-    logs: Array.isArray(state.logs) ? [...state.logs] : [],
-    summary: state.summary ?? null,
-    status: state.status ?? 'idle',
-    planRevision: state.planRevision ?? 0,
-    planPatches: Array.isArray(state.planPatches) ? state.planPatches.map((patch) => ({ ...patch })) : [],
+    conversation: Array.isArray(displayState.conversation) ? displayState.conversation.map((message) => ({ ...message })) : [],
+    chain: Array.isArray(displayState.chain) ? displayState.chain.map((step) => ({ ...step })) : [],
+    plan: Array.isArray(displayState.plan) && displayState.plan.length > 0
+      ? displayState.plan.map((step) => ({ ...step }))
+      : null,
+    activities: Array.isArray(displayState.activities) ? displayState.activities.map((activity) => ({ ...activity })) : [],
+    logs: Array.isArray(displayState.logs) ? [...displayState.logs] : [],
+    summary: displayState.summary ?? null,
+    status: displayState.status ?? 'idle',
+    planRevision: displayState.planRevision ?? 0,
+    planPatches: Array.isArray(displayState.planPatches) ? displayState.planPatches.map((patch) => ({ ...patch })) : [],
   };
-  session.workflow = state.workflow && typeof state.workflow === 'object'
+  session.workflow = displayState.workflow && typeof displayState.workflow === 'object'
     ? {
         ...state.workflow,
         nodes: Array.isArray(state.workflow.nodes) ? state.workflow.nodes.map((node) => ({ ...node })) : [],
@@ -795,7 +807,7 @@ export function applyRuntimeStateToShellSession(session, state) {
   // Runtime queue items replace the local jobQueue wholesale on every sync.
   // Tag their origin so /queue cancel can refuse to fake-cancel them locally
   // (a local status flip would be silently reverted by the next SSE sync).
-  if (Array.isArray(state.queue)) session.jobQueue = state.queue.map((item) => ({ ...item, origin: 'runtime' }));
+  if (Array.isArray(displayState.queue)) session.jobQueue = displayState.queue.map((item) => ({ ...item, origin: 'runtime' }));
   const production = session.agentProjection.activities.filter((activity) => activity.source === 'production').at(-1);
   if (production) {
     session.productionActivity = {
@@ -809,21 +821,29 @@ export function applyRuntimeStateToShellSession(session, state) {
   return true;
 }
 
-// Submits a prompt to the shared runtime. If the workspace is already busy
-// (HTTP 409 from POST /run), route the input through the runtime control lane
-// so status questions and plan-change proposals do not become future runs.
-// A plain question or small talk must never start a runtime run (nor be
-// enqueued as a future one): it only needs an answer. Route converse/observe
-// to the local agent EVEN during an active run — the chat is supposed to stay
-// available, and the graph already restricts tools to read-only in that case.
-// Actions/cancels/approvals still go to the runtime.
-export function shouldHandleFreeTextLocally(line, session, { llmAvailable = Boolean(session?.llm) } = {}) {
-  const classification = classifyAgentInput(line, session);
-  // cancel intents included: Donna interprets "supprime le job et la queue"
-  // and calls runtime__kill / runtime__cancel herself — no hardcoded regex
-  // deciding between soft and hard stop. The control lane remains the
-  // deterministic fallback when the local LLM is down.
-  if (!['converse', 'observe', 'cancel', 'approve', 'enqueue_run', 'ambiguous'].includes(classification.kind)) return { local: false, classification };
+export function sanitizeRuntimeStateForDisplay(state) {
+  if (!state || typeof state !== 'object') return state;
+  const status = String(state.status ?? 'idle').toLowerCase();
+  const visible = ['running', 'queued', 'pending', 'waiting', 'pending_approval', 'error', 'failed']
+    .includes(status);
+  if (visible) return state;
+  return {
+    ...state,
+    conversation: [],
+    chain: [],
+    plan: [],
+    activities: [],
+    workflow: null,
+    logs: [],
+    summary: null,
+    planPatches: [],
+  };
+}
+
+// In agent mode, Donna receives every free-text turn and decides whether to
+// answer or call an exposed tool. Slash commands remain the deterministic UI.
+export function shouldHandleFreeTextLocally(_line, session, { llmAvailable = Boolean(session?.llm) } = {}) {
+  const classification = { kind: 'agent_turn', confidence: 1, reason: 'agent_mode_llm_decision' };
   if (!llmAvailable) return { local: false, classification, fallbackReason: 'local LLM unavailable' };
   return { local: true, classification };
 }
@@ -1041,17 +1061,12 @@ async function runAgentTurn(input, { agent, session, onUpdate, onStep, displayIn
   };
   session._onStreamReset = () => {
     if (!donnaMessage) return;
-    if (donnaMessage.content.trim()) {
-      // Intermediate streamed text before tool calls: keep it, add separator.
-      donnaMessage.content += '\n\n';
-      onUpdate?.();
-    } else {
-      // Still empty ("Thinking…"): remove it cleanly.
-      const index = messages.indexOf(donnaMessage);
-      if (index !== -1) messages.splice(index, 1);
-      donnaMessage = null;
-      onUpdate?.();
-    }
+    // Text emitted before a tool call is provisional narration, not an answer.
+    // Remove it; the post-tool result gets a fresh Donna bubble.
+    const index = messages.indexOf(donnaMessage);
+    if (index !== -1) messages.splice(index, 1);
+    donnaMessage = null;
+    onUpdate?.();
   };
 
   let agentResult;

package/src/shell/repl.test.js

@@ -9,12 +9,40 @@ import {
   conversationMessages,
   recordRuntimeUnavailableAgentInput,
   runLine,
+  sanitizeRuntimeStateForDisplay,
   runtimeStatusLine,
   runtimeUnavailableAgentMessage,
   shouldHandleFreeTextLocally,
   submitRuntimeRun,
 } from './repl.js';
 
+test('runtime display preserves a failed plan and its diagnostic evidence', () => {
+  const state = {
+    status: 'error',
+    plan: [{ id: 'apply', status: 'failed' }],
+    activities: [{ id: 'job-1', status: 'failed', error: 'exitCode=1' }],
+    logs: ['run_error: ingest_apply exitCode=1'],
+    conversation: [{ role: 'assistant', content: 'Échec de l’ingestion.' }],
+  };
+
+  assert.equal(sanitizeRuntimeStateForDisplay(state), state);
+});
+
+test('runtime display still clears completed historical execution state', () => {
+  const display = sanitizeRuntimeStateForDisplay({
+    status: 'done',
+    plan: [{ id: 'old', status: 'done' }],
+    activities: [{ id: 'old-job', status: 'done' }],
+    logs: ['old log'],
+    conversation: [{ role: 'assistant', content: 'Old run.' }],
+  });
+
+  assert.deepEqual(display.plan, []);
+  assert.deepEqual(display.activities, []);
+  assert.deepEqual(display.logs, []);
+  assert.deepEqual(display.conversation, []);
+});
+
 function stubFetch(handler) {
   const original = globalThis.fetch;
   globalThis.fetch = handler;
@@ -74,6 +102,50 @@ test('applyRuntimeStateToShellSession projects runtime state into shell session'
   assert.deepEqual(conversationMessages(session), []);
 });
 
+test('applyRuntimeStateToShellSession clears terminal plan and activities when runtime is idle', () => {
+  const session = createSession();
+  session.headlessPlan = [{ step: 1, description: 'Old read', status: 'failed' }];
+  session.activities = { old: { key: 'old', status: 'failed', terminal: true } };
+
+  applyRuntimeStateToShellSession(session, {
+    status: 'idle',
+    conversation: [{ role: 'assistant', content: 'Old failed answer' }],
+    chain: [{ id: 'old-step' }],
+    plan: [{ step: 1, description: 'Old read', status: 'failed' }],
+    activities: [{ key: 'old', status: 'failed', terminal: true }],
+    workflow: { nodes: [{ id: 'task:old' }], relations: [] },
+    logs: ['Runtime evaluator rejected the old run'],
+    summary: 'Old run failed',
+    planPatches: [{ id: 'old-patch' }],
+  });
+
+  assert.equal(session.headlessPlan, null);
+  assert.deepEqual(session.activities, {});
+  assert.equal(session.workflow, null);
+  assert.deepEqual(session.agentProjection.logs, []);
+  assert.equal(session.agentProjection.summary, null);
+  assert.deepEqual(session.agentProjection.conversation, []);
+  assert.deepEqual(session.agentProjection.chain, []);
+  assert.deepEqual(session.agentProjection.planPatches, []);
+});
+
+test('direct chat system prompt forbids unsolicited next steps', async () => {
+  const session = createSession();
+  let systemPrompt = '';
+  session.llm = {
+    async *stream({ system }) {
+      systemPrompt = system;
+      yield 'Réponse concise.';
+    },
+  };
+
+  await runLine('bonjour', { agent: null, packageJson: { version: 'test' }, session, chatMode: true });
+
+  assert.match(systemPrompt, /Never add a "Next steps", "Prochaines étapes", "À suivre"/);
+  assert.match(systemPrompt, /unless the user explicitly asks what to do next/);
+  assert.equal(conversationMessages(session).at(-1).content, 'Réponse concise.');
+});
+
 test('submitRuntimeRun reports acceptance without throwing', async () => {
   const restore = stubFetch(async (url) => {
     assert.equal(pathOf(url), '/run');
@@ -241,37 +313,34 @@ test('/queue cancel on a runtime workflow id points to run cancellation commands
   assert.match(conversationMessages(session).at(-1).content, /\/run kill/);
 });
 
-test('free text routing keeps questions local and sends actions to the runtime', () => {
+test('agent mode sends every free-text turn to Donna', () => {
   const session = createSession();
   session.llm = { completeWithTools: () => {} };
 
-  // The original incident: a config question must never start a run.
   const question = shouldHandleFreeTextLocally('donne moi la config du cme', session);
   assert.equal(question.local, true);
-  assert.equal(question.classification.kind, 'observe');
+  assert.equal(question.classification.kind, 'agent_turn');
 
   const smallTalk = shouldHandleFreeTextLocally('bonjour', session);
   assert.equal(smallTalk.local, true);
 
   const action = shouldHandleFreeTextLocally('lance le pipeline complet', session);
-  assert.equal(action.local, false);
-  assert.equal(action.classification.kind, 'start_run');
+  assert.equal(action.local, true);
+  assert.equal(action.classification.kind, 'agent_turn');
+
+  const pending = shouldHandleFreeTextLocally('as ton des fichier en attente d ingestion', session);
+  assert.equal(pending.local, true);
+  assert.equal(pending.classification.kind, 'agent_turn');
 });
 
-test('free text routing keeps questions local even during an active run', () => {
-  // The chat must stay available during a run: a status question or small
-  // talk answered locally (read-only tools) — never enqueued as a future run.
+test('Donna keeps receiving free text during an active run', () => {
   const session = createSession();
   session.llm = { completeWithTools: () => {} };
   session.agentProjection = { status: 'running', activities: [], conversation: [] };
   assert.equal(shouldHandleFreeTextLocally('où en est le run', session).local, true);
   assert.equal(shouldHandleFreeTextLocally('salut', session).local, true);
-  // Cancel intents are handled by Donna locally (runtime__kill/cancel tools);
-  // approvals stay on the deterministic control lane.
   assert.equal(shouldHandleFreeTextLocally('stop le job', session).local, true);
   assert.equal(shouldHandleFreeTextLocally('supprime le job et la queue', session).local, true);
-  // Approvals and "later" requests too: Donna owns runtime__approve and
-  // runtime__enqueue. Only plan modifications and new runs bypass her.
   assert.equal(shouldHandleFreeTextLocally('approuve le run', session).local, true);
   assert.equal(shouldHandleFreeTextLocally('fais le build plus tard', session).local, true);
 

package/src/shell/tui.tsx

@@ -116,6 +116,29 @@ function App(props: {
   // sync at every call site.
   const [screen, setScreen] = createSignal<'startup' | 'setup' | 'main'>('startup');
   let ctrlCTimer: ReturnType<typeof setTimeout> | null = null;
+  let exiting = false;
+  // Single exit path: the owned-runtime shutdown MUST happen here, on the
+  // user's actual exit gesture. render() resolves at MOUNT, so code placed
+  // after `await runOpenTuiShell(...)` runs while the shell is still on
+  // screen — 0.12.9 shipped that and killed the runtime mid-session.
+  const exitShell = () => {
+    if (exiting) return;
+    exiting = true;
+    void (async () => {
+      const messages: string[] = [];
+      try {
+        if (props.runtime?.url) {
+          const { shutdownOwnedRuntime } = await import('../runtime/lifecycle.js');
+          await shutdownOwnedRuntime(props.runtime, { log: (message: string) => { messages.push(message); } });
+        }
+      } catch {
+        // Best effort: never block the exit on runtime cleanup.
+      }
+      renderer.destroy();
+      // Print AFTER destroy so the note survives on the restored terminal.
+      for (const message of messages) console.log(`[wiki-manager] ${message}`);
+    })();
+  };
   let copyHintTimer: ReturnType<typeof setTimeout> | null = null;
   let selectionCopyTimer: ReturnType<typeof setTimeout> | null = null;
   let startupKeyboardEventId = 0;
@@ -141,7 +164,7 @@ function App(props: {
       return;
     }
     void state.submitInput(value).then((result) => {
-      if (result?.exit) renderer.destroy();
+      if (result?.exit) exitShell();
     });
   };
 
@@ -263,7 +286,7 @@ function App(props: {
         return;
       }
       if (exitHint()) {
-        renderer.destroy();
+        exitShell();
         return;
       }
       setExitHint(true);
@@ -378,7 +401,7 @@ function App(props: {
         height={dimensions().height}
         keyboardEvent={startupKeyboardEvent()}
         onSelect={openAction}
-        onQuit={() => renderer.destroy()}
+        onQuit={() => exitShell()}
       />
     </Show>
   );