@dotdrelle/wiki-manager 0.12.1 → 0.12.7

package/src/runtime/store.test.js

@@ -606,6 +606,38 @@ test('runtime store persists cancelled run status', () => {
   store.close();
 });
 
+test('runtime store interrupts runs by runId and does not recover killed runs after reopen', () => {
+  const stateDir = mkdtempSync(join(tmpdir(), 'wiki-manager-runtime-'));
+  const store = openRuntimeStore({ stateDir });
+  for (const runId of ['run-kill', 'run-keep']) {
+    store.persistEvent(createAgentEvent('run_started', {
+      origin: 'test',
+      runId,
+      workspace: 'docs',
+      payload: { input: runId, workspace: 'docs' },
+    }));
+    store.persistEvent(createAgentEvent('task.created', {
+      origin: 'test',
+      runId,
+      taskId: `${runId}:task`,
+      workspace: 'docs',
+      payload: { runId, task: { ...plannedTask(`${runId}:task`), status: 'running' } },
+    }));
+  }
+
+  assert.equal(store.interruptRuns({ workspace: 'docs', runId: 'run-kill' }), 1);
+  assert.equal(store.cancelActiveTasksForInterruptedRuns({ workspace: 'docs', runId: 'run-kill' }), 1);
+  assert.equal(store.listRuns().find((run) => run.id === 'run-kill').status, 'interrupted');
+  assert.equal(store.listRuns().find((run) => run.id === 'run-keep').status, 'running');
+  assert.equal(store.listTasks({ runId: 'run-kill' })[0].status, 'cancelled');
+  assert.equal(store.listTasks({ runId: 'run-keep' })[0].status, 'running');
+  store.close();
+
+  const reopened = openRuntimeStore({ stateDir });
+  assert.deepEqual(reopened.listRecoverableRuns({ workspace: 'docs' }).map((run) => run.id), ['run-keep']);
+  reopened.close();
+});
+
 test('runtime store migrates legacy databases without workspace columns', () => {
   const stateDir = mkdtempSync(join(tmpdir(), 'wiki-manager-runtime-'));
   const db = new DatabaseSync(join(stateDir, 'runtime.db'));

package/src/runtime/supervisor.js

@@ -98,8 +98,55 @@ export async function pollActivitiesOnce(session, {
           payload: { activity: polledActivity },
         }));
         syncQueueWithActivity(session, polledActivity);
-        emitRuntimeLog(session, `activity: ${polledActivity.label} -> ${polledActivity.status}`);
+        // Only log when something actually changed: the poll fires every
+        // second and an unchanged "activity: X -> running" line repeated
+        // dozens of times drowned Logs/Trace and looked like a frozen system.
+        // The line itself carries the operational signal (current file,
+        // percent, batch, last trace event, retry/backoff) so the panel
+        // reads as a narrative of the job, not a heartbeat.
+        const progress = payload?.progress ?? polledActivity.progress ?? {};
+        const percent = Number(progress.percent ?? polledActivity.progress?.percent);
+        const detail = progress.detail ?? progress.step ?? '';
+        // The trace's batchIndex is 0-based and the human detail already says
+        // "Batch 1/2" — printing both gave "Batch 1/2 · batch 0/2". Display
+        // 1-based, and only when the detail doesn't already carry it.
+        const batch = progress.batchIndex != null && progress.batchCount != null && !/batch/i.test(String(detail))
+          ? `batch ${Number(progress.batchIndex) + 1}/${progress.batchCount}`
+          : null;
+        const lastEvent = progress.lastEvent ? String(progress.lastEvent) : null;
+        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 ?? ''}`;
+        session._activityLogKeys ??= {};
+        if (session._activityLogKeys[key] !== progressKey) {
+          session._activityLogKeys[key] = progressKey;
+          const progressLabel = [
+            Number.isFinite(percent) ? `${Math.round(percent)}%` : null,
+            detail ? String(detail) : null,
+            batch,
+            lastEvent,
+            retry,
+          ].filter(Boolean).join(' · ');
+          emitRuntimeLog(session, `activity: ${polledActivity.label} -> ${polledActivity.status}${progressLabel ? ` (${progressLabel})` : ''}`);
+        }
+        // Stream NEW job-log lines into Logs/Trace: document names, chunking,
+        // LLM call/token summaries and errors live in the job log, not in the
+        // status fields. Diff against the last line already shown.
+        const logTail = Array.isArray(payload?.logTail) ? payload.logTail.map(String) : [];
+        if (logTail.length > 0) {
+          session._activityLogCursors ??= {};
+          const lastSeen = session._activityLogCursors[key];
+          const lastIndex = lastSeen ? logTail.lastIndexOf(lastSeen) : -1;
+          for (const line of logTail.slice(lastIndex + 1)) {
+            const clean = line.trim();
+            if (clean) emitRuntimeLog(session, `job ${polledActivity.id ?? key}: ${clean}`);
+          }
+          session._activityLogCursors[key] = logTail.at(-1);
+        }
         if (polledActivity.terminal) {
+          delete session._activityLogKeys[key];
+          delete session._activityLogCursors?.[key];
           await startNextQueuedJob(session, {
             addLog: (message) => emitRuntimeLog(session, message),
           });
@@ -134,3 +181,32 @@ function registryIntervalFromEnv() {
   const value = Number(process.env.WIKI_MANAGER_AGENT_REGISTRY_INTERVAL_MS);
   return Number.isFinite(value) && value >= 0 ? Math.floor(value) : 60000;
 }
+
+// Cancelling a runtime run must also cancel the asynchronous jobs it started:
+// the run's abort only stopped the manager-side loop while the agent kept
+// executing (an ingest subprocess ran on for minutes after "cancel requested",
+// with the panels frozen on its last known state). Best effort: prefer the
+// orchestration contract's agent_cancel, fall back to legacy *_cancel_job.
+export async function cancelActiveActivityJobs(session, { callTool = callMcpTool } = {}) {
+  const cancelled = [];
+  for (const activity of sessionActivities(session)) {
+    if (activity.terminal || !activity.poll) continue;
+    const jobId = activity.poll.args?.jobId ?? activity.id ?? null;
+    const server = activity.poll.server;
+    const endpoint = session.mcp?.[server];
+    if (!jobId || !endpoint || endpoint.status !== 'connected') continue;
+    const names = (endpoint.tools ?? []).map((tool) => String(tool.name ?? ''));
+    const cancelTool = names.find((name) => /(^|__)agent_cancel$/.test(name))
+      ?? names.find((name) => /_cancel_job$/.test(name))
+      ?? names.find((name) => /(^|__)[a-z]*_?cancel$/.test(name));
+    if (!cancelTool) continue;
+    try {
+      await callTool(session.mcp, server, cancelTool, { jobId });
+      emitRuntimeLog(session, `cancel: requested ${server}.${cancelTool} for job ${jobId}`);
+      cancelled.push({ server, jobId });
+    } catch (err) {
+      emitRuntimeLog(session, `cancel: ${server}.${cancelTool} failed for ${jobId}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  return cancelled;
+}

package/src/shell/RightPane.tsx

@@ -16,7 +16,9 @@ type QueueItem = {
 type QueueInfo = { active: number; current: number; frozen: number };
 type LogLineParts = { time: string | null; message: string };
 
-const ACTIVITY_SLOTS = Array.from({ length: 6 }, (_, index) => index);
+// 4 slots (was 6): items can now span up to 5 lines each (wrapped label +
+// wrapped status/error), so fewer, readable entries beat more, truncated ones.
+const ACTIVITY_SLOTS = Array.from({ length: 4 }, (_, index) => index);
 const LOG_SLOTS = Array.from({ length: 24 }, (_, index) => index);
 
 function wrapLine(value: string, width: number) {
@@ -70,7 +72,18 @@ function queueColor(status: string) {
 function activityLine(activity: any) {
   const detail = activity?.progress?.detail ?? null;
   const phase = activity?.progress?.step ?? activity?.progress?.phase ?? activity?.progress?.currentStep ?? null;
-  return [activity?.status ?? 'unknown', detail ?? phase].filter(Boolean).join(' · ');
+  // On failure the error message is the information that matters — surface
+  // it instead of repeating the bare status the label color already conveys.
+  const error = activityErrorText(activity);
+  return [activity?.status ?? 'unknown', error ?? detail ?? phase].filter(Boolean).join(' · ');
+}
+
+function activityErrorText(activity: any): string | null {
+  const status = String(activity?.status ?? '').toLowerCase();
+  if (!['failed', 'error', 'cancelled', 'canceled'].includes(status)) return null;
+  const error = activity?.error ?? activity?.result?.error ?? activity?.progress?.detail ?? null;
+  const text = error == null ? '' : String(error).replace(/\s+/g, ' ').trim();
+  return text || null;
 }
 
 function activityPercentBadge(activity: any): { text: string; bg: string; fg: string } | null {
@@ -127,13 +140,19 @@ export function PlanPanel(props: { plan: PlanStep[]; width: number; jobName?: st
     <box flexShrink={0} flexDirection="column" padding={1}>
       <text width={lineWidth()} fg="#D6DEE8" content={fit(title(), lineWidth())} />
       <Index each={props.plan}>
-        {(step) => (
-          <text
-            width={lineWidth()}
-            fg={planStepColor(step(), firstPending())}
-            content={fit(`${icon(step().status)} ${step().step}. ${step().description}`, lineWidth())}
-          />
-        )}
+        {(step) => {
+          // Wrap step descriptions over up to 2 lines instead of truncating —
+          // "Ingest des 39 documents raw/untrac…" hid the actual target.
+          const lines = () => wrapLine(`${icon(step().status)} ${step().step}. ${step().description}`, lineWidth()).slice(0, 2);
+          return (
+            <box flexDirection="column">
+              <text width={lineWidth()} fg={planStepColor(step(), firstPending())} content={lines()[0]} />
+              <Show when={lines()[1]}>
+                <text width={lineWidth()} fg={planStepColor(step(), firstPending())} content={`    ${fit(lines()[1], Math.max(8, lineWidth() - 4))}`} />
+              </Show>
+            </box>
+          );
+        }}
       </Index>
     </box>
   );
@@ -141,7 +160,7 @@ export function PlanPanel(props: { plan: PlanStep[]; width: number; jobName?: st
 
 export function ActivityPanel(props: { activities: any[]; width: number }) {
   const lineWidth = () => Math.max(8, props.width - 2);
-  const visible = () => props.activities.slice(-6).reverse();
+  const visible = () => props.activities.slice(-ACTIVITY_SLOTS.length).reverse();
   const activityAt = (index: number) => visible()[index] ?? null;
   return (
     <box flexShrink={0} flexDirection="column" padding={1}>
@@ -150,21 +169,39 @@ export function ActivityPanel(props: { activities: any[]; width: number }) {
         <Index each={ACTIVITY_SLOTS}>
           {(slot) => {
             const activity = () => activityAt(slot());
-            const label = () => {
+            // Wrap instead of hard-truncating: a 40-column pane cut labels to
+            // "Appliquer la config recommandée (doct…" and hid the one thing
+            // that mattered. Labels get up to 2 lines, the status/error line
+            // up to 2 lines; empty continuation lines are not rendered.
+            const labelLines = () => {
               const item = activity();
-              if (!item) return '';
-              return fit(item.progress?.label ?? item.label ?? `${item.source ?? 'mcp'} ${item.kind ?? 'job'}`, lineWidth());
+              if (!item) return [''];
+              const label = String(item.progress?.label ?? item.label ?? `${item.source ?? 'mcp'} ${item.kind ?? 'job'}`);
+              const lines = wrapLine(label, lineWidth()).slice(0, 2);
+              if (lines.length === 2 && String(label).length > lines[0].length + lines[1].length) {
+                lines[1] = fit(lines[1], lineWidth());
+              }
+              return lines;
             };
             const badge = () => activityPercentBadge(activity());
             const badgeLen = () => badge()?.text.length ?? 0;
+            const statusLines = () => {
+              const item = activity();
+              if (!item) return [''];
+              return wrapLine(activityLine(item), Math.max(8, lineWidth() - badgeLen())).slice(0, 2);
+            };
+            const statusColor = () => (activityErrorText(activity()) ? '#F38BA8' : '#AAB7C4');
             return (
               <box flexDirection="column" marginTop={slot() === 0 ? 1 : 0}>
-                <text width={lineWidth()} fg={activityColor(activity()?.status)} content={label()} />
+                <text width={lineWidth()} fg={activityColor(activity()?.status)} content={labelLines()[0]} />
+                <Show when={labelLines()[1]}>
+                  <text width={lineWidth()} fg={activityColor(activity()?.status)} content={labelLines()[1]} />
+                </Show>
                 <box height={1} flexDirection="row">
                   <text
                     width={lineWidth() - badgeLen()}
-                    fg="#AAB7C4"
-                    content={activity() ? fit(activityLine(activity()), lineWidth() - badgeLen()) : ''}
+                    fg={statusColor()}
+                    content={activity() ? fit(statusLines()[0], lineWidth() - badgeLen()) : ''}
                   />
                   <text
                     width={badgeLen()}
@@ -173,6 +210,9 @@ export function ActivityPanel(props: { activities: any[]; width: number }) {
                     content={badge()?.text ?? ''}
                   />
                 </box>
+                <Show when={statusLines()[1]}>
+                  <text width={lineWidth()} fg={statusColor()} content={fit(statusLines()[1], lineWidth())} />
+                </Show>
                 <text width={lineWidth()} fg="#7F8C8D" content={activity() ? fit(updatedLine(activity()), lineWidth()) : ''} />
               </box>
             );
@@ -183,31 +223,84 @@ export function ActivityPanel(props: { activities: any[]; width: number }) {
   );
 }
 
+type LogSegment = { text: string; fg: string };
+
+// Per-line coloring: 'runtime' source tag in violet, HH:MM:SS in blue,
+// message tinted by nature (errors red, warnings amber, activity teal).
+// Continuation lines of a wrapped entry are indented and dimmed so each
+// entry reads as one visual block instead of an undifferentiated wall.
+function logMessageColor(message: string): string {
+  if (/\b(error|failed|exception|unavailable|introuvable|HTTP 4\d\d|HTTP 5\d\d)\b/i.test(message)) return '#F38BA8';
+  if (/\b(warn|warning|avertissement|fallback|retry|expired|stale)\b/i.test(message)) return '#FBBF24';
+  if (/^(activity|job)\b/i.test(message)) return '#8BD5CA';
+  return '#AAB7C4';
+}
+
+function logRenderLines(logs: string[], width: number): LogSegment[][] {
+  // Newest entry FIRST (descending): the freshest information belongs at the
+  // top of the pane. Wrapped continuation lines stay attached below their
+  // entry's first line.
+  const blocks: LogSegment[][][] = [];
+  for (const raw of logs) {
+    blocks.push(logEntryLines(raw, width));
+  }
+  return blocks.reverse().flat();
+}
+
+function logEntryLines(raw: string, width: number): LogSegment[][] {
+  const out: LogSegment[][] = [];
+  for (const item of [raw]) {
+    const rawLine = item;
+    const sourceMatch = String(rawLine).match(/^(runtime)\s+(.*)$/);
+    const source = sourceMatch ? sourceMatch[1] : null;
+    const rest = sourceMatch ? sourceMatch[2] : String(rawLine);
+    const parts = logLineParts(rest);
+    const prefix: LogSegment[] = [];
+    if (source) prefix.push({ text: `${source} `, fg: '#C6A0F6' });
+    if (parts.time) prefix.push({ text: `${parts.time} `, fg: '#89B4FA' });
+    const prefixLength = prefix.reduce((total, segment) => total + segment.text.length, 0);
+    const messageColor = logMessageColor(parts.message);
+    const wrapped = wrapLine(parts.message, Math.max(8, width - prefixLength));
+    wrapped.forEach((text, index) => {
+      if (index === 0) {
+        out.push([...prefix, { text, fg: messageColor }]);
+      } else {
+        const indent = ' '.repeat(Math.min(prefixLength, 4));
+        out.push([{ text: `${indent}${text}`, fg: messageColor === '#F38BA8' ? messageColor : '#7F8C8D' }]);
+      }
+    });
+  }
+  return out;
+}
+
 export function LogPanel(props: { logs: string[]; width: number; filter?: string }) {
   const lineWidth = () => Math.max(8, props.width - 2);
   const filteredLogs = () => filterRuntimeLogs(props.logs, props.filter ?? '');
-  const visibleLines = () => filteredLogs().flatMap((line) => wrapLine(line, lineWidth())).slice(-24);
-  const logLineAt = (index: number) => visibleLines()[index] ?? '';
+  const visibleLines = createMemo(() => logRenderLines(filteredLogs(), lineWidth()).slice(0, 24));
+  const segmentsAt = (index: number): LogSegment[] => visibleLines()[index] ?? [];
   return (
     <box flexGrow={1} flexDirection="column" padding={1}>
       <text width={lineWidth()} fg="#D6DEE8" content="Logs / Trace" />
       <box flexGrow={1} flexDirection="column" overflow="hidden">
         <Index each={LOG_SLOTS}>
           {(slot) => {
-            const line = () => logLineAt(slot());
-            const parts = createMemo(() => logLineParts(line()));
-            const timeWidth = () => parts().time ? Math.min(parts().time!.length + 1, lineWidth()) : 0;
-            const messageWidth = () => Math.max(1, lineWidth() - timeWidth());
+            const segments = () => segmentsAt(slot());
+            const segmentAt = (position: number): LogSegment => segments()[position] ?? { text: '', fg: '#AAB7C4' };
+            const usedWidth = (upTo: number) => segments().slice(0, upTo).reduce((total, segment) => total + segment.text.length, 0);
+            const widthFor = (position: number) => {
+              const segment = segmentAt(position);
+              if (!segment.text) return 0;
+              // Last visible segment absorbs the remaining width.
+              return position === segments().length - 1
+                ? Math.max(1, lineWidth() - usedWidth(position))
+                : Math.min(segment.text.length, lineWidth() - usedWidth(position));
+            };
             return (
-              <Show
-                when={parts().time}
-                fallback={<text width={lineWidth()} fg="#AAB7C4" content={line()} />}
-              >
-                <box height={1} flexDirection="row" overflow="hidden">
-                  <text width={timeWidth()} fg="#89B4FA" content={`${parts().time} `} />
-                  <text width={messageWidth()} fg="#AAB7C4" content={parts().message} />
-                </box>
-              </Show>
+              <box height={1} flexDirection="row" overflow="hidden">
+                <text width={widthFor(0)} fg={segmentAt(0).fg} content={segmentAt(0).text} />
+                <text width={widthFor(1)} fg={segmentAt(1).fg} content={segmentAt(1).text} />
+                <text width={widthFor(2)} fg={segmentAt(2).fg} content={segmentAt(2).text} />
+              </box>
             );
           }}
         </Index>

package/src/shell/SetupWizard.tsx

@@ -1,7 +1,7 @@
 /** @jsxImportSource @opentui/solid */
 import { execFileSync } from 'node:child_process';
 import { join } from 'node:path';
-import { useKeyboard } from '@opentui/solid';
+import { useKeyboard, usePaste } from '@opentui/solid';
 import { createEffect, createMemo, createSignal, For, Show } from 'solid-js';
 import { fallbackModels, normalizeProvider } from '../core/modelFetch.js';
 import {
@@ -606,6 +606,18 @@ export function SetupWizard(props: {
     } catch { return ''; }
   }
 
+  // Terminal paste (Cmd+V/middle-click) arrives as a bracketed-paste block.
+  // openTUI's key parser swallows the \x1b[200~/\x1b[201~ markers and emits a
+  // dedicated `paste` event instead of key events — the text NEVER reaches
+  // useKeyboard, so the legacy bracketed-paste branch below can't fire.
+  usePaste((event: any) => {
+    if (busy() || step().kind !== 'text') return;
+    const raw = event?.text
+      ?? (event?.bytes != null ? Buffer.from(event.bytes).toString('utf8') : '');
+    const pasted = String(raw).replace(/\r\n?/g, '\n').replace(/\n+$/, '').split('\n').join(' ');
+    if (pasted) setInput((value) => value + pasted);
+  });
+
   useKeyboard((key: any) => {
     if (busy()) return;
     const s = step();

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, formatLlmUnavailableMessage } from '../agent/graph.js';
+import { buildAgentSystemPrompt, classifyAgentInput, 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';
@@ -16,6 +16,7 @@ import { listSkills } from '../core/skills.js';
 import { listWikircProfiles } from '../core/wikirc.js';
 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());
 // marked-terminal's text renderer extracts token.text (raw string) instead of
@@ -74,6 +75,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.',
   '/approve': 'Approve a pending runtime run or tool.',
 };
 
@@ -89,6 +91,9 @@ const SUBCOMMAND_COMPLETION_DESCRIPTIONS = {
   '/upload:convert': 'Convert one stored upload or all pending uploads.',
   '/uploads:clean': 'Clean old stored document uploads.',
   '/uploads:list': 'List uploaded documents.',
+  '/run:status': 'Show runtime run status.',
+  '/run:cancel': 'Cancel the active runtime run.',
+  '/run:kill': 'Hard-kill runtime run(s).',
   '/queue': 'Inspect or cancel queued MCP jobs.',
   '/queue:cancel': 'Cancel a queued or running queue item.',
   '/queue:clear': 'Clear finished queue items.',
@@ -136,7 +141,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', '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', 'queue', 'approve'],
     chatMode: true,
     llm: null,
     activities: {},
@@ -241,6 +246,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 === '/queue' && tokenIndex === 1) return ['cancel', 'clear'];
   if (command === '/queue' && previousToken === 'cancel') {
     return (session.jobQueue ?? [])
@@ -786,7 +792,10 @@ export function applyRuntimeStateToShellSession(session, state) {
   session.activities = Object.fromEntries(
     session.agentProjection.activities.map((activity) => [activity.key, { ...activity }]),
   );
-  if (Array.isArray(state.queue)) session.jobQueue = state.queue.map((item) => ({ ...item }));
+  // 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' }));
   const production = session.agentProjection.activities.filter((activity) => activity.source === 'production').at(-1);
   if (production) {
     session.productionActivity = {
@@ -803,14 +812,54 @@ export function applyRuntimeStateToShellSession(session, state) {
 // 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 };
+  if (!llmAvailable) return { local: false, classification, fallbackReason: 'local LLM unavailable' };
+  return { local: true, classification };
+}
+
 export async function submitRuntimeRun(line, { runtime, session }) {
   const workspace = session.workspace ?? null;
   try {
+    if (runtimeRunActive(session)) {
+      // POST /run during an active run blindly ENQUEUES a future run server-
+      // side (202 queued) — the 409→control fallback below never fires, so
+      // "stop le job" / "annule" ended up in the queue instead of being
+      // classified. Send an explicit control message: the server classifies
+      // it (cancel aborts the run, approve grants, modify proposes a patch).
+      const result = await postRuntimeControl('message', { url: runtime.url, workspace, input: line });
+      // The client-side "run active" flag can be STALE (projection still says
+      // running right after a run ended). The server's answer carries the
+      // truth: if the runtime is actually idle and only produced a canned
+      // read-only reply ("Runtime is idle."), the user's input was meant to
+      // START a run — fall through to POST /run instead of dead-ending.
+      const idleCannedReply = result?.running === false
+        && ['converse', 'observe', 'ambiguous'].includes(String(result?.kind ?? ''));
+      if (!idleCannedReply) {
+        return { kind: result?.kind ?? 'control', result };
+      }
+    }
     const result = await postRuntimeRun(line, { url: runtime.url, workspace });
     if (result?.queued || result?.kind === 'enqueue_run' || result?.kind === 'enqueue') {
       return { kind: 'queued', result };
     }
-    return { kind: 'accepted' };
+    if (result?.kind && !result?.runId) {
+      // The server was actually running (stale idle flag client-side) and
+      // classified our input as a control message — surface its kind and
+      // localized explanation instead of pretending a run was accepted.
+      return { kind: result.kind, result };
+    }
+    return { kind: 'accepted', result };
   } catch (err) {
     if (err?.status !== 409) {
       return { kind: 'error', message: err instanceof Error ? err.message : String(err) };
@@ -876,7 +925,7 @@ function renderScreen({ packageJson, session, messages, inputBuffer, busy = fals
   const prompt = promptFor(session);
   const title = '';
   const context = [
-    `wiki-manager ${packageJson.version}`,
+    `wiki-manager ${versionWithBuild(packageJson)}`,
     session.workspace ? session.workspace : 'no workspace',
     session.wikirc?.profile ? session.wikirc.profile : 'no wikirc',
     session.language ? session.language : 'no language',
@@ -1164,7 +1213,7 @@ function directChatUnavailableText(session) {
   return 'Direct chat unavailable: no streaming LLM configured.';
 }
 
-export async function runLine(line, { agent, packageJson, session, onUpdate, onStep, chatMode = session.chatMode ?? true }) {
+export async function runLine(line, { agent, packageJson, session, onUpdate, onStep, chatMode = session.chatMode ?? true, runtime = null }) {
   const trimmed = stripHtml(line).trim();
   if (!trimmed) return { exit: false };
 
@@ -1175,7 +1224,7 @@ export async function runLine(line, { agent, packageJson, session, onUpdate, onS
 
   if (trimmed.startsWith('/')) {
     onStep?.(`Shell: ${trimmed}`);
-    const result = await handleSlashCommand(trimmed, { packageJson, session, onStep });
+    const result = await handleSlashCommand(trimmed, { packageJson, session, onStep, runtime });
     const messages = conversationMessages(session);
     const handoffRawToAgent = Boolean(result.rawOutput && result.agentTrigger && agent);
     if (result.output) {
@@ -1574,7 +1623,19 @@ async function runTuiShell({ agent, packageJson, session, runtime = null }) {
             syncRuntimeState();
           }
         } else {
-          if (runtime?.url && !session.chatMode && !line.trim().startsWith('/')) {
+          const freeTextRouting = (runtime?.url && !session.chatMode && !line.trim().startsWith('/'))
+            ? shouldHandleFreeTextLocally(line, session)
+            : null;
+          if (freeTextRouting?.local) {
+            // Question/small talk → local agent (read tools), no runtime run.
+            activityLines = [...activityLines, `agent: ${freeTextRouting.classification.kind} handled locally`].slice(-LOWER_DETAIL_ROWS);
+            const result = await runLine(line, { agent, packageJson, session, onUpdate: rerender, onStep, runtime });
+            done = result.exit;
+            aborted = result.aborted ?? false;
+          } else if (runtime?.url && !session.chatMode && !line.trim().startsWith('/')) {
+            if (freeTextRouting?.fallbackReason) {
+              activityLines = [...activityLines, `runtime: ${freeTextRouting.fallbackReason}, routing to runtime run`].slice(-LOWER_DETAIL_ROWS);
+            }
             conversationMessages(session).push({ role: 'user', content: line });
             const outcome = await submitRuntimeRun(line, { runtime, session });
             if (outcome.kind === 'accepted') {
@@ -1590,6 +1651,11 @@ async function runTuiShell({ agent, packageJson, session, runtime = null }) {
             } else if (outcome.kind === 'ambiguous') {
               conversationMessages(session).push({ role: 'command', content: String(outcome.result?.explanation ?? 'Runtime could not classify that message. Use /queue for a future run, or ask/status more explicitly.') });
               activityLines = [...activityLines, 'runtime: ambiguous control'].slice(-LOWER_DETAIL_ROWS);
+            } else if (outcome.result?.explanation) {
+              // cancel / approve / modify_run and any future control kinds:
+              // always surface the server's localized explanation.
+              conversationMessages(session).push({ role: 'command', content: String(outcome.result.explanation) });
+              activityLines = [...activityLines, `runtime: ${outcome.kind}`].slice(-LOWER_DETAIL_ROWS);
             } else {
               conversationMessages(session).push({ role: 'command', content: `Runtime error: ${outcome.message}` });
               activityLines = [...activityLines, `runtime error: ${outcome.message}`].slice(-LOWER_DETAIL_ROWS);
@@ -1599,7 +1665,7 @@ async function runTuiShell({ agent, packageJson, session, runtime = null }) {
             const message = recordRuntimeUnavailableAgentInput(session, line, runtime);
             activityLines = [...activityLines, message ?? 'runtime: disconnected'].slice(-LOWER_DETAIL_ROWS);
           } else {
-            const result = await runLine(line, { agent, packageJson, session, onUpdate: rerender, onStep });
+            const result = await runLine(line, { agent, packageJson, session, onUpdate: rerender, onStep, runtime });
             done = result.exit;
             aborted = result.aborted ?? false;
           }
@@ -1718,6 +1784,9 @@ async function runTuiShell({ agent, packageJson, session, runtime = null }) {
 
 export async function runShell({ agent, packageJson, runtime = null }) {
   const session = createSession();
+  // Donna's runtime control tools (runtime__kill/cancel/status) read the
+  // endpoint from the session.
+  session.runtime = runtime;
   if (!input.isTTY || !output.isTTY) {
     await runPipeShell({ agent, packageJson, session });
     return;