@dotdrelle/wiki-manager 0.12.0 → 0.12.7

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,21 +1623,39 @@ 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') {
               activityLines = [...activityLines, 'runtime: run accepted'].slice(-LOWER_DETAIL_ROWS);
             } else if (outcome.kind === 'queued') {
-              conversationMessages(session).push({ role: 'command', content: 'Runtime is busy — request added to the control queue, it will start automatically.' });
+              // Server-localized acknowledgement (src/runtime/controlMessages.js).
+              conversationMessages(session).push({ role: 'command', content: String(outcome.result?.explanation ?? 'Request added to the queue.') });
               activityLines = [...activityLines, 'runtime: control queued'].slice(-LOWER_DETAIL_ROWS);
             } else if (outcome.kind === 'observe' || outcome.kind === 'converse' || outcome.kind === 'mutate') {
               const explanation = outcome.result?.explanation ?? 'Runtime control message accepted.';
               conversationMessages(session).push({ role: 'command', content: explanation });
               activityLines = [...activityLines, `runtime: ${outcome.kind}`].slice(-LOWER_DETAIL_ROWS);
             } else if (outcome.kind === 'ambiguous') {
-              conversationMessages(session).push({ role: 'command', content: 'Runtime could not classify that message. Use /queue for a future run, or ask/status more explicitly.' });
+              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);
@@ -1598,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;
           }
@@ -1717,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();
   }
@@ -183,7 +186,7 @@ test('agent mode without runtime records a visible error instead of falling back
 
 test('runtime status exposes the disconnected reason', () => {
   assert.equal(
-    runtimeStatusLine({ error: 'token mismatch' }, { workspace: 'juno' }),
+    runtimeStatusLine({ error: 'token mismatch' }, { workspace: 'acme' }),
     'runtime: disconnected: token mismatch',
   );
   assert.equal(
@@ -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(() => {

package/src/shell/useAgent.ts

@@ -1,6 +1,6 @@
 import { createSignal } from 'solid-js';
 import { postRuntimeCancel } from '../runtime/client.js';
-import { conversationMessages, recordRuntimeUnavailableAgentInput, runLine, submitRuntimeRun } from './repl.js';
+import { conversationMessages, recordRuntimeUnavailableAgentInput, runLine, shouldHandleFreeTextLocally, submitRuntimeRun } from './repl.js';
 
 export function useAgent(props: { agent: unknown; packageJson: Record<string, unknown>; session: Record<string, any>; chatMode: () => boolean; runtimeUrl?: string | null; runtimeUnavailableReason?: string | null; refresh: () => void; addLog: (line: string) => void; onRuntimeAccepted?: () => void }) {
   const [busy, setBusy] = createSignal(false);
@@ -18,7 +18,17 @@ export function useAgent(props: { agent: unknown; packageJson: Record<string, un
     props.addLog(`input: ${trimmed}`);
 
     try {
-      if (props.runtimeUrl && !props.chatMode() && !trimmed.startsWith('/')) {
+      // Questions and small talk are answered by the local agent: the reply
+      // shows up in the chat immediately and no runtime run (plan, SQLite
+      // state, replans) is created for a sentence that only needed an answer.
+      // Actions still go to the runtime below.
+      const freeTextRouting = (props.runtimeUrl && !props.chatMode() && !trimmed.startsWith('/'))
+        ? shouldHandleFreeTextLocally(trimmed, props.session)
+        : null;
+      if (props.runtimeUrl && !props.chatMode() && !trimmed.startsWith('/') && !freeTextRouting?.local) {
+        if (freeTextRouting?.fallbackReason) {
+          props.addLog(`runtime: ${freeTextRouting.fallbackReason}, routing to runtime run`);
+        }
         // Marked _pending so mergeRuntimeConversation (useSession.ts) can
         // confirm this exact entry instead of pushing a second copy once the
         // same user message comes back from the runtime's own /state.
@@ -29,10 +39,26 @@ export function useAgent(props: { agent: unknown; packageJson: Record<string, un
         });
         if (outcome.kind === 'accepted') {
           props.onRuntimeAccepted?.();
+          const runId = (outcome as any).result?.runId ?? null;
+          // Light, immediate feedback in the chat: without it an accepted run
+          // is invisible until its first activity lands in the side panels.
+          conversationMessages(props.session).push({
+            role: 'command',
+            content: `▶ Run accepté${runId ? ` (${String(runId).slice(0, 8)})` : ''} — progression dans le panneau Activity, réponse ici à la fin du run.`,
+          });
           props.addLog('runtime: run accepted');
         } else if (outcome.kind === 'queued') {
-          conversationMessages(props.session).push({ role: 'command', content: 'Runtime is busy — request added to the control queue, it will start automatically.' });
+          // The server localizes control-lane acknowledgements from the
+          // session language (src/runtime/controlMessages.js) — always prefer
+          // its explanation over a local hardcoded string.
+          const explanation = (outcome as any).result?.explanation ?? 'Request added to the queue.';
+          conversationMessages(props.session).push({ role: 'command', content: String(explanation) });
           props.addLog('runtime: control queued');
+        } else if ((outcome as any).result?.explanation) {
+          // Control-lane kinds (cancel / approve / observe / modify_run…):
+          // surface the server's localized explanation instead of an error.
+          conversationMessages(props.session).push({ role: 'command', content: String((outcome as any).result.explanation) });
+          props.addLog(`runtime: ${outcome.kind}`);
         } else {
           conversationMessages(props.session).push({ role: 'command', content: `Runtime error: ${outcome.message}` });
           props.addLog(`runtime error: ${outcome.message}`);
@@ -40,7 +66,7 @@ export function useAgent(props: { agent: unknown; packageJson: Record<string, un
         props.refresh();
         return { exit: false, runtime: true };
       }
-      if (!props.chatMode() && !trimmed.startsWith('/')) {
+      if (!props.chatMode() && !trimmed.startsWith('/') && !freeTextRouting?.local) {
         const message = recordRuntimeUnavailableAgentInput(props.session, trimmed, {
           error: props.runtimeUnavailableReason ?? 'runtime introuvable',
         });
@@ -48,6 +74,9 @@ export function useAgent(props: { agent: unknown; packageJson: Record<string, un
         props.refresh();
         return { exit: false, runtimeUnavailable: true };
       }
+      if (freeTextRouting?.local) {
+        props.addLog(`agent: ${freeTextRouting.classification.kind} handled locally`);
+      }
       const result = await runLine(trimmed, {
         agent: props.agent,
         packageJson: props.packageJson,
@@ -55,6 +84,10 @@ export function useAgent(props: { agent: unknown; packageJson: Record<string, un
         onUpdate: props.refresh,
         onStep: props.addLog,
         chatMode: props.chatMode(),
+        // Without this, slash commands that target the runtime (/run kill,
+        // /run cancel, /run status) reported "Runtime unavailable" in the
+        // TUI even while the status bar showed "runtime: connected".
+        runtime: props.runtimeUrl ? { url: props.runtimeUrl } : null,
       });
       props.refresh();
       return result;

package/src/shell/useSession.ts

@@ -2,6 +2,7 @@ import { writeFileSync } from 'node:fs';
 import { isAbsolute, relative, resolve, sep } from 'node:path';
 import { createEffect, createMemo, createSignal, onCleanup } from 'solid-js';
 import { formatMcpToolResult, callMcpTool } from '../core/mcp.js';
+import { versionWithBuild } from '../core/buildInfo.js';
 import { extractActivity, parseJsonText, sessionActivities } from '../core/activity.js';
 import { formatPlanStatus, formatCompletedActivities, formatPlanStep } from '../core/plan.js';
 import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
@@ -47,6 +48,12 @@ function buildContinuationPrompt(session: any, completed: any[]): string {
 
 export function useSession(props: { agent: unknown; packageJson: Record<string, unknown>; runtime?: any }) {
   const session = createSession();
+  // Donna's runtime__kill/cancel/status/approve/enqueue tools (graph.js)
+  // read session.runtime.url directly — without this the OpenTUI session
+  // never had it set (only the legacy runShell path did), so those tools
+  // reported "Runtime not connected" even with the runtime up and the
+  // status bar showing "connected".
+  (session as any).runtime = props.runtime ?? null;
   const [version, setVersion] = createSignal(0);
   const [logs, setLogs] = createSignal<string[]>([]);
   const [runtimeState, setRuntimeState] = createSignal<any | null>(null);
@@ -139,7 +146,7 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
   const statusLine = createMemo(() => {
     version();
     return [
-      `wiki-manager ${props.packageJson.version ?? ''}`.trim(),
+      `wiki-manager ${versionWithBuild(props.packageJson)}`.trim(),
       session.workspace ? session.workspace : 'no workspace',
       session.wikirc?.profile ? session.wikirc.profile : 'no wikirc',
       session.language ? session.language : 'no language',
@@ -224,36 +231,64 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
       ? lastVisibleActivities.map((activity) => ({ ...activity }))
       : current;
   });
+  // Control-lane run requests (user messages queued while the runtime is
+  // busy) live in state.controlQueue, a separate lane from the MCP job
+  // queue. They must appear in the Queue panel too — otherwise a queued run
+  // request is invisible (Queue (0)) even though it is registered and will
+  // start automatically.
+  const controlQueueItems = createMemo(() => {
+    version();
+    const controlQueue = runtimeState()?.controlQueue;
+    if (!Array.isArray(controlQueue)) return [] as any[];
+    return controlQueue
+      .filter((item: any) => ['queued', 'running', 'starting'].includes(String(item.status ?? '').toLowerCase()))
+      .map((item: any) => ({
+        ...item,
+        id: item.id,
+        label: `run: ${String(item.input ?? '').slice(0, 64)}`,
+        status: item.status,
+        _runtime: true,
+        _control: true,
+      }));
+  });
   const queueItems = createMemo(() => {
     version();
+    const control = controlQueueItems();
     const workflowQueue = nonEmptyRuntimeArray(runtimeState()?.workflow?.nodes?.filter((node: any) => node.type === 'queue'));
     if (workflowQueue) {
-      return workflowQueue.map((node: any) => ({ ...(node.raw ?? {}), id: node.itemId ?? node.id, label: node.label, status: node.status, _runtime: true, _workflow: true }));
+      return [...control, ...workflowQueue.map((node: any) => ({ ...(node.raw ?? {}), id: node.itemId ?? node.id, label: node.label, status: node.status, _runtime: true, _workflow: true }))];
     }
     const runtimeQueue = nonEmptyRuntimeArray(runtimeState()?.queue);
-    if (runtimeQueue) return runtimeQueue.map((item: any) => ({ ...item, _runtime: true }));
-    return projectQueue((session as any).headlessPlan, (session as any).jobQueue ?? [], { workspace: (session as any).workspace ?? null })
-      .map((item: any) => ({ ...item }));
+    if (runtimeQueue) return [...control, ...runtimeQueue.map((item: any) => ({ ...item, _runtime: true }))];
+    return [
+      ...control,
+      ...projectQueue((session as any).headlessPlan, (session as any).jobQueue ?? [], { workspace: (session as any).workspace ?? null })
+        .map((item: any) => ({ ...item })),
+    ];
   });
   const queueInfo = createMemo(() => {
     version();
+    const control = controlQueueItems();
+    const controlActive = control.length;
+    const controlCurrent = control.filter((item: any) => ['starting', 'running'].includes(String(item.status ?? '').toLowerCase())).length;
     const workflowQueue = runtimeState()?.workflow?.nodes?.filter((node: any) => node.type === 'queue');
     if (Array.isArray(workflowQueue)) {
       return {
-        active: workflowQueue.filter((item: any) => ['waiting', 'starting', 'running', 'queued', 'pending', 'pending_approval'].includes(String(item.status ?? '').toLowerCase())).length,
-        current: workflowQueue.filter((item: any) => ['starting', 'running'].includes(String(item.status ?? '').toLowerCase())).length,
+        active: controlActive + workflowQueue.filter((item: any) => ['waiting', 'starting', 'running', 'queued', 'pending', 'pending_approval'].includes(String(item.status ?? '').toLowerCase())).length,
+        current: controlCurrent + workflowQueue.filter((item: any) => ['starting', 'running'].includes(String(item.status ?? '').toLowerCase())).length,
         frozen: 0,
       };
     }
     const runtimeQueue = runtimeState()?.queue;
     if (Array.isArray(runtimeQueue)) {
       return {
-        active: runtimeQueue.filter((item: any) => ['waiting', 'starting', 'running', 'queued', 'pending', 'pending_approval'].includes(String(item.status ?? '').toLowerCase())).length,
-        current: runtimeQueue.filter((item: any) => ['starting', 'running'].includes(String(item.status ?? '').toLowerCase())).length,
+        active: controlActive + runtimeQueue.filter((item: any) => ['waiting', 'starting', 'running', 'queued', 'pending', 'pending_approval'].includes(String(item.status ?? '').toLowerCase())).length,
+        current: controlCurrent + runtimeQueue.filter((item: any) => ['starting', 'running'].includes(String(item.status ?? '').toLowerCase())).length,
         frozen: 0,
       };
     }
-    return queueCounts(session);
+    const base = queueCounts(session);
+    return { ...base, active: (base.active ?? 0) + controlActive, current: (base.current ?? 0) + controlCurrent };
   });
   const plan = createMemo(() => {
     version();
@@ -309,6 +344,12 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
     const target = conversationMessages(session);
     const backed = runtimeConversationRefsByWorkspace.get(workspace) ?? [];
     runtimeConversationRefsByWorkspace.set(workspace, backed);
+    // The merge is index-aligned with the runtime conversation array. If that
+    // array got SHORTER (runtime restart, projection reset), keeping stale
+    // refs would make every new runtime entry silently overwrite an old
+    // backed entry instead of appearing in the chat. Drop the refs and let
+    // the new conversation append cleanly.
+    if (runtimeConversation.length < backed.length) backed.length = 0;
     if (backed.length === 0 && target.length === 0 && !runtimeConversation.some((message: any) => message?._pending)) {
       backed.push(...runtimeConversation.map((message: any) => ({
         role: message.role === 'assistant' ? 'donna' : message.role,