@dotdrelle/wiki-manager 0.15.27 → 0.15.29

package/src/shell/LeftPane.tsx

@@ -77,8 +77,6 @@ type RenderedLine = {
   statusLeft?: string;
   statusRight?: string;
   copyContent?: string;
-  redoContent?: string;
-  redoIndex?: number;
 };
 const STATUS_COLUMN_GAP = 2;
 type HelpCard = { title: string; text: string; example: string };
@@ -142,14 +140,11 @@ function WelcomeHelpPanels(props: { width: number }) {
 }
 
 const COPY_BTN = ' [ copy ]';
-// Only user messages carry it: redo re-asks *this* question, so the action has
-// to sit on the message it acts upon.
-const REDO_BTN = ' [ redo ]';
 
-function messageHeaderSegments(role: string, columns: number, withRedo = false): Segment[] {
+function messageHeaderSegments(role: string, columns: number): Segment[] {
   const label = `[${roleLabel(role)}]`;
   const left = '── ';
-  const actionsLength = COPY_BTN.length + (withRedo ? REDO_BTN.length : 0);
+  const actionsLength = COPY_BTN.length;
   const rightLength = Math.max(2, columns - left.length - label.length - 1 - actionsLength);
   return [
     { text: left, color: '#4B5563' },
@@ -370,6 +365,13 @@ function statusValueColor(value: string) {
 function statusSegments(value: string): Segment[] {
   const text = value || ' ';
   const trimmed = text.trim();
+  const linkedValue = text.match(/^(\s*[A-Za-z][A-Za-z0-9 _./-]{0,34}:\s*)\[([^\]]+)\]\((https?:\/\/[^)]+)\)\s*$/);
+  if (linkedValue) {
+    return [
+      { text: linkedValue[1], color: '#8BD5CA' },
+      { text: linkedValue[2], color: '#5DADE2', url: linkedValue[3] },
+    ];
+  }
   if (trimmed && !text.startsWith(' ') && !trimmed.includes(':') && !/^[●◐○-]/.test(trimmed)) {
     return [{ text, color: '#FBBF24' }];
   }
@@ -416,13 +418,11 @@ function conversationLines(messages: Array<{ role: string; content: string }>, c
     const raw = String(message.content || '');
     const previous = index > 0 ? messages[index - 1] : null;
     const showHeader = !previous || headerGroupKey(previous.role) !== headerGroupKey(message.role);
-    const canRedo = message.role === 'user' && raw.trim().length > 0;
     const headerLines: RenderedLine[] = showHeader
       ? [
           {
-            segments: messageHeaderSegments(message.role, columns, canRedo),
+            segments: messageHeaderSegments(message.role, columns),
             copyContent: raw,
-            ...(canRedo ? { redoContent: raw, redoIndex: index } : {}),
           },
           { segments: [{ text: ' ', color: '#D6DEE8' }] },
         ]
@@ -433,6 +433,11 @@ function conversationLines(messages: Array<{ role: string; content: string }>, c
         ...headerLines,
         ...raw.split('\n').map((line) => {
           const { left, right } = statusColumns(line || ' ');
+          // A row with nothing on either side is vertical padding, not data.
+          // Rendering it as a status row drew an empty blue-bordered box under
+          // the last real line — the leftover visible at the bottom right of
+          // /status. Emit a plain spacer so the boxes stop with the content.
+          if (!left.trim() && !right.trim()) return { segments: [{ text: ' ', color: '#D6DEE8' }] };
           return { status: true, statusLeft: left, statusRight: right, segments: [] };
         }),
         { segments: [{ text: ' ', color: '#D6DEE8' }] },
@@ -472,15 +477,18 @@ export function ConversationView(props: {
   onScroll: (delta: number) => void;
   spinnerFrame: string;
   onCopy?: (content: string) => void;
-  onRedo?: (index: number, content: string) => void;
   onOpenLink?: (url: string) => void;
 }) {
   const renderer = useRenderer();
+  const [hoveredUrl, setHoveredUrl] = createSignal<string | null>(null);
   // Terminals have no CSS cursor, but OpenTUI can ask the emulator to swap the
   // mouse pointer shape. Without it nothing on screen distinguishes a clickable
   // link from ordinary blue text, so operators never discovered links were
   // clickable at all.
-  const hoverLink = (url: string | null) => renderer?.setMousePointer?.(url ? 'pointer' : 'default');
+  const hoverLink = (url: string | null) => {
+    setHoveredUrl(url);
+    renderer?.setMousePointer?.(url ? 'pointer' : 'default');
+  };
   const allLines = createMemo(() => conversationLines(props.messages, props.columns));
   const visibleLines = () => {
     const lines = allLines();
@@ -516,7 +524,9 @@ export function ConversationView(props: {
         event.stopPropagation?.();
       }}
     >
-      <text height={1} fg="#7F8C8D">{scrollHint()}</text>
+      <text height={1} fg={hoveredUrl() ? '#5DADE2' : '#7F8C8D'}>
+        {hoveredUrl() ? `↗ ${hoveredUrl()}` : scrollHint()}
+      </text>
       <For each={visibleLines()}>
         {(line) => (
           line.copyContent !== undefined ? (
@@ -525,13 +535,6 @@ export function ConversationView(props: {
                 {(seg: Segment) => <text width={seg.width} fg={seg.color} bg={seg.bg}>{seg.text}</text>}
               </For>
               <text fg="#4B5563" content={COPY_BTN} onMouseUp={() => props.onCopy?.(line.copyContent!)} />
-              <Show when={line.redoContent !== undefined}>
-                <text
-                  fg="#FBBF24"
-                  content={REDO_BTN}
-                  onMouseUp={() => props.onRedo?.(line.redoIndex!, line.redoContent!)}
-                />
-              </Show>
             </box>
           ) : line.role === 'user' && line.userBubbleWidth ? (
             <box height={1} flexDirection="row" overflow="hidden">
@@ -562,7 +565,19 @@ export function ConversationView(props: {
                 overflow="hidden"
               >
                 <For each={statusSegments(line.statusLeft ?? '')}>
-                  {(seg) => <text width={seg.width} fg={seg.color} bg="#111318">{seg.text}</text>}
+                  {(seg) => (
+                    <text
+                      width={seg.width}
+                      fg={seg.color}
+                      bg="#111318"
+                      onMouseOver={() => hoverLink(seg.url ? normalizeExternalUrl(seg.url) : null)}
+                      onMouseOut={() => hoverLink(null)}
+                      onMouseUp={() => {
+                        const url = seg.url ? normalizeExternalUrl(seg.url) : null;
+                        if (url) props.onOpenLink?.(url);
+                      }}
+                    >{seg.text}</text>
+                  )}
                 </For>
               </box>
               {line.statusRight ? (
@@ -578,7 +593,19 @@ export function ConversationView(props: {
                   overflow="hidden"
                 >
                   <For each={statusSegments(line.statusRight)}>
-                    {(seg) => <text width={seg.width} fg={seg.color} bg="#111318">{seg.text}</text>}
+                    {(seg) => (
+                      <text
+                        width={seg.width}
+                        fg={seg.color}
+                        bg="#111318"
+                        onMouseOver={() => hoverLink(seg.url ? normalizeExternalUrl(seg.url) : null)}
+                        onMouseOut={() => hoverLink(null)}
+                        onMouseUp={() => {
+                          const url = seg.url ? normalizeExternalUrl(seg.url) : null;
+                          if (url) props.onOpenLink?.(url);
+                        }}
+                      >{seg.text}</text>
+                    )}
                   </For>
                 </box>
               ) : null}
@@ -774,7 +801,6 @@ export function LeftPane(props: {
   spinnerFrame: string;
   onInputHeightChange: (height: number) => void;
   onCopy?: (content: string) => void;
-  onRedo?: (index: number, content: string) => void;
   onOpenLink?: (url: string) => void;
 }) {
   const modeColor = () => props.chatMode ? '#22C55E' : '#06B6D4';
@@ -805,7 +831,6 @@ export function LeftPane(props: {
           onScroll={props.scrollConversation}
           spinnerFrame={props.spinnerFrame}
           onCopy={props.onCopy}
-          onRedo={props.onRedo}
           onOpenLink={props.onOpenLink}
         />
       )}

package/src/shell/repl.js

@@ -8,7 +8,7 @@ import { stdin as input, stdout as output } from 'node:process';
 import { marked } from 'marked';
 import { markedTerminal } from 'marked-terminal';
 import { buildAgentSystemPrompt, formatLlmUnavailableMessage, isOrchestrationBypassTool } from '../agent/graph.js';
-import { handleSlashCommand } from '../commands/slash.js';
+import { handleSlashCommand, rawCommandAgentPrompt } from '../commands/slash.js';
 import { serviceDescription, serviceNames as composeServiceNames } from '../core/compose.js';
 import { extractActivity, parseJsonText, sessionActivities } from '../core/activity.js';
 import { syncActivitiesToPlan } from '../core/plan.js';
@@ -74,7 +74,7 @@ const COMMAND_COMPLETION_DESCRIPTIONS = {
   '/config': 'Inspect or switch .wikirc.yaml profiles.',
   '/status': 'Show the current workspace and session state.',
   '/services': 'List workspace Docker Compose services.',
-  '/start': 'Start one service or the workspace service set.',
+  '/start': 'Start everything (all), the agents only, or one service.',
   '/stop': 'Stop one service or the workspace service set.',
   '/logs': 'Show recent logs for a service.',
   '/mcp': 'Inspect or call workspace MCP servers.',
@@ -301,7 +301,8 @@ function completionValuesFor(parts, inputBuffer, session) {
   if (command === '/wiki' && tokenIndex === 1) return ['run'];
   if (command === '/skills' && tokenIndex === 1) return ['edit', 'list', 'run', 'show'];
   if (command === '/skills' && ['edit', 'run', 'show'].includes(previousToken ?? '')) return skillNames(session);
-  if ((command === '/start' || command === '/stop') && tokenIndex === 1) return ['agents', ...serviceNames()];
+  if (command === '/start' && tokenIndex === 1) return ['all', 'agents', 'services', ...serviceNames()];
+  if (command === '/stop' && tokenIndex === 1) return ['agents', ...serviceNames()];
   if (command === '/logs' && tokenIndex === 1) return serviceNames();
   return [];
 }
@@ -434,6 +435,7 @@ function buildDirectChatSystemPrompt(session, rawOpenWikiPages) {
   return [
     'You are Donna, the llm-wiki-manager chat assistant: warm, plain-spoken, and helpful — like an attentive colleague, never a raw status dump.',
     'You have a small READ-ONLY toolset — the tools provided to you for this turn, which may be none. Use them to answer questions about live state (e.g. "le CME est-il configuré", "quelles pages sont en attente"), and answer only from their results.',
+    'Questions about Donna, wikiLLM, the manager, its interfaces, commands, configuration, agents, concurrency, or troubleshooting are product-help questions, not action requests. When PRODUCT HELP REFERENCE content is attached, answer directly from it in chat mode; never redirect such a question to /agent.',
     'When the conversation already contains attached document content (delimited by BEGIN/END ATTACHED DOCUMENT markers), read and summarize or answer from that content directly — you do NOT need a tool for it, and must not claim you cannot read the document.',
     'If no provided tool covers the request and no attached content answers it — or the request is an action or mutation (ingest, build, export, configure, send, delete…), or needs a service that is not connected — say plainly you cannot do it in chat mode and to switch to agent mode (/agent). Do not pretend to execute it and never guess.',
     'Answer directly and concisely. Do not claim to have called tools or changed files beyond the tools actually provided.',
@@ -449,6 +451,50 @@ function buildDirectChatSystemPrompt(session, rawOpenWikiPages) {
   ].join('\n');
 }
 
+export function isProductHelpQuestion(input) {
+  const text = String(input ?? '')
+    .normalize('NFKD')
+    .replace(/\p{Diacritic}/gu, '')
+    .toLowerCase();
+  if (!text.trim()) return false;
+  if (/\b(donna|wikillm|llm-wiki|wiki-manager)\b/.test(text)) return true;
+  if (/\/(status|help|chat|agent|start|services|mcp|run|approve|queue)\b/.test(text)) return true;
+  if (/\b(manager ceiling|parallelism|throughput|collection concurrency|scheduler workers?)\b/.test(text)) return true;
+  const productConcept = /\b(workspaces?|agents?|connecteurs?|connectors?|mcp|runtime|approbations?|approvals?|ingestion|deliverables?|parallelisme|concurrence)\b/.test(text);
+  const explanatoryQuestion = /\b(comment|pourquoi|a quoi|qu est ce|que signifie|explique|fonctionne|difference|combien)\b/.test(text);
+  return productConcept && explanatoryQuestion;
+}
+
+async function productHelpContextMessages(input, session, onStep) {
+  if (!isProductHelpQuestion(input)) return [];
+  const provider = Object.entries(session?.mcp ?? {}).find(([, entry]) =>
+    entry?.status === 'connected'
+    && (entry.tools ?? []).some((tool) => String(tool?.name ?? '') === 'help_search'));
+  if (!provider) return [];
+  const [server] = provider;
+  try {
+    onStep?.('Chat: consulting product documentation…');
+    const result = await callMcpTool(
+      session.mcp,
+      server,
+      'help_search',
+      { query: input },
+      session._abortSignal,
+    );
+    const content = formatMcpToolResult(result).trim();
+    if (!content) return [];
+    return [{
+      role: 'user',
+      content:
+        'PRODUCT HELP REFERENCE follows. It is read-only product documentation. '
+        + 'Use it to answer the question directly and do not redirect me to agent mode:\n\n'
+        + `--- BEGIN PRODUCT HELP REFERENCE ---\n${content}\n--- END PRODUCT HELP REFERENCE ---`,
+    }];
+  } catch {
+    return [];
+  }
+}
+
 function commonPrefix(values) {
   if (values.length === 0) return '';
   let prefix = values[0];
@@ -486,7 +532,12 @@ export function completionDescription(value, parts) {
   const subcommand = SUBCOMMAND_COMPLETION_DESCRIPTIONS[`${command}:${value}`];
   if (subcommand) return subcommand;
   if (command === '/use') return 'Load this workspace.';
-  if (command === '/start') return serviceDescription(value) ?? 'Start this Docker Compose service.';
+  if (command === '/start') {
+    if (value === 'all') return 'Start the workspace services AND the external agents.';
+    if (value === 'agents' || value === 'agent') return 'Start the external agents only.';
+    if (value === 'services') return 'Start the workspace services only.';
+    return serviceDescription(value) ?? 'Start this Docker Compose service.';
+  }
   if (command === '/stop') return serviceDescription(value) ?? 'Stop this Docker Compose service.';
   if (command === '/logs') return serviceDescription(value) ?? 'Show logs for this Docker Compose service.';
   if (command === '/workspace') {
@@ -925,20 +976,24 @@ function rememberProductionActivity(session, payload) {
 export function applyRuntimeStateToShellSession(session, state) {
   if (!state || typeof state !== 'object') return false;
   const displayState = sanitizeRuntimeStateForDisplay(state);
+  const terminalStateDismissed = session._dismissedTerminalRunId
+    && state.runId === session._dismissedTerminalRunId
+    && ['done', 'error', 'failed', 'cancelled'].includes(String(displayState.status ?? '').toLowerCase());
+  session._lastRuntimeRunId = state.runId ?? session._lastRuntimeRunId ?? null;
   session.agentProjection = {
     conversation: Array.isArray(displayState.conversation) ? displayState.conversation.map((message) => ({ ...message })) : [],
     chain: Array.isArray(displayState.chain) ? displayState.chain.map((step) => ({ ...step })) : [],
-    plan: Array.isArray(displayState.plan) && displayState.plan.length > 0
+    plan: !terminalStateDismissed && Array.isArray(displayState.plan) && displayState.plan.length > 0
       ? displayState.plan.map((step) => ({ ...step }))
       : null,
-    activities: Array.isArray(displayState.activities) ? displayState.activities.map((activity) => ({ ...activity })) : [],
-    logs: Array.isArray(displayState.logs) ? [...displayState.logs] : [],
-    summary: displayState.summary ?? null,
+    activities: !terminalStateDismissed && Array.isArray(displayState.activities) ? displayState.activities.map((activity) => ({ ...activity })) : [],
+    logs: !terminalStateDismissed && Array.isArray(displayState.logs) ? [...displayState.logs] : [],
+    summary: terminalStateDismissed ? null : displayState.summary ?? null,
     status: displayState.status ?? 'idle',
     planRevision: displayState.planRevision ?? 0,
-    planPatches: Array.isArray(displayState.planPatches) ? displayState.planPatches.map((patch) => ({ ...patch })) : [],
+    planPatches: !terminalStateDismissed && Array.isArray(displayState.planPatches) ? displayState.planPatches.map((patch) => ({ ...patch })) : [],
   };
-  session.workflow = displayState.workflow && typeof displayState.workflow === 'object'
+  session.workflow = !terminalStateDismissed && displayState.workflow && typeof displayState.workflow === 'object'
     ? {
         ...state.workflow,
         nodes: Array.isArray(state.workflow.nodes) ? state.workflow.nodes.map((node) => ({ ...node })) : [],
@@ -1206,11 +1261,26 @@ function renderScreen({ packageJson, session, messages, inputBuffer, busy = fals
   output.write(buf);
 }
 
-async function runAgentTurn(input, { agent, session, onUpdate, onStep, displayInput = input }) {
+async function runAgentTurn(input, {
+  agent,
+  session,
+  onUpdate,
+  onStep,
+  displayInput = input,
+  synthesisOnly = false,
+}) {
   const messages = conversationMessages(session);
   const history = toConversationHistory(messages);
   session._onStep = onStep ?? null;
   session.packageJson = session.packageJson ?? {};
+  if (
+    session._lastRuntimeRunId
+    && ['done', 'error', 'failed', 'cancelled'].includes(
+      String(session.agentProjection?.status ?? '').toLowerCase(),
+    )
+  ) {
+    session._dismissedTerminalRunId = session._lastRuntimeRunId;
+  }
   dispatchAgentEvent(session, createAgentEvent('run_started', {
     origin: 'user',
     payload: { input: displayInput },
@@ -1252,6 +1322,7 @@ async function runAgentTurn(input, { agent, session, onUpdate, onStep, displayIn
 
   let agentResult;
   try {
+    if (synthesisOnly) session._responseSynthesisOnly = true;
     agentResult = await agent.invoke({ input, session, messages: history });
   } catch (err) {
     if (err.name === 'AbortError') {
@@ -1272,6 +1343,7 @@ async function runAgentTurn(input, { agent, session, onUpdate, onStep, displayIn
     delete session._onStep;
     delete session._onStream;
     delete session._onStreamReset;
+    delete session._responseSynthesisOnly;
   }
 
   if (agentResult.streamedInline) {
@@ -1403,15 +1475,25 @@ async function runDirectChatTurn(input, { session, onUpdate, onStep }) {
   messages.push(donnaMessage);
   onUpdate?.();
   const allowedTools = chatAllowedTools(session);
+  const productHelpMessages = await productHelpContextMessages(input, session, onStep);
   const canUseTools = allowedTools.length > 0 && typeof session.llm.completeWithTools === 'function';
   try {
     if (canUseTools) {
-      await runChatToolLoop({ input, session, history, donnaMessage, onUpdate, onStep, allowedTools });
+      await runChatToolLoop({
+        input,
+        session,
+        history,
+        donnaMessage,
+        onUpdate,
+        onStep,
+        allowedTools,
+        contextMessages: productHelpMessages,
+      });
     } else {
       onStep?.('Chat: streaming direct answer…');
       for await (const delta of session.llm.stream({
         system: buildDirectChatSystemPrompt(session),
-        messages: [...history, { role: 'user', content: input }],
+        messages: [...history, ...productHelpMessages, { role: 'user', content: input }],
         signal: session._abortSignal,
       })) {
         const cleanDelta = stripDsmlArtifacts(delta);
@@ -1454,7 +1536,10 @@ export async function runHeadlessChatTurn(session, input, { history = [], onStep
   // a read tool is offered or the model chooses to call it. Multiple documents
   // (up to five) are each folded in as their own delimited block.
   const attachedDocs = await readSelectedPageDocuments(session, selectedPages);
-  const contextMessages = buildAttachedDocMessages(attachedDocs);
+  const contextMessages = [
+    ...buildAttachedDocMessages(attachedDocs),
+    ...await productHelpContextMessages(input, session, onStep),
+  ];
   const canUseTools = allowedTools.length > 0 && typeof session.llm?.completeWithTools === 'function';
   if (canUseTools) {
     await runChatToolLoop({ input, session, history, donnaMessage, onStep, allowedTools, openWikiPages: selectedPages, contextMessages });
@@ -1532,7 +1617,11 @@ export async function runLine(line, { agent, packageJson, session, onUpdate, onS
     // and only for slash commands — free text got a single row.
     const result = await handleSlashCommand(trimmed, { packageJson, session, onStep, runtime });
     const messages = conversationMessages(session);
-    const handoffRawToAgent = Boolean(result.rawOutput && result.agentTrigger && agent);
+    const deterministicDisplayOnly = /^\/status(?:\s|$)/.test(trimmed);
+    const commandAgentTrigger = result.output && agent && !deterministicDisplayOnly
+      ? (result.agentTrigger ?? rawCommandAgentPrompt(trimmed, result.output))
+      : null;
+    const handoffToAgent = Boolean(commandAgentTrigger);
     if (result.output) {
       const parts = trimmed.split(/\s+/);
       if (parts[0] === '/mcp' && parts[1] === 'call' && parts[2]) {
@@ -1548,15 +1637,19 @@ export async function runLine(line, { agent, packageJson, session, onUpdate, onS
         }
       }
     }
-    if (result.output && !handoffRawToAgent) {
+    if (result.output && !handoffToAgent) {
       messages.push({ role: 'command', content: result.output });
       onUpdate?.();
     }
-    if (handoffRawToAgent) {
-      const agentResult = await runAgentTurn(result.agentTrigger, { agent, session, onUpdate, onStep, displayInput: trimmed });
-      if (agentResult.aborted) return { exit: false, aborted: true };
-    } else if (result.agentTrigger && agent) {
-      const agentResult = await runAgentTurn(result.agentTrigger, { agent, session, onUpdate, onStep });
+    if (handoffToAgent) {
+      const agentResult = await runAgentTurn(commandAgentTrigger, {
+        agent,
+        session,
+        onUpdate,
+        onStep,
+        displayInput: trimmed,
+        synthesisOnly: true,
+      });
       if (agentResult.aborted) return { exit: false, aborted: true };
     }
     return { exit: Boolean(result.exit), setMode: result.setMode };

package/src/shell/repl.test.js

@@ -7,6 +7,7 @@ import {
   applyRuntimeStateToShellSession,
   chatAllowedTools,
   createSession,
+  isProductHelpQuestion,
   runHeadlessChatTurn,
   sanitizeOpenWikiPage,
   sanitizeOpenWikiPages,
@@ -42,23 +43,30 @@ test('ShellUI renders the user header full-width before constraining only its bo
   assert.match(source.slice(userBodyBranch), /justifyContent="flex-start"/);
   assert.doesNotMatch(source.slice(userBodyBranch, source.indexOf(') : line.status ?', userBodyBranch)), /#12263A/);
   assert.doesNotMatch(source, /messageHeaderSegments\(message\.role, contentColumns\)/);
-  // The third argument reserves room for [ redo ]; the width stays `columns`.
-  assert.match(source, /messageHeaderSegments\(message\.role, columns(, canRedo)?\)/);
+  assert.match(source, /messageHeaderSegments\(message\.role, columns\)/);
 });
 
-test('redo is offered on user questions only, next to copy', async () => {
+test('ShellUI exposes copy without a reply or redo action', async () => {
   const source = await readFile(new URL('./LeftPane.tsx', import.meta.url), 'utf8');
-  assert.match(source, /const canRedo = message\.role === 'user' && raw\.trim\(\)\.length > 0;/);
-  assert.match(source, /props\.onRedo\?\.\(line\.redoIndex!, line\.redoContent!\)/);
+  assert.match(source, /const COPY_BTN = ' \[ copy \]';/);
+  assert.doesNotMatch(source, /\[\s*(?:reply|redo)\s*\]/i);
+  assert.doesNotMatch(source, /onRedo|redoContent|redoIndex|REDO_BTN/);
+});
 
+test('redo translates the local thread index into a runtime conversation index', async () => {
   const session = await readFile(new URL('./useSession.ts', import.meta.url), 'utf8');
-  // The runtime must be truncated first: its conversation is derived from the
-  // event log and would be merged straight back in otherwise.
-  const truncateIndex = session.indexOf('postRuntimeConversationTruncate(index');
-  const spliceIndex = session.indexOf('full.splice(index)');
-  const submitIndex = session.indexOf('return submitInput(content)');
-  assert.ok(truncateIndex > 0 && spliceIndex > truncateIndex && submitIndex > spliceIndex);
-  assert.match(session, /const windowOffset = Math\.max\(0, full\.length - messages\(\)\.length\);/);
+  const redo = session.slice(
+    session.indexOf('async function redoMessage('),
+    session.indexOf('function updateInput('),
+  );
+  // The local thread holds entries the runtime never recorded (slash-command
+  // output, help panels). Passing the raw local index to /conversation/truncate
+  // is what produced `index_out_of_range`; `backed` is the translation table.
+  assert.match(redo, /const backed = runtimeConversationRefsByWorkspace\.get\(workspaceKey\)/);
+  assert.match(redo, /let runtimeIndex = backed\.indexOf\(full\[index\]\)/);
+  assert.match(redo, /if \(full\.indexOf\(backed\[i\]\) < index\)/);
+  assert.match(redo, /props\.runtime\?\.url && runtimeIndex >= 0/);
+  assert.doesNotMatch(redo, /postRuntimeConversationTruncate\(index/);
 });
 
 test('ShellUI renders newest-first order in both Runtime and Agent status', async () => {
@@ -372,6 +380,29 @@ test('applyRuntimeStateToShellSession preserves terminal diagnostics when runtim
   assert.deepEqual(session.agentProjection.planPatches, [{ id: 'old-patch' }]);
 });
 
+test('runtime sync does not resurrect a terminal plan dismissed by a newer user turn', () => {
+  const session = createSession();
+  session._dismissedTerminalRunId = 'old-run';
+  applyRuntimeStateToShellSession(session, {
+    runId: 'old-run',
+    status: 'error',
+    conversation: [{ role: 'assistant', content: 'Old failure' }],
+    plan: [{ id: 'old-task', status: 'failed' }],
+    activities: [{ key: 'old-job', status: 'failed', terminal: true }],
+    logs: ['old error'],
+    summary: 'Old run failed',
+    workflow: { nodes: [{ id: 'task:old' }], relations: [] },
+    planPatches: [{ id: 'old-patch' }],
+  });
+
+  assert.equal(session.headlessPlan, null);
+  assert.deepEqual(session.activities, {});
+  assert.equal(session.workflow, null);
+  assert.deepEqual(session.agentProjection.logs, []);
+  assert.equal(session.agentProjection.summary, null);
+  assert.deepEqual(session.agentProjection.conversation, [{ role: 'assistant', content: 'Old failure' }]);
+});
+
 test('legacy runtime sync does not synthesize per-job or canned completion messages', () => {
   const session = createSession();
   applyRuntimeStateToShellSession(session, {
@@ -551,6 +582,53 @@ test('/agent <question> reports an unavailable runtime without leaving chat mode
   assert.match(conversationMessages(session).at(-1).content, /runtime stopped/);
 });
 
+test('every slash-command result is presented by Donna when an agent is available', async () => {
+  const session = createSession();
+  let synthesisInput = '';
+  const agent = {
+    async invoke({ input, session: activeSession }) {
+      synthesisInput = input;
+      assert.equal(activeSession._responseSynthesisOnly, true);
+      return { response: 'Vous utilisez wiki-manager test.' };
+    },
+  };
+
+  const result = await runLine('/version', {
+    agent,
+    packageJson: { version: 'test' },
+    session,
+  });
+
+  assert.equal(result.exit, false);
+  assert.ok(synthesisInput.includes('commande shell /version'));
+  assert.deepEqual(conversationMessages(session).map((message) => message.role), ['user', 'donna']);
+  assert.equal(conversationMessages(session)[0].content, '/version');
+  assert.equal(conversationMessages(session)[1].content, 'Vous utilisez wiki-manager test.');
+  assert.equal(session._responseSynthesisOnly, undefined);
+});
+
+test('/status remains an immediate deterministic display without Donna', async () => {
+  const session = createSession();
+  let invoked = false;
+  const agent = {
+    async invoke() {
+      invoked = true;
+      return { response: 'must not run' };
+    },
+  };
+
+  const result = await runLine('/status', {
+    agent,
+    packageJson: { version: 'test' },
+    session,
+  });
+
+  assert.equal(result.exit, false);
+  assert.equal(invoked, false);
+  assert.equal(conversationMessages(session).at(-1)?.role, 'command');
+  assert.match(conversationMessages(session).at(-1)?.content ?? '', /Workspace · -/);
+});
+
 test('runLine does not update workspace profile before Donna handles the request', async () => {
   const workspacePath = mkdtempSync(join(tmpdir(), 'donna-profile-shell-'));
   mkdirSync(join(workspacePath, '.wiki'), { recursive: true });
@@ -729,9 +807,9 @@ test('chatAllowedTools exposes exactly the declared MCP tools to /chat', () => {
   };
   const names = chatAllowedTools(session).map((item) => item.function.name).sort();
   // cme_setup: not declared. documents_status: server absent from chatAccess.
-  // cme_export_run: declared, so it is offered — the allow-list is the
-  // operator's explicit decision, not a suggestion filtered by a heuristic.
-  assert.deepEqual(names, ['cme__cme_export_run', 'cme__cme_sources_list', 'cme__cme_status']);
+  // cme_export_run is an orchestration bypass and stays hidden even when an
+  // older allow-list still names it.
+  assert.deepEqual(names, ['cme__cme_sources_list', 'cme__cme_status']);
 });
 
 test('chatAllowedTools offers every declared tool, reads and writes alike', () => {
@@ -924,6 +1002,15 @@ test('runHeadlessChatTurn (HTTP /chat) uses the read-tool path and returns text'
   assert.doesNotMatch(reply, /STREAM_FALLBACK/);
 });
 
+test('product-help questions are detected without treating ordinary domain questions as product help', () => {
+  assert.equal(isProductHelpQuestion('À quoi correspond Parallelism & throughput ?'), true);
+  assert.equal(isProductHelpQuestion('Comment fonctionne Donna ?'), true);
+  assert.equal(isProductHelpQuestion('Explique le panneau /status'), true);
+  assert.equal(isProductHelpQuestion('Comment fonctionnent les approbations ?'), true);
+  assert.equal(isProductHelpQuestion('Que dit le wiki sur la météo ?'), false);
+  assert.equal(isProductHelpQuestion('Résume ce document'), false);
+});
+
 test('sanitizeOpenWikiPage accepts wiki and untracked markdown context paths', () => {
   assert.equal(sanitizeOpenWikiPage('wiki/concepts/foo.md'), 'wiki/concepts/foo.md');
   assert.equal(sanitizeOpenWikiPage('  wiki/a.md '), 'wiki/a.md');

package/src/shell/tui.tsx

@@ -398,7 +398,6 @@ function App(props: {
             scrollConversation={state.scrollConversation}
             spinnerFrame={SPINNER_FRAMES[spinnerIndex()] ?? SPINNER_FRAMES[0]}
             onInputHeightChange={setChatInputHeight}
-            onRedo={(index, content) => { void state.redoMessage(index, content); }}
             onCopy={(content) => showCopyHint(
               copyToClipboard(content, renderer)
                 ? 'Copied.'

package/src/shell/useSession.ts

@@ -667,10 +667,28 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
     const index = windowOffset + displayIndex;
     if (index < 0 || index >= full.length) return { exit: false };
 
-    if (props.runtime?.url) {
+    const workspaceKey = (session as any).workspace || '__global__';
+    // The local thread and the runtime conversation are NOT the same list:
+    // slash-command output, help panels and any other local-only entry live in
+    // `full` but were never recorded as events. Sending a `full` index straight
+    // to /conversation/truncate therefore points at the wrong entry — or past
+    // the end (`index_out_of_range`) — as soon as one local entry precedes the
+    // redone question. `backed` is index-aligned with the runtime conversation,
+    // so it is the only correct translation table.
+    const backed = runtimeConversationRefsByWorkspace.get(workspaceKey) ?? [];
+    let runtimeIndex = backed.indexOf(full[index]);
+    if (runtimeIndex === -1) {
+      // Local-only entry: truncate after the last runtime-backed entry that
+      // still precedes it, so nothing recorded before the question is lost.
+      for (let i = backed.length - 1; i >= 0; i -= 1) {
+        if (full.indexOf(backed[i]) < index) { runtimeIndex = i; break; }
+      }
+    }
+
+    if (props.runtime?.url && runtimeIndex >= 0) {
       // The runtime derives the conversation from its event log: deleting
       // locally alone would be undone by the next /state merge.
-      const result = await postRuntimeConversationTruncate(index, {
+      const result = await postRuntimeConversationTruncate(runtimeIndex, {
         url: props.runtime.url,
         workspace: (session as any).workspace ?? null,
       }) as { truncated?: boolean; reason?: string };
@@ -690,8 +708,7 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
     // truncate above — clearing every workspace's refs here would desync
     // other workspaces' `backed` arrays from their untouched `target`
     // arrays and duplicate their history on the next merge.
-    const currentWorkspace = (session as any).workspace || '__global__';
-    runtimeConversationRefsByWorkspace.get(currentWorkspace)?.splice(0);
+    runtimeConversationRefsByWorkspace.get(workspaceKey)?.splice(0);
     refresh();
     return submitInput(content);
   }