@dotdrelle/wiki-manager 0.15.28 → 0.15.32

package/src/orchestrator/objectiveResolver.test.js

@@ -64,6 +64,33 @@ test('resolveObjective uses an unambiguously mentioned registry operation withou
   assert.equal(result.provider.agentInstanceId, 'production-1');
 });
 
+test('resolveObjective declines an objective no listed capability covers', async () => {
+  // Forcing a pick is how "cree l'auth pour le gmail" became a doctor run on
+  // the production agent. Declining must be reported as such, not as a defect.
+  const session = sessionWithSelection({ capability: null, reason: 'Gmail authorization is not an orchestrable capability.' });
+  await assert.rejects(
+    resolveObjective("cree l'auth pour le gmail", session),
+    (err) => {
+      assert.equal(err.name, 'ObjectiveNotOrchestrableError');
+      assert.match(err.message, /No connected agent can do that\./);
+      assert.match(err.message, /Available capabilities: knowledge\.update\./);
+      assert.deepEqual(err.candidates, ['knowledge.update']);
+      return true;
+    },
+  );
+});
+
+test('resolveObjective treats a malformed selection as a resolution defect, not a decline', async () => {
+  await assert.rejects(
+    resolveObjective('Traite tout', sessionWithSelection({ reason: 'missing capability' })),
+    (err) => {
+      assert.notEqual(err.name, 'ObjectiveNotOrchestrableError');
+      assert.match(err.message, /unknown capability/);
+      return true;
+    },
+  );
+});
+
 test('resolveObjective rejects invented capability and operation', async () => {
   await assert.rejects(
     resolveObjective('Traite tout', sessionWithSelection({ capability: 'ingest', operation: 'ingest_all_pending' })),

package/src/runtime/auth.test.js

@@ -4,7 +4,7 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import test from 'node:test';
 import { resolveRuntimeAuthToken } from './auth.js';
-import { assertRuntimeNode, runtimeNodeExecutable, shutdownOwnedRuntime } from './lifecycle.js';
+import { assertRuntimeNode, runtimeNodeExecutable } from './lifecycle.js';
 
 test('resolveRuntimeAuthToken: loopback host does not require token', () => {
   const result = resolveRuntimeAuthToken({ host: '127.0.0.1', explicitToken: null });
@@ -27,67 +27,3 @@ test('runtime lifecycle uses a Node executable with node:sqlite support', async
   assert.ok(runtimeNode.executable);
   assert.ok(Number(runtimeNode.version.split('.')[0]) >= 22);
 });
-
-test('shutdownOwnedRuntime reports progress and stops an idle owned runtime', async () => {
-  const originalFetch = globalThis.fetch;
-  const calls = [];
-  const logs = [];
-  globalThis.fetch = async (url, options = {}) => {
-    calls.push({ url: String(url), method: options.method ?? 'GET' });
-    return new Response(JSON.stringify(calls.length === 1 ? { activeRuns: [] } : { shutdown: true }), {
-      status: calls.length === 1 ? 200 : 202,
-      headers: { 'content-type': 'application/json' },
-    });
-  };
-  try {
-    const result = await shutdownOwnedRuntime(
-      { url: 'http://127.0.0.1:7788', started: true, token: null },
-      { log: (message) => logs.push(message), timeoutMs: 100 },
-    );
-    assert.equal(result.action, 'shutdown');
-    assert.deepEqual(calls.map((call) => call.method), ['GET', 'POST']);
-    assert.match(logs.join('\n'), /runtime arrêté/);
-  } finally {
-    globalThis.fetch = originalFetch;
-  }
-});
-
-test('shutdownOwnedRuntime also stops an idle reused runtime', async () => {
-  const originalFetch = globalThis.fetch;
-  const calls = [];
-  globalThis.fetch = async (_url, options = {}) => {
-    calls.push(options.method ?? 'GET');
-    return new Response(JSON.stringify(calls.length === 1 ? { activeRuns: [] } : { shutdown: true }), {
-      status: calls.length === 1 ? 200 : 202,
-      headers: { 'content-type': 'application/json' },
-    });
-  };
-  try {
-    const result = await shutdownOwnedRuntime(
-      { url: 'http://127.0.0.1:7788', started: false, token: null },
-      { timeoutMs: 100 },
-    );
-    assert.equal(result.action, 'shutdown');
-    assert.deepEqual(calls, ['GET', 'POST']);
-  } finally {
-    globalThis.fetch = originalFetch;
-  }
-});
-
-test('shutdownOwnedRuntime bounds an unresponsive shutdown', async () => {
-  const originalFetch = globalThis.fetch;
-  const logs = [];
-  globalThis.fetch = async (_url, { signal } = {}) => new Promise((_resolve, reject) => {
-    signal?.addEventListener('abort', () => reject(new DOMException('aborted', 'AbortError')), { once: true });
-  });
-  try {
-    const result = await shutdownOwnedRuntime(
-      { url: 'http://127.0.0.1:7788', started: true, token: null },
-      { log: (message) => logs.push(message), timeoutMs: 5 },
-    );
-    assert.equal(result.action, 'timeout');
-    assert.match(logs.join('\n'), /délai de fermeture/);
-  } finally {
-    globalThis.fetch = originalFetch;
-  }
-});

package/src/runtime/donna-contract.test.js

@@ -146,7 +146,8 @@ test('CME setup and source configuration stay outside export orchestration', asy
   const calledTools = [];
   globalThis.fetch = async (_url, options = {}) => {
     const body = JSON.parse(String(options.body ?? '{}'));
-    calledTools.push(body.params?.name);
+    // Record tool calls only — the MCP session handshake is not a tool call.
+    if (body.method === 'tools/call') calledTools.push(body.params?.name);
     return {
       ok: true,
       status: 200,

package/src/runtime/lifecycle.js

@@ -139,36 +139,3 @@ export async function runtimeHealthOrNull(url = runtimeUrlFromEnv(), token = run
     return null;
   }
 }
-
-// Close the runtime attached to the shell when it is idle, including a process
-// reused at startup. Restricting cleanup to `started: true` left ownerless
-// runtimes occupying port 7788 with another manager directory/token.
-// An active run still survives the shell.
-export async function shutdownOwnedRuntime(runtime, { log = (_message) => {}, timeoutMs = 3000 } = {}) {
-  if (!runtime?.url) return { action: 'kept', reason: 'unavailable' };
-  const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), Math.max(1, Number(timeoutMs) || 3000));
-  try {
-    const health = await runtimeHealthOrNull(runtime.url, runtime.token, controller.signal);
-    if (!health) return { action: 'kept', reason: 'unreachable' };
-    const activeRuns = Array.isArray(health.activeRuns) ? health.activeRuns : [];
-    if (activeRuns.length > 0) {
-      const labels = activeRuns
-        .map((run) => [run.workspace, run.runId ? String(run.runId).slice(0, 8) : null].filter(Boolean).join('/'))
-        .join(', ');
-      log(`runtime laissé actif : run en cours (${labels}) — il survivra à ce shell ; relance wiki-manager pour le retrouver.`);
-      return { action: 'kept', reason: 'run_active', activeRuns };
-    }
-    await postRuntimeShutdown({ url: runtime.url, token: runtime.token, signal: controller.signal });
-    log('runtime arrêté (aucun run en cours).');
-    return { action: 'shutdown' };
-  } catch (err) {
-    if (controller.signal.aborted) {
-      log('délai de fermeture du runtime dépassé — le shell termine sans attendre davantage.');
-      return { action: 'timeout', reason: 'shutdown_timeout' };
-    }
-    return { action: 'error', reason: err instanceof Error ? err.message : String(err) };
-  } finally {
-    clearTimeout(timeout);
-  }
-}

package/src/runtime/runner.test.js

@@ -401,7 +401,16 @@ test('replanRuntimeRun requires runtime approval for mutating replanned work', a
 test('runRuntimeAgenticWorkflow replans after terminal activity error', async () => {
   const originalFetch = globalThis.fetch;
   let pollAttempts = 0;
-  globalThis.fetch = async () => {
+  globalThis.fetch = async (_url, init) => {
+    // Count polls, not the one-off MCP session handshake.
+    if (JSON.parse(init.body).method === 'initialize') {
+      return {
+        ok: true,
+        status: 200,
+        headers: { get: () => null },
+        text: async () => '{"jsonrpc":"2.0","id":0,"result":{"protocolVersion":"2025-06-18"}}',
+      };
+    }
     pollAttempts += 1;
     return {
       ok: true,

package/src/runtime/supervisor.test.js

@@ -93,7 +93,17 @@ test('pollActivitiesOnce does not repeat an unchanged retry state when retryAt m
 test('pollActivitiesOnce retries transient MCP poll failures', async () => {
   const originalFetch = globalThis.fetch;
   let attempts = 0;
-  globalThis.fetch = async () => {
+  globalThis.fetch = async (_url, init) => {
+    // The session handshake is not the thing under test: answer it, and make
+    // the first *poll* the transient failure.
+    if (JSON.parse(init.body).method === 'initialize') {
+      return {
+        ok: true,
+        status: 200,
+        headers: { get: () => null },
+        text: async () => '{"jsonrpc":"2.0","id":0,"result":{"protocolVersion":"2025-06-18"}}',
+      };
+    }
     attempts += 1;
     if (attempts === 1) {
       return {

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 };