@dotdrelle/wiki-manager 0.6.47 → 0.8.2

package/src/runtime/supervisor.test.js

@@ -0,0 +1,240 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
+import { pollActivitiesOnce, startActivitySupervisor } from './supervisor.js';
+
+test('pollActivitiesOnce updates activity through the event reducer', async () => {
+  const session = {
+    mcp: { production: { status: 'connected' } },
+    activities: {},
+    headlessPlan: null,
+    jobQueue: [],
+  };
+  dispatchAgentEvent(session, createAgentEvent('activity_upserted', {
+    payload: {
+      activity: {
+        id: 'job-1',
+        source: 'production',
+        status: 'running',
+        poll: { server: 'production', tool: 'production_job_status', args: { jobId: 'job-1' }, intervalMs: 1000 },
+      },
+    },
+  }));
+  const key = Object.keys(session.activities)[0];
+  session.activities[key].lastPolledAt = '1970-01-01T00:00:00.000Z';
+
+  await pollActivitiesOnce(session, {
+    callTool: async () => ({
+      content: [{ type: 'text', text: JSON.stringify({
+        _activity: {
+          id: 'job-1',
+          source: 'production',
+          status: 'done',
+          terminal: true,
+        },
+      }) }],
+    }),
+  });
+
+  assert.equal(session.activities[key].status, 'done');
+  assert.equal(session.activities[key].terminal, true);
+  assert.ok(session.agentProjection.logs.some((line) => line.includes('activity:')));
+});
+
+test('pollActivitiesOnce retries transient MCP poll failures', async () => {
+  const originalFetch = globalThis.fetch;
+  let attempts = 0;
+  globalThis.fetch = async () => {
+    attempts += 1;
+    if (attempts === 1) {
+      return {
+        ok: false,
+        status: 503,
+        headers: { get: () => null },
+        text: async () => 'temporarily unavailable',
+      };
+    }
+    return {
+      ok: true,
+      status: 200,
+      headers: { get: () => null },
+      text: async () => JSON.stringify({
+        result: {
+          content: [{ type: 'text', text: JSON.stringify({
+            _activity: {
+              id: 'job-retry',
+              source: 'production',
+              status: 'done',
+              terminal: true,
+            },
+          }) }],
+        },
+      }),
+    };
+  };
+
+  const session = {
+    mcp: {
+      production: {
+        status: 'connected',
+        url: 'http://127.0.0.1:3000/mcp/',
+        retry: { maxAttempts: 2, backoffMs: 0 },
+      },
+    },
+    activities: {},
+    headlessPlan: null,
+    jobQueue: [],
+  };
+  dispatchAgentEvent(session, createAgentEvent('activity_upserted', {
+    payload: {
+      activity: {
+        id: 'job-retry',
+        source: 'production',
+        status: 'running',
+        poll: { server: 'production', tool: 'production_job_status', args: { jobId: 'job-retry' }, intervalMs: 0 },
+      },
+    },
+  }));
+
+  try {
+    await pollActivitiesOnce(session);
+    const key = Object.keys(session.activities)[0];
+    assert.equal(attempts, 2);
+    assert.equal(session.activities[key].status, 'done');
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test('startActivitySupervisor passes the active run signal to background polls', async () => {
+  const session = {
+    mcp: { production: { status: 'connected' } },
+    activities: {},
+    headlessPlan: null,
+    jobQueue: [],
+  };
+  dispatchAgentEvent(session, createAgentEvent('activity_upserted', {
+    payload: {
+      activity: {
+        id: 'job-2',
+        source: 'production',
+        status: 'running',
+        poll: { server: 'production', tool: 'production_job_status', args: { jobId: 'job-2' }, intervalMs: 0 },
+      },
+    },
+  }));
+
+  const controller = new AbortController();
+  const signals = [];
+  const supervisor = startActivitySupervisor(session, {
+    intervalMs: 10,
+    queueIntervalMs: 1000,
+    callTool: async (_mcp, _server, _tool, _args, signal) => {
+      signals.push(signal ?? null);
+      return {
+        content: [{ type: 'text', text: JSON.stringify({
+          _activity: {
+            id: 'job-2',
+            source: 'production',
+            status: 'running',
+            terminal: false,
+            poll: { server: 'production', tool: 'production_job_status', args: { jobId: 'job-2' }, intervalMs: 0 },
+          },
+        }) }],
+      };
+    },
+  });
+
+  try {
+    supervisor.setRunSignal(controller.signal);
+    await waitFor(() => signals.includes(controller.signal));
+    assert.ok(signals.includes(controller.signal));
+  } finally {
+    supervisor.stop();
+  }
+});
+
+test('pollActivitiesOnce fires _onActivitiesTerminal when last activity becomes terminal', async () => {
+  let fired = false;
+  const session = {
+    mcp: { production: { status: 'connected' } },
+    activities: {},
+    headlessPlan: null,
+    jobQueue: [],
+    _onActivitiesTerminal: () => { fired = true; },
+  };
+  dispatchAgentEvent(session, createAgentEvent('activity_upserted', {
+    payload: {
+      activity: {
+        id: 'job-hook',
+        source: 'production',
+        status: 'running',
+        poll: { server: 'production', tool: 'production_job_status', args: { jobId: 'job-hook' }, intervalMs: 0 },
+      },
+    },
+  }));
+  const key = Object.keys(session.activities)[0];
+  session.activities[key].lastPolledAt = '1970-01-01T00:00:00.000Z';
+
+  await pollActivitiesOnce(session, {
+    callTool: async () => ({
+      content: [{ type: 'text', text: JSON.stringify({
+        _activity: { id: 'job-hook', source: 'production', status: 'done', terminal: true },
+      }) }],
+    }),
+  });
+
+  assert.equal(fired, true);
+  assert.equal(session._onActivitiesTerminal, undefined);
+});
+
+test('pollActivitiesOnce does not fire _onActivitiesTerminal while other activities remain', async () => {
+  let fired = false;
+  const session = {
+    mcp: { production: { status: 'connected' } },
+    activities: {},
+    headlessPlan: null,
+    jobQueue: [],
+    _onActivitiesTerminal: () => { fired = true; },
+  };
+  for (const id of ['job-a', 'job-b']) {
+    dispatchAgentEvent(session, createAgentEvent('activity_upserted', {
+      payload: {
+        activity: {
+          id,
+          source: 'production',
+          status: 'running',
+          poll: { server: 'production', tool: 'production_job_status', args: { jobId: id }, intervalMs: 0 },
+        },
+      },
+    }));
+  }
+  for (const key of Object.keys(session.activities)) {
+    session.activities[key].lastPolledAt = '1970-01-01T00:00:00.000Z';
+  }
+
+  let callCount = 0;
+  await pollActivitiesOnce(session, {
+    callTool: async (_mcp, _server, _tool, args) => {
+      callCount += 1;
+      const terminal = args.jobId === 'job-a';
+      return {
+        content: [{ type: 'text', text: JSON.stringify({
+          _activity: { id: args.jobId, source: 'production', status: terminal ? 'done' : 'running', terminal },
+        }) }],
+      };
+    },
+  });
+
+  assert.equal(fired, false);
+  assert.equal(callCount, 2);
+});
+
+async function waitFor(predicate, timeoutMs = 250) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (predicate()) return;
+    await new Promise((resolve) => setTimeout(resolve, 10));
+  }
+  assert.fail('Timed out waiting for condition.');
+}

package/src/shell/RightPane.tsx

@@ -68,7 +68,7 @@ function activityColor(status: string) {
 
 function queueColor(status: string) {
   const value = String(status ?? '').toLowerCase();
-  if (value === 'waiting') return '#FBBF24';
+  if (value === 'waiting' || value === 'pending_approval') return '#FBBF24';
   return activityColor(status);
 }
 

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, postRuntimeApprove, postRuntimeCancel, postRuntimeRun, streamRuntimeEvents } from '../runtime/client.js';
 
 marked.use(markedTerminal());
 // marked-terminal's text renderer extracts token.text (raw string) instead of
@@ -72,6 +74,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.',
+  '/approve': 'Approve a pending runtime run or tool.',
 };
 
 const SUBCOMMAND_COMPLETION_DESCRIPTIONS = {
@@ -108,7 +111,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', 'queue'],
+    commands: ['help', 'version', 'exit', 'workspace', 'new', 'use', 'config', 'status', 'services', 'start', 'stop', 'logs', 'mcp', 'wiki', 'skills', 'upload', 'uploads', 'clear', 'chat', 'agent', 'openui', 'queue', 'approve'],
     chatMode: true,
     llm: null,
     activities: {},
@@ -669,14 +672,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() ?? '';
 }
@@ -738,6 +733,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);
@@ -748,6 +782,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);
@@ -1142,7 +1180,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',
@@ -1168,6 +1206,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;
@@ -1198,8 +1241,55 @@ async function runTuiShell({ agent, packageJson, session }) {
     rerender();
   }
 
+  function syncRuntimeState() {
+    if (!runtime?.url) return;
+    void fetchRuntimeState({ url: runtime.url, workspace: session.workspace ?? null })
+      .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, workspace: session.workspace ?? null })) {
+        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) {
@@ -1307,14 +1397,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 {
@@ -1336,6 +1424,18 @@ async function runTuiShell({ agent, packageJson, session }) {
         rerender();
         return;
       }
+      if (runtime?.url && runtimeRunActive(session)) {
+        void postRuntimeCancel({ url: runtime.url, workspace: session.workspace ?? null })
+          .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;
@@ -1383,9 +1483,35 @@ 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 && line.trim().startsWith('/approve')) {
+          const parts = line.trim().split(/\s+/).slice(1);
+          const kind = ['run', 'item', 'approval'].includes(parts[0]) ? parts.shift() : 'run';
+          const id = parts[0];
+          if (!id) {
+            conversationMessages(session).push({ role: 'command', content: 'Usage: /approve [run|item|approval] <id>' });
+          } else {
+            const result = await postRuntimeApprove({
+              url: runtime.url,
+              workspace: session.workspace ?? null,
+              ...(kind === 'item' ? { itemId: id } : kind === 'approval' ? { approvalId: id } : { runId: id }),
+            });
+            conversationMessages(session).push({ role: 'command', content: `Approval ${result.approved ? 'accepted' : 'not found'}: ${id}` });
+            syncRuntimeState();
+          }
+        } else 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;
@@ -1480,6 +1606,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);
@@ -1493,11 +1623,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, workspace: props.session.workspace ?? null })
+        .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');
   }