@dotdrelle/wiki-manager 0.11.10 → 0.12.1

package/src/runtime/store.test.js

@@ -1,5 +1,5 @@
 import assert from 'node:assert/strict';
-import { mkdirSync, mkdtempSync, readFileSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { DatabaseSync } from 'node:sqlite';
@@ -11,6 +11,26 @@ function runtimeStateDir() {
   return join(mkdtempSync(join(tmpdir(), 'wiki-manager-runtime-')), '.wiki-manager');
 }
 
+function plannedTask(id) {
+  return {
+    id,
+    label: 'Build A',
+    description: 'Build A',
+    requiredCapability: 'document.build',
+    operation: 'build',
+    arguments: { templates: ['templates/a.md'] },
+    dependsOn: [],
+    parallelizable: true,
+    inputRefs: [],
+    expectedOutputRefs: [{ type: 'file', ref: 'deliverables/a.md' }],
+    locks: ['deliverable:deliverables/a.md'],
+    requiresApproval: false,
+    idempotencyKey: 'test-key',
+    progressWeight: 1,
+    status: 'pending',
+  };
+}
+
 test('runtime store persists and replays agent events into a projection', () => {
   const stateDir = mkdtempSync(join(tmpdir(), 'wiki-manager-runtime-'));
   const store = openRuntimeStore({ stateDir });
@@ -33,15 +53,184 @@ test('runtime store persists and replays agent events into a projection', () =>
   reopened.close();
 });
 
+test('runtime store persists agent registry tables and exposes registry in state', () => {
+  const stateDir = mkdtempSync(join(tmpdir(), 'wiki-manager-runtime-'));
+  const store = openRuntimeStore({ stateDir });
+  const agent = {
+    agentInstanceId: 'production-main',
+    health: 'available',
+    firstSeenAt: '2026-01-01T00:00:00.000Z',
+    lastSeenAt: '2026-01-01T00:00:00.000Z',
+    description: {
+      contractVersion: '1',
+      agentType: 'production',
+      agentInstanceId: 'production-main',
+      displayName: 'Production',
+      capabilities: [{
+        id: 'knowledge.update',
+        version: '1',
+        description: 'Update wiki knowledge',
+        inputSchema: {},
+        outputSchema: {},
+        supportedOperations: ['ingest'],
+        defaultRequiresApproval: true,
+      }],
+      orchestration: {
+        canPlan: true,
+        canExpandPlan: false,
+        canExecute: true,
+        canCancel: true,
+        canResume: false,
+        supportsIdempotency: false,
+        supportsParallelWorkers: true,
+      },
+      limits: {
+        recommendedConcurrency: 1,
+        maxConcurrency: 2,
+      },
+      health: { status: 'available' },
+    },
+  };
+
+  store.persistEvent(createAgentEvent('agent.registered', {
+    origin: 'agent_registry',
+    payload: { agent },
+  }));
+
+  assert.equal(store.db.prepare('SELECT COUNT(*) AS n FROM agents').get().n, 1);
+  assert.equal(store.db.prepare('SELECT COUNT(*) AS n FROM agent_capabilities').get().n, 1);
+  assert.equal(store.listAgents()[0].agentInstanceId, 'production-main');
+  const state = store.getState();
+  assert.equal(state.agents[0].agentInstanceId, 'production-main');
+  assert.equal(state.capabilityRegistry['knowledge.update@1'][0].agentInstanceId, 'production-main');
+  store.close();
+});
+
+test('runtime store persists task assignments attempts and results from events', () => {
+  const stateDir = mkdtempSync(join(tmpdir(), 'wiki-manager-runtime-'));
+  const store = openRuntimeStore({ stateDir });
+  const runId = 'run-task-persistence';
+  const taskId = 'run-task-persistence:build-a';
+  const attemptId = 'attempt-1';
+
+  for (const event of [
+    createAgentEvent('run_started', {
+      origin: 'runtime',
+      runId,
+      workspace: 'docs',
+      payload: { input: 'build docs', workspace: 'docs' },
+    }),
+    createAgentEvent('task.created', {
+      origin: 'plan_integrator',
+      runId,
+      taskId,
+      workspace: 'docs',
+      payload: { runId, task: plannedTask(taskId) },
+    }),
+    createAgentEvent('task.assigned', {
+      origin: 'assignment_manager',
+      runId,
+      taskId,
+      workspace: 'docs',
+      payload: {
+        runId,
+        taskId,
+        attemptId,
+        assignment: {
+          attemptId,
+          agentInstanceId: 'production-main',
+          agentId: 'production',
+          poolId: 'production-pool',
+        },
+      },
+    }),
+    createAgentEvent('task.started', {
+      origin: 'dispatcher',
+      runId,
+      taskId,
+      workspace: 'docs',
+      payload: { runId, taskId, attemptId, jobId: 'job-1', startedAt: '2026-07-07T10:00:00.000Z' },
+    }),
+    createAgentEvent('task.result_returned', {
+      origin: 'result_aggregator',
+      runId,
+      taskId,
+      workspace: 'docs',
+      payload: {
+        runId,
+        taskId,
+        attemptId,
+        result: {
+          attemptId,
+          taskId,
+          jobId: 'job-1',
+          status: 'succeeded',
+          summary: 'Built A',
+          outputRefs: [{ type: 'file', ref: 'deliverables/a.md' }],
+          metrics: { durationMs: 42 },
+        },
+      },
+    }),
+    createAgentEvent('task.completed', {
+      origin: 'result_aggregator',
+      runId,
+      taskId,
+      workspace: 'docs',
+      payload: { runId, taskId, attemptId, result: { attemptId, taskId, status: 'succeeded' } },
+    }),
+    createAgentEvent('task.retry_scheduled', {
+      origin: 'attempt_manager',
+      runId,
+      taskId,
+      workspace: 'docs',
+      payload: {
+        runId,
+        taskId,
+        attemptId: 'attempt-2',
+        reason: 'retryable_error',
+        error: { code: 'rate_limit', retryable: true },
+      },
+    }),
+  ]) {
+    store.persistEvent(event);
+  }
+
+  assert.equal(store.db.prepare('SELECT COUNT(*) AS n FROM task_assignments').get().n, 1);
+  assert.equal(store.db.prepare('SELECT COUNT(*) AS n FROM task_attempts').get().n, 2);
+  assert.equal(store.db.prepare('SELECT COUNT(*) AS n FROM task_results').get().n, 1);
+  assert.equal(store.listTasks({ runId })[0].id, taskId);
+  assert.deepEqual(store.listTaskAssignments({ taskId })[0], {
+    taskId,
+    attemptId,
+    agentInstanceId: 'production-main',
+    agentId: 'production',
+    poolId: 'production-pool',
+    assignedAt: store.listTaskAssignments({ taskId })[0].assignedAt,
+  });
+  assert.deepEqual(store.listTaskAttempts({ taskId }).map((attempt) => attempt.status), ['done', 'retry_scheduled']);
+  assert.deepEqual(store.getTaskResult({ taskId }).outputRefs, [{ type: 'file', ref: 'deliverables/a.md' }]);
+  assert.equal(store.getTaskResult({ taskId }).metrics.durationMs, 42);
+  store.close();
+
+  const reopened = openRuntimeStore({ stateDir });
+  const session = { activities: {}, headlessPlan: null };
+  reopened.hydrateSession(session, { workspace: 'docs' });
+  assert.ok(reopened.getState(session, { workspace: 'docs' }).logs.some((line) => line === `Task assigned: ${taskId}`));
+  assert.equal(reopened.listTaskAttempts({ taskId })[0].jobId, 'job-1');
+  assert.equal(reopened.getTaskResult({ taskId }).status, 'succeeded');
+  reopened.close();
+});
+
 test('runtime store writes schema versions to sqlite and meta file', () => {
   const root = mkdtempSync(join(tmpdir(), 'wiki-manager-runtime-'));
   const stateDir = join(root, '.wiki-manager');
   const store = openRuntimeStore({ stateDir });
   const version = store.db.prepare('PRAGMA user_version').get().user_version;
-  const meta = JSON.parse(readFileSync(join(root, '.wiki', 'meta.json'), 'utf8'));
+  const meta = JSON.parse(readFileSync(join(root, '.wiki-manager', 'meta.json'), 'utf8'));
 
   assert.equal(version, 1);
   assert.equal(meta.schemaVersion, 1);
+  assert.equal(existsSync(join(root, '.wiki', 'meta.json')), false);
   store.close();
 });
 
@@ -61,8 +250,8 @@ test('runtime store refuses unknown sqlite schema versions', () => {
 test('runtime store refuses unknown runtime metadata versions', () => {
   const root = mkdtempSync(join(tmpdir(), 'wiki-manager-runtime-'));
   const stateDir = join(root, '.wiki-manager');
-  mkdirSync(join(root, '.wiki'), { recursive: true });
-  writeFileSync(join(root, '.wiki', 'meta.json'), '{"schemaVersion":99}\n', 'utf8');
+  mkdirSync(stateDir, { recursive: true });
+  writeFileSync(join(stateDir, 'meta.json'), '{"schemaVersion":99}\n', 'utf8');
 
   assert.throws(
     () => openRuntimeStore({ stateDir }),
@@ -70,6 +259,21 @@ test('runtime store refuses unknown runtime metadata versions', () => {
   );
 });
 
+test('runtime store migrates legacy .wiki metadata to .wiki-manager', () => {
+  const root = mkdtempSync(join(tmpdir(), 'wiki-manager-runtime-'));
+  const stateDir = join(root, '.wiki-manager');
+  mkdirSync(join(root, '.wiki'), { recursive: true });
+  writeFileSync(join(root, '.wiki', 'meta.json'), '{"schemaVersion":1,"legacy":true}\n', 'utf8');
+
+  const store = openRuntimeStore({ stateDir });
+  const meta = JSON.parse(readFileSync(join(stateDir, 'meta.json'), 'utf8'));
+
+  assert.equal(meta.schemaVersion, 1);
+  assert.equal(meta.legacy, true);
+  assert.equal(existsSync(join(root, '.wiki', 'meta.json')), false);
+  store.close();
+});
+
 test('runtime store persists duplicate events idempotently', () => {
   const stateDir = mkdtempSync(join(tmpdir(), 'wiki-manager-runtime-'));
   const store = openRuntimeStore({ stateDir });
@@ -77,8 +281,8 @@ test('runtime store persists duplicate events idempotently', () => {
     origin: 'test',
     runId: 'run-1',
     turnId: 'run-1:turn-0',
-    workspace: 'juno',
-    payload: { input: 'build wiki', workspace: 'juno' },
+    workspace: 'acme',
+    payload: { input: 'build wiki', workspace: 'acme' },
   });
 
   store.persistEvent(event);
@@ -88,7 +292,7 @@ test('runtime store persists duplicate events idempotently', () => {
   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].workspace, 'acme');
   assert.equal(store.listRuns()[0].status, 'running');
   store.close();
 });
@@ -299,6 +503,43 @@ test('runtime store tracks pending approval run status', () => {
   store.close();
 });
 
+test('runtime store persists bounded approval grants', () => {
+  const stateDir = mkdtempSync(join(tmpdir(), 'wiki-manager-runtime-'));
+  const store = openRuntimeStore({ stateDir });
+  store.persistEvent(createAgentEvent('approval.granted', {
+    origin: 'runtime',
+    runId: 'run-approval-grant',
+    workspace: 'docs',
+    payload: {
+      id: 'grant-1',
+      scope: 'run',
+      runId: 'run-approval-grant',
+      workspaceId: 'docs',
+      planRevision: 3,
+      approvalClasses: ['workspace-write'],
+      reason: 'valide tout',
+    },
+  }));
+
+  const grants = store.listApprovalGrants({ runId: 'run-approval-grant' });
+  assert.deepEqual(grants, [{
+    id: 'grant-1',
+    runId: 'run-approval-grant',
+    workspaceId: 'docs',
+    planRevision: 3,
+    scope: 'run',
+    taskId: null,
+    groupId: null,
+    approvalClasses: ['workspace-write'],
+    status: 'approved',
+    reason: 'valide tout',
+    createdAt: grants[0].createdAt,
+    grantedAt: grants[0].grantedAt,
+    rejectedAt: null,
+  }]);
+  store.close();
+});
+
 test('runtime store orders events by durable sequence', () => {
   const stateDir = mkdtempSync(join(tmpdir(), 'wiki-manager-runtime-'));
   const store = openRuntimeStore({ stateDir });
@@ -349,19 +590,19 @@ test('runtime store persists cancelled run status', () => {
     origin: 'test',
     runId: 'run-1',
     turnId: 'run-1:turn-0',
-    workspace: 'juno',
-    payload: { input: 'build wiki', workspace: 'juno' },
+    workspace: 'acme',
+    payload: { input: 'build wiki', workspace: 'acme' },
   }));
   store.persistEvent(createAgentEvent('run_cancelled', {
     origin: 'test',
     runId: 'run-1',
     turnId: 'run-1:turn-1',
-    workspace: 'juno',
-    payload: { runId: 'run-1', workspace: 'juno' },
+    workspace: 'acme',
+    payload: { runId: 'run-1', workspace: 'acme' },
   }));
 
   assert.equal(store.listRuns()[0].status, 'cancelled');
-  assert.equal(store.listRuns()[0].workspace, 'juno');
+  assert.equal(store.listRuns()[0].workspace, 'acme');
   store.close();
 });
 
@@ -483,10 +724,10 @@ test('runtime store filters events runs and queue by workspace', () => {
   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' },
+    runId: 'run-acme',
+    turnId: 'run-acme:turn-0',
+    workspace: 'acme',
+    payload: { input: 'acme', workspace: 'acme' },
   }));
   store.persistEvent(createAgentEvent('run_started', {
     origin: 'test',
@@ -495,12 +736,12 @@ test('runtime store filters events runs and queue by workspace', () => {
     workspace: 'docs',
     payload: { input: 'docs', workspace: 'docs' },
   }));
-  store.saveQueue([{ id: 'q-juno', workspace: 'juno', status: 'waiting' }], { workspace: 'juno' });
+  store.saveQueue([{ id: 'q-acme', workspace: 'acme', status: 'waiting' }], { workspace: 'acme' });
   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.listEvents({ workspace: 'acme' }).map((event) => event.runId), ['run-acme']);
   assert.deepEqual(store.listRuns({ workspace: 'docs' }).map((run) => run.id), ['run-docs']);
-  assert.deepEqual(store.listQueue({ workspace: 'juno' }).map((item) => item.id), ['q-juno']);
+  assert.deepEqual(store.listQueue({ workspace: 'acme' }).map((item) => item.id), ['q-acme']);
 
   const session = { activities: {}, headlessPlan: null };
   store.hydrateSession(session, { workspace: 'docs' });
@@ -553,8 +794,8 @@ test('runtime store persists and replays control queue events without mixing MCP
   }));
   store.persistEvent(createAgentEvent('control_enqueued', {
     origin: 'runtime',
-    workspace: 'juno',
-    payload: { id: 'control-juno', workspace: 'juno', input: 'other' },
+    workspace: 'acme',
+    payload: { id: 'control-acme', workspace: 'acme', input: 'other' },
   }));
   store.close();
 
@@ -684,10 +925,10 @@ 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',
+    id: 'run-acme',
+    workspace: 'acme',
     status: 'running',
-    input: 'build juno',
+    input: 'build acme',
   });
   store.persistRun({
     id: 'run-done',
@@ -697,9 +938,9 @@ test('runtime store identifies recoverable workspaces and interrupts stale runs'
   });
   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');
+  assert.deepEqual(store.listRecoverableWorkspaces(), ['acme', 'docs']);
+  assert.deepEqual(store.listRecoverableRuns({ workspace: 'acme' }).map((run) => run.id), ['run-acme']);
+  assert.equal(store.interruptRuns({ workspace: 'acme' }), 1);
+  assert.equal(store.listRuns({ workspace: 'acme' })[0].status, 'interrupted');
   store.close();
 });

package/src/runtime/supervisor.js

@@ -1,16 +1,22 @@
 import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
 import { extractActivity, parseJsonText, sessionActivities } from '../core/activity.js';
 import { callMcpTool, formatMcpToolResult } from '../core/mcp.js';
+import { normalizeRuntimeLog } from '../core/runtimeLog.js';
 import { startNextQueuedJob, syncQueueWithActivity } from '../core/jobQueue.js';
+import { createAgentRegistry } from '../orchestrator/agentRegistry.js';
 
 export function startActivitySupervisor(session, {
   intervalMs = 1000,
   queueIntervalMs = 10000,
+  agentRegistryIntervalMs = registryIntervalFromEnv(),
+  agentRegistry = null,
   callTool = callMcpTool,
 } = {}) {
   const pollBusy = new Set();
   let stopped = false;
   let runSignal = null;
+  const registry = agentRegistry ?? createAgentRegistry({ callTool });
+  session.agentRegistry ??= registry;
 
   const pollTimer = setInterval(() => {
     void pollActivitiesOnce(session, { pollBusy, callTool, signal: runSignal });
@@ -24,7 +30,14 @@ export function startActivitySupervisor(session, {
     }
   }, queueIntervalMs);
 
+  const agentRegistryTimer = agentRegistryIntervalMs > 0
+    ? setInterval(() => {
+      void discoverAgentsOnce(session, { registry, signal: runSignal });
+    }, agentRegistryIntervalMs)
+    : null;
+
   void pollActivitiesOnce(session, { pollBusy, callTool, signal: runSignal });
+  void discoverAgentsOnce(session, { registry, signal: runSignal });
 
   return {
     pollBusy,
@@ -36,11 +49,21 @@ export function startActivitySupervisor(session, {
       stopped = true;
       clearInterval(pollTimer);
       clearInterval(queueTimer);
+      if (agentRegistryTimer) clearInterval(agentRegistryTimer);
       pollBusy.clear();
     },
   };
 }
 
+export async function discoverAgentsOnce(session, {
+  registry = session?.agentRegistry ?? createAgentRegistry(),
+  signal = null,
+} = {}) {
+  if (!session) return [];
+  session.agentRegistry ??= registry;
+  return registry.discover(session, { signal });
+}
+
 export async function pollActivitiesOnce(session, {
   pollBusy = new Set(),
   callTool = callMcpTool,
@@ -97,8 +120,17 @@ export async function pollActivitiesOnce(session, {
 }
 
 export function emitRuntimeLog(session, message) {
+  const payload = normalizeRuntimeLog(message, { session });
   dispatchAgentEvent(session, createAgentEvent('runtime_log', {
     origin: 'runtime',
-    payload: { message },
+    runId: payload.runId ?? null,
+    taskId: payload.taskId ?? null,
+    workspace: payload.workspaceId ?? null,
+    payload,
   }));
 }
+
+function registryIntervalFromEnv() {
+  const value = Number(process.env.WIKI_MANAGER_AGENT_REGISTRY_INTERVAL_MS);
+  return Number.isFinite(value) && value >= 0 ? Math.floor(value) : 60000;
+}

package/src/runtime/supervisor.test.js

@@ -1,7 +1,7 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
 import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
-import { pollActivitiesOnce, startActivitySupervisor } from './supervisor.js';
+import { discoverAgentsOnce, pollActivitiesOnce, startActivitySupervisor } from './supervisor.js';
 
 test('pollActivitiesOnce updates activity through the event reducer', async () => {
   const session = {
@@ -154,6 +154,52 @@ test('startActivitySupervisor passes the active run signal to background polls',
   }
 });
 
+test('startActivitySupervisor periodically re-scans the agent registry', async () => {
+  const session = {
+    mcp: {},
+    activities: {},
+    headlessPlan: null,
+    jobQueue: [],
+  };
+  let discoveries = 0;
+  const registry = {
+    async discover() {
+      discoveries += 1;
+      return [];
+    },
+    snapshot() {
+      return [];
+    },
+  };
+
+  const supervisor = startActivitySupervisor(session, {
+    intervalMs: 1000,
+    queueIntervalMs: 1000,
+    agentRegistryIntervalMs: 10,
+    agentRegistry: registry,
+  });
+
+  try {
+    await waitFor(() => discoveries >= 2);
+    assert.equal(session.agentRegistry, registry);
+  } finally {
+    supervisor.stop();
+  }
+});
+
+test('discoverAgentsOnce uses the session registry and returns discovered agents', async () => {
+  const expected = [{ agentInstanceId: 'a' }];
+  const registry = {
+    async discover(session) {
+      assert.equal(session.workspace, 'docs');
+      return expected;
+    },
+  };
+  const session = { workspace: 'docs', agentRegistry: registry };
+
+  assert.equal(await discoverAgentsOnce(session), expected);
+});
+
 test('pollActivitiesOnce fires _onActivitiesTerminal when last activity becomes terminal', async () => {
   let fired = false;
   const session = {

package/src/shell/RightPane.tsx

@@ -1,5 +1,6 @@
 /** @jsxImportSource @opentui/solid */
 import { createMemo, Index, Show } from 'solid-js';
+import { filterRuntimeLogs } from '../core/runtimeLog.js';
 import { fit } from './textFit';
 
 type PlanStep = { step: number; description: string; status: string };
@@ -182,9 +183,10 @@ export function ActivityPanel(props: { activities: any[]; width: number }) {
   );
 }
 
-export function LogPanel(props: { logs: string[]; width: number }) {
+export function LogPanel(props: { logs: string[]; width: number; filter?: string }) {
   const lineWidth = () => Math.max(8, props.width - 2);
-  const visibleLines = () => props.logs.slice(-12).flatMap((line) => wrapLine(line, lineWidth())).slice(-24);
+  const filteredLogs = () => filterRuntimeLogs(props.logs, props.filter ?? '');
+  const visibleLines = () => filteredLogs().flatMap((line) => wrapLine(line, lineWidth())).slice(-24);
   const logLineAt = (index: number) => visibleLines()[index] ?? '';
   return (
     <box flexGrow={1} flexDirection="column" padding={1}>
@@ -202,8 +204,8 @@ export function LogPanel(props: { logs: string[]; width: number }) {
                 fallback={<text width={lineWidth()} fg="#AAB7C4" content={line()} />}
               >
                 <box height={1} flexDirection="row" overflow="hidden">
-                  <text width={timeWidth()} fg="#89B4FA" content={fit(`${parts().time} `, timeWidth())} />
-                  <text width={messageWidth()} fg="#AAB7C4" content={fit(parts().message, messageWidth())} />
+                  <text width={timeWidth()} fg="#89B4FA" content={`${parts().time} `} />
+                  <text width={messageWidth()} fg="#AAB7C4" content={parts().message} />
                 </box>
               </Show>
             );
@@ -284,6 +286,7 @@ export function RightPane(props: {
   queueItems: QueueItem[];
   queueInfo: QueueInfo;
   activeTab: 'plan' | 'queue';
+  logFilter?: string;
   onTabClick: (tab: 'plan' | 'queue') => void;
 }) {
   const planJobName = () => activityJobName(
@@ -302,7 +305,7 @@ export function RightPane(props: {
       )}>
         <QueuePanel width={props.width} items={props.queueItems} info={props.queueInfo} />
       </Show>
-      <LogPanel width={props.width} logs={props.logs} />
+      <LogPanel width={props.width} logs={props.logs} filter={props.logFilter} />
     </box>
   );
 }

package/src/shell/repl.js

@@ -797,14 +797,6 @@ export function applyRuntimeStateToShellSession(session, state) {
       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;
 }
 
@@ -814,7 +806,10 @@ export function applyRuntimeStateToShellSession(session, state) {
 export async function submitRuntimeRun(line, { runtime, session }) {
   const workspace = session.workspace ?? null;
   try {
-    await postRuntimeRun(line, { url: runtime.url, workspace });
+    const result = await postRuntimeRun(line, { url: runtime.url, workspace });
+    if (result?.queued || result?.kind === 'enqueue_run' || result?.kind === 'enqueue') {
+      return { kind: 'queued', result };
+    }
     return { kind: 'accepted' };
   } catch (err) {
     if (err?.status !== 409) {
@@ -1585,14 +1580,15 @@ async function runTuiShell({ agent, packageJson, session, runtime = null }) {
             if (outcome.kind === 'accepted') {
               activityLines = [...activityLines, 'runtime: run accepted'].slice(-LOWER_DETAIL_ROWS);
             } else if (outcome.kind === 'queued') {
-              conversationMessages(session).push({ role: 'command', content: 'Runtime is busy — request added to the control queue, it will start automatically.' });
+              // Server-localized acknowledgement (src/runtime/controlMessages.js).
+              conversationMessages(session).push({ role: 'command', content: String(outcome.result?.explanation ?? 'Request added to the queue.') });
               activityLines = [...activityLines, 'runtime: control queued'].slice(-LOWER_DETAIL_ROWS);
             } else if (outcome.kind === 'observe' || outcome.kind === 'converse' || outcome.kind === 'mutate') {
               const explanation = outcome.result?.explanation ?? 'Runtime control message accepted.';
               conversationMessages(session).push({ role: 'command', content: explanation });
               activityLines = [...activityLines, `runtime: ${outcome.kind}`].slice(-LOWER_DETAIL_ROWS);
             } else if (outcome.kind === 'ambiguous') {
-              conversationMessages(session).push({ role: 'command', content: 'Runtime could not classify that message. Use /queue for a future run, or ask/status more explicitly.' });
+              conversationMessages(session).push({ role: 'command', content: String(outcome.result?.explanation ?? 'Runtime could not classify that message. Use /queue for a future run, or ask/status more explicitly.') });
               activityLines = [...activityLines, 'runtime: ambiguous control'].slice(-LOWER_DETAIL_ROWS);
             } else {
               conversationMessages(session).push({ role: 'command', content: `Runtime error: ${outcome.message}` });