@dotdrelle/wiki-manager 0.11.10 → 0.12.1

package/src/shell/repl.test.js

@@ -59,6 +59,10 @@ test('applyRuntimeStateToShellSession projects runtime state into shell session'
 
   assert.equal(applied, true);
   assert.equal(session.agentProjection.status, 'running');
+  assert.deepEqual(session.agentProjection.conversation, [
+    { role: 'user', content: 'Build docs' },
+    { role: 'assistant', content: 'Working.' },
+  ]);
   assert.equal(session.headlessPlan[0].description, 'Build');
   assert.equal(session.activities['production:job-1'].status, 'running');
   assert.equal(session.productionActivity.jobId, 'job-1');
@@ -66,10 +70,7 @@ test('applyRuntimeStateToShellSession projects runtime state into shell session'
   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.' },
-  ]);
+  assert.deepEqual(conversationMessages(session), []);
 });
 
 test('submitRuntimeRun reports acceptance without throwing', async () => {
@@ -108,6 +109,26 @@ test('submitRuntimeRun routes busy runtime input through the control lane', asyn
   }
 });
 
+test('submitRuntimeRun reports queued runs from non-blocking runtime', async () => {
+  const restore = stubFetch(async (url) => {
+    assert.equal(pathOf(url), '/run');
+    return jsonResponse(202, {
+      accepted: true,
+      queued: true,
+      kind: 'enqueue_run',
+      item: { id: 'control-1', status: 'queued' },
+    });
+  });
+  try {
+    const session = createSession();
+    const outcome = await submitRuntimeRun('build the doc', { runtime: { url: 'http://runtime.test' }, session });
+    assert.equal(outcome.kind, 'queued');
+    assert.equal(outcome.result.item.id, 'control-1');
+  } finally {
+    restore();
+  }
+});
+
 test('submitRuntimeRun reports a non-409 error without throwing or calling /control', async () => {
   let controlCalled = false;
   const restore = stubFetch(async (url) => {
@@ -162,7 +183,7 @@ test('agent mode without runtime records a visible error instead of falling back
 
 test('runtime status exposes the disconnected reason', () => {
   assert.equal(
-    runtimeStatusLine({ error: 'token mismatch' }, { workspace: 'juno' }),
+    runtimeStatusLine({ error: 'token mismatch' }, { workspace: 'acme' }),
     'runtime: disconnected: token mismatch',
   );
   assert.equal(

package/src/shell/tui.tsx

@@ -336,6 +336,7 @@ function App(props: {
             queueItems={state.queueItems()}
             queueInfo={state.queueInfo()}
             activeTab={state.rightTab()}
+            logFilter={state.runtimeLogFilter()}
             onTabClick={state.selectRightTab}
           />
           <SlashDialog context={state.activeEditor() ? null : state.slash()} />

package/src/shell/useAgent.ts

@@ -31,7 +31,11 @@ export function useAgent(props: { agent: unknown; packageJson: Record<string, un
           props.onRuntimeAccepted?.();
           props.addLog('runtime: run accepted');
         } else if (outcome.kind === 'queued') {
-          conversationMessages(props.session).push({ role: 'command', content: 'Runtime is busy — request added to the control queue, it will start automatically.' });
+          // The server localizes control-lane acknowledgements from the
+          // session language (src/runtime/controlMessages.js) — always prefer
+          // its explanation over a local hardcoded string.
+          const explanation = (outcome as any).result?.explanation ?? 'Request added to the queue.';
+          conversationMessages(props.session).push({ role: 'command', content: String(explanation) });
           props.addLog('runtime: control queued');
         } else {
           conversationMessages(props.session).push({ role: 'command', content: `Runtime error: ${outcome.message}` });

package/src/shell/useSession.ts

@@ -3,10 +3,11 @@ import { isAbsolute, relative, resolve, sep } from 'node:path';
 import { createEffect, createMemo, createSignal, onCleanup } from 'solid-js';
 import { formatMcpToolResult, callMcpTool } from '../core/mcp.js';
 import { extractActivity, parseJsonText, sessionActivities } from '../core/activity.js';
-import { formatPlanStatus, formatCompletedActivities } from '../core/plan.js';
+import { formatPlanStatus, formatCompletedActivities, formatPlanStep } from '../core/plan.js';
 import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
 import { projectQueue, queueCounts, startNextQueuedJob, syncQueueWithActivity } from '../core/jobQueue.js';
 import { queueStoreFor } from '../core/queueStore.js';
+import { filterRuntimeLogs } from '../core/runtimeLog.js';
 import { fetchRuntimeState, streamRuntimeEvents } from '../runtime/client.js';
 import type { ActiveFileEditor } from './FileEditorDialog';
 import {
@@ -99,11 +100,13 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
     },
   });
   const runtimeRunStatus = createMemo(() => String(runtimeState()?.status ?? 'idle'));
-  const agentBusy = createMemo(() =>
+  const conversationBusy = createMemo(() => agent.busy());
+  const executionActive = createMemo(() =>
     props.runtime?.url
-      ? runtimeRunStatus() === 'running' || agent.busy()
-      : agent.busy(),
+      ? runtimeRunStatus() === 'running'
+      : sessionActivities(session).some((activity) => !activity.terminal),
   );
+  const agentBusy = conversationBusy;
   const localFallbackActive = createMemo(() => !props.runtime?.url || runtimeStatus() === 'disconnected');
 
   // Runtime conversation entries are merged into conversationMessages(session)
@@ -182,6 +185,20 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
   let lastVisiblePlan: Array<{ step: number; description: string; status: string }> | null = null;
   const activities = createMemo(() => {
     version();
+    const activityLines = nonEmptyRuntimeArray(runtimeState()?.workflow?.activity?.lines);
+    if (activityLines) {
+      return activityLines.map((line: any, index: number) => ({
+        key: line.id ?? `activity-line-${index}`,
+        id: line.id ?? `activity-line-${index}`,
+        label: line.label,
+        status: line.status ?? 'running',
+        progress: line.progress ?? null,
+        terminal: ['done', 'failed', 'cancelled'].includes(String(line.status)),
+        _runtime: true,
+        _workflow: true,
+        _aggregated: true,
+      }));
+    }
     const workflowActivities = nonEmptyRuntimeArray(runtimeState()?.workflow?.nodes?.filter((node: any) => node.type === 'activity'));
     if (workflowActivities) {
       return workflowActivities.map((node: any) => ({
@@ -207,36 +224,64 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
       ? lastVisibleActivities.map((activity) => ({ ...activity }))
       : current;
   });
+  // Control-lane run requests (user messages queued while the runtime is
+  // busy) live in state.controlQueue, a separate lane from the MCP job
+  // queue. They must appear in the Queue panel too — otherwise a queued run
+  // request is invisible (Queue (0)) even though it is registered and will
+  // start automatically.
+  const controlQueueItems = createMemo(() => {
+    version();
+    const controlQueue = runtimeState()?.controlQueue;
+    if (!Array.isArray(controlQueue)) return [] as any[];
+    return controlQueue
+      .filter((item: any) => ['queued', 'running', 'starting'].includes(String(item.status ?? '').toLowerCase()))
+      .map((item: any) => ({
+        ...item,
+        id: item.id,
+        label: `run: ${String(item.input ?? '').slice(0, 64)}`,
+        status: item.status,
+        _runtime: true,
+        _control: true,
+      }));
+  });
   const queueItems = createMemo(() => {
     version();
+    const control = controlQueueItems();
     const workflowQueue = nonEmptyRuntimeArray(runtimeState()?.workflow?.nodes?.filter((node: any) => node.type === 'queue'));
     if (workflowQueue) {
-      return workflowQueue.map((node: any) => ({ ...(node.raw ?? {}), id: node.itemId ?? node.id, label: node.label, status: node.status, _runtime: true, _workflow: true }));
+      return [...control, ...workflowQueue.map((node: any) => ({ ...(node.raw ?? {}), id: node.itemId ?? node.id, label: node.label, status: node.status, _runtime: true, _workflow: true }))];
     }
     const runtimeQueue = nonEmptyRuntimeArray(runtimeState()?.queue);
-    if (runtimeQueue) return runtimeQueue.map((item: any) => ({ ...item, _runtime: true }));
-    return projectQueue((session as any).headlessPlan, (session as any).jobQueue ?? [], { workspace: (session as any).workspace ?? null })
-      .map((item: any) => ({ ...item }));
+    if (runtimeQueue) return [...control, ...runtimeQueue.map((item: any) => ({ ...item, _runtime: true }))];
+    return [
+      ...control,
+      ...projectQueue((session as any).headlessPlan, (session as any).jobQueue ?? [], { workspace: (session as any).workspace ?? null })
+        .map((item: any) => ({ ...item })),
+    ];
   });
   const queueInfo = createMemo(() => {
     version();
+    const control = controlQueueItems();
+    const controlActive = control.length;
+    const controlCurrent = control.filter((item: any) => ['starting', 'running'].includes(String(item.status ?? '').toLowerCase())).length;
     const workflowQueue = runtimeState()?.workflow?.nodes?.filter((node: any) => node.type === 'queue');
     if (Array.isArray(workflowQueue)) {
       return {
-        active: workflowQueue.filter((item: any) => ['waiting', 'starting', 'running', 'queued', 'pending', 'pending_approval'].includes(String(item.status ?? '').toLowerCase())).length,
-        current: workflowQueue.filter((item: any) => ['starting', 'running'].includes(String(item.status ?? '').toLowerCase())).length,
+        active: controlActive + workflowQueue.filter((item: any) => ['waiting', 'starting', 'running', 'queued', 'pending', 'pending_approval'].includes(String(item.status ?? '').toLowerCase())).length,
+        current: controlCurrent + workflowQueue.filter((item: any) => ['starting', 'running'].includes(String(item.status ?? '').toLowerCase())).length,
         frozen: 0,
       };
     }
     const runtimeQueue = runtimeState()?.queue;
     if (Array.isArray(runtimeQueue)) {
       return {
-        active: runtimeQueue.filter((item: any) => ['waiting', 'starting', 'running', 'queued', 'pending', 'pending_approval'].includes(String(item.status ?? '').toLowerCase())).length,
-        current: runtimeQueue.filter((item: any) => ['starting', 'running'].includes(String(item.status ?? '').toLowerCase())).length,
+        active: controlActive + runtimeQueue.filter((item: any) => ['waiting', 'starting', 'running', 'queued', 'pending', 'pending_approval'].includes(String(item.status ?? '').toLowerCase())).length,
+        current: controlCurrent + runtimeQueue.filter((item: any) => ['starting', 'running'].includes(String(item.status ?? '').toLowerCase())).length,
         frozen: 0,
       };
     }
-    return queueCounts(session);
+    const base = queueCounts(session);
+    return { ...base, active: (base.active ?? 0) + controlActive, current: (base.current ?? 0) + controlCurrent };
   });
   const plan = createMemo(() => {
     version();
@@ -246,7 +291,7 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
         .sort((a: any, b: any) => Number(a.step ?? 0) - Number(b.step ?? 0))
         .map((node: any, index: number) => ({
           step: Number(node.step ?? index + 1),
-          description: String(node.description ?? node.label ?? `Step ${index + 1}`),
+          description: formatPlanStep(node) || `Step ${index + 1}`,
           status: String(node.status ?? 'pending'),
         }));
     }
@@ -254,7 +299,7 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
     if (runtimePlan) {
       return runtimePlan.map((step: any, index: number) => ({
         step: Number(step.step ?? index + 1),
-        description: String(step.description ?? step.label ?? step.name ?? `Step ${index + 1}`),
+        description: formatPlanStep(step) || `Step ${index + 1}`,
         status: String(step.status ?? 'pending'),
       }));
     }
@@ -272,8 +317,9 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
     version();
     const runtimeLogs = runtimeState()?.logs;
     if (!Array.isArray(runtimeLogs) || runtimeLogs.length === 0) return logs();
-    const tagged = runtimeLogs.slice(-80).map((line: any) => `runtime ${String(line)}`);
-    return [...logs(), ...tagged].slice(-200);
+    const filter = String((session as any).runtimeLogFilter ?? '').trim();
+    const tagged = filterRuntimeLogs(runtimeLogs.map((line: any) => `runtime ${String(line)}`), filter);
+    return [...logs(), ...tagged];
   });
 
   // Index-aligned with each workspace's runtimeConversation array — not just
@@ -291,6 +337,13 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
     const target = conversationMessages(session);
     const backed = runtimeConversationRefsByWorkspace.get(workspace) ?? [];
     runtimeConversationRefsByWorkspace.set(workspace, backed);
+    if (backed.length === 0 && target.length === 0 && !runtimeConversation.some((message: any) => message?._pending)) {
+      backed.push(...runtimeConversation.map((message: any) => ({
+        role: message.role === 'assistant' ? 'donna' : message.role,
+        content: String(message.content ?? ''),
+      })));
+      return;
+    }
     for (let i = 0; i < runtimeConversation.length; i += 1) {
       const message = runtimeConversation[i];
       const content = String(message.content ?? '');
@@ -437,7 +490,7 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
               const plan = (session as any).headlessPlan;
               const stillRunning = sessionActivities(session).filter((a) => !a.terminal && a.poll);
               const pendingSteps = (plan ?? []).filter((s: any) => s.status === 'pending');
-              if (stillRunning.length === 0 && pendingSteps.length > 0 && !agentBusy()) {
+              if (stillRunning.length === 0 && pendingSteps.length > 0 && !conversationBusy()) {
                 const completedAll = sessionActivities(session).filter((a) => a.terminal);
                 const prompt = buildContinuationPrompt(session, completedAll);
                 void agent.submit(prompt);
@@ -469,7 +522,7 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
 
   async function submitInput(submittedValue?: string) {
     const line = typeof submittedValue === 'string' && submittedValue.trim() ? submittedValue : input();
-    if (agentBusy()) return { exit: false, busy: true };
+    if (conversationBusy()) return { exit: false, busy: true };
     setInput('');
     setConversationScroll(0);
     if (line.trim()) {
@@ -593,6 +646,7 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
     session,
     messages,
     logs: visibleLogs,
+    runtimeLogFilter: () => String((session as any).runtimeLogFilter ?? ''),
     input,
     setInput: updateInput,
     title,
@@ -613,6 +667,8 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
     plan,
     conversationScroll,
     scrollConversation,
+    conversationBusy,
+    executionActive,
     busy: agentBusy,
     abort,
     submitInput,