@dotdrelle/wiki-manager 0.15.66 → 0.15.71

package/src/runtime/recoveryManager.js

@@ -1,7 +1,7 @@
 import { parseJsonText } from '../core/activity.js';
 import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
 import { formatMcpToolResult, callMcpTool as defaultCallMcpTool } from '../core/mcp.js';
-import { createCapabilityRegistry } from '../orchestrator/capabilityRegistry.js';
+import { capabilityRegistryForSession } from '../orchestrator/capabilityRegistry.js';
 import { accept as acceptResult } from '../orchestrator/resultAggregator.js';
 import { isSuccessful, isTerminal } from '../orchestrator/taskStatuses.js';
 
@@ -100,6 +100,9 @@ async function recoverTask({ store, session, run, task, callTool, resultAggregat
   }
 
   const agent = agentFor(session, assignment.agentInstanceId);
+  if (agent?.providerKind === 'external-runtime' && typeof agent?.runtimeProvider?.status === 'function') {
+    return recoverExternalRuntimeTask({ store, session, run, task, attempt, assignment, agent, resultAggregator });
+  }
   const serverName = agent?.serverName ?? assignment.agentId ?? assignment.agentInstanceId;
   const statusTool = toolNameFor(session, serverName, 'agent_status');
   const status = parseToolPayload(await callTool(session.mcp, serverName, statusTool, { jobId: attempt.jobId }));
@@ -146,6 +149,70 @@ async function recoverTask({ store, session, run, task, callTool, resultAggregat
   return interruptTask({ store, session, run, task, reason: 'active job is non-terminal and task has no idempotencyKey' });
 }
 
+// An MCP job survives a manager restart on the agent's own side and reports
+// its status through agent_status. An external-runtime job has no such
+// side-channel here: the only way to check on it, or to give it up, is the
+// same RuntimeProvider the dispatcher used to start it, re-resolved by
+// agentInstanceId from the live registry rather than replayed from storage.
+async function recoverExternalRuntimeTask({ store, session, run, task, attempt, assignment, agent, resultAggregator }) {
+  const runtimeProvider = agent.runtimeProvider;
+  let status;
+  try {
+    status = await runtimeProvider.status(attempt.jobId);
+  } catch (error) {
+    return interruptTask({
+      store,
+      session,
+      run,
+      task,
+      reason: `external runtime status check failed: ${error instanceof Error ? error.message : String(error)}`,
+    });
+  }
+
+  if (isTerminal(status?.status)) {
+    const result = {
+      ok: isSuccessful(String(status?.status ?? '').toLowerCase()),
+      taskId: task.id,
+      attemptId: attempt.attemptId ?? null,
+      jobId: attempt.jobId,
+      agentInstanceId: assignment.agentInstanceId,
+      status: status?.status,
+      outputRefs: Array.isArray(status?.result?.outputRefs) ? status.result.outputRefs : [],
+      metrics: status?.result?.metrics ?? {},
+      // The gateway reports its failure at the TOP level of the status
+      // payload ({ runId, status, error }), not inside `result` — same fix
+      // already applied in dispatcher.js's taskResultFromStatus and
+      // deepAgentsProvider.js's status().
+      error: status?.result?.error ?? status?.error ?? null,
+      rawStatus: status,
+    };
+    await resultAggregator(result, {
+      session,
+      runId: run.id,
+      task,
+      assignment: { agentInstanceId: assignment.agentInstanceId, serverName: null, agent },
+      store,
+      registry: capabilityRegistryForSession(session),
+      workspaceConfig: session.wikircConfig ?? session.wikirc?.config ?? {},
+    });
+    return { status: 'recovered', runId: run.id, taskId: task.id, jobId: attempt.jobId };
+  }
+
+  // The runtime declares supportsIdempotency: false (runtimeProviders.js), so
+  // a fresh invocation cannot be deduped against the one still running on the
+  // external side. Requeuing it to `pending` like the MCP path below would
+  // start a duplicate while the orphaned original keeps running/billing.
+  // Cancel it explicitly instead of leaving it to run unattended.
+  await runtimeProvider.cancel(attempt.jobId).catch(() => null);
+  return interruptTask({
+    store,
+    session,
+    run,
+    task,
+    reason: 'active external-runtime job cancelled on recovery (no idempotency support)',
+  });
+}
+
 function interruptTask({ store, session, run, task, reason }) {
   dispatch(session, store, 'runtime_log', {
     origin: 'recovery_manager',
@@ -171,10 +238,7 @@ function latestAssignment(assignments, attemptId) {
 
 
 function capabilityResolvable(session, capability) {
-  const registry = session.capabilityRegistry
-    ?? ((session.agentRegistrySnapshot ?? []).length > 0
-      ? createCapabilityRegistry({ agents: session.agentRegistrySnapshot })
-      : null);
+  const registry = capabilityRegistryForSession(session);
   if (!registry || typeof registry.providersFor !== 'function') return true;
   // Only trust a registry that actually knows about capabilities. An empty
   // one (discovery not finished, or agents described without capability
@@ -211,6 +275,7 @@ function agentFor(session, agentInstanceId) {
   return [
     ...(session.agentRegistrySnapshot ?? []),
     ...(session.agents ?? []),
+    ...(session.runtimeProviderAgents ?? []),
   ].find((agent) => agent?.agentInstanceId === agentInstanceId) ?? null;
 }
 

package/src/runtime/runner.test.js

@@ -829,7 +829,7 @@ test('runRuntimeParallelPlan fails cleanly when scheduler budget is exceeded', a
  laissait le run « stalled ». Ne pas attendre d'approbation était déjà acquis,
  mais s'arrêter là déclenchait une replanification et laissait le run vivant.
 
- Cas observé le 2026-08-04 (workspace juno) : dix fichiers à ingérer, neuf
+ Cas observé le 2026-08-04 (workspace demo) : dix fichiers à ingérer, neuf
  réussis, un en échec sur du JSON malformé — le run n'est jamais retombé.
  Une tâche qui ne deviendra jamais exécutable est donc marquée `skipped` avec
  le nom de la dépendance fautive, et le run se termine sur un résultat partiel.

package/src/runtime/server.test.js

@@ -2154,7 +2154,7 @@ test('runtime health reports active runs across workspaces', async (t) => {
       session: {},
       // The shell reads this at exit: shutting down its own runtime must not
       // kill a run that is supposed to survive the shell.
-      listActiveRuns: () => [{ workspace: 'juno', runId: 'run-1234abcd' }],
+      listActiveRuns: () => [{ workspace: 'demo', runId: 'run-1234abcd' }],
     });
   } catch (err) {
     if (err?.code === 'EPERM') {
@@ -2166,7 +2166,7 @@ test('runtime health reports active runs across workspaces', async (t) => {
 
   try {
     const health = await (await fetch(`http://127.0.0.1:${handle.port}/health`)).json();
-    assert.deepEqual(health.activeRuns, [{ workspace: 'juno', runId: 'run-1234abcd' }]);
+    assert.deepEqual(health.activeRuns, [{ workspace: 'demo', runId: 'run-1234abcd' }]);
   } finally {
     await handle.close();
   }

package/src/runtime/skillChain.e2e.test.js

@@ -142,7 +142,7 @@ test('E2E-002 wiki-sync: two objectives, two ordered runs, one chainId', async (
   assert.equal(body.objectives, 2);
   assert.equal(env.runs.length, 2, 'the second objective must run after the first');
   assert.match(env.runs[0].input, /^Export the requested Confluence source/);
-  assert.match(env.runs[1].input, /^Run the production pipeline over the newly exported Markdown/);
+  assert.match(env.runs[1].input, /^Run the production pipeline step ingest over the newly exported Markdown/);
   // CME first, Production second — and the parameter reaches the step that
   // consumes it, not only the last objective.
   for (const run of env.runs) assert.match(run.input, /User parameters:\nsource: docs/);
@@ -202,7 +202,7 @@ test('E2E-003 cancel: the running step and its chain stop, unrelated queue survi
 // that silently fragments would show up as extra runs, not as extra objectives.
 const PERFORMANCE_TABLE = {
   pipeline: 1,
-  'wiki-ingest': 2,
+  'wiki-ingest': 1,
   'wiki-build': 1,
   deliver: 1,
   diagnose: 1,

package/src/runtime/store.test.js

@@ -216,7 +216,10 @@ test('runtime store persists task assignments attempts and results from events',
   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}`));
+  const assignedLine = reopened.getState(session, { workspace: 'docs' }).logs.find((line) => /▸ Build A — started/.test(line));
+  assert.ok(assignedLine, 'expected a readable task-started line carrying the plan label');
+  assert.match(assignedLine, /document\.build/);
+  assert.match(assignedLine, /production-main/);
   assert.equal(reopened.listTaskAttempts({ taskId })[0].jobId, 'job-1');
   assert.equal(reopened.getTaskResult({ taskId }).status, 'succeeded');
   reopened.close();
@@ -1131,10 +1134,10 @@ test('un agent restauré par hydrateSession n’est plus routable tant qu’aucu
    premiers.
   */
   const store = openRuntimeStore({ stateDir: mkdtempSync(join(tmpdir(), 'wiki-manager-agent-staleness-')) });
-  const writer = { agentEvents: [], workspace: 'juno' };
+  const writer = { agentEvents: [], workspace: 'demo' };
   dispatchAgentEvent(writer, createAgentEvent('agent.registered', {
     origin: 'runtime',
-    workspace: 'juno',
+    workspace: 'demo',
     payload: {
       agent: {
         agentInstanceId: 'cme-main',
@@ -1152,8 +1155,8 @@ test('un agent restauré par hydrateSession n’est plus routable tant qu’aucu
   for (const event of writer.agentEvents) store.persistEvent(event);
 
   // Redémarrage : une session neuve, aucun scan encore effectué.
-  const rebooted = { agentEvents: [], workspace: 'juno' };
-  store.hydrateSession(rebooted, { workspace: 'juno' });
+  const rebooted = { agentEvents: [], workspace: 'demo' };
+  store.hydrateSession(rebooted, { workspace: 'demo' });
 
   const restored = [...(rebooted.agents ?? []), ...(rebooted.agentRegistrySnapshot ?? [])];
   assert.ok(restored.length > 0, 'the agent must be restored, only not trusted');

package/src/runtime/supervisor.js

@@ -1,11 +1,11 @@
 import { openSync, readSync, closeSync, fstatSync } from 'node:fs';
 import { isAbsolute, join, normalize, resolve } from 'node:path';
-import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
+import { createAgentEvent, dispatchAgentEvent, dispatchRuntimeLog } from '../core/agentEvents.js';
 import { extractActivity, mergePolledActivity, 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';
+import { discoverRuntimeProvidersOnce } from '../orchestrator/providers/runtimeProviders.js';
 
 export function startActivitySupervisor(session, {
   intervalMs = 1000,
@@ -52,11 +52,13 @@ export function startActivitySupervisor(session, {
         }
       }
       void discoverAgentsOnce(session, { registry, signal: runSignal });
+      void discoverRuntimeProvidersOnce(session, { signal: runSignal });
     }, agentRegistryIntervalMs)
     : null;
 
   void pollActivitiesOnce(session, { pollBusy, callTool, signal: runSignal });
   void discoverAgentsOnce(session, { registry, signal: runSignal });
+  void discoverRuntimeProvidersOnce(session, { signal: runSignal });
 
   return {
     pollBusy,
@@ -199,14 +201,7 @@ export async function pollActivitiesOnce(session, {
 }
 
 export function emitRuntimeLog(session, message) {
-  const payload = normalizeRuntimeLog(message, { session });
-  dispatchAgentEvent(session, createAgentEvent('runtime_log', {
-    origin: 'runtime',
-    runId: payload.runId ?? null,
-    taskId: payload.taskId ?? null,
-    workspace: payload.workspaceId ?? null,
-    payload,
-  }));
+  dispatchRuntimeLog(session, message);
 }
 
 function registryIntervalFromEnv() {

package/src/runtime/workspaceIsolation.test.js

@@ -34,39 +34,39 @@ test('a session stamps its workspace on every event it dispatches', () => {
   // ne le retrouverait jamais. La plan/activité d'un run serait perdue au
   // redémarrage, pour tout le monde.
   const store = freshStore();
-  const acpi = sessionFor(store, 'acpi');
+  const acmeSession = sessionFor(store, 'acme');
 
-  dispatchAgentEvent(acpi, createAgentEvent('user_message', {
+  dispatchAgentEvent(acmeSession, createAgentEvent('user_message', {
     origin: 'user',
     payload: { content: 'ingest démarré' },
   }));
 
-  const [event] = store.listEvents({ workspace: 'acpi' });
-  assert.equal(event.workspace, 'acpi', "l'événement doit porter son workspace");
+  const [event] = store.listEvents({ workspace: 'acme' });
+  assert.equal(event.workspace, 'acme', "l'événement doit porter son workspace");
 });
 
 test('two workspaces writing at the same time never see each other', () => {
   const store = freshStore();
-  const acpi = sessionFor(store, 'acpi');
+  const acmeSession = sessionFor(store, 'acme');
   const demo = sessionFor(store, 'demo');
 
   // Entrelacé volontairement : c'est la situation réelle de deux `serve`
   // ouverts côte à côte, pas deux runs successifs.
   for (let i = 0; i < 5; i += 1) {
-    dispatchAgentEvent(acpi, createAgentEvent('user_message', {
-      origin: 'user', payload: { content: `acpi-${i}` },
+    dispatchAgentEvent(acmeSession, createAgentEvent('user_message', {
+      origin: 'user', payload: { content: `acme-${i}` },
     }));
     dispatchAgentEvent(demo, createAgentEvent('user_message', {
       origin: 'user', payload: { content: `demo-${i}` },
     }));
   }
 
-  const acpiEvents = store.listEvents({ workspace: 'acpi' });
+  const acmeEvents = store.listEvents({ workspace: 'acme' });
   const demoEvents = store.listEvents({ workspace: 'demo' });
 
-  assert.equal(acpiEvents.length, 5);
+  assert.equal(acmeEvents.length, 5);
   assert.equal(demoEvents.length, 5);
-  assert.ok(acpiEvents.every((event) => event.payload.content.startsWith('acpi-')));
+  assert.ok(acmeEvents.every((event) => event.payload.content.startsWith('acme-')));
   assert.ok(demoEvents.every((event) => event.payload.content.startsWith('demo-')));
 });
 
@@ -74,32 +74,32 @@ test('a conversation is rebuilt from its own workspace only', () => {
   // C'est ce qui décide de ce qu'affiche un `serve` au chargement. Un mélange
   // ici afficherait les échanges du voisin dans sa fenêtre de chat.
   const store = freshStore();
-  const acpi = sessionFor(store, 'acpi');
+  const acmeSession = sessionFor(store, 'acme');
   const demo = sessionFor(store, 'demo');
 
-  dispatchAgentEvent(acpi, createAgentEvent('user_message', { origin: 'user', payload: { content: 'question acpi' } }));
+  dispatchAgentEvent(acmeSession, createAgentEvent('user_message', { origin: 'user', payload: { content: 'acme question' } }));
   dispatchAgentEvent(demo, createAgentEvent('user_message', { origin: 'user', payload: { content: 'question demo' } }));
-  dispatchAgentEvent(acpi, createAgentEvent('assistant_message', { origin: 'runtime', payload: { content: 'réponse acpi' } }));
+  dispatchAgentEvent(acmeSession, createAgentEvent('assistant_message', { origin: 'runtime', payload: { content: 'acme answer' } }));
 
-  const projection = reduceAgentEvents(store.listEvents({ workspace: 'acpi' }));
+  const projection = reduceAgentEvents(store.listEvents({ workspace: 'acme' }));
 
   assert.deepEqual(projection.conversation.map((entry) => entry.content), [
-    'question acpi',
-    'réponse acpi',
+    'acme question',
+    'acme answer',
   ]);
 });
 
 test('purging one workspace leaves the others intact', () => {
   // `/clear --all` depuis un `serve` ne doit pas vider le runtime du voisin.
   const store = freshStore();
-  const acpi = sessionFor(store, 'acpi');
+  const acmeSession = sessionFor(store, 'acme');
   const demo = sessionFor(store, 'demo');
-  dispatchAgentEvent(acpi, createAgentEvent('user_message', { origin: 'user', payload: { content: 'a' } }));
+  dispatchAgentEvent(acmeSession, createAgentEvent('user_message', { origin: 'user', payload: { content: 'a' } }));
   dispatchAgentEvent(demo, createAgentEvent('user_message', { origin: 'user', payload: { content: 'd' } }));
 
-  store.clearWorkspaceState({ workspace: 'acpi' });
+  store.clearWorkspaceState({ workspace: 'acme' });
 
-  assert.equal(store.listEvents({ workspace: 'acpi' }).length, 0);
+  assert.equal(store.listEvents({ workspace: 'acme' }).length, 0);
   assert.equal(store.listEvents({ workspace: 'demo' }).length, 1);
 });
 
@@ -119,12 +119,12 @@ test('a purge without a workspace wipes EVERY workspace', () => {
    où on décide de refuser plutôt que d'élargir, ce soit un choix explicite.
   */
   const store = freshStore();
-  dispatchAgentEvent(sessionFor(store, 'acpi'), createAgentEvent('user_message', { origin: 'user', payload: { content: 'a' } }));
+  dispatchAgentEvent(sessionFor(store, 'acme'), createAgentEvent('user_message', { origin: 'user', payload: { content: 'a' } }));
   dispatchAgentEvent(sessionFor(store, 'demo'), createAgentEvent('user_message', { origin: 'user', payload: { content: 'd' } }));
 
   store.clearWorkspaceState({ workspace: null });
 
-  assert.equal(store.listEvents({ workspace: 'acpi' }).length, 0);
+  assert.equal(store.listEvents({ workspace: 'acme' }).length, 0);
   assert.equal(store.listEvents({ workspace: 'demo' }).length, 0);
 });
 
@@ -135,11 +135,11 @@ test('the SSE publisher delivers an event only to its own workspace', () => {
   const deliver = (clientWorkspace, eventWorkspace) =>
     !(clientWorkspace && eventWorkspace !== clientWorkspace);
 
-  assert.equal(deliver('acpi', 'acpi'), true);
-  assert.equal(deliver('acpi', 'demo'), false, 'un client scopé ne doit rien recevoir du voisin');
-  assert.equal(deliver('acpi', null), false);
+  assert.equal(deliver('acme', 'acme'), true);
+  assert.equal(deliver('acme', 'demo'), false, 'un client scopé ne doit rien recevoir du voisin');
+  assert.equal(deliver('acme', null), false);
   // Le cas qui fuit : un abonné SANS workspace reçoit tout.
-  assert.equal(deliver(null, 'acpi'), true);
+  assert.equal(deliver(null, 'acme'), true);
   assert.equal(deliver(null, 'demo'), true);
 });
 

package/src/shell/RightPane.tsx

@@ -1,6 +1,6 @@
 /** @jsxImportSource @opentui/solid */
 import { createMemo, createSignal, Index, Show } from 'solid-js';
-import { compactRuntimeLogForDisplay, filterRuntimeLogs } from '../core/runtimeLog.js';
+import { compactRuntimeLogForDisplay, filterRuntimeLogs, isDispatchPlumbingLine } from '../core/runtimeLog.js';
 import { fit } from './textFit';
 
 type PlanStep = { step: number; description: string; status: string };
@@ -263,7 +263,11 @@ export function PlanPanel(props: { plan: PlanStep[]; width: number; jobName?: st
 
 export function ActivityPanel(props: { activities: any[]; width: number }) {
   const lineWidth = () => Math.max(8, props.width - 2);
-  const visible = () => props.activities.slice().reverse();
+  // session.activities is never pruned within a run (see core/agentEvents.js),
+  // so a long batch job's activity count is unbounded — render only the most
+  // recent slice, memoized like LogPanel's allLines, instead of copying and
+  // re-wrapping the entire lifetime history on every reactive tick.
+  const visible = createMemo(() => props.activities.slice(-200).reverse());
   return (
     <box flexGrow={1} flexDirection="column" paddingX={1} backgroundColor="#111318">
       <text width={lineWidth()} fg="#D6DEE8" content="Activity" />
@@ -340,6 +344,15 @@ type LogSegment = { text: string; fg: string };
 // Continuation lines of a wrapped entry are indented and dimmed so each
 // entry reads as one visual block instead of an undifferentiated wall.
 function logMessageColor(message: string): string {
+  // Task-lifecycle glyphs win outright: ✓ done (green), ✗ failed (red),
+  // ▸ started / ↻ retry keep the neutral/amber tone the keyword rules below
+  // would give them anyway.
+  if (/^\s*✓/.test(message)) return '#A6E3A1';
+  if (/^\s*✗/.test(message)) return '#F38BA8';
+  // A doctor summary with ZERO errors is a warning by construction
+  // ("⚠ 0 error(s), 2 warning(s)") — amber, never red, even though it
+  // mentions the word "error".
+  if (/(?<!\d)0 error\(s\)/i.test(message)) return '#FBBF24';
   if (/\b(?:trace:\s*)?WARN\b/i.test(message)) return '#FBBF24';
   if (/\b(error|failed|exception|unavailable|introuvable|HTTP 4\d\d|HTTP 5\d\d)\b/i.test(message)) return '#F38BA8';
   if (/\b(warn|warning|avertissement|fallback|retry|expired|stale)\b/i.test(message)) return '#FBBF24';
@@ -388,7 +401,14 @@ function logEntryLines(raw: string, width: number): LogSegment[][] {
 export function LogPanel(props: { logs: string[]; width: number; filter?: string }) {
   const [activeLogTab, setActiveLogTab] = createSignal<'flow' | 'agent-status'>('flow');
   const lineWidth = () => Math.max(8, props.width - 2);
-  const isAgentStatus = (line: string) => /agent[_ -]?status/i.test(line);
+  // "Agent status" collects the dispatch plumbing — capability resolution,
+  // agent selection, agent_execute/agent_status polling, job acceptance — so
+  // the "Runtime" tab is left with the readable business flow (plan + the
+  // ▸/✓/✗/↻ task lines). isDispatchPlumbingLine (shared with agentEvents'
+  // dedup) recognises the formatRuntimeLogPayload shape structurally; the old
+  // token enumeration only ever matched agent_status/agent_execute and missed
+  // every dotted event ('job.accepted' → 'ACCEPTED', …).
+  const isAgentStatus = (line: string) => isDispatchPlumbingLine(line);
   // Filtering preserves the runtime history order. logRenderLines performs
   // the single block-level reversal shared by both tabs.
   const filteredLogs = () => filterRuntimeLogs(props.logs, props.filter ?? '')

package/src/shell/StartupScreen.tsx

@@ -238,9 +238,36 @@ export function StartupScreen(props: {
   });
 
   const preflightChecks = createMemo(() => props.preflight?.checks ?? []);
+  const checkByKind = createMemo(() => {
+    const map = new Map<string, any>();
+    for (const check of preflightChecks()) map.set(check.kind, check);
+    return map;
+  });
+  // Docker and Internet leave the check list: they are ambient state, shown in
+  // the header (top right), not among the startup rows.
+  const dockerCheck = createMemo(() => checkByKind().get('docker'));
+  const internetCheck = createMemo(() => checkByKind().get('internet'));
+  const listChecks = createMemo(() => {
+    const order = ['workspace', 'runtime', 'agentic', 'agents', 'containers', 'mcp'];
+    const seen = new Set<string>(['docker', 'internet']);
+    const ordered: Array<{ kind: string; ok?: boolean; skipped?: boolean; pending?: boolean; detail?: string }> = [];
+    for (const kind of order) {
+      const check = checkByKind().get(kind);
+      if (!check) continue;
+      // An optional engine is not part of the startup story: when nothing is
+      // enabled, its row disappears instead of showing a misleading green ✓.
+      if (kind === 'agentic' && check.skipped) continue;
+      ordered.push(check);
+      seen.add(kind);
+    }
+    for (const check of preflightChecks()) {
+      if (!seen.has(check.kind)) ordered.push(check);
+    }
+    return ordered;
+  });
   const checkLabel = (kind: string) => ({
     docker: 'Docker', internet: 'Internet', agents: 'Agents', workspace: 'Workspaces',
-    containers: 'Containers', mcp: 'MCP', runtime: 'Runtime',
+    containers: 'Containers', mcp: 'MCP', agentic: 'Agentic runtime', runtime: 'Runtime',
   } as Record<string, string>)[kind] ?? kind;
 
   const subtitle = createMemo(() => {
@@ -281,10 +308,20 @@ export function StartupScreen(props: {
         overflow="hidden"
       >
         <box height={1} flexDirection="row">
-          <text fg="#8BD5CA" content={fit(`DONNA v${props.version}`, Math.floor(innerWidth() * 0.5))} />
-          <text fg={statusColor()} content={fit(` ${props.preflightBusy ? '◐' : statusDot(props.preflight?.status === 'ready')} ${status()}`, Math.floor(innerWidth() * 0.45))} />
+          <text fg="#8BD5CA" content={fit(`DONNA v${props.version}`, Math.floor(innerWidth() * 0.4))} />
+          <text fg={statusColor()} content={fit(` ${props.preflightBusy ? '◐' : statusDot(props.preflight?.status === 'ready')} ${status()}`, Math.floor(innerWidth() * 0.32))} />
+          <box flexGrow={1} />
+          <text fg="#7F8C8D" content={dockerCheck() ? fit(`Docker — ${dockerCheck()?.detail ?? '—'}`, Math.floor(innerWidth() * 0.28)) : ''} />
+        </box>
+        <box height={1} flexDirection="row">
+          <text height={1} fg="#7F8C8D" content={fit(subtitle(), Math.floor(innerWidth() * 0.6))} />
+          <box flexGrow={1} />
+          <text
+            height={1}
+            fg={internetCheck() ? (internetCheck()?.ok ? '#8BD5CA' : '#FBBF24') : '#7F8C8D'}
+            content={internetCheck() ? fit(`Internet — ${internetCheck()?.ok ? 'OK' : 'KO'}`, Math.floor(innerWidth() * 0.28)) : ''}
+          />
         </box>
-        <text height={1} fg="#7F8C8D" content={fit(subtitle(), innerWidth())} />
         <text height={1}>{''}</text>
         <box
           height={8}
@@ -295,7 +332,7 @@ export function StartupScreen(props: {
           overflow="hidden"
         >
           <text fg="#d6a85f">{DONNA_LOGO}</text>
-          <text fg="#888888">Intelligent workspace</text>
+          <text fg="#888888">Intelligent Agentic workspace(s)</text>
         </box>
         <text height={1}>{''}</text>
         <text height={1} fg="#7F8C8D" content={menuTitle()} />
@@ -320,8 +357,8 @@ export function StartupScreen(props: {
           </For>
         </box>
         <text height={1}>{''}</text>
-        <box height={Math.max(3, preflightChecks().length)} flexDirection="column" border={['left']} borderStyle="heavy" borderColor="#5DADE2" paddingX={1} overflow="hidden">
-          <For each={preflightChecks().length ? preflightChecks() : [
+        <box height={Math.max(3, listChecks().length)} flexDirection="column" border={['left']} borderStyle="heavy" borderColor="#5DADE2" paddingX={1} overflow="hidden">
+          <For each={listChecks().length ? listChecks() : [
             { kind: 'workspace', ok: props.wikiReady, detail: props.wikiReady ? 'default profile ready' : 'init required' },
             { kind: 'mcp', ok: props.connectedMcpServers > 0, detail: `${props.connectedMcpServers} server(s) configured` },
             { kind: 'llm', ok: Boolean(props.model), detail: props.model || 'not configured' },

package/src/shell/repl.js

@@ -3,19 +3,21 @@ import { createInterface } from 'node:readline';
 import { emitKeypressEvents } from 'node:readline';
 import { Transform } from 'node:stream';
 import { execFileSync } from 'node:child_process';
+import { statSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import path from 'node:path';
 import { stdin as input, stdout as output } from 'node:process';
 import { marked } from 'marked';
 import { markedTerminal } from 'marked-terminal';
 import { buildAgentSystemPrompt, formatLlmUnavailableMessage, isOrchestrationBypassTool } from '../agent/graph.js';
-import { handleSlashCommand, rawCommandAgentPrompt } from '../commands/slash.js';
+import { handleSlashCommand, rawCommandAgentPrompt, refreshMcpRuntimeStatus } from '../commands/slash.js';
 import { serviceChoices as composeServiceChoices, serviceDescription } from '../core/compose.js';
 import { extractActivity, mergePolledActivity, parseJsonText, sessionActivities } from '../core/activity.js';
 import { syncActivitiesToPlan } from '../core/plan.js';
 import { buildLlmTools, callMcpTool, formatMcpToolResult, parseToolCallName, resolveToolCallName } from '../core/mcp.js';
 import { runBoundedToolLoop } from '../core/toolLoop.js';
-import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
+import { createAgentEvent, dispatchAgentEvent, dispatchRuntimeLog } from '../core/agentEvents.js';
+import { managerMcpEndpointsFile } from '../core/env.js';
 import { togglableAgentNames } from '../core/agentsCompose.js';
 import { loadWorkspaceProfile } from '../core/profile.js';
 import { artifactFromToolCall, currentArtifactFor, currentArtifactPromptLine, rememberArtifact } from '../core/currentArtifact.js';
@@ -1922,6 +1924,25 @@ async function runTuiShell({ agent, packageJson, session, runtime = null }) {
     void subscribeRuntimeEvents();
   }
 
+  // Connectors added from the serve panel land in mcp.endpoints.json while the
+  // shell keeps running. Without a re-read, the new server stays invisible in
+  // /chat and /agent until a restart — the operator had to delete and re-add
+  // the connector and still saw nothing. Watch the file's mtime: a change
+  // refreshes MCP status and tools IN PLACE, no restart.
+  let endpointsMtimeMs = null;
+  const endpointsWatchInterval = setInterval(async () => {
+    if (runtimePollingActive) return;
+    try {
+      const mtime = statSync(managerMcpEndpointsFile()).mtimeMs;
+      if (endpointsMtimeMs === null) { endpointsMtimeMs = mtime; return; }
+      if (mtime === endpointsMtimeMs) return;
+      endpointsMtimeMs = mtime;
+      await refreshMcpRuntimeStatus(session);
+      dispatchRuntimeLog(session, 'mcp: endpoints file changed — connectors refreshed in place');
+      rerender();
+    } catch { /* file absent or mid-write: try again next tick */ }
+  }, 3000);
+
   const pollBusy = new Set();
   const productionPollInterval = setInterval(async () => {
     if (runtimePollingActive) return;
@@ -2259,6 +2280,7 @@ async function runTuiShell({ agent, packageJson, session, runtime = null }) {
     clearTimeout(runtimeReconnectTimer);
     clearTimeout(runtimeSyncTimer);
     clearInterval(productionPollInterval);
+    clearInterval(endpointsWatchInterval);
     clearTimeout(ctrlCTimer);
     clearTimeout(mouseSelectionTimer);
     output.off('resize', onResize);

package/src/shell/repl.test.js

@@ -173,6 +173,19 @@ test('Flow/Trace does not repeat the runtime source prefix on every line', async
   assert.match(entryRenderer, /prefix\.push\(\{ text: `\$\{parts\.time\} /);
 });
 
+test('a doctor summary with a nonzero error count is colored as an error, not a warning', async () => {
+  const source = await readFile(new URL('./RightPane.tsx', import.meta.url), 'utf8');
+  const colorFn = source.slice(
+    source.indexOf('function logMessageColor'),
+    source.indexOf('function logRenderLines'),
+  );
+  // The "0 error(s)" amber shortcut must be digit-anchored: "10 error(s)"
+  // ends in "0 error(s)" too, and an unanchored test painted a 10-error
+  // doctor failure the same colour as a clean run.
+  assert.match(colorFn, /\(\?<!\\d\)0 error\\\(s\\\)/);
+  assert.doesNotMatch(colorFn, /\/0 error\\\(s\\\)\/i\.test/);
+});
+
 test('runtime logs have a separator and a concise Runtime tab label', async () => {
   const source = await readFile(new URL('./RightPane.tsx', import.meta.url), 'utf8');
   const logPanel = source.slice(