@dotdrelle/wiki-manager 0.12.10 → 0.12.12

package/src/runtime/runner.test.js

@@ -713,7 +713,9 @@ test('runRuntimeParallelPlan fails cleanly when scheduler budget is exceeded', a
   assert.equal(result.budgetExceeded, true);
   assert.equal(result.reason, 'max_tasks_exceeded');
   assert.ok(session.agentEvents.some((event) => event.type === 'run_error' && event.payload?.budget?.reason === 'max_tasks_exceeded'));
-  assert.equal(session.headlessPlan[0].status, 'pending');
+  // run_error now cancels leftover pending steps: a dead run must not leave
+  // ghost work in the panels or reappear at the next relaunch.
+  assert.equal(session.headlessPlan[0].status, 'cancelled');
 });
 
 test('runRuntimeParallelPlan retries a retryable task on a fallback agent', async () => {
@@ -915,3 +917,36 @@ async function waitFor(predicate, timeoutMs = 500) {
   }
   assert.fail('condition was not met before timeout');
 }
+
+test('runtime runs are seeded with the chat that preceded them', async () => {
+  // "Donna n'a pas de contexte" was literally true: runs started with an
+  // empty history, so the model reinvented the missing context. The seed
+  // carries the prior exchanges, minus the run's own triggering message.
+  const { conversationSeed } = await import('./runner.js');
+  const session = {
+    agentProjection: {
+      conversation: [
+        { role: 'user', content: 'peux-tu configurer le CME ?' },
+        { role: 'assistant', content: 'CME configuré sur confluent.meteo.fr. Veux-tu ingérer les documents en attente ?' },
+        { role: 'user', content: 'oui lance l\'ingestion' },
+      ],
+    },
+  };
+
+  const seed = conversationSeed(session, "oui lance l'ingestion");
+  assert.deepEqual(seed.map((message) => message.role), ['user', 'assistant']);
+  assert.match(seed[1].content, /confluent\.meteo\.fr/);
+
+  // Long entries are clipped, empty/technical roles dropped.
+  const noisy = {
+    agentProjection: {
+      conversation: [
+        { role: 'command', content: 'Runtime is idle.' },
+        { role: 'assistant', content: 'x'.repeat(5000) },
+      ],
+    },
+  };
+  const clipped = conversationSeed(noisy, 'autre demande');
+  assert.equal(clipped.length, 1);
+  assert.equal(clipped[0].content.length, 2000);
+});

package/src/runtime/supervisor.js

@@ -1,3 +1,5 @@
+import { openSync, readSync, closeSync, fstatSync } from 'node:fs';
+import { isAbsolute, join, normalize, resolve } from 'node:path';
 import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
 import { extractActivity, parseJsonText, sessionActivities } from '../core/activity.js';
 import { callMcpTool, formatMcpToolResult } from '../core/mcp.js';
@@ -144,9 +146,19 @@ export async function pollActivitiesOnce(session, {
           }
           session._activityLogCursors[key] = logTail.at(-1);
         }
+        // The job log is terse — the actual narrative (per-document plans,
+        // LLM calls with token counts, apply operations) lives in the
+        // engine's trace file, whose path the status exposes. Tail it from
+        // the host and surface the significant events.
+        if (progress.traceFile) {
+          for (const line of readNewTraceLines(session, key, progress.traceFile)) {
+            emitRuntimeLog(session, `trace: ${line}`);
+          }
+        }
         if (polledActivity.terminal) {
           delete session._activityLogKeys[key];
           delete session._activityLogCursors?.[key];
+          delete session._activityTraceCursors?.[key];
           await startNextQueuedJob(session, {
             addLog: (message) => emitRuntimeLog(session, message),
           });
@@ -210,3 +222,52 @@ export async function cancelActiveActivityJobs(session, { callTool = callMcpTool
   }
   return cancelled;
 }
+
+// Trace events worth surfacing in the chat-side log: plan/apply milestones,
+// LLM calls (with token counts), warnings and errors. The raw trace is far
+// chattier — streaming everything would recreate the noise the dedupe killed.
+const TRACE_EVENT_PATTERN = /\b(llm:start|llm:end|llm:json|llm:error|ingest:plan|ingest:operations|ingest:apply|ingest:source|build:template|retrieval:|embedding:|WARN|ERROR)\b/;
+const TRACE_MAX_BYTES_PER_POLL = 64 * 1024;
+const TRACE_MAX_LINES_PER_POLL = 12;
+
+export function readNewTraceLines(session, key, traceFile) {
+  const workspacePath = session?.workspacePath;
+  if (!workspacePath) return [];
+  // The trace path comes from an agent payload: never let it escape the
+  // workspace directory.
+  const resolved = resolve(workspacePath, normalize(String(traceFile)));
+  if (isAbsolute(String(traceFile)) || !resolved.startsWith(resolve(workspacePath))) return [];
+  let fd;
+  try {
+    fd = openSync(resolved, 'r');
+    const size = fstatSync(fd).size;
+    session._activityTraceCursors ??= {};
+    let offset = session._activityTraceCursors[key];
+    // First sighting (or file rotation): start near the end, not at byte 0 —
+    // replaying a long history would flood the panel.
+    if (offset == null || offset > size) offset = Math.max(0, size - 4096);
+    if (size <= offset) return [];
+    const length = Math.min(size - offset, TRACE_MAX_BYTES_PER_POLL);
+    const buffer = Buffer.alloc(length);
+    readSync(fd, buffer, 0, length, offset);
+    const chunk = buffer.toString('utf8');
+    // Only advance past COMPLETE lines so a partially-written line is
+    // re-read whole on the next poll.
+    const lastNewline = chunk.lastIndexOf('\n');
+    if (lastNewline === -1) return [];
+    session._activityTraceCursors[key] = offset + Buffer.byteLength(chunk.slice(0, lastNewline + 1), 'utf8');
+    return chunk
+      .slice(0, lastNewline)
+      .split('\n')
+      .map((line) => line.trim())
+      .filter((line) => line && TRACE_EVENT_PATTERN.test(line))
+      .slice(0, TRACE_MAX_LINES_PER_POLL)
+      // Strip the ISO timestamp + elapsed prefix: the runtime log adds its
+      // own clock, and the double timestamp ate half the panel width.
+      .map((line) => line.replace(/^\S+\s+\+[\d.]+(?:ms|s|m|h)\s+(INFO|WARN|ERROR)\s+/, (_m, level) => (level === 'INFO' ? '' : `${level} `)));
+  } catch {
+    return [];
+  } finally {
+    if (fd !== undefined) closeSync(fd);
+  }
+}

package/src/runtime/supervisor.test.js

@@ -284,3 +284,34 @@ async function waitFor(predicate, timeoutMs = 250) {
   }
   assert.fail('Timed out waiting for condition.');
 }
+
+test('readNewTraceLines streams significant trace events with a per-activity cursor', async () => {
+  const { readNewTraceLines } = await import('./supervisor.js');
+  const { mkdtempSync, writeFileSync, appendFileSync, rmSync } = await import('node:fs');
+  const { tmpdir } = await import('node:os');
+  const { join } = await import('node:path');
+  const workspacePath = mkdtempSync(join(tmpdir(), 'trace-tail-'));
+  try {
+    const rel = '.wiki/logs/ingest-test.log';
+    const abs = join(workspacePath, rel);
+    (await import('node:fs')).mkdirSync(join(workspacePath, '.wiki/logs'), { recursive: true });
+    writeFileSync(abs, '2026-07-10T13:00:00.000Z +10ms INFO llm:start label=ingest_plan promptChars=42000\n');
+    const session = { workspacePath };
+
+    const first = readNewTraceLines(session, 'k1', rel);
+    assert.deepEqual(first, ['llm:start label=ingest_plan promptChars=42000']);
+
+    // No new content → nothing re-emitted.
+    assert.deepEqual(readNewTraceLines(session, 'k1', rel), []);
+
+    appendFileSync(abs, '2026-07-10T13:01:00.000Z +70s INFO noise: irrelevant heartbeat\n2026-07-10T13:02:00.000Z +130s WARN embedding:neutralized-input status=413\n');
+    const second = readNewTraceLines(session, 'k1', rel);
+    assert.deepEqual(second, ['WARN embedding:neutralized-input status=413']);
+
+    // Path traversal attempts are refused.
+    assert.deepEqual(readNewTraceLines(session, 'k1', '../../etc/passwd'), []);
+    assert.deepEqual(readNewTraceLines(session, 'k1', '/etc/passwd'), []);
+  } finally {
+    rmSync(workspacePath, { recursive: true, force: true });
+  }
+});

package/src/shell/LeftPane.tsx

@@ -272,9 +272,16 @@ function renderMarkdownLines(lines: Array<{ text: string; isCode: boolean }>, ro
   for (let index = 0; index < lines.length; index += 1) {
     const { text, isCode } = lines[index];
     if (isCode) {
-      output.push(...wrapLine(text || ' ', columns).map((piece) => ({
-        segments: [{ text: piece || ' ', color: '#D6DEE8', bg: '#1A2235' }],
+      const blockStarts = index === 0 || !lines[index - 1].isCode;
+      const blockEnds = index === lines.length - 1 || !lines[index + 1].isCode;
+      // Blank line before/after the block + 2-space inner padding: fenced
+      // blocks used to render as a dense background slab glued to the text.
+      if (blockStarts) output.push({ segments: [{ text: ' ', color: '#D6DEE8' }] });
+      const innerWidth = Math.max(8, columns - 4);
+      output.push(...wrapLine(text || ' ', innerWidth).map((piece) => ({
+        segments: [{ text: `  ${(piece || ' ').padEnd(innerWidth)}  `, color: '#D6DEE8', bg: '#1A2235' }],
       })));
+      if (blockEnds) output.push({ segments: [{ text: ' ', color: '#D6DEE8' }] });
       continue;
     }
 
@@ -375,7 +382,10 @@ function conversationLines(messages: Array<{ role: string; content: string }>, c
     let inFence = false;
     const lines: Array<{ text: string; isCode: boolean }> = [];
     for (const line of raw.split('\n')) {
-      if (/^(`{2,3}|~{2,3})/.test(line)) { inFence = !inFence; continue; }
+      // LLM responses often indent fenced blocks as part of a list. Accept
+      // leading whitespace so ```bash / ~~~ fences are rendered as code
+      // instead of leaking their Markdown markers into the conversation.
+      if (/^\s*(`{3,}|~{3,})/.test(line)) { inFence = !inFence; continue; }
       lines.push({ text: line, isCode: inFence });
     }
     return [

package/src/shell/repl.js

@@ -18,7 +18,15 @@ 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());
+// Code blocks: marked-terminal's default paints a dense background block
+// glued to the surrounding text. Indent the content, keep a plain style and
+// guarantee a blank line before/after so fenced blocks breathe in the chat.
+const CODE_INDENT = '  ';
+const CODE_TINT = '\u001b[38;5;152m'; // soft blue-grey, readable on dark bg
+const CODE_RESET = '\u001b[0m';
+marked.use(markedTerminal({
+  code: (code) => `\n${String(code).split('\n').map((line) => `${CODE_INDENT}${CODE_TINT}${line}${CODE_RESET}`).join('\n')}\n`,
+}));
 // marked-terminal's text renderer extracts token.text (raw string) instead of
 // calling parseInline(token.tokens), so inline Markdown inside list items is
 // silently dropped. Patch it to call parseInline when tokens are available.
@@ -75,7 +83,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.',
+  '/run': 'Inspect, cancel, kill runtime runs, or start a capability run.',
   '/approve': 'Approve a pending runtime run or tool.',
 };
 
@@ -141,7 +149,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', 'run', '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', 'cancel', 'queue', 'approve'],
     chatMode: true,
     llm: null,
     activities: {},
@@ -246,7 +254,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 === '/run' && tokenIndex === 1) return ['status', 'cancel', 'kill', 'capability'];
   if (command === '/queue' && tokenIndex === 1) return ['cancel', 'clear'];
   if (command === '/queue' && previousToken === 'cancel') {
     return (session.jobQueue ?? [])

package/src/shell/tui.tsx

@@ -116,6 +116,29 @@ function App(props: {
   // sync at every call site.
   const [screen, setScreen] = createSignal<'startup' | 'setup' | 'main'>('startup');
   let ctrlCTimer: ReturnType<typeof setTimeout> | null = null;
+  let exiting = false;
+  // Single exit path: the owned-runtime shutdown MUST happen here, on the
+  // user's actual exit gesture. render() resolves at MOUNT, so code placed
+  // after `await runOpenTuiShell(...)` runs while the shell is still on
+  // screen — 0.12.9 shipped that and killed the runtime mid-session.
+  const exitShell = () => {
+    if (exiting) return;
+    exiting = true;
+    void (async () => {
+      const messages: string[] = [];
+      try {
+        if (props.runtime?.url) {
+          const { shutdownOwnedRuntime } = await import('../runtime/lifecycle.js');
+          await shutdownOwnedRuntime(props.runtime, { log: (message: string) => { messages.push(message); } });
+        }
+      } catch {
+        // Best effort: never block the exit on runtime cleanup.
+      }
+      renderer.destroy();
+      // Print AFTER destroy so the note survives on the restored terminal.
+      for (const message of messages) console.log(`[wiki-manager] ${message}`);
+    })();
+  };
   let copyHintTimer: ReturnType<typeof setTimeout> | null = null;
   let selectionCopyTimer: ReturnType<typeof setTimeout> | null = null;
   let startupKeyboardEventId = 0;
@@ -141,7 +164,7 @@ function App(props: {
       return;
     }
     void state.submitInput(value).then((result) => {
-      if (result?.exit) renderer.destroy();
+      if (result?.exit) exitShell();
     });
   };
 
@@ -263,7 +286,7 @@ function App(props: {
         return;
       }
       if (exitHint()) {
-        renderer.destroy();
+        exitShell();
         return;
       }
       setExitHint(true);
@@ -378,7 +401,7 @@ function App(props: {
         height={dimensions().height}
         keyboardEvent={startupKeyboardEvent()}
         onSelect={openAction}
-        onQuit={() => renderer.destroy()}
+        onQuit={() => exitShell()}
       />
     </Show>
   );