@dotdrelle/wiki-manager 0.12.1 → 0.12.8

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;

package/src/shell/repl.test.js

@@ -11,6 +11,7 @@ import {
   runLine,
   runtimeStatusLine,
   runtimeUnavailableAgentMessage,
+  shouldHandleFreeTextLocally,
   submitRuntimeRun,
 } from './repl.js';
 
@@ -81,7 +82,9 @@ test('submitRuntimeRun reports acceptance without throwing', async () => {
   try {
     const session = createSession();
     const outcome = await submitRuntimeRun('build the doc', { runtime: { url: 'http://runtime.test' }, session });
-    assert.deepEqual(outcome, { kind: 'accepted' });
+    // The accepted payload is passed through so callers can surface the runId
+    // in the chat (immediate feedback that the run started).
+    assert.deepEqual(outcome, { kind: 'accepted', result: { accepted: true, runId: 'run-1' } });
   } finally {
     restore();
   }
@@ -191,3 +194,113 @@ test('runtime status exposes the disconnected reason', () => {
     '⚠ Runtime indisponible : token mismatch — /agent désactivé, /chat reste possible',
   );
 });
+
+test('/run kill posts to the runtime kill endpoint', async () => {
+  let calledUrl = null;
+  const restore = stubFetch(async (url) => {
+    calledUrl = new URL(String(url));
+    return jsonResponse(202, { killed: true, runs: 1, tasks: 2 });
+  });
+  try {
+    const session = createSession();
+    session.workspace = 'docs';
+
+    const result = await runLine('/run kill', {
+      agent: null,
+      packageJson: { version: 'test' },
+      session,
+      runtime: { url: 'http://runtime.test' },
+    });
+
+    assert.equal(result.exit, false);
+    assert.equal(calledUrl.pathname, '/kill');
+    assert.equal(calledUrl.searchParams.get('workspace'), 'docs');
+    assert.match(conversationMessages(session).at(-1).content, /Runtime kill requested: 1 run, 2 tasks cancelled/);
+  } finally {
+    restore();
+  }
+});
+
+test('/queue cancel on a runtime workflow id points to run cancellation commands', async () => {
+  const session = createSession();
+  session.workspace = 'docs';
+  session.jobQueue = [];
+  session.workflow = {
+    nodes: [{ id: 'task:runtime-a', type: 'task', label: 'Runtime task', status: 'pending' }],
+    relations: [],
+  };
+
+  const result = await runLine('/queue cancel task:runtime-a', {
+    agent: null,
+    packageJson: { version: 'test' },
+    session,
+  });
+
+  assert.equal(result.exit, false);
+  assert.match(conversationMessages(session).at(-1).content, /Item géré par le runtime/);
+  assert.match(conversationMessages(session).at(-1).content, /\/run kill/);
+});
+
+test('free text routing keeps questions local and sends actions to the runtime', () => {
+  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');
+
+  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');
+});
+
+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.
+  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);
+
+  const offline = createSession();
+  offline.llm = null;
+  const fallback = shouldHandleFreeTextLocally('donne moi la config du cme', offline);
+  assert.equal(fallback.local, false);
+  assert.match(fallback.fallbackReason ?? '', /LLM unavailable/);
+});
+
+test('submitRuntimeRun sends a control message instead of /run while a run is active', async () => {
+  const paths = [];
+  const restore = stubFetch(async (url) => {
+    paths.push(pathOf(url));
+    return jsonResponse(200, {
+      accepted: true,
+      kind: 'cancel',
+      classification: { kind: 'cancel' },
+      explanation: 'Runtime cancellation requested.',
+    });
+  });
+  try {
+    const session = createSession();
+    session.agentProjection = { status: 'running', activities: [], conversation: [] };
+    const outcome = await submitRuntimeRun('stop le job', { runtime: { url: 'http://runtime.test' }, session });
+    assert.deepEqual(paths, ['/control'], 'active run must use the control lane, not POST /run');
+    assert.equal(outcome.kind, 'cancel');
+    assert.match(outcome.result?.explanation ?? '', /cancellation requested/i);
+  } finally {
+    restore();
+  }
+});

package/src/shell/tui.tsx

@@ -126,7 +126,10 @@ function App(props: {
   const conversationRows = createMemo(() => Math.max(4, dimensions().height - 5 - chatInputHeight()));
   const rightColumns = createMemo(() => {
     const width = dimensions().width;
-    return Math.max(26, Math.min(44, Math.floor(width * 0.32)));
+    // 38% / cap 56 (was 32% / cap 44): the Plan/Activity/Logs panes carry job
+    // labels, file names and error messages — 40 columns truncated everything
+    // into unreadable stubs.
+    return Math.max(30, Math.min(56, Math.floor(width * 0.38)));
   });
   const leftColumns = createMemo(() => Math.max(32, dimensions().width - rightColumns() - 1));
   const conversationColumns = createMemo(() => {