@dotdrelle/wiki-manager 0.7.3 → 0.9.3

package/src/runtime/store.test.js

@@ -2,6 +2,7 @@ import assert from 'node:assert/strict';
 import { mkdtempSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
 import test from 'node:test';
 import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
 import { openRuntimeStore } from './store.js';
@@ -24,7 +25,7 @@ test('runtime store persists and replays agent events into a projection', () =>
   reopened.hydrateSession(replayedSession);
   assert.equal(replayedSession.headlessPlan.length, 1);
   assert.equal(replayedSession.headlessPlan[0].description, 'Ingest');
-  assert.equal(reopened.getState(replayedSession).eventsCursor, event.id);
+  assert.equal(reopened.getState(replayedSession).eventsCursor, 1);
   reopened.close();
 });
 
@@ -34,33 +35,281 @@ test('runtime store persists duplicate events idempotently', () => {
   const event = createAgentEvent('run_started', {
     origin: 'test',
     runId: 'run-1',
-    payload: { input: 'build wiki' },
+    turnId: 'run-1:turn-0',
+    workspace: 'juno',
+    payload: { input: 'build wiki', workspace: 'juno' },
   });
 
   store.persistEvent(event);
   store.persistEvent(event);
 
   assert.equal(store.listEvents().length, 1);
+  assert.equal(store.listEvents()[0].sequence, 1);
+  assert.equal(store.getState().eventsCursor, 1);
   assert.equal(store.listRuns()[0].id, 'run-1');
+  assert.equal(store.listRuns()[0].workspace, 'juno');
   assert.equal(store.listRuns()[0].status, 'running');
   store.close();
 });
 
+test('runtime store persists run identity fields on events', () => {
+  const stateDir = mkdtempSync(join(tmpdir(), 'wiki-manager-runtime-'));
+  const store = openRuntimeStore({ stateDir });
+  store.persistEvent(createAgentEvent('assistant_message', {
+    origin: 'agent',
+    runId: 'run-2',
+    turnId: 'run-2:turn-1',
+    workspace: 'docs',
+    payload: { content: 'done' },
+  }));
+
+  const [event] = store.listEvents();
+  assert.equal(event.runId, 'run-2');
+  assert.equal(event.turnId, 'run-2:turn-1');
+  assert.equal(event.workspace, 'docs');
+  store.close();
+});
+
+test('runtime store replays evaluator verdict into state', () => {
+  const stateDir = mkdtempSync(join(tmpdir(), 'wiki-manager-runtime-'));
+  const store = openRuntimeStore({ stateDir });
+  store.persistEvent(createAgentEvent('run_started', {
+    origin: 'runtime',
+    runId: 'run-eval',
+    turnId: 'run-eval:turn-0',
+    workspace: 'docs',
+    payload: { input: 'build docs', workspace: 'docs' },
+  }));
+  store.persistEvent(createAgentEvent('run_evaluated', {
+    origin: 'runtime',
+    runId: 'run-eval',
+    turnId: 'run-eval:turn-1',
+    workspace: 'docs',
+    payload: {
+      ok: true,
+      reason: 'Task complete.',
+      suggestedAction: null,
+    },
+  }));
+  store.close();
+
+  const reopened = openRuntimeStore({ stateDir });
+  const session = { activities: {}, headlessPlan: null };
+  reopened.hydrateSession(session, { workspace: 'docs' });
+
+  assert.deepEqual(reopened.getState(session, { workspace: 'docs' }).evaluation, {
+    ok: true,
+    reason: 'Task complete.',
+    suggestedAction: null,
+    runId: 'run-eval',
+  });
+  reopened.close();
+});
+
+test('runtime store replays replan trace into state', () => {
+  const stateDir = mkdtempSync(join(tmpdir(), 'wiki-manager-runtime-'));
+  const store = openRuntimeStore({ stateDir });
+  store.persistEvent(createAgentEvent('run_started', {
+    origin: 'runtime',
+    runId: 'run-replan',
+    turnId: 'run-replan:turn-0',
+    workspace: 'docs',
+    payload: { input: 'build docs', workspace: 'docs' },
+  }));
+  store.persistEvent(createAgentEvent('run_replanned', {
+    origin: 'runtime',
+    runId: 'run-replan',
+    turnId: 'run-replan:turn-1',
+    workspace: 'docs',
+    payload: {
+      reason: 'Build failed.',
+      plan: ['Retry build'],
+      replansLeft: 1,
+    },
+  }));
+  store.close();
+
+  const reopened = openRuntimeStore({ stateDir });
+  const session = { activities: {}, headlessPlan: null };
+  reopened.hydrateSession(session, { workspace: 'docs' });
+
+  assert.deepEqual(reopened.getState(session, { workspace: 'docs' }).replans, [{
+    reason: 'Build failed.',
+    plan: ['Retry build'],
+    replansLeft: 1,
+    runId: 'run-replan',
+  }]);
+  reopened.close();
+});
+
+test('runtime store tracks pending approval run status', () => {
+  const stateDir = mkdtempSync(join(tmpdir(), 'wiki-manager-runtime-'));
+  const store = openRuntimeStore({ stateDir });
+  store.persistEvent(createAgentEvent('run_started', {
+    origin: 'runtime',
+    runId: 'run-approval',
+    workspace: 'docs',
+    payload: { input: 'build docs', workspace: 'docs' },
+  }));
+  store.persistEvent(createAgentEvent('run_pending_approval', {
+    origin: 'runtime',
+    runId: 'run-approval',
+    workspace: 'docs',
+    payload: { approvalId: 'approval-1', runId: 'run-approval', plan: ['Build'] },
+  }));
+
+  assert.equal(store.listRuns({ workspace: 'docs' })[0].status, 'pending_approval');
+
+  store.persistEvent(createAgentEvent('run_approved', {
+    origin: 'runtime',
+    runId: 'run-approval',
+    workspace: 'docs',
+    payload: { approvalId: 'approval-1', runId: 'run-approval' },
+  }));
+
+  assert.equal(store.listRuns({ workspace: 'docs' })[0].status, 'running');
+  assert.equal(store.getState(null, { workspace: 'docs' }).approvals[0].status, 'approved');
+  store.close();
+});
+
+test('runtime store orders events by durable sequence', () => {
+  const stateDir = mkdtempSync(join(tmpdir(), 'wiki-manager-runtime-'));
+  const store = openRuntimeStore({ stateDir });
+  const ts = '2026-01-01T00:00:00.000Z';
+
+  store.persistEvent({
+    id: 'event-b',
+    ts,
+    type: 'user_message',
+    origin: 'test',
+    runId: 'run-seq',
+    turnId: 'run-seq:turn-0',
+    workspace: 'docs',
+    payload: { content: 'first' },
+  });
+  store.persistEvent({
+    id: 'event-a',
+    ts,
+    type: 'assistant_message',
+    origin: 'test',
+    runId: 'run-seq',
+    turnId: 'run-seq:turn-1',
+    workspace: 'docs',
+    payload: { content: 'second' },
+  });
+  store.persistEvent({
+    id: 'event-c',
+    ts,
+    type: 'assistant_message',
+    origin: 'test',
+    runId: 'run-other',
+    turnId: 'run-other:turn-1',
+    workspace: 'other',
+    payload: { content: 'third' },
+  });
+
+  const events = store.listEvents({ workspace: 'docs' });
+  assert.deepEqual(events.map((event) => event.id), ['event-b', 'event-a']);
+  assert.deepEqual(events.map((event) => event.sequence), [1, 2]);
+  assert.equal(store.getState(null, { workspace: 'docs' }).eventsCursor, 2);
+  store.close();
+});
+
 test('runtime store persists cancelled run status', () => {
   const stateDir = mkdtempSync(join(tmpdir(), 'wiki-manager-runtime-'));
   const store = openRuntimeStore({ stateDir });
   store.persistEvent(createAgentEvent('run_started', {
     origin: 'test',
     runId: 'run-1',
-    payload: { input: 'build wiki' },
+    turnId: 'run-1:turn-0',
+    workspace: 'juno',
+    payload: { input: 'build wiki', workspace: 'juno' },
   }));
   store.persistEvent(createAgentEvent('run_cancelled', {
     origin: 'test',
     runId: 'run-1',
-    payload: { runId: 'run-1' },
+    turnId: 'run-1:turn-1',
+    workspace: 'juno',
+    payload: { runId: 'run-1', workspace: 'juno' },
   }));
 
   assert.equal(store.listRuns()[0].status, 'cancelled');
+  assert.equal(store.listRuns()[0].workspace, 'juno');
+  store.close();
+});
+
+test('runtime store migrates legacy databases without workspace columns', () => {
+  const stateDir = mkdtempSync(join(tmpdir(), 'wiki-manager-runtime-'));
+  const db = new DatabaseSync(join(stateDir, 'runtime.db'));
+  db.exec(`
+    CREATE TABLE events (
+      id TEXT PRIMARY KEY,
+      ts TEXT NOT NULL,
+      type TEXT NOT NULL,
+      run_id TEXT,
+      turn_id TEXT,
+      origin TEXT,
+      payload TEXT NOT NULL
+    );
+    CREATE TABLE runs (
+      id TEXT PRIMARY KEY,
+      status TEXT NOT NULL,
+      input TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+  `);
+  db.close();
+
+  const store = openRuntimeStore({ stateDir });
+  store.persistEvent(createAgentEvent('run_started', {
+    origin: 'test',
+    runId: 'run-legacy',
+    turnId: 'run-legacy:turn-0',
+    workspace: 'legacy',
+    payload: { input: 'migrate', workspace: 'legacy' },
+  }));
+
+  assert.equal(store.listEvents()[0].workspace, 'legacy');
+  assert.equal(store.listEvents()[0].sequence, 1);
+  assert.equal(store.listRuns()[0].workspace, 'legacy');
+  store.close();
+});
+
+test('runtime store backfills sequence for legacy event rows', () => {
+  const stateDir = mkdtempSync(join(tmpdir(), 'wiki-manager-runtime-'));
+  const db = new DatabaseSync(join(stateDir, 'runtime.db'));
+  db.exec(`
+    CREATE TABLE events (
+      id TEXT PRIMARY KEY,
+      ts TEXT NOT NULL,
+      type TEXT NOT NULL,
+      run_id TEXT,
+      turn_id TEXT,
+      workspace TEXT,
+      origin TEXT,
+      payload TEXT NOT NULL
+    );
+    CREATE TABLE runs (
+      id TEXT PRIMARY KEY,
+      workspace TEXT,
+      status TEXT NOT NULL,
+      input TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+    INSERT INTO events (id, ts, type, run_id, turn_id, workspace, origin, payload)
+    VALUES
+      ('legacy-b', '2026-01-01T00:00:00.000Z', 'user_message', 'run-legacy', 'run-legacy:turn-0', 'docs', 'test', '{"content":"first"}'),
+      ('legacy-a', '2026-01-01T00:00:00.000Z', 'assistant_message', 'run-legacy', 'run-legacy:turn-1', 'docs', 'test', '{"content":"second"}');
+  `);
+  db.close();
+
+  const store = openRuntimeStore({ stateDir });
+  const events = store.listEvents({ workspace: 'docs' });
+
+  assert.deepEqual(events.map((event) => event.id), ['legacy-b', 'legacy-a']);
+  assert.deepEqual(events.map((event) => event.sequence), [1, 2]);
   store.close();
 });
 
@@ -101,3 +350,113 @@ test('runtime store persists and hydrates queue items', () => {
   assert.equal(reopened.getState(session).queue[0].workspace, 'docs');
   reopened.close();
 });
+
+test('runtime store filters events runs and queue by workspace', () => {
+  const stateDir = mkdtempSync(join(tmpdir(), 'wiki-manager-runtime-'));
+  const store = openRuntimeStore({ stateDir });
+  store.persistEvent(createAgentEvent('run_started', {
+    origin: 'test',
+    runId: 'run-juno',
+    turnId: 'run-juno:turn-0',
+    workspace: 'juno',
+    payload: { input: 'juno', workspace: 'juno' },
+  }));
+  store.persistEvent(createAgentEvent('run_started', {
+    origin: 'test',
+    runId: 'run-docs',
+    turnId: 'run-docs:turn-0',
+    workspace: 'docs',
+    payload: { input: 'docs', workspace: 'docs' },
+  }));
+  store.saveQueue([{ id: 'q-juno', workspace: 'juno', status: 'waiting' }], { workspace: 'juno' });
+  store.saveQueue([{ id: 'q-docs', workspace: 'docs', status: 'waiting' }], { workspace: 'docs' });
+
+  assert.deepEqual(store.listEvents({ workspace: 'juno' }).map((event) => event.runId), ['run-juno']);
+  assert.deepEqual(store.listRuns({ workspace: 'docs' }).map((run) => run.id), ['run-docs']);
+  assert.deepEqual(store.listQueue({ workspace: 'juno' }).map((item) => item.id), ['q-juno']);
+
+  const session = { activities: {}, headlessPlan: null };
+  store.hydrateSession(session, { workspace: 'docs' });
+  assert.equal(session.jobQueue[0].id, 'q-docs');
+  assert.deepEqual(store.getState(session, { workspace: 'docs' }).runs.map((run) => run.id), ['run-docs']);
+  store.close();
+});
+
+test('runtime state exposes queue as blocked jobs and pending plan steps', () => {
+  const stateDir = mkdtempSync(join(tmpdir(), 'wiki-manager-runtime-'));
+  const store = openRuntimeStore({ stateDir });
+  const session = { activities: {}, headlessPlan: null };
+
+  store.persistEvent(dispatchAgentEvent(session, createAgentEvent('plan_set', {
+    origin: 'tool',
+    workspace: 'docs',
+    payload: {
+      steps: [
+        { step: 1, description: 'Analyze', status: 'done' },
+        { step: 2, description: 'Build', status: 'pending' },
+        { step: 3, description: 'Verify', status: 'pending' },
+      ],
+    },
+  })));
+  store.saveQueue([
+    { id: 'q-wait', workspace: 'docs', status: 'waiting', args: { type: 'blocked' } },
+    { id: 'q-run', workspace: 'docs', status: 'running', args: { type: 'active' } },
+    { id: 'q-done', workspace: 'docs', status: 'done', args: { type: 'done' } },
+  ], { workspace: 'docs' });
+
+  const queue = store.getState(session, { workspace: 'docs' }).queue;
+  assert.deepEqual(queue.map((item) => item.id), ['q-wait', 'plan-2', 'plan-3']);
+  assert.equal(queue[0].queueType, 'blocked_job');
+  assert.equal(queue[1].queueType, 'pending_step');
+  assert.equal(queue[1].args.type, 'Build');
+  store.close();
+});
+
+test('runtime store persists and replays control queue events without mixing MCP queue', () => {
+  const stateDir = mkdtempSync(join(tmpdir(), 'wiki-manager-runtime-'));
+  const store = openRuntimeStore({ stateDir });
+  store.persistEvent(createAgentEvent('control_enqueued', {
+    origin: 'runtime',
+    workspace: 'docs',
+    payload: { id: 'control-docs', workspace: 'docs', input: 'later' },
+  }));
+  store.persistEvent(createAgentEvent('control_enqueued', {
+    origin: 'runtime',
+    workspace: 'juno',
+    payload: { id: 'control-juno', workspace: 'juno', input: 'other' },
+  }));
+  store.close();
+
+  const reopened = openRuntimeStore({ stateDir });
+  const session = { activities: {}, headlessPlan: null };
+  reopened.hydrateSession(session, { workspace: 'docs' });
+  const state = reopened.getState(session, { workspace: 'docs' });
+  assert.deepEqual(state.controlQueue.map((item) => item.id), ['control-docs']);
+  assert.deepEqual(state.queue, []);
+  assert.deepEqual(session.controlQueue.map((item) => item.id), ['control-docs']);
+  reopened.close();
+});
+
+test('runtime store identifies recoverable workspaces and interrupts stale runs', () => {
+  const stateDir = mkdtempSync(join(tmpdir(), 'wiki-manager-runtime-'));
+  const store = openRuntimeStore({ stateDir });
+  store.persistRun({
+    id: 'run-juno',
+    workspace: 'juno',
+    status: 'running',
+    input: 'build juno',
+  });
+  store.persistRun({
+    id: 'run-done',
+    workspace: 'docs',
+    status: 'done',
+    input: 'done',
+  });
+  store.saveQueue([{ id: 'q-docs', workspace: 'docs', status: 'waiting' }], { workspace: 'docs' });
+
+  assert.deepEqual(store.listRecoverableWorkspaces(), ['docs', 'juno']);
+  assert.deepEqual(store.listRecoverableRuns({ workspace: 'juno' }).map((run) => run.id), ['run-juno']);
+  assert.equal(store.interruptRuns({ workspace: 'juno' }), 1);
+  assert.equal(store.listRuns({ workspace: 'juno' })[0].status, 'interrupted');
+  store.close();
+});

package/src/runtime/supervisor.js

@@ -80,6 +80,12 @@ export async function pollActivitiesOnce(session, {
           await startNextQueuedJob(session, {
             addLog: (message) => emitRuntimeLog(session, message),
           });
+          const remainingPollable = sessionActivities(session).filter((a) => !a.terminal && a.poll);
+          if (remainingPollable.length === 0 && typeof session._onActivitiesTerminal === 'function') {
+            const cb = session._onActivitiesTerminal;
+            delete session._onActivitiesTerminal;
+            cb(session);
+          }
         }
       }
     } catch (err) {

package/src/runtime/supervisor.test.js

@@ -41,6 +41,71 @@ test('pollActivitiesOnce updates activity through the event reducer', async () =
   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' } },
@@ -89,6 +154,82 @@ test('startActivitySupervisor passes the active run signal to background polls',
   }
 });
 
+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) {

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

@@ -15,7 +15,7 @@ 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';
+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
@@ -74,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 = {
@@ -110,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: {},
@@ -1242,7 +1243,7 @@ async function runTuiShell({ agent, packageJson, session, runtime = null }) {
 
   function syncRuntimeState() {
     if (!runtime?.url) return;
-    void fetchRuntimeState({ url: runtime.url })
+    void fetchRuntimeState({ url: runtime.url, workspace: session.workspace ?? null })
       .then((state) => {
         runtimePollingActive = true;
         applyRuntimeStateToShellSession(session, state);
@@ -1263,7 +1264,7 @@ async function runTuiShell({ agent, packageJson, session, runtime = null }) {
     if (!runtime?.url || runtimeStreamStopped) return;
     runtimeStreamAbort = new AbortController();
     try {
-      for await (const event of streamRuntimeEvents({ url: runtime.url, signal: runtimeStreamAbort.signal })) {
+      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);
@@ -1424,7 +1425,7 @@ async function runTuiShell({ agent, packageJson, session, runtime = null }) {
         return;
       }
       if (runtime?.url && runtimeRunActive(session)) {
-        void postRuntimeCancel({ url: runtime.url })
+        void postRuntimeCancel({ url: runtime.url, workspace: session.workspace ?? null })
           .then(() => {
             activityLines = [...activityLines, 'runtime: cancel requested'].slice(-LOWER_DETAIL_ROWS);
             rerender();
@@ -1482,7 +1483,22 @@ async function runTuiShell({ agent, packageJson, session, runtime = null }) {
       session._abortSignal = currentAbortController.signal;
       let aborted = false;
       try {
-        if (runtime?.url && !session.chatMode && !line.trim().startsWith('/')) {
+        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,

package/src/shell/useAgent.ts

@@ -53,7 +53,7 @@ export function useAgent(props: { agent: unknown; packageJson: Record<string, un
 
   function abort() {
     if (props.runtimeUrl) {
-      void postRuntimeCancel({ url: 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)}`));
     }