@dotdrelle/wiki-manager 0.6.47 → 0.7.3

package/bin/wiki-manager.js

@@ -80,8 +80,8 @@ async function main() {
   // Fallback for already-bootstrapped direct invocations; the shell wrapper
   // exports these before Bun starts.
   if (parsed.cacert) Object.assign(process.env, cacertEnvVars(parsed.cacert));
-  await import('@opentui/solid/preload');
-  const interactive = process.stdout.isTTY && process.stdin.isTTY && !argv.includes('--setup-wizard') && !argv.includes('--headless') && !argv.includes('--once') && !argv.includes('--version') && !argv.includes('-v') && !argv.includes('--help') && !argv.includes('-h');
+  const interactive = process.stdout.isTTY && process.stdin.isTTY && argv[0] !== 'runtime' && !argv.includes('--setup-wizard') && !argv.includes('--headless') && !argv.includes('--once') && !argv.includes('--version') && !argv.includes('-v') && !argv.includes('--help') && !argv.includes('-h');
+  if (interactive || argv.includes('--setup-wizard')) await import('@opentui/solid/preload');
   if (interactive) process.stdout.write('Starting wiki-manager…\r');
   const { runCli } = await import('../src/cli/wiki-manager.js');
   await runCli(argv);

package/docker-compose.yml

@@ -62,6 +62,8 @@ services:
       - DOCUMENT_MAX_UPLOAD_BYTES=${DOCUMENT_MAX_UPLOAD_BYTES:-52428800}
       - WIKI_MCP_PROXY_URL=http://host.docker.internal:${WIKI_MCP_PORT:-3101}/mcp
       - PRODUCTION_MCP_PROXY_URL=http://host.docker.internal:${PRODUCTION_MCP_PORT:-3102}/mcp/
+      - WIKI_MANAGER_RUNTIME_URL=http://host.docker.internal:7788
+      - WIKI_MANAGER_RUNTIME_TOKEN=${WIKI_MANAGER_RUNTIME_TOKEN:-}
       # HTTPS — set paths inside the container (e.g. /certs/server.crt) and uncomment the volume above
       #- WIKI_SERVE_TLS_CERT_PATH=/certs/server.crt
       #- WIKI_SERVE_TLS_KEY_PATH=/certs/server.key
@@ -95,6 +97,25 @@ services:
       - host.docker.internal:host-gateway
     restart: unless-stopped
 
+  # ── wiki-manager runtime ─────────────────────────────────────────────────
+
+  agent-runtime:
+    image: dotdrelle/llm-wiki-manager:latest
+    labels:
+      wiki-manager.description: "Agentic runtime — runs, plan, activities, queue."
+    command: runtime --host 0.0.0.0 --port 7788 --state-dir /state
+    volumes:
+      - ./.wiki-manager:/state
+      - ${WIKI_WORKSPACES_DIR:-./workspaces}:/workspaces
+    environment:
+      - WIKI_WORKSPACES_DIR=/workspaces
+      - WIKI_MANAGER_RUNTIME_TOKEN=${WIKI_MANAGER_RUNTIME_TOKEN:-}
+    ports:
+      - '127.0.0.1:7788:7788'
+    extra_hosts:
+      - host.docker.internal:host-gateway
+    restart: unless-stopped
+
   # ── agent-wiki-production ─────────────────────────────────────────────────
 
   production-mcp:
@@ -119,7 +140,7 @@ services:
 x-wiki-manager:
   service-aliases:
     all:
-      targets: [serve, mcp-http, production-mcp]
+      targets: [serve, mcp-http, agent-runtime, production-mcp]
       description: "Full workspace service set."
     ui:
       targets: [serve]
@@ -130,6 +151,9 @@ x-wiki-manager:
     mcp:
       targets: [mcp-http]
       description: "Alias for mcp-http: wiki MCP server."
+    runtime:
+      targets: [agent-runtime]
+      description: "Alias for agent-runtime: agentic runtime."
     production:
       targets: [production-mcp]
       description: "Alias for production-mcp: production jobs."

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotdrelle/wiki-manager",
-  "version": "0.6.47",
+  "version": "0.7.3",
   "description": "Agentic shell and orchestration cockpit for llm-wiki workspaces.",
   "license": "PolyForm-Noncommercial-1.0.0",
   "author": "dotrelle",
@@ -11,7 +11,7 @@
   },
   "scripts": {
     "start": "bun ./bin/wiki-manager.js",
-    "test": "node --test src/core/activity.test.js src/core/agentEvents.test.js src/core/plan.test.js src/core/mcp.test.js src/core/documentIntake.test.js src/core/wikirc.test.js src/core/modelFetch.test.js src/core/startupCheck.test.js src/commands/slash.test.js",
+    "test": "node --test src/core/activity.test.js src/core/agentEvents.test.js src/core/agentLoop.test.js src/core/plan.test.js src/core/mcp.test.js src/core/documentIntake.test.js src/core/dockerCompose.test.js src/core/wikirc.test.js src/core/modelFetch.test.js src/core/startupCheck.test.js src/core/queueStore.test.js src/commands/slash.test.js src/shell/repl.test.js src/runtime/store.test.js src/runtime/server.test.js src/runtime/supervisor.test.js src/runtime/auth.test.js",
     "check": "bun ./bin/wiki-manager.js --version && bun ./bin/wiki-manager.js --help && bun ./bin/wiki-manager.js --once \"verifie le mode agent\""
   },
   "engines": {

package/src/cli/wiki-manager.js

@@ -1,17 +1,21 @@
+import { randomUUID } from 'node:crypto';
 import { readFileSync } from 'node:fs';
 import { mkdir, writeFile } from 'node:fs/promises';
 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 { createAgentGraph } from '../agent/graph.js';
 import { handleSlashCommand, printHelp, printVersion } 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');
@@ -39,6 +43,7 @@ function createSession() {
     packageJson,
     conversations: { __global__: [] },
     activities: {},
+    jobQueue: [],
     productionActivity: null,
     headlessPlan: null,
   };
@@ -57,20 +62,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 +141,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 +253,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 +272,171 @@ 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 } = 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 { runRuntimeAgenticLoop } = 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 session = createSession();
+  session.headless = true;
+  session.chatMode = false;
+  session.packageJson = packageJson;
+
+  const store = openRuntimeStore({ stateDir });
+  store.hydrateSession(session);
+  session.queueStore = createSqliteQueueStore(store, session);
+
+  let serverHandle = 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 },
+    }));
+  };
+
+  let supervisor = null;
+
+  async function executeRun(body, { signal } = {}) {
+    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 runId = randomUUID();
+    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}`);
+      }
+      dispatchAgentEvent(session, createAgentEvent('run_started', {
+        origin: 'runtime',
+        runId,
+        payload: { input, workspace },
+      }));
+      dispatchAgentEvent(session, createAgentEvent('user_message', {
+        origin: 'user',
+        runId,
+        payload: { content: input },
+      }));
+      session._abortSignal = signal ?? null;
+      supervisor?.setRunSignal(signal);
+      session._onStep = (message) => emitRuntimeLog(session, message);
+      const result = await runRuntimeAgenticLoop(agent, session, input, {
+        signal,
+        timeoutMs,
+        maxTurns,
+        runId,
+        pollBusy: supervisor?.pollBusy,
+      });
+      if (!result.ok) {
+        dispatchAgentEvent(session, createAgentEvent('run_error', {
+          origin: 'runtime',
+          runId,
+          payload: {
+            runId,
+            message: result.timedOut
+              ? 'Runtime agentic loop timed out.'
+              : result.maxTurns
+                ? `Runtime agentic loop reached max turns (${maxTurns}).`
+                : 'Runtime agentic loop failed.',
+          },
+        }));
+        return;
+      }
+      dispatchAgentEvent(session, createAgentEvent('run_done', {
+        origin: 'runtime',
+        runId,
+        payload: { runId },
+      }));
+    } 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;
+    }
+  }
+
+  serverHandle = await startRuntimeServer({
+    host,
+    port,
+    store,
+    session,
+    run: executeRun,
+    cancel: () => emitRuntimeLog(session, 'runtime: cancel requested'),
+    token: auth.token,
+  });
+  supervisor = startActivitySupervisor(session);
+
+  console.log(`wiki-manager runtime listening on http://${host}:${port}`);
+  console.log(`runtime state: ${store.dbPath}`);
+  if (auth.tokenPath) console.log(`runtime token: ${auth.tokenPath}`);
+
+  const shutdown = async () => {
+    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 +487,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/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

package/src/core/agentEvents.js

@@ -7,6 +7,18 @@ const SESSION_PROJECTION_EVENTS = new Set([
   'plan_step_updated',
   'activity_upserted',
   'run_error',
+  'run_cancelled',
+  'runtime_log',
+]);
+
+// Events that can mutate state.plan in applyEvent() — only these warrant the
+// before/after plan comparison below (runtime_log fires far more often and
+// never touches the plan).
+const PLAN_MUTATING_EVENTS = new Set([
+  'run_started',
+  'plan_set',
+  'plan_step_updated',
+  'activity_upserted',
 ]);
 
 export function createAgentEvent(type, { origin = 'system', payload = {}, runId = null, turnId = null } = {}) {
@@ -23,7 +35,8 @@ export function createAgentEvent(type, { origin = 'system', payload = {}, runId
 
 export function dispatchAgentEvent(session, event) {
   const normalized = event.id && event.ts ? event : createAgentEvent(event.type, event);
-  const previousPlan = JSON.stringify(session.headlessPlan ?? null);
+  const tracksPlan = PLAN_MUTATING_EVENTS.has(normalized.type);
+  const previousPlan = tracksPlan ? JSON.stringify(session.headlessPlan ?? null) : null;
   session.agentEvents ??= [];
   session.agentEvents.push(normalized);
   session._agentProjectionState ??= createProjectionState();
@@ -31,10 +44,11 @@ export function dispatchAgentEvent(session, event) {
   session.agentProjection = publicProjection(session._agentProjectionState);
   if (SESSION_PROJECTION_EVENTS.has(normalized.type)) {
     applyAgentProjectionToSession(session, session.agentProjection);
-    if (JSON.stringify(session.headlessPlan ?? null) !== previousPlan) {
+    if (tracksPlan && JSON.stringify(session.headlessPlan ?? null) !== previousPlan) {
       session._onPlanUpdate?.();
     }
   }
+  session._onAgentEvent?.(normalized, session.agentProjection);
   return normalized;
 }
 
@@ -133,10 +147,18 @@ function applyEvent(state, event) {
     case 'run_done':
       state.status = 'done';
       return;
+    case 'run_cancelled':
+      state.status = 'cancelled';
+      state.logs.push(String(event.payload?.message ?? 'Agent run cancelled.'));
+      return;
     case 'run_error':
       state.status = 'error';
       state.logs.push(String(event.payload?.message ?? 'Agent run failed.'));
       return;
+    case 'runtime_log':
+      state.logs.push(String(event.payload?.message ?? ''));
+      state.logs = state.logs.slice(-200);
+      return;
     default:
       return;
   }