@dotdrelle/wiki-manager 0.6.34 → 0.7.3

package/src/shell/repl.js

@@ -1,19 +1,21 @@
 import { createInterface } from 'node:readline';
 import { emitKeypressEvents } from 'node:readline';
 import { Transform } from 'node:stream';
+import { execFileSync } from 'node:child_process';
 import { stdin as input, stdout as output } from 'node:process';
 import { marked } from 'marked';
 import { markedTerminal } from 'marked-terminal';
 import { buildAgentSystemPrompt, buildLimitedAgentResponse } from '../agent/graph.js';
 import { handleSlashCommand } from '../commands/slash.js';
 import { serviceDescription, serviceNames as composeServiceNames } from '../core/compose.js';
-import { extractActivity, sessionActivities } from '../core/activity.js';
+import { extractActivity, parseJsonText, sessionActivities } from '../core/activity.js';
 import { syncActivitiesToPlan } from '../core/plan.js';
 import { callMcpTool, formatMcpToolResult } from '../core/mcp.js';
 import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
 import { listSkills } from '../core/skills.js';
 import { listWikircProfiles } from '../core/wikirc.js';
 import { listWorkspaces } from '../core/workspaces.js';
+import { fetchRuntimeState, postRuntimeCancel, postRuntimeRun, streamRuntimeEvents } from '../runtime/client.js';
 
 marked.use(markedTerminal());
 // marked-terminal's text renderer extracts token.text (raw string) instead of
@@ -202,6 +204,7 @@ function completionValuesFor(parts, inputBuffer, session) {
   if (tokenIndex === 0) return slashCompletions(session);
   if (command === '/new' && tokenIndex === 1) return [];
   if (command === '/use' && tokenIndex === 1) return workspaceNames();
+  if (command === '/use' && tokenIndex === 2) return [];
   if (command === '/config' && tokenIndex === 1) return ['edit', 'list', 'status', 'use'];
   if (command === '/config' && (previousToken === 'use' || previousToken === 'edit')) return wikircProfileNames(session);
   if (command === '/mcp' && tokenIndex === 1) return ['call', 'endpoints', 'status', 'tools'];
@@ -668,14 +671,6 @@ function renderBannerWithMcpPanel(columns, session) {
 
 const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
 
-function parseJsonText(text) {
-  try {
-    return JSON.parse(text);
-  } catch {
-    return null;
-  }
-}
-
 function pathBaseName(value) {
   return String(value ?? '').split('/').filter(Boolean).pop() ?? '';
 }
@@ -737,6 +732,45 @@ function rememberProductionActivity(session, payload) {
   return true;
 }
 
+export function applyRuntimeStateToShellSession(session, state) {
+  if (!state || typeof state !== 'object') return false;
+  session.agentProjection = {
+    conversation: Array.isArray(state.conversation) ? state.conversation.map((message) => ({ ...message })) : [],
+    chain: Array.isArray(state.chain) ? state.chain.map((step) => ({ ...step })) : [],
+    plan: Array.isArray(state.plan) ? state.plan.map((step) => ({ ...step })) : null,
+    activities: Array.isArray(state.activities) ? state.activities.map((activity) => ({ ...activity })) : [],
+    logs: Array.isArray(state.logs) ? [...state.logs] : [],
+    summary: state.summary ?? null,
+    status: state.status ?? 'idle',
+  };
+  session.headlessPlan = session.agentProjection.plan
+    ? session.agentProjection.plan.map((step) => ({ ...step }))
+    : null;
+  session.activities = Object.fromEntries(
+    session.agentProjection.activities.map((activity) => [activity.key, { ...activity }]),
+  );
+  if (Array.isArray(state.queue)) session.jobQueue = state.queue.map((item) => ({ ...item }));
+  const production = session.agentProjection.activities.filter((activity) => activity.source === 'production').at(-1);
+  if (production) {
+    session.productionActivity = {
+      jobId: production.id,
+      status: production.status,
+      label: production.label,
+      terminal: production.terminal,
+      updatedAt: production.updatedAt,
+    };
+  }
+  const runtimeConversation = session.agentProjection.conversation;
+  if (runtimeConversation.length > 0) {
+    session.conversations ??= { [GLOBAL_CONVERSATION_KEY]: [] };
+    session.conversations[conversationKey(session)] = runtimeConversation.map((message) => ({
+      role: message.role === 'assistant' ? 'donna' : message.role,
+      content: String(message.content ?? ''),
+    }));
+  }
+  return true;
+}
+
 function activityText(session) {
   const activity = sessionActivities(session).find((item) => !item.terminal)
     ?? (session.productionActivity?.label ? session.productionActivity : null);
@@ -747,6 +781,10 @@ function activityText(session) {
   return `${color}${truncateAnsi(activity.label, 72)}${styles.reset}`;
 }
 
+function runtimeRunActive(session) {
+  return String(session.agentProjection?.status ?? '').toLowerCase() === 'running';
+}
+
 function dividerWithActivity(session, columns) {
   const activity = activityText(session);
   if (!activity) return '─'.repeat(columns);
@@ -1141,7 +1179,7 @@ async function runPipeShell({ agent, packageJson, session }) {
 let lastBodyLineCount = 0;
 let lastMiddleHeight = 5;
 
-async function runTuiShell({ agent, packageJson, session }) {
+async function runTuiShell({ agent, packageJson, session, runtime = null }) {
   const messages = conversationMessages(session);
   messages.push({
     role: 'donna',
@@ -1167,6 +1205,11 @@ async function runTuiShell({ agent, packageJson, session }) {
   let mouseSelectionTimer = null;
   let done = false;
   let processing = Promise.resolve();
+  let runtimePollingActive = false;
+  let runtimeStreamAbort = null;
+  let runtimeReconnectTimer = null;
+  let runtimeSyncTimer = null;
+  let runtimeStreamStopped = false;
   let finish;
   const finished = new Promise((resolve) => {
     finish = resolve;
@@ -1197,8 +1240,55 @@ async function runTuiShell({ agent, packageJson, session }) {
     rerender();
   }
 
+  function syncRuntimeState() {
+    if (!runtime?.url) return;
+    void fetchRuntimeState({ url: runtime.url })
+      .then((state) => {
+        runtimePollingActive = true;
+        applyRuntimeStateToShellSession(session, state);
+        rerender();
+      })
+      .catch(() => {
+        runtimePollingActive = false;
+        rerender();
+      });
+  }
+
+  function scheduleRuntimeStateSync() {
+    if (runtimeSyncTimer) clearTimeout(runtimeSyncTimer);
+    runtimeSyncTimer = setTimeout(syncRuntimeState, 200);
+  }
+
+  async function subscribeRuntimeEvents() {
+    if (!runtime?.url || runtimeStreamStopped) return;
+    runtimeStreamAbort = new AbortController();
+    try {
+      for await (const event of streamRuntimeEvents({ url: runtime.url, signal: runtimeStreamAbort.signal })) {
+        runtimePollingActive = true;
+        if (event.type === 'state') {
+          applyRuntimeStateToShellSession(session, event.data);
+          rerender();
+        } else {
+          scheduleRuntimeStateSync();
+        }
+      }
+    } catch {
+      // Runtime stream may be temporarily unavailable; the local MCP polling fallback resumes below.
+    }
+    if (runtimeStreamStopped) return;
+    runtimePollingActive = false;
+    rerender();
+    runtimeReconnectTimer = setTimeout(() => { void subscribeRuntimeEvents(); }, 1500);
+  }
+
+  if (runtime?.url) {
+    syncRuntimeState();
+    void subscribeRuntimeEvents();
+  }
+
   const pollBusy = new Set();
   const productionPollInterval = setInterval(async () => {
+    if (runtimePollingActive) return;
     const candidates = sessionActivities(session).filter((item) => item.poll && !item.terminal);
     // Legacy fallback: if no generic activities tracked yet, fall back to productionActivity.
     if (candidates.length === 0 && session.productionActivity?.jobId && !session.productionActivity.terminal) {
@@ -1306,14 +1396,12 @@ async function runTuiShell({ agent, packageJson, session }) {
     }
 
     if (key?.ctrl && key.name === 'y') {
-      const messages = conversationMessages(session);
       const lastDonna = [...messages].reverse().find((m) => isDonnaRole(m.role));
       if (lastDonna) {
         const text = stripAnsi(colorizeStatus(lastDonna.content)).replace(/\[[0-9;]*m/g, '');
         const clipCmd = process.platform === 'darwin'
           ? { command: 'pbcopy', args: [] }
           : { command: 'xclip', args: ['-selection', 'clipboard'] };
-        const { execFileSync } = await import('node:child_process');
         const prevLabel = spinnerLabel;
         const prevBusy = busy;
         try {
@@ -1335,6 +1423,18 @@ async function runTuiShell({ agent, packageJson, session }) {
         rerender();
         return;
       }
+      if (runtime?.url && runtimeRunActive(session)) {
+        void postRuntimeCancel({ url: runtime.url })
+          .then(() => {
+            activityLines = [...activityLines, 'runtime: cancel requested'].slice(-LOWER_DETAIL_ROWS);
+            rerender();
+          })
+          .catch((err) => {
+            activityLines = [...activityLines, `runtime cancel error: ${err instanceof Error ? err.message : String(err)}`].slice(-LOWER_DETAIL_ROWS);
+            rerender();
+          });
+        return;
+      }
       const now = Date.now();
       if (now - lastCtrlCAt <= 1500) {
         done = true;
@@ -1382,9 +1482,20 @@ async function runTuiShell({ agent, packageJson, session }) {
       session._abortSignal = currentAbortController.signal;
       let aborted = false;
       try {
-        const result = await runLine(line, { agent, packageJson, session, onUpdate: rerender, onStep });
-        done = result.exit;
-        aborted = result.aborted ?? false;
+        if (runtime?.url && !session.chatMode && !line.trim().startsWith('/')) {
+          await postRuntimeRun(line, {
+            url: runtime.url,
+            workspace: session.workspace ?? null,
+          });
+          conversationMessages(session).push({ role: 'user', content: line });
+          conversationMessages(session).push({ role: 'command', content: `Runtime run queued: ${runtime.url}` });
+          activityLines = [...activityLines, 'runtime: run accepted'].slice(-LOWER_DETAIL_ROWS);
+          syncRuntimeState();
+        } else {
+          const result = await runLine(line, { agent, packageJson, session, onUpdate: rerender, onStep });
+          done = result.exit;
+          aborted = result.aborted ?? false;
+        }
       } catch (err) {
         if (err.name !== 'AbortError') throw err;
         aborted = true;
@@ -1479,6 +1590,10 @@ async function runTuiShell({ agent, packageJson, session }) {
     await processing;
   } finally {
     mouseFilter.off('keypress', onKeypress);
+    runtimeStreamStopped = true;
+    runtimeStreamAbort?.abort();
+    clearTimeout(runtimeReconnectTimer);
+    clearTimeout(runtimeSyncTimer);
     clearInterval(productionPollInterval);
     clearTimeout(ctrlCTimer);
     clearTimeout(mouseSelectionTimer);
@@ -1492,11 +1607,11 @@ async function runTuiShell({ agent, packageJson, session }) {
   }
 }
 
-export async function runShell({ agent, packageJson }) {
+export async function runShell({ agent, packageJson, runtime = null }) {
   const session = createSession();
   if (!input.isTTY || !output.isTTY) {
     await runPipeShell({ agent, packageJson, session });
     return;
   }
-  throw new Error('Interactive TUI requires Bun/OpenTUI. Run: bun ./bin/wiki-manager.js');
+  await runTuiShell({ agent, packageJson, session, runtime });
 }

package/src/shell/repl.test.js

@@ -0,0 +1,38 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { applyRuntimeStateToShellSession, createSession, conversationMessages } from './repl.js';
+
+test('applyRuntimeStateToShellSession projects runtime state into shell session', () => {
+  const session = createSession();
+  session.workspace = 'docs';
+
+  const applied = applyRuntimeStateToShellSession(session, {
+    status: 'running',
+    conversation: [
+      { role: 'user', content: 'Build docs' },
+      { role: 'assistant', content: 'Working.' },
+    ],
+    plan: [{ step: 1, description: 'Build', status: 'running' }],
+    activities: [{
+      key: 'production:job-1',
+      id: 'job-1',
+      source: 'production',
+      label: 'Production: build',
+      status: 'running',
+      terminal: false,
+    }],
+    queue: [{ id: 'q-1', status: 'waiting' }],
+    logs: ['agentic-loop: turn 1/20'],
+  });
+
+  assert.equal(applied, true);
+  assert.equal(session.agentProjection.status, 'running');
+  assert.equal(session.headlessPlan[0].description, 'Build');
+  assert.equal(session.activities['production:job-1'].status, 'running');
+  assert.equal(session.productionActivity.jobId, 'job-1');
+  assert.equal(session.jobQueue[0].id, 'q-1');
+  assert.deepEqual(conversationMessages(session), [
+    { role: 'user', content: 'Build docs' },
+    { role: 'donna', content: 'Working.' },
+  ]);
+});

package/src/shell/tui.tsx

@@ -41,6 +41,7 @@ function copyToClipboard(text: string, renderer: unknown) {
 function App(props: {
   agent: unknown;
   packageJson: Record<string, unknown>;
+  runtime?: any;
 }) {
   const renderer = useRenderer();
   const dimensions = useTerminalDimensions();
@@ -204,11 +205,13 @@ function App(props: {
 export async function runOpenTuiShell({
   agent,
   packageJson,
+  runtime = null,
 }: {
   agent: unknown;
   packageJson: Record<string, unknown>;
+  runtime?: any;
 }) {
-  await render(() => <App agent={agent} packageJson={packageJson} />, {
+  await render(() => <App agent={agent} packageJson={packageJson} runtime={runtime} />, {
     exitOnCtrlC: false,
     useMouse: true,
     targetFps: 30,

package/src/shell/useAgent.ts

@@ -1,7 +1,8 @@
 import { createSignal } from 'solid-js';
-import { runLine } from './repl.js';
+import { postRuntimeCancel, postRuntimeRun } from '../runtime/client.js';
+import { conversationMessages, runLine } from './repl.js';
 
-export function useAgent(props: { agent: unknown; packageJson: Record<string, unknown>; session: Record<string, any>; chatMode: () => boolean; refresh: () => void; addLog: (line: string) => void }) {
+export function useAgent(props: { agent: unknown; packageJson: Record<string, unknown>; session: Record<string, any>; chatMode: () => boolean; runtimeUrl?: string | null; refresh: () => void; addLog: (line: string) => void; onRuntimeAccepted?: () => void }) {
   const [busy, setBusy] = createSignal(false);
   const [abortController, setAbortController] = createSignal<AbortController | null>(null);
 
@@ -17,6 +18,18 @@ export function useAgent(props: { agent: unknown; packageJson: Record<string, un
     props.addLog(`input: ${trimmed}`);
 
     try {
+      if (props.runtimeUrl && !props.chatMode() && !trimmed.startsWith('/')) {
+        await postRuntimeRun(trimmed, {
+          url: props.runtimeUrl,
+          workspace: props.session.workspace ?? null,
+        });
+        conversationMessages(props.session).push({ role: 'user', content: trimmed });
+        conversationMessages(props.session).push({ role: 'command', content: `Runtime run queued: ${props.runtimeUrl}` });
+        props.onRuntimeAccepted?.();
+        props.addLog('runtime: run accepted');
+        props.refresh();
+        return { exit: false, runtime: true };
+      }
       const result = await runLine(trimmed, {
         agent: props.agent,
         packageJson: props.packageJson,
@@ -39,6 +52,11 @@ export function useAgent(props: { agent: unknown; packageJson: Record<string, un
   }
 
   function abort() {
+    if (props.runtimeUrl) {
+      void postRuntimeCancel({ url: props.runtimeUrl })
+        .then(() => props.addLog('runtime: cancel requested'))
+        .catch((err) => props.addLog(`runtime cancel error: ${err instanceof Error ? err.message : String(err)}`));
+    }
     abortController()?.abort();
     props.addLog('interrupt requested');
   }

package/src/shell/useSession.ts

@@ -6,6 +6,8 @@ import { extractActivity, parseJsonText, sessionActivities } from '../core/activ
 import { formatPlanStatus, formatCompletedActivities } from '../core/plan.js';
 import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
 import { queueCounts, startNextQueuedJob, syncQueueWithActivity } from '../core/jobQueue.js';
+import { queueStoreFor } from '../core/queueStore.js';
+import { fetchRuntimeState, streamRuntimeEvents } from '../runtime/client.js';
 import type { ActiveFileEditor } from './FileEditorDialog';
 import {
   completionContext,
@@ -15,6 +17,16 @@ import {
 } from './repl.js';
 import { useAgent } from './useAgent';
 
+function runtimeStatusText(status: 'disabled' | 'connected' | 'disconnected', runStatus: string): string {
+  if (status === 'connected') return `runtime ${runStatus}`;
+  if (status === 'disconnected') return 'runtime offline';
+  return 'runtime off';
+}
+
+function nonEmptyRuntimeArray<T>(value: T[] | undefined | null): T[] | null {
+  return Array.isArray(value) && value.length > 0 ? value : null;
+}
+
 function buildContinuationPrompt(session: any, completed: any[]): string {
   const originalTask = [...conversationMessages(session)]
     .reverse()
@@ -31,10 +43,12 @@ function buildContinuationPrompt(session: any, completed: any[]): string {
   ].filter(Boolean).join('\n');
 }
 
-export function useSession(props: { agent: unknown; packageJson: Record<string, unknown> }) {
+export function useSession(props: { agent: unknown; packageJson: Record<string, unknown>; runtime?: any }) {
   const session = createSession();
   const [version, setVersion] = createSignal(0);
   const [logs, setLogs] = createSignal<string[]>([]);
+  const [runtimeState, setRuntimeState] = createSignal<any | null>(null);
+  const [runtimeStatus, setRuntimeStatus] = createSignal<'disabled' | 'connected' | 'disconnected'>(props.runtime ? 'disconnected' : 'disabled');
   const [input, setInput] = createSignal('');
   const [chatMode, setChatMode] = createSignal(true);
   (session as any).chatMode = true;
@@ -60,10 +74,45 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
   const addLog = (line: string) => {
     setLogs((items) => [...items, `${new Date().toLocaleTimeString()} ${line}`].slice(-200));
   };
-  const agent = useAgent({ agent: props.agent, packageJson: props.packageJson, session, chatMode, refresh, addLog });
+  if (props.runtime?.url) addLog(`runtime: connected ${props.runtime.url}${props.runtime.started ? ' (started)' : ''}`);
+  const agent = useAgent({
+    agent: props.agent,
+    packageJson: props.packageJson,
+    session,
+    chatMode,
+    runtimeUrl: props.runtime?.url ?? null,
+    refresh,
+    addLog,
+    onRuntimeAccepted: () => {
+      setRuntimeState((state) => ({ ...(state ?? {}), status: 'running' }));
+      setRuntimeStatus('connected');
+      refresh();
+    },
+  });
+  const runtimeRunStatus = createMemo(() => String(runtimeState()?.status ?? 'idle'));
+  const agentBusy = createMemo(() =>
+    props.runtime?.url
+      ? runtimeRunStatus() === 'running' || agent.busy()
+      : agent.busy(),
+  );
+  const localFallbackActive = createMemo(() => !props.runtime?.url || runtimeStatus() === 'disconnected');
 
   const messages = createMemo(() => {
     version();
+    const runtimeConversation = runtimeState()?.conversation;
+    const localCommands = conversationMessages(session)
+      .filter((message: any) => message.role === 'command')
+      .map((message: any) => ({
+        role: 'command',
+        content: String(message.content ?? ''),
+      }));
+    if (Array.isArray(runtimeConversation) && runtimeConversation.length > 0) {
+      const runtimeMessages = runtimeConversation.map((message: any) => ({
+        role: message.role === 'assistant' ? 'donna' : message.role,
+        content: String(message.content ?? ''),
+      }));
+      return [...runtimeMessages, ...localCommands].slice(-200);
+    }
     return [...conversationMessages(session)];
   });
   const prompt = createMemo(() => {
@@ -84,6 +133,7 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
       session.wikirc?.profile ? session.wikirc.profile : 'no wikirc',
       session.language ? session.language : 'no language',
       session.llm ? 'llm ready' : 'llm limited',
+      runtimeStatusText(runtimeStatus(), runtimeRunStatus()),
     ].join('  ');
   });
   const matchContext = createMemo(() => {
@@ -119,37 +169,117 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
   let lastVisiblePlan: Array<{ step: number; description: string; status: string }> | null = null;
   const activities = createMemo(() => {
     version();
+    const runtimeActivities = nonEmptyRuntimeArray(runtimeState()?.activities);
+    if (runtimeActivities) {
+      return runtimeActivities.map((activity: any) => ({ ...activity, _runtime: true }));
+    }
     const current = sessionActivities(session);
     if (current.length > 0) {
       lastVisibleActivities = current.map((activity) => ({ ...activity }));
       return current;
     }
-    return agent.busy() && lastVisibleActivities.length > 0
+    return agentBusy() && lastVisibleActivities.length > 0
       ? lastVisibleActivities.map((activity) => ({ ...activity }))
       : current;
   });
   const queueItems = createMemo(() => {
     version();
+    const runtimeQueue = nonEmptyRuntimeArray(runtimeState()?.queue);
+    if (runtimeQueue) return runtimeQueue.map((item: any) => ({ ...item, _runtime: true }));
     return ((session as any).jobQueue ?? []).map((item: any) => ({ ...item }));
   });
   const queueInfo = createMemo(() => {
     version();
+    const runtimeQueue = runtimeState()?.queue;
+    if (Array.isArray(runtimeQueue)) {
+      return {
+        active: runtimeQueue.filter((item: any) => ['waiting', 'starting', 'running', 'queued', 'pending'].includes(String(item.status ?? '').toLowerCase())).length,
+        current: runtimeQueue.filter((item: any) => ['starting', 'running'].includes(String(item.status ?? '').toLowerCase())).length,
+        frozen: 0,
+      };
+    }
     return queueCounts(session);
   });
   const plan = createMemo(() => {
     version();
+    const runtimePlan = nonEmptyRuntimeArray(runtimeState()?.plan);
+    if (runtimePlan) {
+      return runtimePlan.map((step: any, index: number) => ({
+        step: Number(step.step ?? index + 1),
+        description: String(step.description ?? step.label ?? step.name ?? `Step ${index + 1}`),
+        status: String(step.status ?? 'pending'),
+      }));
+    }
     const p = (session as any).headlessPlan as Array<{ step: number; description: string; status: string }> | null;
     const current = p ? p.map((s) => ({ ...s })) : null;
     if (current && current.length > 0) {
       lastVisiblePlan = current.map((step) => ({ ...step }));
       return current;
     }
-    return agent.busy() && lastVisiblePlan && lastVisiblePlan.length > 0
+    return agentBusy() && lastVisiblePlan && lastVisiblePlan.length > 0
       ? lastVisiblePlan.map((step) => ({ ...step }))
       : current;
   });
+  const visibleLogs = createMemo(() => {
+    version();
+    const runtimeLogs = runtimeState()?.logs;
+    if (!Array.isArray(runtimeLogs) || runtimeLogs.length === 0) return logs();
+    const tagged = runtimeLogs.slice(-80).map((line: any) => `runtime ${String(line)}`);
+    return [...logs(), ...tagged].slice(-200);
+  });
+
+  function syncRuntimeState() {
+    void fetchRuntimeState({ url: props.runtime.url })
+      .then((state) => {
+        setRuntimeState(state);
+        setRuntimeStatus('connected');
+        refresh();
+      })
+      .catch(() => {
+        setRuntimeStatus('disconnected');
+        refresh();
+      });
+  }
+  let runtimeStreamAbort: AbortController | null = null;
+  let runtimeSyncDebounce: ReturnType<typeof setTimeout> | null = null;
+  let runtimeReconnectTimer: ReturnType<typeof setTimeout> | null = null;
+  let runtimeStreamStopped = false;
+
+  function debouncedSyncRuntimeState() {
+    if (runtimeSyncDebounce) clearTimeout(runtimeSyncDebounce);
+    runtimeSyncDebounce = setTimeout(syncRuntimeState, 200);
+  }
+
+  async function subscribeRuntimeEvents() {
+    if (!props.runtime?.url || runtimeStreamStopped) return;
+    runtimeStreamAbort = new AbortController();
+    try {
+      for await (const _event of streamRuntimeEvents({ url: props.runtime.url, signal: runtimeStreamAbort.signal })) {
+        setRuntimeStatus('connected');
+        debouncedSyncRuntimeState();
+      }
+    } catch {
+      // stream dropped or errored — fall through to reconnect below
+    }
+    if (runtimeStreamStopped) return;
+    setRuntimeStatus('disconnected');
+    refresh();
+    runtimeReconnectTimer = setTimeout(() => { void subscribeRuntimeEvents(); }, 1500);
+  }
+
+  if (props.runtime?.url) {
+    syncRuntimeState();
+    void subscribeRuntimeEvents();
+  }
+  onCleanup(() => {
+    runtimeStreamStopped = true;
+    runtimeStreamAbort?.abort();
+    if (runtimeSyncDebounce) clearTimeout(runtimeSyncDebounce);
+    if (runtimeReconnectTimer) clearTimeout(runtimeReconnectTimer);
+  });
 
   const activityPollTimer = setInterval(() => {
+    if (!localFallbackActive()) return;
     for (const activity of sessionActivities(session)) {
       if (activity.terminal || !activity.poll) continue;
       const key = activity.key ?? `${activity.poll.server}:${activity.id ?? activity.label}`;
@@ -195,7 +325,7 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
               const plan = (session as any).headlessPlan;
               const stillRunning = sessionActivities(session).filter((a) => !a.terminal && a.poll);
               const pendingSteps = (plan ?? []).filter((s: any) => s.status === 'pending');
-              if (stillRunning.length === 0 && pendingSteps.length > 0 && !agent.busy()) {
+              if (stillRunning.length === 0 && pendingSteps.length > 0 && !agentBusy()) {
                 const completedAll = sessionActivities(session).filter((a) => a.terminal);
                 const prompt = buildContinuationPrompt(session, completedAll);
                 void agent.submit(prompt);
@@ -211,18 +341,23 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
         });
     }
   }, 1000);
-  onCleanup(() => clearInterval(activityPollTimer));
+  onCleanup(() => {
+    if (activityPollTimer) clearInterval(activityPollTimer);
+  });
 
   const queueFallbackTimer = setInterval(() => {
-    if ((session as any).jobQueue?.some((item: any) => item.status === 'waiting')) {
+    if (!localFallbackActive()) return;
+    if (queueStoreFor(session).list().some((item: any) => item.status === 'waiting')) {
       void startNextQueuedJob(session, { addLog, refresh });
     }
   }, 10000);
-  onCleanup(() => clearInterval(queueFallbackTimer));
+  onCleanup(() => {
+    if (queueFallbackTimer) clearInterval(queueFallbackTimer);
+  });
 
   async function submitInput(submittedValue?: string) {
     const line = typeof submittedValue === 'string' && submittedValue.trim() ? submittedValue : input();
-    if (agent.busy()) return { exit: false, busy: true };
+    if (agentBusy()) return { exit: false, busy: true };
     setInput('');
     setConversationScroll(0);
     if (line.trim()) {
@@ -344,7 +479,7 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
   return {
     session,
     messages,
-    logs,
+    logs: visibleLogs,
     input,
     setInput: updateInput,
     title,
@@ -364,7 +499,7 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
     plan,
     conversationScroll,
     scrollConversation,
-    busy: agent.busy,
+    busy: agentBusy,
     abort,
     submitInput,
     completeSelected,