@dotdrelle/wiki-manager 0.12.11 → 0.12.12

package/src/core/buildInfo.json

@@ -1,4 +1,4 @@
 {
-  "version": "0.12.11",
-  "commit": "d8eae0b"
+  "version": "0.12.12",
+  "commit": "e1e43ae"
 }

package/src/core/mcp.js

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { managerEnvFile, managerMcpEndpointsFile, readEnvFile } from './env.js';
 
-const WIKI_MANAGER_VERSION = '0.12.11';
+const WIKI_MANAGER_VERSION = '0.12.12';
 
 function envValue(key) {
   const filePath = managerEnvFile();
@@ -305,8 +305,7 @@ export function formatMcpToolResult(result) {
 const DEFAULT_TOOL_RESULT_MAX_CHARS = 16000;
 
 function toolResultMaxChars() {
-  const parsed = Number(process.env.WIKI_MANAGER_TOOL_RESULT_MAX_CHARS);
-  return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : DEFAULT_TOOL_RESULT_MAX_CHARS;
+  return DEFAULT_TOOL_RESULT_MAX_CHARS;
 }
 
 // Bound what a tool result injects into the LLM context and the conversation

package/src/core/mcp.test.js

@@ -529,15 +529,3 @@ test('truncateToolResult keeps short results intact and bounds long ones head+ta
   assert.match(bounded, /caractères tronqués/);
 });
 
-test('truncateToolResult honours WIKI_MANAGER_TOOL_RESULT_MAX_CHARS', () => {
-  const previous = process.env.WIKI_MANAGER_TOOL_RESULT_MAX_CHARS;
-  process.env.WIKI_MANAGER_TOOL_RESULT_MAX_CHARS = '500';
-  try {
-    const bounded = truncateToolResult('y'.repeat(5000));
-    assert.ok(bounded.length < 700);
-    assert.match(bounded, /caractères tronqués/);
-  } finally {
-    if (previous === undefined) delete process.env.WIKI_MANAGER_TOOL_RESULT_MAX_CHARS;
-    else process.env.WIKI_MANAGER_TOOL_RESULT_MAX_CHARS = previous;
-  }
-});

package/src/orchestrator/scheduler.js

@@ -9,6 +9,30 @@ export function resolveSchedulerConcurrency(value = process.env.WIKI_MANAGER_SCH
     : DEFAULT_SCHEDULER_CONCURRENCY;
 }
 
+export function resolvePlanConcurrency({ plan = [], agents = [], configured = null } = {}) {
+  const capabilities = new Set(plan.map((task) => task?.requiredCapability).filter(Boolean).map(String));
+  const assignedAgents = new Set(plan.map((task) => task?.agentInstanceId).filter(Boolean).map(String));
+  const relevantAgents = agents.filter((agent) => {
+    const id = String(agent?.agentInstanceId ?? agent?.description?.agentInstanceId ?? '');
+    if (id && assignedAgents.has(id)) return true;
+    return (agent?.description?.capabilities ?? []).some((capability) => capabilities.has(String(capability?.id ?? '')));
+  });
+  const values = [
+    positiveInteger(configured),
+    ...plan.flatMap(concurrencyValues),
+    ...relevantAgents.flatMap(concurrencyValues),
+  ].filter(Boolean);
+  return values.length > 0 ? Math.max(1, Math.min(...values)) : DEFAULT_SCHEDULER_CONCURRENCY;
+}
+
+export function resolveCapabilityConcurrency(agent = null, ...constraints) {
+  const values = [
+    ...concurrencyValues(agent),
+    ...constraints.map(positiveInteger),
+  ].filter(Boolean);
+  return values.length > 0 ? Math.max(1, Math.min(...values)) : DEFAULT_SCHEDULER_CONCURRENCY;
+}
+
 export function effectiveConcurrency(group = null, agent = null, donna = null, provider = null) {
   const limits = [
     ...concurrencyValues(donna),

package/src/orchestrator/scheduler.test.js

@@ -6,7 +6,12 @@ import test from 'node:test';
 import { createBudgetManager } from './budgetManager.js';
 import { readyTasks } from './dependencyResolver.js';
 import { createLockManager } from './lockManager.js';
-import { effectiveConcurrency, startReadyTasks } from './scheduler.js';
+import {
+  effectiveConcurrency,
+  resolveCapabilityConcurrency,
+  resolvePlanConcurrency,
+  startReadyTasks,
+} from './scheduler.js';
 
 test('dependencyResolver holds a barrier task until its dependsOnGroup is done', () => {
   const plan = [
@@ -76,6 +81,40 @@ test('scheduler.effectiveConcurrency returns the minimum effective concurrency',
   assert.equal(effectiveConcurrency(group, agent, donna, provider), 2);
 });
 
+test('scheduler uses the relevant agent declaration instead of hard-capping plans at three', () => {
+  const plan = [{ id: 'task-1', requiredCapability: 'ingest' }];
+  const agents = [{
+    description: {
+      capabilities: [{ id: 'ingest' }],
+      limits: { recommendedConcurrency: 10, maxConcurrency: 12 },
+    },
+  }];
+
+  assert.equal(resolvePlanConcurrency({ plan, agents }), 10);
+  assert.equal(resolvePlanConcurrency({ plan, agents, configured: 3 }), 3);
+  assert.equal(resolvePlanConcurrency({ plan, agents, configured: 20 }), 10);
+});
+
+test('scheduler ignores unrelated agents and falls back to three without declarations', () => {
+  const plan = [{ id: 'task-1', requiredCapability: 'ingest' }];
+  const agents = [{
+    description: {
+      capabilities: [{ id: 'production' }],
+      limits: { recommendedConcurrency: 1 },
+    },
+  }];
+
+  assert.equal(resolvePlanConcurrency({ plan, agents }), 3);
+});
+
+test('capability constraints can lower but never raise an agent declaration', () => {
+  const agent = { description: { limits: { recommendedConcurrency: 6, maxConcurrency: 10 } } };
+
+  assert.equal(resolveCapabilityConcurrency(agent), 6);
+  assert.equal(resolveCapabilityConcurrency(agent, 2), 2);
+  assert.equal(resolveCapabilityConcurrency(agent, 20), 6);
+});
+
 test('startReadyTasks starts only ready tasks and respects lock starvation', () => {
   const active = new Map();
   const lockManager = createLockManager();

package/src/runtime/client.js

@@ -52,6 +52,7 @@ export async function postRuntimeRun(input, {
   workspace = null,
   evaluate = undefined,
   replans = undefined,
+  capabilityPlan = undefined,
 } = {}) {
   const response = await fetch(runtimeEndpoint(url, '/run', workspace), {
     method: 'POST',
@@ -59,7 +60,7 @@ export async function postRuntimeRun(input, {
       ...runtimeHeaders(token),
       'Content-Type': 'application/json',
     },
-    body: JSON.stringify(Object.assign({ input, workspace }, evaluate !== undefined && { evaluate }, replans !== undefined && { replans })),
+    body: JSON.stringify(Object.assign({ input, workspace }, evaluate !== undefined && { evaluate }, replans !== undefined && { replans }, capabilityPlan !== undefined && { capabilityPlan })),
   });
   if (!response.ok) {
     const err = new Error(`Runtime run failed: HTTP ${response.status}`);

package/src/runtime/lifecycle.js

@@ -109,7 +109,7 @@ export async function runtimeHealthOrNull(url = runtimeUrlFromEnv(), token = run
 // alive after exit produced zombie runtimes running yesterday's code and
 // yesterday's endpoints. Nuance preserved: if a run is active anywhere, the
 // runtime is left alive so the run survives the shell (that promise stays).
-export async function shutdownOwnedRuntime(runtime, { log = () => {} } = {}) {
+export async function shutdownOwnedRuntime(runtime, { log = (_message) => {} } = {}) {
   if (!runtime?.url || !runtime?.started) return { action: 'kept', reason: 'not_owned' };
   try {
     const health = await runtimeHealthOrNull(runtime.url, runtime.token);

package/src/runtime/runner.js

@@ -9,10 +9,16 @@ import { createBudgetManager, BudgetExceededError } from '../orchestrator/budget
 import { createDispatcher } from '../orchestrator/dispatcher.js';
 import { assertValidatedFragment } from '../orchestrator/planValidator.js';
 import { createResultAggregator } from '../orchestrator/resultAggregator.js';
-import { drainActive, resolveSchedulerConcurrency, startReadyTasks } from '../orchestrator/scheduler.js';
+import { drainActive, resolvePlanConcurrency, startReadyTasks } from '../orchestrator/scheduler.js';
 import { emitRuntimeLog, pollActivitiesOnce } from './supervisor.js';
 
-const DEFAULT_MAX_REPLANS = 2;
+// 0 by default: automatic replans turn evaluator/replanner TEXT into
+// executable pseudo-tasks (no capability, no operation) that stall at 0%
+// and pile up as replan-1/2/3 ghost work — the same disease as the removed
+// text-plan extraction. Failures now end with an honest report; the user
+// (or a stronger model) decides what to do next. Re-enable explicitly with
+// WIKI_MANAGER_REPLANNER_MAX_REPLANS if desired.
+const DEFAULT_MAX_REPLANS = 0;
 
 async function waitForRuntimeActivities(session, startedActivities, { timeoutMs, signal, pollBusy }) {
   const deadline = Date.now() + timeoutMs;
@@ -43,13 +49,35 @@ async function waitForRuntimeActivities(session, startedActivities, { timeoutMs,
   return { ok: false, timedOut: true, completed: tracked };
 }
 
-export async function runRuntimeAgenticLoop(agent, session, initialInput, { signal, timeoutMs, maxTurns, runId, pollBusy, parallelHandoff = false }) {
+// Last chat exchanges (user/assistant) that preceded this run, so the run's
+// LLM knows WHAT was agreed before acting. Long messages are clipped: the
+// context is for grounding, not for re-reading novels.
+// Env knobs (documented in .env.example): every tunable introduced by the
+// grounding/orchestration work is overridable — nothing business-critical
+// is frozen in code.
+export function conversationSeed(session, currentInput, { limit = 12, maxChars = 2000 } = {}) {
+  const conversation = Array.isArray(session.agentProjection?.conversation)
+    ? session.agentProjection.conversation
+    : [];
+  const seed = conversation
+    .filter((message) => ['user', 'assistant'].includes(message?.role) && String(message?.content ?? '').trim())
+    .slice(-limit)
+    .map((message) => ({ role: message.role, content: String(message.content).slice(0, maxChars) }));
+  // The run's own triggering user message is appended by the loop itself —
+  // drop it from the seed to avoid sending it twice.
+  const last = seed.at(-1);
+  if (last && last.role === 'user' && last.content === String(currentInput ?? '').slice(0, maxChars)) seed.pop();
+  return seed;
+}
+
+export async function runRuntimeAgenticLoop(agent, session, initialInput, { signal, timeoutMs, maxTurns, runId, pollBusy, parallelHandoff = false, initialMessages = [] }) {
   return runAgenticLoop(agent, session, initialInput, {
     signal,
     timeoutMs,
     maxTurns,
     runId,
     parallelHandoff,
+    initialMessages,
     deterministicTerminalSummary: true,
     abortMessage: 'Runtime run cancelled.',
     waitForActivities: (turnSession, startedActivities, waitOptions) =>
@@ -107,6 +135,9 @@ export async function runRuntimeAgenticWorkflow(agent, session, input, {
 } = {}) {
   let currentInput = initialInput ?? input;
   let replansLeft = Math.max(0, Math.floor(Number(maxReplans) || 0));
+  // Computed ONCE at run start: the pre-run chat. Re-computing inside the
+  // loop would re-ingest this run's own turns and duplicate them.
+  const runConversationSeed = conversationSeed(session, currentInput);
 
   while (true) {
     sanitizeSessionPlanForExecution(session, runId);
@@ -127,6 +158,7 @@ export async function runRuntimeAgenticWorkflow(agent, session, input, {
         runId,
         pollBusy,
         parallelHandoff: true,
+        initialMessages: runConversationSeed,
       });
     if (result.ok && result.handoff) continue;
     if (!result.ok) {
@@ -212,6 +244,20 @@ export async function runRuntimeAgenticWorkflow(agent, session, input, {
             continue;
           }
         }
+        // Surface the verdict in the CHAT: the work that ran stays done, the
+        // user sees why the evaluator was unsatisfied and decides — no
+        // self-generated follow-up tasks.
+        dispatchAgentEvent(session, createAgentEvent('assistant_message', {
+          origin: 'runtime',
+          runId,
+          payload: {
+            content: [
+              `Le run est terminé mais l'évaluation le juge incomplet : ${evaluation.reason}`,
+              evaluation.suggestedAction ? `Piste suggérée : ${evaluation.suggestedAction}` : null,
+              'Aucune tâche supplémentaire n\'a été créée automatiquement — dis-moi si tu veux poursuivre.',
+            ].filter(Boolean).join('\n'),
+          },
+        }));
         dispatchAgentEvent(session, createAgentEvent('run_error', {
           origin: 'runtime',
           runId,
@@ -240,7 +286,7 @@ export async function runRuntimeParallelPlan(agent, session, input, {
   maxTurns,
   runId = null,
   pollBusy,
-  concurrency = resolveSchedulerConcurrency(),
+  concurrency = null,
   fragment = null,
   assignmentManager = null,
   attemptManager = null,
@@ -252,7 +298,15 @@ export async function runRuntimeParallelPlan(agent, session, input, {
   dispatcherPollIntervalMs = 250,
 } = {}) {
   if (fragment != null) assertValidatedFragment(fragment);
-  const limit = Math.max(1, Math.floor(Number(concurrency) || 1));
+  const agents = session.agentRegistry?.snapshot?.() ?? session.agentRegistrySnapshot ?? [];
+  const configuredConcurrency = Number(concurrency) > 0
+    ? Number(concurrency)
+    : Number(process.env.WIKI_MANAGER_CAPABILITY_CONCURRENCY || process.env.WIKI_MANAGER_SCHEDULER_CONCURRENCY);
+  const limit = resolvePlanConcurrency({
+    plan: session.headlessPlan ?? [],
+    agents,
+    configured: configuredConcurrency,
+  });
   const active = new Map();
   const attempts = attemptManager ?? createAttemptManager();
   const assigner = assignmentManager ?? createAssignmentManager({ session });
@@ -278,6 +332,15 @@ export async function runRuntimeParallelPlan(agent, session, input, {
   sanitizeSessionPlanForExecution(session, runId);
   ensurePlanProjection(session, runId);
   emitRuntimeLog(session, `scheduler: parallel plan enabled (concurrency ${limit})`);
+  let approvalNoticeSent = false;
+  // Interactive approvals do NOT expire: the user has /approve, "valide
+  // tout", /cancel and /run kill — an arbitrary timer only created mystery
+  // failures. A deadline exists only when explicitly configured (headless
+  // runs, CI) via the session or the env escape hatch.
+  const configuredApprovalWait = Number(session._approvalTimeoutMs) > 0
+    ? Number(session._approvalTimeoutMs)
+    : (Number(process.env.WIKI_MANAGER_APPROVAL_TIMEOUT_MS) > 0 ? Number(process.env.WIKI_MANAGER_APPROVAL_TIMEOUT_MS) : null);
+  const approvalDeadline = configuredApprovalWait ? Date.now() + configuredApprovalWait : Infinity;
 
   try {
     while (true) {
@@ -371,6 +434,44 @@ export async function runRuntimeParallelPlan(agent, session, input, {
           emitRuntimeLog(session, `scheduler: budget exceeded (${exceeded.reason})`);
           return { ok: false, budgetExceeded: true, reason: exceeded.reason, budget: exceeded, completed: sessionActivities(session), failures };
         }
+        const needingApproval = pending.filter((step) => step.requiresApproval === true);
+        if (needingApproval.length > 0) {
+          // The plan is only blocked on a HUMAN decision — wait for it
+          // (bounded) instead of declaring the run stalled. Announce once in
+          // the chat: users cannot approve what they never saw asked.
+          if (!approvalNoticeSent) {
+            approvalNoticeSent = true;
+            dispatchAgentEvent(session, createAgentEvent('assistant_message', {
+              origin: 'runtime',
+              runId,
+              payload: {
+                content: [
+                  `⏸ Approbation requise avant exécution : ${needingApproval.length} tâche(s) mutante(s) en attente.`,
+                  ...needingApproval.slice(0, 5).map((step) => `  - ${step.description ?? step.id}`),
+                  needingApproval.length > 5 ? `  … et ${needingApproval.length - 5} autre(s).` : null,
+                  'Réponds « valide tout » (ou tape /approve) pour lancer, « annule » pour abandonner.',
+                ].filter(Boolean).join('\n'),
+              },
+            }));
+            emitRuntimeLog(session, `scheduler: waiting for approval (${needingApproval.length} task(s))`);
+          }
+          if (Date.now() < approvalDeadline) {
+            await new Promise((resolveDelay) => setTimeout(resolveDelay, 500));
+            continue;
+          }
+          // Configured timeout (headless/CI) reached: say it PLAINLY in the
+          // chat and let run_error clean the plan/activities so nothing
+          // lingers in the panels.
+          emitRuntimeLog(session, 'scheduler: approval wait timed out');
+          dispatchAgentEvent(session, createAgentEvent('assistant_message', {
+            origin: 'runtime',
+            runId,
+            payload: {
+              content: `⏱ Approbation non reçue dans le délai imparti — run arrêté, ${needingApproval.length} tâche(s) annulée(s). Relance la demande quand tu veux.`,
+            },
+          }));
+          return { ok: false, stalled: true, reason: 'awaiting_approval', completed: sessionActivities(session), failures };
+        }
         const reason = pending.every((step) => approvalWaitingStatus(step.status)) ? 'awaiting_approval' : 'no_ready_plan_task';
         emitRuntimeLog(session, `scheduler: stalled (${reason})`);
         return { ok: false, stalled: true, reason, completed: sessionActivities(session), failures };
@@ -1016,7 +1117,7 @@ function formatRecentConversation(session, n = 12) {
     .join('\n');
 }
 
-function resolveMaxReplans(value = process.env.WIKI_MANAGER_REPLANNER_MAX_REPLANS) {
+function resolveMaxReplans(value) {
   const parsed = Number(value);
   return Number.isFinite(parsed) ? Math.max(0, Math.floor(parsed)) : DEFAULT_MAX_REPLANS;
 }

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

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