@dotdrelle/wiki-manager 0.6.47 → 0.8.2

package/src/cli/wiki-manager.js

@@ -4,19 +4,22 @@ import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { loadManagerEnv } from '../core/env.js';
 loadManagerEnv();
-import { createAgentGraph, buildAgentSystemPrompt, buildLimitedAgentResponse } from '../agent/graph.js';
-import { handleSlashCommand, printHelp, printVersion } from '../commands/slash.js';
+import { createAgentGraph } from '../agent/graph.js';
+import { handleSlashCommand, printHelp, printVersion, refreshMcpRuntimeStatus } from '../commands/slash.js';
 import { runShell } from '../shell/repl.js';
 import { runChecks } from '../core/startupCheck.js';
 import { callMcpTool, formatMcpToolResult } from '../core/mcp.js';
-import { extractActivity, parseJsonText, sessionActivities } from '../core/activity.js';
-import { extractHeadlessPlan, syncActivitiesToPlan, formatPlanStatus, formatCompletedActivities } from '../core/plan.js';
+import { extractActivity, parseJsonText, sessionActivities, terminalFailures } from '../core/activity.js';
+import { syncActivitiesToPlan, formatPlanStatus } from '../core/plan.js';
 import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
+import { runAgentTurn, runAgenticLoop } from '../core/agentLoop.js';
+// Runtime modules use node:sqlite (Node.js built-in unavailable in Bun).
+// They are imported dynamically so the shell / TUI path never loads them.
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const packageJsonPath = resolve(__dirname, '../../package.json');
 const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
-const SHELL_COMMANDS = ['help', 'version', 'exit', 'workspace', 'new', 'use', 'config', 'status', 'services', 'start', 'stop', 'logs', 'mcp', 'wiki', 'skills', 'clear', 'chat', 'agent'];
+const SHELL_COMMANDS = ['help', 'version', 'exit', 'workspace', 'new', 'use', 'config', 'status', 'services', 'start', 'stop', 'logs', 'mcp', 'wiki', 'skills', 'clear', 'chat', 'agent', 'approve'];
 
 function valueAfter(argv, flag) {
   const index = argv.indexOf(flag);
@@ -39,6 +42,7 @@ function createSession() {
     packageJson,
     conversations: { __global__: [] },
     activities: {},
+    jobQueue: [],
     productionActivity: null,
     headlessPlan: null,
   };
@@ -57,20 +61,6 @@ async function writeHeadlessLog(session, lines, explicitPath) {
   return logPath;
 }
 
-function activitySnapshot(session) {
-  return new Set(sessionActivities(session).map((a) => a.key));
-}
-
-function newNonTerminalActivities(snapshotBefore, session) {
-  return sessionActivities(session).filter((a) => !snapshotBefore.has(a.key) && !a.terminal);
-}
-
-function terminalFailures(activities) {
-  return activities.filter(
-    (a) => a.terminal && ['failed', 'error', 'cancelled', 'canceled'].includes(String(a.status).toLowerCase()),
-  );
-}
-
 
 async function runHeadlessActivityLoop(session, log, { wait, timeoutMs }) {
   if (!wait) return { exitCode: 0, completed: [], timedOut: false };
@@ -150,118 +140,54 @@ async function runHeadlessActivityLoop(session, log, { wait, timeoutMs }) {
   return { exitCode: 1, completed, timedOut: true };
 }
 
-async function runHeadlessAgentTurn(agent, session, input, log, messages = []) {
-  session.packageJson = packageJson;
-  let streamedContent = '';
-  session._onStream = (delta) => { streamedContent += delta; };
-  session._onStreamReset = () => { streamedContent = ''; };
-  let result;
-  try {
-    result = await agent.invoke({ input, session, messages });
-  } finally {
-    delete session._onStream;
-    delete session._onStreamReset;
-  }
-  if (result.streamedInline) {
-    return streamedContent.trim() || buildLimitedAgentResponse({ input, session }, 'LLM stream ended without content');
-  }
-  if (result.response != null) return result.response;
-  if (result.readyToStream && session.llm?.stream) {
-    const { system, messages: streamMessages = [] } = result.streamContext ?? {};
-    let content = '';
-    for await (const delta of session.llm.stream({
-      system: system ?? buildAgentSystemPrompt({ input, session }),
-      messages: streamMessages,
-    })) {
-      content += delta;
-    }
-    return content.trim() || buildLimitedAgentResponse({ input, session }, 'LLM stream ended without content');
-  }
-  return buildLimitedAgentResponse({ input, session });
-}
-
 async function runHeadlessAgenticLoop(agent, session, initialInput, log, { timeoutMs, maxTurns }) {
-  const conversationHistory = [];
-  let currentInput = initialInput;
-
-  for (let turn = 1; turn <= maxTurns; turn++) {
-    log.push(`agentic-loop: turn ${turn}/${maxTurns}`);
-    console.log(`[headless] Agent turn ${turn}/${maxTurns}…`);
-
-    const snapshot = activitySnapshot(session);
-
-    const response = await runHeadlessAgentTurn(agent, session, currentInput, log, conversationHistory);
-    log.push(`agentic-loop: turn ${turn} response:`);
-    log.push(response);
-    console.log(response);
-
-    conversationHistory.push(
-      { role: 'user', content: currentInput },
-      { role: 'assistant', content: response },
-    );
-
-    // session.headlessPlan is set authoritatively by wiki__plan_set tool call.
-    // Fall back to text extraction only if the agent didn't call the tool.
-    if (turn === 1 && session.headlessPlan === null) {
-      const extractedPlan = extractHeadlessPlan(response);
-      if (extractedPlan) {
-        dispatchAgentEvent(session, createAgentEvent('plan_set', {
-          origin: 'llm',
-          payload: { steps: extractedPlan },
-        }));
-        log.push(`agentic-loop: plan extracted from text (${session.headlessPlan.length} steps, fallback)`);
-      }
-    } else if (turn === 1 && session.headlessPlan) {
-      log.push(`agentic-loop: plan set via tool (${session.headlessPlan.length} steps)`);
-    }
-
-    const newPending = newNonTerminalActivities(snapshot, session);
-    if (newPending.length === 0) {
-      const pendingSteps = (session.headlessPlan ?? []).filter((s) => s.status === 'pending');
-      if (pendingSteps.length === 0) {
-        log.push('agentic-loop: no new non-terminal activities — plan complete');
-        console.log('[headless] Plan complete.');
-        return { exitCode: 0 };
-      }
+  const result = await runAgenticLoop(agent, session, initialInput, {
+    timeoutMs,
+    maxTurns,
+    waitForActivities: async (turnSession, _startedActivities, waitOptions) => {
+      const waitResult = await runHeadlessActivityLoop(turnSession, log, { wait: true, timeoutMs: waitOptions.timeoutMs });
+      return {
+        ok: waitResult.exitCode === 0 && !waitResult.timedOut,
+        ...waitResult,
+      };
+    },
+    onTurnStart: ({ turn, maxTurns: totalTurns }) => {
+      log.push(`agentic-loop: turn ${turn}/${totalTurns}`);
+      console.log(`[headless] Agent turn ${turn}/${totalTurns}…`);
+    },
+    onTurnResponse: ({ turn, response }) => {
+      log.push(`agentic-loop: turn ${turn} response:`);
+      log.push(response);
+      console.log(response);
+    },
+    onPlanExtracted: ({ steps }) => {
+      log.push(`agentic-loop: plan extracted from text (${steps.length} steps, fallback)`);
+    },
+    onPlanAlreadySet: ({ steps }) => {
+      log.push(`agentic-loop: plan set via tool (${steps.length} steps)`);
+    },
+    onComplete: () => {
+      log.push('agentic-loop: no new non-terminal activities — plan complete');
+      console.log('[headless] Plan complete.');
+    },
+    onPendingSteps: ({ pendingSteps }) => {
       log.push(`agentic-loop: no new async activity, ${pendingSteps.length} pending step(s) remain`);
       if (session.headlessPlan) log.push(`agentic-loop: plan status:\n${formatPlanStatus(session.headlessPlan)}`);
-      currentInput = [
-        'Original task:',
-        initialInput,
-        '',
-        `Plan status:\n${formatPlanStatus(session.headlessPlan)}`,
-        '',
-        'No new background activity was started in the previous turn.',
-        'Continue the original plan. Start the next pending step only.',
-        'If required information is missing and cannot be inferred, stop with a clear blocker.',
-      ].join('\n');
-      continue;
-    }
-
-    log.push(`agentic-loop: ${newPending.length} new job(s) started, waiting…`);
-    const { exitCode, completed, timedOut } = await runHeadlessActivityLoop(session, log, { wait: true, timeoutMs });
-
-    if (timedOut || exitCode !== 0) return { exitCode };
-
-    const summary = formatCompletedActivities(completed);
-    log.push(`agentic-loop: completed activities:\n${summary}`);
-    if (session.headlessPlan) log.push(`agentic-loop: plan status:\n${formatPlanStatus(session.headlessPlan)}`);
-    currentInput = [
-      'Original task:',
-      initialInput,
-      '',
-      session.headlessPlan ? `Plan status:\n${formatPlanStatus(session.headlessPlan)}\n` : null,
-      'Completed activities:',
-      summary,
-      '',
-      'Continue the original plan. Start the next required step only.',
-      'If all steps are complete, provide the final summary.',
-    ].filter(Boolean).join('\n');
-  }
-
-  log.push(`agentic-loop: max turns (${maxTurns}) reached without completing`);
-  console.error(`[headless] Max agent turns (${maxTurns}) reached.`);
-  return { exitCode: 1 };
+    },
+    onActivitiesStarted: ({ activities }) => {
+      log.push(`agentic-loop: ${activities.length} new job(s) started, waiting…`);
+    },
+    onActivitiesCompleted: ({ summary }) => {
+      log.push(`agentic-loop: completed activities:\n${summary}`);
+      if (session.headlessPlan) log.push(`agentic-loop: plan status:\n${formatPlanStatus(session.headlessPlan)}`);
+    },
+    onMaxTurns: ({ maxTurns: totalTurns }) => {
+      log.push(`agentic-loop: max turns (${totalTurns}) reached without completing`);
+      console.error(`[headless] Max agent turns (${totalTurns}) reached.`);
+    },
+  });
+
+  return { exitCode: result.ok ? 0 : (result.waitResult?.exitCode ?? 1) };
 }
 
 async function runHeadless(argv, agent) {
@@ -326,7 +252,7 @@ async function runHeadless(argv, agent) {
     if (useAgenticLoop) {
       ({ exitCode } = await runHeadlessAgenticLoop(agent, session, input, log, { timeoutMs, maxTurns }));
     } else {
-      const response = await runHeadlessAgentTurn(agent, session, input, log);
+      const response = await runAgentTurn(agent, session, input);
       log.push('response:');
       log.push(response);
       console.log(response);
@@ -345,7 +271,393 @@ async function runHeadless(argv, agent) {
   }
 }
 
+async function runRuntime(argv, agent) {
+  if (argv.includes('--help') || argv.includes('-h')) {
+    console.log([
+      'Usage: wiki-manager runtime [--host <host>] [--port <port>] [--state-dir <dir>]',
+      '',
+      'Runs the local agentic runtime used by wiki-manager Shell and llm-wiki serve.',
+      '',
+      'Defaults:',
+      '  --host 0.0.0.0',
+      '  --port 7788',
+      '  --state-dir .wiki-manager',
+    ].join('\n'));
+    return;
+  }
+  const { defaultRuntimeStateDir, openRuntimeStore, RECOVERABLE_QUEUE_STATUSES } = await import('../runtime/store.js');
+  const { startRuntimeServer } = await import('../runtime/server.js');
+  const { emitRuntimeLog, startActivitySupervisor } = await import('../runtime/supervisor.js');
+  const { resolveRuntimeAuthToken } = await import('../runtime/auth.js');
+  const { createSqliteQueueStore } = await import('../runtime/queueStore.js');
+  const { createApprovalManager } = await import('../runtime/approvals.js');
+  const { runRuntimeAgenticWorkflow } = await import('../runtime/runner.js');
+
+  const host = valueAfter(argv, '--host') ?? process.env.WIKI_MANAGER_RUNTIME_HOST ?? '0.0.0.0';
+  const port = Number(valueAfter(argv, '--port') ?? process.env.WIKI_MANAGER_RUNTIME_PORT ?? 7788);
+  const stateDir = valueAfter(argv, '--state-dir') ?? defaultRuntimeStateDir();
+  const auth = resolveRuntimeAuthToken({ host, stateDir });
+  if (auth.token) process.env.WIKI_MANAGER_RUNTIME_TOKEN = auth.token;
+  if (!Number.isInteger(port) || port <= 0 || port > 65535) {
+    throw new Error(`Invalid runtime port: ${port}`);
+  }
+
+  const store = openRuntimeStore({ stateDir });
+  let serverHandle = null;
+  const contexts = new Map();
+
+  async function getWorkspaceContext(workspaceName = null) {
+    const requestedWorkspace = workspaceName ? String(workspaceName).trim() : null;
+    const key = requestedWorkspace ?? '__default__';
+    if (contexts.has(key)) return contexts.get(key);
+
+    const pending = (async () => {
+      const session = createSession();
+      session.headless = true;
+      session.chatMode = false;
+      session.packageJson = packageJson;
+
+      if (requestedWorkspace) {
+        const result = await handleSlashCommand(`/use ${requestedWorkspace}`, { packageJson, session });
+        if (!session.workspacePath) throw new Error(result.output || `Workspace not loaded: ${requestedWorkspace}`);
+      }
+      const workspace = session.workspace ?? requestedWorkspace ?? null;
+      store.hydrateSession(session, { workspace });
+      session.queueStore = createSqliteQueueStore(store, session, { workspace });
+
+      const context = {
+        workspace,
+        session,
+        supervisor: null,
+        running: false,
+        currentAbortController: null,
+        approvalManager: null,
+      };
+      session._onAgentEvent = (event) => {
+        store.persistEvent(event);
+        serverHandle?.publish(event);
+      };
+      session._onRuntimeError = (err) => {
+        const message = err instanceof Error ? err.message : String(err);
+        dispatchAgentEvent(session, createAgentEvent('run_error', {
+          origin: 'runtime',
+          payload: { message, workspace },
+        }));
+      };
+      context.approvalManager = createApprovalManager(session, {
+        defaultTimeoutMs: Number.isFinite(Number(process.env.WIKI_MANAGER_APPROVAL_TIMEOUT_MS))
+          ? Math.max(1, Number(process.env.WIKI_MANAGER_APPROVAL_TIMEOUT_MS))
+          : undefined,
+      });
+      session._requestApproval = (request) => context.approvalManager.requestApproval(request);
+      context.supervisor = startActivitySupervisor(session);
+      contexts.set(key, context);
+      if (workspace && workspace !== key) contexts.set(workspace, context);
+      return context;
+    })();
+    contexts.set(key, pending);
+    pending.catch(() => {
+      if (contexts.get(key) === pending) contexts.delete(key);
+    });
+    return pending;
+  }
+
+  function recoveryMcpGaps(context) {
+    const gaps = [];
+    const session = context.session;
+    for (const activity of sessionActivities(session)) {
+      if (activity.terminal || !activity.poll?.server) continue;
+      const endpoint = session.mcp?.[activity.poll.server];
+      if (endpoint?.status !== 'connected') gaps.push(activity.poll.server);
+    }
+    for (const item of session.queueStore?.list?.() ?? []) {
+      const status = String(item.status ?? '').toLowerCase();
+      if (!RECOVERABLE_QUEUE_STATUSES.includes(status)) continue;
+      const endpoint = session.mcp?.[item.server ?? 'production'];
+      if (endpoint?.status !== 'connected') gaps.push(item.server ?? 'production');
+    }
+    return [...new Set(gaps)];
+  }
+
+  function activeNonTerminalActivities(session) {
+    return sessionActivities(session).filter((activity) => !activity.terminal);
+  }
+
+  function activePollingActivities(session) {
+    return activeNonTerminalActivities(session).filter((activity) => activity.poll);
+  }
+
+  function buildRecoveryPrompt(run, session) {
+    const conversation = session.agentProjection?.conversation ?? [];
+    const recentConversation = conversation
+      .slice(-8)
+      .map((message) => `${message.role}: ${message.content}`)
+      .join('\n');
+    return [
+      'Resume an interrupted runtime run.',
+      '',
+      'Original task:',
+      run.input ?? '(unknown)',
+      '',
+      session.headlessPlan ? `Current plan:\n${formatPlanStatus(session.headlessPlan)}` : null,
+      recentConversation ? `Recent conversation:\n${recentConversation}` : null,
+      '',
+      'Continue from the current plan state. Start only the next pending step.',
+      'If the work is already complete, provide a concise final summary.',
+    ].filter(Boolean).join('\n');
+  }
+
+  function startRecoveredAgenticRun(context, run) {
+    if (context.running) return false;
+    const session = context.session;
+    const supervisor = context.supervisor;
+    const runId = run.id;
+    const input = buildRecoveryPrompt(run, session);
+    context.running = true;
+    context.currentAbortController = new AbortController();
+    session._currentRunIdentity = {
+      runId,
+      turnId: `${runId}:resume-0`,
+      workspace: context.workspace,
+    };
+    session._abortSignal = context.currentAbortController.signal;
+    supervisor?.setRunSignal(context.currentAbortController.signal);
+    session._onStep = (message) => emitRuntimeLog(session, message);
+    emitRuntimeLog(session, `runtime: resuming interrupted run ${runId}`);
+
+    runRuntimeAgenticWorkflow(agent, session, run.input ?? input, {
+      initialInput: input,
+      signal: context.currentAbortController.signal,
+      timeoutMs: 3600 * 1000,
+      maxTurns: 20,
+      runId,
+      pollBusy: supervisor?.pollBusy,
+    })
+      .catch((err) => {
+        if (err?.name === 'AbortError') {
+          dispatchAgentEvent(session, createAgentEvent('run_cancelled', {
+            origin: 'runtime',
+            runId,
+            payload: { runId, message: 'Recovered runtime run cancelled.' },
+          }));
+          return;
+        }
+        dispatchAgentEvent(session, createAgentEvent('run_error', {
+          origin: 'runtime',
+          runId,
+          payload: {
+            runId,
+            message: err instanceof Error ? err.message : String(err),
+          },
+        }));
+      })
+      .finally(() => {
+        context.running = false;
+        context.currentAbortController = null;
+        supervisor?.setRunSignal(null);
+        delete session._abortSignal;
+        delete session._onStep;
+        delete session._currentRunIdentity;
+      });
+
+    return true;
+  }
+
+  async function recoverWorkspace(workspace, { manual = false } = {}) {
+    try {
+      const context = await getWorkspaceContext(workspace);
+      await refreshMcpRuntimeStatus(context.session);
+      const gaps = recoveryMcpGaps(context);
+      if (gaps.length > 0) {
+        const interrupted = store.interruptRuns({ workspace: context.workspace });
+        return {
+          workspace: context.workspace ?? workspace ?? null,
+          resumed: false,
+          interrupted,
+          reason: `MCP unavailable: ${gaps.join(', ')}`,
+        };
+      }
+      const recoverableRuns = store.listRecoverableRuns({ workspace: context.workspace });
+      const runningRun = recoverableRuns.find((run) => run.status === 'running');
+      const activeActivities = activeNonTerminalActivities(context.session);
+      const pollingActivities = activePollingActivities(context.session);
+      if (runningRun && activeActivities.length === 0) {
+        if (!runningRun.input) {
+          const interrupted = store.interruptRuns({ workspace: context.workspace });
+          return {
+            workspace: context.workspace ?? workspace ?? null,
+            resumed: false,
+            interrupted,
+            reason: 'Missing original run input.',
+          };
+        }
+        const started = startRecoveredAgenticRun(context, runningRun);
+        return {
+          workspace: context.workspace ?? workspace ?? null,
+          resumed: started,
+          interrupted: 0,
+          mode: 'agentic_loop',
+        };
+      }
+      if (runningRun && runningRun.input && pollingActivities.length > 0) {
+        context.session._onActivitiesTerminal = () => {
+          startRecoveredAgenticRun(context, runningRun);
+        };
+        emitRuntimeLog(context.session, `runtime: recovery watching ${pollingActivities.length} active activity(s)`);
+        return {
+          workspace: context.workspace ?? workspace ?? null,
+          resumed: true,
+          interrupted: 0,
+          mode: 'activity_poll_then_resume',
+        };
+      }
+      emitRuntimeLog(context.session, manual ? 'runtime: manual resume completed' : 'runtime: recovery completed');
+      return {
+        workspace: context.workspace ?? workspace ?? null,
+        resumed: true,
+        interrupted: 0,
+        mode: pollingActivities.length > 0 ? 'activity_poll' : 'context',
+      };
+    } catch (err) {
+      const interrupted = store.interruptRuns({ workspace });
+      return {
+        workspace: workspace ?? null,
+        resumed: false,
+        interrupted,
+        reason: err instanceof Error ? err.message : String(err),
+      };
+    }
+  }
+
+  async function recoverRuntime({ workspace = null, manual = false } = {}) {
+    const workspaces = workspace ? [workspace] : store.listRecoverableWorkspaces();
+    const results = await Promise.all(workspaces.map((item) => recoverWorkspace(item, { manual })));
+    return {
+      resumed: results.filter((result) => result.resumed).length,
+      interrupted: results.reduce((sum, result) => sum + Number(result.interrupted ?? 0), 0),
+      workspaces: results,
+    };
+  }
+
+  async function executeRun(context, body, { signal } = {}) {
+    const session = context.session;
+    const supervisor = context.supervisor;
+    const input = String(body.input ?? body.prompt ?? '').trim();
+    const workspace = body.workspace ? String(body.workspace).trim() : null;
+    const timeoutMs = (Number.isFinite(Number(body.timeout)) ? Math.max(1, Number(body.timeout)) : 3600) * 1000;
+    const maxTurns = Number.isFinite(Number(body.maxTurns)) ? Math.max(1, Number(body.maxTurns)) : 20;
+    const maxReplans = Number.isFinite(Number(body.replans)) ? Math.max(0, Math.floor(Number(body.replans))) : undefined;
+    const runId = String(body.runId);
+    try {
+      if (workspace && session.workspace !== workspace) {
+        const result = await handleSlashCommand(`/use ${workspace}`, { packageJson, session });
+        if (!session.workspacePath) throw new Error(result.output || `Workspace not loaded: ${workspace}`);
+      }
+      context.workspace = session.workspace ?? workspace ?? context.workspace ?? null;
+      session._currentRunIdentity = {
+        runId,
+        turnId: `${runId}:turn-0`,
+        workspace: context.workspace,
+      };
+      dispatchAgentEvent(session, createAgentEvent('run_started', {
+        origin: 'runtime',
+        runId,
+        payload: { input, workspace: session._currentRunIdentity.workspace },
+      }));
+      dispatchAgentEvent(session, createAgentEvent('user_message', {
+        origin: 'user',
+        runId,
+        payload: { content: input },
+      }));
+      session._abortSignal = signal ?? null;
+      session._runApprovalRequired = body.requireApproval === true;
+      session._runApprovalResolved = false;
+      session._approvalTimeoutMs = Number.isFinite(Number(body.approvalTimeoutMs))
+        ? Math.max(1, Number(body.approvalTimeoutMs))
+        : undefined;
+      supervisor?.setRunSignal(signal);
+      session._onStep = (message) => emitRuntimeLog(session, message);
+      await runRuntimeAgenticWorkflow(agent, session, input, {
+        signal,
+        timeoutMs,
+        maxTurns,
+        runId,
+        pollBusy: supervisor?.pollBusy,
+        evaluate: body.evaluate !== false,
+        ...(maxReplans === undefined ? {} : { maxReplans }),
+      });
+    } catch (err) {
+      if (err?.name === 'AbortError') {
+        dispatchAgentEvent(session, createAgentEvent('run_cancelled', {
+          origin: 'runtime',
+          runId,
+          payload: {
+            runId,
+            message: 'Agent run cancelled.',
+          },
+        }));
+        return;
+      }
+      dispatchAgentEvent(session, createAgentEvent('run_error', {
+        origin: 'runtime',
+        runId,
+        payload: {
+          runId,
+          message: err instanceof Error ? err.message : String(err),
+        },
+      }));
+    } finally {
+      supervisor?.setRunSignal(null);
+      delete session._abortSignal;
+      delete session._onStep;
+      delete session._currentRunIdentity;
+      delete session._runApprovalRequired;
+      delete session._runApprovalResolved;
+      delete session._approvalTimeoutMs;
+    }
+  }
+
+  serverHandle = await startRuntimeServer({
+    host,
+    port,
+    store,
+    getContext: getWorkspaceContext,
+    run: executeRun,
+    cancel: (context) => emitRuntimeLog(context.session, 'runtime: cancel requested'),
+    resume: ({ workspace }) => recoverRuntime({ workspace, manual: true }),
+    approve: async ({ workspace, runId, itemId, approvalId }) => {
+      const context = await getWorkspaceContext(workspace);
+      return context.approvalManager?.approve({ runId, itemId, approvalId }) ?? { approved: false };
+    },
+    token: auth.token,
+  });
+  const recovery = await recoverRuntime();
+
+  console.log(`wiki-manager runtime listening on http://${host}:${port}`);
+  console.log(`runtime state: ${store.dbPath}`);
+  if (recovery.resumed > 0 || recovery.interrupted > 0) {
+    console.log(`runtime recovery: resumed=${recovery.resumed} interrupted=${recovery.interrupted}`);
+  }
+  if (auth.tokenPath) console.log(`runtime token: ${auth.tokenPath}`);
+
+  const shutdown = async () => {
+    await Promise.all([...new Set(contexts.values())].map(async (v) => { (await v).supervisor?.stop(); }));
+    await serverHandle.close();
+    store.close();
+    process.exit(0);
+  };
+  process.once('SIGINT', shutdown);
+  process.once('SIGTERM', shutdown);
+  await new Promise(() => {});
+}
+
 export async function runCli(argv) {
+  if (argv[0] === 'runtime') {
+    const agent = createAgentGraph();
+    await runRuntime(argv.slice(1), agent);
+    return;
+  }
+
   if (argv.includes('--setup-wizard')) {
     if (!process.versions.bun) {
       throw new Error('Setup wizard requires Bun. Run: bun ./bin/wiki-manager.js --setup-wizard');
@@ -396,9 +708,25 @@ export async function runCli(argv) {
     const { runOpenTuiShell, runStartupWizard } = await import('../shell/tui.tsx');
     const gaps = await runChecks();
     if (gaps.length > 0) await runStartupWizard(gaps);
-    await runOpenTuiShell({ agent, packageJson });
+    let runtime = null;
+    try {
+      const { ensureRuntime } = await import('../runtime/lifecycle.js');
+      runtime = await ensureRuntime();
+    } catch (err) {
+      console.error(`Runtime unavailable: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    await runOpenTuiShell({ agent, packageJson, runtime });
     return;
   }
 
-  await runShell({ agent, packageJson });
+  let runtime = null;
+  if (process.stdin.isTTY && process.stdout.isTTY) {
+    try {
+      const { ensureRuntime } = await import('../runtime/lifecycle.js');
+      runtime = await ensureRuntime();
+    } catch (err) {
+      console.error(`Runtime unavailable: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  await runShell({ agent, packageJson, runtime });
 }

package/src/commands/slash.js

@@ -490,7 +490,7 @@ function publishDocumentActivity(session, activity) {
   return publishPayloadActivity(session, { _activity: activity }, { server: 'documents', tool: 'documents_convert_to_markdown' });
 }
 
-async function refreshMcpRuntimeStatus(session) {
+export async function refreshMcpRuntimeStatus(session) {
   session.mcp = buildMcpStatus(session);
   if (!session.workspacePath) return null;
   try {

package/src/core/activity.js

@@ -222,6 +222,20 @@ export function formatActivitySummary(source, action, resultText) {
   return usefulLine ? `${source}.${action}: ${usefulLine.slice(0, 120)}` : null;
 }
 
+export function activitySnapshot(session) {
+  return new Set(sessionActivities(session).map((a) => a.key));
+}
+
+export function newNonTerminalActivities(snapshotBefore, session) {
+  return sessionActivities(session).filter((a) => !snapshotBefore.has(a.key) && !a.terminal);
+}
+
+export function terminalFailures(activities) {
+  return activities.filter(
+    (a) => a.terminal && ['failed', 'error', 'cancelled', 'canceled'].includes(String(a.status).toLowerCase()),
+  );
+}
+
 export function formatActivityError(source, action, err) {
   const message = err instanceof Error ? err.message : String(err);
   const lines = message