@dotdrelle/wiki-manager 0.8.2 → 0.10.4

package/src/runtime/store.js

@@ -4,6 +4,7 @@ import { DatabaseSync } from 'node:sqlite';
 import { applyAgentProjectionToSession, dispatchAgentEvent, reduceAgentEvents } from '../core/agentEvents.js';
 import { defaultRuntimeStateDir } from '../core/env.js';
 import { projectQueue } from '../core/jobQueue.js';
+import { projectWorkflow } from '../core/workflow.js';
 
 export { defaultRuntimeStateDir };
 
@@ -35,6 +36,7 @@ export function openRuntimeStore({ stateDir = defaultRuntimeStateDir(), fileName
       type TEXT NOT NULL,
       run_id TEXT,
       turn_id TEXT,
+      task_id TEXT,
       workspace TEXT,
       origin TEXT,
       payload TEXT NOT NULL
@@ -69,6 +71,7 @@ export function openRuntimeStore({ stateDir = defaultRuntimeStateDir(), fileName
   `);
   ensureColumn(db, 'events', 'sequence', 'INTEGER');
   ensureColumn(db, 'events', 'workspace', 'TEXT');
+  ensureColumn(db, 'events', 'task_id', 'TEXT');
   ensureColumn(db, 'runs', 'workspace', 'TEXT');
   backfillEventSequence(db);
   db.exec('CREATE INDEX IF NOT EXISTS idx_events_workspace ON events(workspace)');
@@ -78,17 +81,17 @@ export function openRuntimeStore({ stateDir = defaultRuntimeStateDir(), fileName
   let lastEventSequence = null;
 
   const insertEvent = db.prepare(`
-    INSERT OR IGNORE INTO events (sequence, id, ts, type, run_id, turn_id, workspace, origin, payload)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    INSERT OR IGNORE INTO events (sequence, id, ts, type, run_id, turn_id, task_id, workspace, origin, payload)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
   `);
   const nextEventSequenceStatement = db.prepare('SELECT COALESCE(MAX(sequence), 0) + 1 AS next_sequence FROM events');
   const listEventsStatement = db.prepare(`
-    SELECT sequence, id, ts, type, run_id, turn_id, workspace, origin, payload
+    SELECT sequence, id, ts, type, run_id, turn_id, task_id, workspace, origin, payload
     FROM events
     ORDER BY sequence ASC
   `);
   const listEventsByWorkspaceStatement = db.prepare(`
-    SELECT sequence, id, ts, type, run_id, turn_id, workspace, origin, payload
+    SELECT sequence, id, ts, type, run_id, turn_id, task_id, workspace, origin, payload
     FROM events
     WHERE workspace = ?
     ORDER BY sequence ASC
@@ -195,6 +198,7 @@ export function openRuntimeStore({ stateDir = defaultRuntimeStateDir(), fileName
       event.type,
       event.runId ?? null,
       event.turnId ?? null,
+      event.taskId ?? event.payload?.taskId ?? null,
       ws,
       event.origin ?? null,
       JSON.stringify(event.payload ?? {}),
@@ -240,6 +244,12 @@ export function openRuntimeStore({ stateDir = defaultRuntimeStateDir(), fileName
     return rows.map(rowToEvent);
   }
 
+  function listAuditTrail({ workspace = null, runId = null } = {}) {
+    return listEvents({ workspace })
+      .filter((event) => !runId || event.runId === runId || event.payload?.runId === runId)
+      .map(eventToAuditEntry);
+  }
+
   function listRuns({ workspace = null } = {}) {
     const rows = workspace
       ? listRunsByWorkspaceStatement.all(workspace)
@@ -362,12 +372,22 @@ export function openRuntimeStore({ stateDir = defaultRuntimeStateDir(), fileName
     const events = session?.agentProjection ? null : listEvents({ workspace });
     const projection = session?.agentProjection ?? reduceAgentEvents(events);
     const rawQueue = session?.queueStore?.list() ?? listQueue({ workspace });
-    return {
+    const queue = projectQueue(projection.plan, rawQueue, { workspace });
+    const controlQueue = Array.isArray(projection.controlQueue)
+      ? projection.controlQueue.filter((item) => !workspace || item.workspace === workspace || !item.workspace).map((item) => ({ ...item }))
+      : [];
+    const baseState = {
       ...projection,
-      runs: listRuns({ workspace }),
-      queue: projectQueue(projection.plan, rawQueue, { workspace }),
+      queue,
+      controlQueue,
       eventsCursor: session?.agentEvents?.at(-1)?.sequence ?? events?.at(-1)?.sequence ?? lastEventSequence,
     };
+    const runs = listRuns({ workspace });
+    return {
+      ...baseState,
+      runs,
+      workflow: projectWorkflow({ ...baseState, runs, workspace }, events ?? session?.agentEvents ?? []),
+    };
   }
 
   function hydrateSession(session, { workspace = null } = {}) {
@@ -388,6 +408,7 @@ export function openRuntimeStore({ stateDir = defaultRuntimeStateDir(), fileName
     persistEvent,
     persistRun,
     listEvents,
+    listAuditTrail,
     listRuns,
     listRecoverableRuns,
     listRecoverableWorkspaces,
@@ -411,11 +432,42 @@ function rowToEvent(row) {
     origin: row.origin ?? 'system',
     runId: row.run_id ?? null,
     turnId: row.turn_id ?? null,
+    taskId: row.task_id ?? null,
     workspace: row.workspace ?? null,
     payload: row.payload ? JSON.parse(row.payload) : {},
   };
 }
 
+function eventToAuditEntry(event) {
+  const payload = event.payload ?? {};
+  const activity = payload.activity ?? {};
+  return {
+    sequence: event.sequence ?? null,
+    ts: event.ts,
+    type: event.type,
+    runId: event.runId ?? payload.runId ?? null,
+    turnId: event.turnId ?? payload.turnId ?? null,
+    taskId: event.taskId ?? payload.taskId ?? activity.taskId ?? null,
+    activityId: payload.activityId ?? activity.id ?? activity.key ?? null,
+    toolCallId: payload.toolCallId ?? payload.callId ?? null,
+    workspace: event.workspace ?? payload.workspace ?? null,
+    caller: event.origin ?? payload.caller ?? 'system',
+    status: payload.status ?? activity.status ?? null,
+    tool: payload.tool ?? payload.name ?? activity.tool ?? null,
+    summary: auditSummary(event),
+  };
+}
+
+function auditSummary(event) {
+  const payload = event.payload ?? {};
+  if (typeof payload.message === 'string') return payload.message;
+  if (typeof payload.summary === 'string') return payload.summary;
+  if (typeof payload.input === 'string') return payload.input;
+  if (typeof payload.content === 'string') return payload.content.slice(0, 240);
+  if (payload.activity?.label) return payload.activity.label;
+  return event.type;
+}
+
 function ensureColumn(db, table, column, definition) {
   const existing = db.prepare(`PRAGMA table_info(${table})`).all();
   if (existing.some((row) => row.name === column)) return;

package/src/runtime/store.test.js

@@ -59,6 +59,7 @@ test('runtime store persists run identity fields on events', () => {
     origin: 'agent',
     runId: 'run-2',
     turnId: 'run-2:turn-1',
+    taskId: 'task-1',
     workspace: 'docs',
     payload: { content: 'done' },
   }));
@@ -66,10 +67,51 @@ test('runtime store persists run identity fields on events', () => {
   const [event] = store.listEvents();
   assert.equal(event.runId, 'run-2');
   assert.equal(event.turnId, 'run-2:turn-1');
+  assert.equal(event.taskId, 'task-1');
   assert.equal(event.workspace, 'docs');
   store.close();
 });
 
+test('runtime store exposes a correlated audit trail', () => {
+  const stateDir = mkdtempSync(join(tmpdir(), 'wiki-manager-runtime-'));
+  const store = openRuntimeStore({ stateDir });
+  store.persistEvent(createAgentEvent('tool_call_started', {
+    origin: 'agent',
+    runId: 'run-audit',
+    turnId: 'run-audit:turn-1',
+    taskId: 'task-a',
+    workspace: 'docs',
+    payload: { callId: 'call-1', name: 'production_start_job' },
+  }));
+  store.persistEvent(createAgentEvent('activity_upserted', {
+    origin: 'tool',
+    runId: 'run-audit',
+    turnId: 'run-audit:turn-1',
+    taskId: 'task-a',
+    workspace: 'docs',
+    payload: {
+      activity: {
+        id: 'job-1',
+        source: 'production',
+        kind: 'job',
+        label: 'Production job',
+        status: 'running',
+        progress: {},
+        poll: null,
+        outputRefs: [],
+      },
+    },
+  }));
+
+  const audit = store.listAuditTrail({ workspace: 'docs', runId: 'run-audit' });
+  assert.equal(audit.length, 2);
+  assert.equal(audit[0].toolCallId, 'call-1');
+  assert.equal(audit[0].taskId, 'task-a');
+  assert.equal(audit[1].activityId, 'job-1');
+  assert.equal(audit[1].workspace, 'docs');
+  store.close();
+});
+
 test('runtime store replays evaluator verdict into state', () => {
   const stateDir = mkdtempSync(join(tmpdir(), 'wiki-manager-runtime-'));
   const store = openRuntimeStore({ stateDir });
@@ -404,12 +446,41 @@ test('runtime state exposes queue as blocked jobs and pending plan steps', () =>
     { id: 'q-done', workspace: 'docs', status: 'done', args: { type: 'done' } },
   ], { workspace: 'docs' });
 
-  const queue = store.getState(session, { workspace: 'docs' }).queue;
+  const state = store.getState(session, { workspace: 'docs' });
+  const queue = state.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');
+  assert.ok(state.workflow.nodes.some((node) => node.id === 'task:2'));
+  assert.ok(state.workflow.nodes.some((node) => node.id === 'queue:q-wait'));
+  assert.ok(state.workflow.waitingReasons.includes('queue:q-wait'));
+  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', () => {

package/src/shell/RightPane.tsx

@@ -1,5 +1,6 @@
 /** @jsxImportSource @opentui/solid */
 import { createMemo, Index, Show } from 'solid-js';
+import { fit } from './textFit';
 
 type PlanStep = { step: number; description: string; status: string };
 type QueueItem = {
@@ -45,13 +46,6 @@ function wrapLine(value: string, width: number) {
   return lines;
 }
 
-function fit(value: string, width: number) {
-  const max = Math.max(1, width);
-  if (value.length <= max) return value;
-  if (max <= 1) return '…';
-  return value.slice(0, max - 1) + '…';
-}
-
 function logLineParts(line: string): LogLineParts {
   const match = line.match(/^((?:\d{1,2}:\d{2}(?::\d{2})?(?:\s?[AP]M)?|\d{4}-\d{2}-\d{2}[T ][0-9:.]+Z?))\s+(.+)$/i);
   if (!match) return { time: null, message: line };

package/src/shell/StartupScreen.tsx

@@ -0,0 +1,212 @@
+/** @jsxImportSource @opentui/solid */
+import { useKeyboard } from '@opentui/solid';
+import { createMemo, createSignal, For } from 'solid-js';
+import { fit } from './textFit';
+
+export type StartupAction =
+  | 'new-conversation'
+  | 'open-workspace'
+  | 'run-workflow'
+  | 'init-workspace';
+
+type StartupItem = {
+  action: StartupAction;
+  label: string;
+  detail: string;
+};
+
+function statusDot(ready: boolean) {
+  return ready ? '●' : '○';
+}
+
+function initWorkspaceItem(detail: string): StartupItem {
+  return { action: 'init-workspace', label: 'Initialize workspace', detail };
+}
+
+export function StartupScreen(props: {
+  version: string;
+  model: string;
+  connectedMcpServers: number;
+  wikiReady: boolean;
+  workspaceName?: string | null;
+  profileName?: string | null;
+  workspaces: string[];
+  hasWorkspace: boolean;
+  width: number;
+  height: number;
+  onSelect: (action: StartupAction, workspaceName?: string) => void;
+  onQuit: () => void;
+}) {
+  const [mode, setMode] = createSignal<'home' | 'workspace-select'>('home');
+  const [selected, setSelected] = createSignal(0);
+  const panelWidth = createMemo(() => Math.max(54, Math.min(86, props.width - 4)));
+  const panelHeight = createMemo(() => Math.max(24, Math.min(32, props.height - 2)));
+  const left = createMemo(() => Math.max(1, Math.floor((props.width - panelWidth()) / 2)));
+  const top = createMemo(() => Math.max(1, Math.floor((props.height - panelHeight()) / 2)));
+
+  const items = createMemo<StartupItem[]>(() => {
+    if (!props.hasWorkspace) {
+      return [initWorkspaceItem('Create and configure the default workspace')];
+    }
+    return [
+      {
+        action: 'new-conversation',
+        label: 'Start a new conversation',
+        detail: props.workspaceName ? `Load ${props.workspaceName} with default .wikirc` : 'Load default .wikirc',
+      },
+      {
+        action: 'open-workspace',
+        label: 'Open workspace',
+        detail: 'Select, load, then start agents and services',
+      },
+      initWorkspaceItem('Create and configure a new workspace'),
+      {
+        action: 'run-workflow',
+        label: 'Run a workflow',
+        detail: 'Switch to Agent mode after loading the workspace',
+      },
+    ];
+  });
+  const workspaceItems = createMemo(() => props.workspaces.map((name) => ({
+    label: name,
+    detail: name === props.workspaceName ? 'default workspace' : 'available workspace',
+  })));
+  const currentLength = createMemo(() => mode() === 'workspace-select' ? workspaceItems().length : items().length);
+
+  const move = (delta: number) => {
+    setSelected((value) => (value + delta + currentLength()) % currentLength());
+  };
+
+  const choose = (index = selected()) => {
+    if (mode() === 'workspace-select') {
+      const item = workspaceItems()[index];
+      if (item) props.onSelect('open-workspace', item.label);
+      return;
+    }
+    const item = items()[index];
+    if (!item) return;
+    if (item.action === 'open-workspace') {
+      setMode('workspace-select');
+      setSelected(0);
+      return;
+    }
+    props.onSelect(item.action);
+  };
+
+  useKeyboard((key: any) => {
+    const keyName = String(key.name ?? '').toLowerCase();
+    const sequence = String(key.sequence ?? '');
+    if ((key.ctrl || key.meta) && keyName === 'c') {
+      props.onQuit();
+      return;
+    }
+    if (keyName === 'escape' && mode() === 'workspace-select') {
+      setMode('home');
+      setSelected(0);
+      return;
+    }
+    if (keyName === 'escape') {
+      props.onQuit();
+      return;
+    }
+    if (keyName === 'up') {
+      move(-1);
+      return;
+    }
+    if (keyName === 'down') {
+      move(1);
+      return;
+    }
+    if (keyName === 'return' || keyName === 'enter') {
+      choose();
+      return;
+    }
+    const numeric = Number.parseInt(sequence, 10);
+    if (Number.isInteger(numeric) && numeric >= 1 && numeric <= currentLength()) {
+      choose(numeric - 1);
+    }
+  });
+
+  const status = createMemo(() => {
+    if (!props.hasWorkspace) return 'Setup needed';
+    return props.wikiReady ? 'Ready' : 'Default .wikirc missing';
+  });
+
+  const subtitle = createMemo(() => {
+    const workspace = props.workspaceName ?? 'no workspace';
+    const profile = props.profileName ?? 'default';
+    return `${workspace} / ${profile}`;
+  });
+
+  const innerWidth = createMemo(() => Math.max(40, panelWidth() - 6));
+  const shortcutHint = createMemo(() => {
+    const count = currentLength();
+    const quick = count === 1 ? '1 quick select' : `1-${count} quick select`;
+    return mode() === 'workspace-select'
+      ? `↑/↓ select  Enter open  ${quick}  Esc back`
+      : `↑/↓ select  Enter open  ${quick}  Esc quit`;
+  });
+  const menuTitle = createMemo(() => mode() === 'workspace-select' ? 'Select workspace' : '');
+
+  return (
+    <box width="100%" height="100%" backgroundColor="#0B0D12">
+      <box
+        position="absolute"
+        left={left()}
+        top={top()}
+        width={panelWidth()}
+        height={panelHeight()}
+        border
+        borderStyle="rounded"
+        borderColor="#8BD5CA"
+        backgroundColor="#111318"
+        padding={2}
+        flexDirection="column"
+        overflow="hidden"
+      >
+        <box height={1} flexDirection="row">
+          <text fg="#8BD5CA" content={fit(`DONNA v${props.version}`, Math.floor(innerWidth() * 0.5))} />
+          <text fg={props.wikiReady ? '#8BD5CA' : '#FBBF24'} content={fit(` ${statusDot(props.wikiReady)} ${status()}`, Math.floor(innerWidth() * 0.45))} />
+        </box>
+        <text height={1} fg="#7F8C8D" content={fit(subtitle(), innerWidth())} />
+        <text height={1}>{''}</text>
+        <text height={1} fg="#D6DEE8">██████╗  ██████╗ ███╗   ██╗███╗   ██╗ █████╗</text>
+        <text height={1} fg="#D6DEE8">██╔══██╗██╔═══██╗████╗  ██║████╗  ██║██╔══██╗</text>
+        <text height={1} fg="#D6DEE8">██║  ██║██║   ██║██╔██╗ ██║██╔██╗ ██║███████║</text>
+        <text height={1} fg="#D6DEE8">██║  ██║██║   ██║██║╚██╗██║██║╚██╗██║██╔══██║</text>
+        <text height={1} fg="#D6DEE8">██████╔╝╚██████╔╝██║ ╚████║██║ ╚████║██║  ██║</text>
+        <text height={1} fg="#D6DEE8">╚═════╝  ╚═════╝ ╚═╝  ╚═══╝╚═╝  ╚═══╝╚═╝  ╚═╝</text>
+        <text height={1}>{''}</text>
+        <text height={1} fg="#7F8C8D" content={menuTitle()} />
+        <box height={Math.max(1, currentLength())} flexDirection="column">
+          <For each={mode() === 'workspace-select' ? workspaceItems() : items()}>
+            {(item, index) => {
+              const active = () => index() === selected();
+              return (
+                <box
+                  height={1}
+                  flexDirection="row"
+                  onMouseUp={() => choose(index())}
+                >
+                  <text width={4} fg={active() ? '#111318' : '#7F8C8D'} bg={active() ? '#8BD5CA' : undefined}>
+                    {active() ? '›' : ' '} {index() + 1}
+                  </text>
+                  <text width={28} fg={active() ? '#8BD5CA' : '#D6DEE8'} content={fit(item.label, 27)} />
+                  <text fg="#7F8C8D" content={fit(item.detail, Math.max(8, innerWidth() - 34))} />
+                </box>
+              );
+            }}
+          </For>
+        </box>
+        <text height={1}>{''}</text>
+        <box height={3} flexDirection="column" border={['left']} borderStyle="heavy" borderColor="#5DADE2" paddingX={1}>
+          <text height={1} fg="#D6DEE8" content={fit(`LLM  ${statusDot(Boolean(props.model))} ${props.model || 'not configured'}`, innerWidth() - 2)} />
+          <text height={1} fg="#D6DEE8" content={fit(`MCP  ${statusDot(props.connectedMcpServers > 0)} ${props.connectedMcpServers} server(s) configured`, innerWidth() - 2)} />
+          <text height={1} fg="#D6DEE8" content={fit(`Wiki ${statusDot(props.wikiReady)} ${props.wikiReady ? 'default profile ready' : 'init required'}`, innerWidth() - 2)} />
+        </box>
+        <text height={1}>{''}</text>
+        <text height={1} fg="#7F8C8D" content={shortcutHint()} />
+      </box>
+    </box>
+  );
+}

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, postRuntimeApprove, postRuntimeCancel, postRuntimeRun, streamRuntimeEvents } from '../runtime/client.js';
+import { fetchRuntimeState, postRuntimeApprove, postRuntimeCancel, postRuntimeControl, postRuntimeRun, streamRuntimeEvents } from '../runtime/client.js';
 
 marked.use(markedTerminal());
 // marked-terminal's text renderer extracts token.text (raw string) instead of
@@ -743,7 +743,18 @@ export function applyRuntimeStateToShellSession(session, state) {
     logs: Array.isArray(state.logs) ? [...state.logs] : [],
     summary: state.summary ?? null,
     status: state.status ?? 'idle',
+    planRevision: state.planRevision ?? 0,
+    planPatches: Array.isArray(state.planPatches) ? state.planPatches.map((patch) => ({ ...patch })) : [],
   };
+  session.workflow = state.workflow && typeof state.workflow === 'object'
+    ? {
+        ...state.workflow,
+        nodes: Array.isArray(state.workflow.nodes) ? state.workflow.nodes.map((node) => ({ ...node })) : [],
+        relations: Array.isArray(state.workflow.relations) ? state.workflow.relations.map((relation) => ({ ...relation })) : [],
+        waitingReasons: Array.isArray(state.workflow.waitingReasons) ? [...state.workflow.waitingReasons] : [],
+        warnings: Array.isArray(state.workflow.warnings) ? [...state.workflow.warnings] : [],
+      }
+    : null;
   session.headlessPlan = session.agentProjection.plan
     ? session.agentProjection.plan.map((step) => ({ ...step }))
     : null;
@@ -772,6 +783,27 @@ export function applyRuntimeStateToShellSession(session, state) {
   return true;
 }
 
+// Submits a prompt to the shared runtime. If the workspace is already busy
+// (HTTP 409 from POST /run), route the input through the runtime control lane
+// so status questions and plan-change proposals do not become future runs.
+export async function submitRuntimeRun(line, { runtime, session }) {
+  const workspace = session.workspace ?? null;
+  try {
+    await postRuntimeRun(line, { url: runtime.url, workspace });
+    return { kind: 'accepted' };
+  } catch (err) {
+    if (err?.status !== 409) {
+      return { kind: 'error', message: err instanceof Error ? err.message : String(err) };
+    }
+    try {
+      const result = await postRuntimeControl('message', { url: runtime.url, workspace, input: line });
+      return { kind: result?.kind ?? 'control', result };
+    } catch (queueErr) {
+      return { kind: 'error', message: queueErr instanceof Error ? queueErr.message : String(queueErr) };
+    }
+  }
+}
+
 function activityText(session) {
   const activity = sessionActivities(session).find((item) => !item.terminal)
     ?? (session.productionActivity?.label ? session.productionActivity : null);
@@ -1499,13 +1531,25 @@ async function runTuiShell({ agent, packageJson, session, runtime = null }) {
             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);
+          const outcome = await submitRuntimeRun(line, { runtime, session });
+          if (outcome.kind === 'accepted') {
+            conversationMessages(session).push({ role: 'command', content: `Runtime run queued: ${runtime.url}` });
+            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.' });
+            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.' });
+            activityLines = [...activityLines, 'runtime: ambiguous control'].slice(-LOWER_DETAIL_ROWS);
+          } else {
+            conversationMessages(session).push({ role: 'command', content: `Runtime error: ${outcome.message}` });
+            activityLines = [...activityLines, `runtime error: ${outcome.message}`].slice(-LOWER_DETAIL_ROWS);
+          }
           syncRuntimeState();
         } else {
           const result = await runLine(line, { agent, packageJson, session, onUpdate: rerender, onStep });

package/src/shell/repl.test.js

@@ -1,6 +1,20 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
-import { applyRuntimeStateToShellSession, createSession, conversationMessages } from './repl.js';
+import { applyRuntimeStateToShellSession, createSession, conversationMessages, submitRuntimeRun } from './repl.js';
+
+function stubFetch(handler) {
+  const original = globalThis.fetch;
+  globalThis.fetch = handler;
+  return () => { globalThis.fetch = original; };
+}
+
+function jsonResponse(status, body) {
+  return { ok: status >= 200 && status < 300, status, text: async () => JSON.stringify(body), json: async () => body };
+}
+
+function pathOf(url) {
+  return new URL(String(url)).pathname;
+}
 
 test('applyRuntimeStateToShellSession projects runtime state into shell session', () => {
   const session = createSession();
@@ -22,6 +36,12 @@ test('applyRuntimeStateToShellSession projects runtime state into shell session'
       terminal: false,
     }],
     queue: [{ id: 'q-1', status: 'waiting' }],
+    workflow: {
+      nodes: [{ id: 'task:build', type: 'task', label: 'Build', status: 'running' }],
+      relations: [{ type: 'contains', from: 'run:run-1', to: 'task:build' }],
+      waitingReasons: ['queue:q-1'],
+      warnings: ['legacy_sequential_plan'],
+    },
     logs: ['agentic-loop: turn 1/20'],
   });
 
@@ -31,8 +51,64 @@ test('applyRuntimeStateToShellSession projects runtime state into shell session'
   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.equal(session.workflow.nodes[0].id, 'task:build');
+  assert.equal(session.workflow.relations[0].type, 'contains');
+  assert.deepEqual(session.workflow.waitingReasons, ['queue:q-1']);
   assert.deepEqual(conversationMessages(session), [
     { role: 'user', content: 'Build docs' },
     { role: 'donna', content: 'Working.' },
   ]);
 });
+
+test('submitRuntimeRun reports acceptance without throwing', async () => {
+  const restore = stubFetch(async (url) => {
+    assert.equal(pathOf(url), '/run');
+    return jsonResponse(202, { accepted: true, runId: 'run-1' });
+  });
+  try {
+    const session = createSession();
+    const outcome = await submitRuntimeRun('build the doc', { runtime: { url: 'http://runtime.test' }, session });
+    assert.deepEqual(outcome, { kind: 'accepted' });
+  } finally {
+    restore();
+  }
+});
+
+test('submitRuntimeRun routes busy runtime input through the control lane', async () => {
+  let controlBody = null;
+  const restore = stubFetch(async (url, init) => {
+    const path = pathOf(url);
+    if (path === '/run') return jsonResponse(409, { error: 'A runtime run is already active.' });
+    if (path === '/control') {
+      controlBody = JSON.parse(String(init.body));
+      return jsonResponse(200, { accepted: true, kind: 'observe', explanation: 'Runtime run is active.' });
+    }
+    throw new Error(`unexpected fetch: ${url}`);
+  });
+  try {
+    const session = createSession();
+    const outcome = await submitRuntimeRun('Où en est le build ?', { runtime: { url: 'http://runtime.test' }, session });
+    assert.equal(outcome.kind, 'observe');
+    assert.equal(outcome.result.explanation, 'Runtime run is active.');
+    assert.deepEqual(controlBody, { action: 'message', input: 'Où en est le build ?' });
+  } finally {
+    restore();
+  }
+});
+
+test('submitRuntimeRun reports a non-409 error without throwing or calling /control', async () => {
+  let controlCalled = false;
+  const restore = stubFetch(async (url) => {
+    if (pathOf(url) === '/control') controlCalled = true;
+    return jsonResponse(503, { error: 'runtime unavailable' });
+  });
+  try {
+    const session = createSession();
+    const outcome = await submitRuntimeRun('build the doc', { runtime: { url: 'http://runtime.test' }, session });
+    assert.equal(outcome.kind, 'error');
+    assert.match(outcome.message, /503/);
+    assert.equal(controlCalled, false);
+  } finally {
+    restore();
+  }
+});

package/src/shell/textFit.ts

@@ -0,0 +1,6 @@
+export function fit(value: string, width: number): string {
+  const max = Math.max(1, width);
+  if (value.length <= max) return value;
+  if (max <= 1) return '…';
+  return value.slice(0, max - 1) + '…';
+}