@dotdrelle/wiki-manager 0.15.70 → 0.15.71

package/src/orchestrator/providers/runtimeProviders.js

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { dispatchRuntimeLog } from '../../core/agentEvents.js';
-import { managerStateDir } from '../../core/env.js';
+import { managerEnvFile, managerStateDir, readEnvFile } from '../../core/env.js';
 import { createDeepAgentsProvider } from './deepAgentsProvider.js';
 import { createFakeRuntimeProvider } from './fakeRuntimeProvider.js';
 import { assertRuntimeProvider } from './runtimeProvider.js';
@@ -65,7 +65,23 @@ export async function discoverRuntimeProviderAgents(runtimeProviders) {
  *
  * Entrée : `{ id, type, endpoint?, enabled?, capabilities?, limits? }`.
  */
-export function loadAgentRuntimesConfig({ stateDir = managerStateDir(), log = () => {}, env = process.env } = {}) {
+export function loadAgentRuntimesConfig({
+  stateDir = managerStateDir(),
+  log = () => {},
+  env = null,
+} = {}) {
+  // GATEWAY_ENABLED / GATEWAY_AUTH_TOKEN live in the manager .env FILE, not in
+  // the process environment (the runtime child is spawned without them). The
+  // manager's canonical policy is the same as resolvedManagerEnv: the file
+  // wins over stale process values, so a token generated later by `agents up`
+  // is honoured without a restart.
+  const resolvedEnv = env ?? (() => {
+    try {
+      return { ...process.env, ...readEnvFile(managerEnvFile()) };
+    } catch {
+      return process.env;
+    }
+  })();
   const file = join(stateDir, 'agent-runtimes.json');
   let entries = [];
   if (existsSync(file)) {
@@ -78,7 +94,7 @@ export function loadAgentRuntimesConfig({ stateDir = managerStateDir(), log = ()
       log(`agent-runtimes.json unreadable: ${error instanceof Error ? error.message : String(error)}`);
     }
   }
-  return withImpliedGateway(entries, env, log);
+  return withImpliedGateway(entries, resolvedEnv, log);
 }
 
 // One switch: when the operator starts the gateway container
@@ -90,6 +106,25 @@ export function loadAgentRuntimesConfig({ stateDir = managerStateDir(), log = ()
 // case worth stating, not assuming: an operator who wrote `enabled: false`
 // deliberately would otherwise have no way to learn why deepagents ran anyway.
 function withImpliedGateway(entries, env = process.env, log = () => {}) {
+  const token = String(env.GATEWAY_AUTH_TOKEN ?? '').trim();
+  const gatewayPort = String(env.GATEWAY_PORT ?? '7789');
+  if (isTruthy(env.GATEWAY_ENABLED) && token) {
+    // The manager owns THIS gateway (host-local, GATEWAY_PORT): its bearer
+    // token must reach the EXPLICIT entry too. The scaffolded
+    // agent-runtimes.json declares the capabilities but no headers, so
+    // discovery probed /health without the token and the gateway answered 401
+    // forever — "enabled by default" plus "explicit entry" must not combine
+    // into a permanently unavailable runtime. An operator who pinned explicit
+    // headers keeps them; a `deepagents` entry pointing at a foreign or shared
+    // host gets NOTHING — the local gateway secret must never leave the box.
+    for (const entry of entries) {
+      if (entry?.type !== 'deepagents' || entry?.enabled === false) continue;
+      if (!isManagerOwnedGatewayEndpoint(entry.endpoint, gatewayPort)) continue;
+      const headers = entry.headers && typeof entry.headers === 'object' ? entry.headers : {};
+      if ('Authorization' in headers || 'authorization' in headers) continue;
+      entry.headers = { ...headers, Authorization: `Bearer ${token}` };
+    }
+  }
   if (!isTruthy(env.GATEWAY_ENABLED)) return entries;
   const explicitEnabled = entries.some((entry) =>
     entry?.type === 'deepagents' && entry?.enabled !== false);
@@ -98,8 +133,7 @@ function withImpliedGateway(entries, env = process.env, log = () => {}) {
   if (disabledEntry) {
     log('agent-runtimes: GATEWAY_ENABLED=true implies a "deepagents" runtime despite an explicit enabled:false entry in agent-runtimes.json');
   }
-  const port = String(env.GATEWAY_PORT ?? '7789');
-  const token = String(env.GATEWAY_AUTH_TOKEN ?? '').trim();
+  const port = gatewayPort;
   // The implied entry inherits the disabled entry's declared capability shape
   // (approval classes, alias operations, descriptions): the scaffolded
   // agent-runtimes.json ships the full list with enabled:false, and dropping it
@@ -133,6 +167,25 @@ function isTruthy(value) {
   return /^(1|true|yes|on)$/i.test(String(value ?? '').trim());
 }
 
+// The manager-owned gateway is the one the manager itself starts: host-local,
+// on GATEWAY_PORT. An entry with no endpoint relies on the implied host-local
+// one, so it counts too. Anything else — a shared or third-party gateway host
+// an operator pointed a second `deepagents` entry at — must not be handed the
+// manager's local GATEWAY_AUTH_TOKEN.
+function isManagerOwnedGatewayEndpoint(endpoint, gatewayPort) {
+  if (!endpoint) return true;
+  let url;
+  try {
+    url = new URL(String(endpoint));
+  } catch {
+    return false;
+  }
+  const localHosts = new Set(['localhost', '127.0.0.1', '::1', '[::1]', 'host.docker.internal']);
+  if (!localHosts.has(url.hostname)) return false;
+  const entryPort = url.port || (url.protocol === 'https:' ? '443' : '80');
+  return entryPort === String(gatewayPort);
+}
+
 /**
  * Usines de providers par `type`. `fake` sert les tests/plomberie ; `deepagents`
  * parle HTTP à un runtime externe (Phase 5). Un type inconnu est ignoré et

package/src/orchestrator/providers/runtimeProviders.test.js

@@ -194,6 +194,29 @@ test('GATEWAY_ENABLED implies the deepagents runtime with the bearer token (one
   }
 });
 
+test('the local gateway bearer is injected only into the manager-owned host-local entry', () => {
+  const dir = mkdtempSync(join(tmpdir(), 'agent-runtimes-'));
+  try {
+    writeFileSync(join(dir, 'agent-runtimes.json'), JSON.stringify({
+      runtimes: [
+        { id: 'local', type: 'deepagents', endpoint: 'http://127.0.0.1:7789', enabled: true },
+        { id: 'shared', type: 'deepagents', endpoint: 'https://gateway.partner.example', enabled: true },
+        { id: 'otherport', type: 'deepagents', endpoint: 'http://localhost:9999', enabled: true },
+      ],
+    }));
+    const config = loadAgentRuntimesConfig({
+      stateDir: dir,
+      env: { GATEWAY_ENABLED: 'true', GATEWAY_PORT: '7789', GATEWAY_AUTH_TOKEN: 'tok-local' },
+    });
+    const byId = Object.fromEntries(config.map((entry) => [entry.id, entry]));
+    assert.deepEqual(byId.local.headers, { Authorization: 'Bearer tok-local' });
+    assert.equal(byId.shared.headers, undefined, 'a foreign gateway host must never receive the local token');
+    assert.equal(byId.otherport.headers, undefined, 'a non-gateway port is not the manager-owned gateway');
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
 test('an explicit enabled deepagents entry wins over the implied one', () => {
   const dir = mkdtempSync(join(tmpdir(), 'agent-runtimes-'));
   try {

package/src/orchestrator/scheduler.test.js

@@ -246,7 +246,7 @@ function task(id, overrides = {}) {
 }
 
 /*
-  Cas observé le 2026-08-22 (workspace acpi) : `/wiki-ingest` planifie 13
+  Cas observé le 2026-08-22 (workspace acme) : `/wiki-ingest` planifie 13
   ingest_plan (groupe `ingest`) + 13 ingest_apply (groupe `apply`, sérialisés
   sur le lock `workspace-write`, derrière la barrière `ingest`) + 1 taxonomy
   (barrière `apply`). Le grant run-scope émis par le bouton Approve est « nu » :
@@ -260,7 +260,7 @@ function task(id, overrides = {}) {
 test('un grant run-scope « nu » (sans classes ni révision) débloque les apply derrière une barrière', () => {
   const plan = {
     runId: 'run-1',
-    workspace: 'acpi',
+    workspace: 'acme',
     planRevision: 1,
     tasks: [
       // 13 ingest_plan du groupe ingest, tous done.
@@ -307,7 +307,7 @@ test('un grant run-scope « nu » (sans classes ni révision) débloque les appl
       status: 'approved',
       scope: 'run',
       runId: 'run-1',
-      workspaceId: 'acpi',
+      workspaceId: 'acme',
       planRevision: null,
       approvalClasses: [],
     }],
@@ -322,7 +322,7 @@ test('un grant run-scope « nu » (sans classes ni révision) débloque les appl
 });
 
 /*
- Cas observé le 2026-08-04 (workspace juno) : une ingestion de dix fichiers,
+ Cas observé le 2026-08-04 (workspace demo) : une ingestion de dix fichiers,
  neuf réussis, le dixième en échec sur du JSON malformé. La barrière de groupe
  exigeait que TOUS les membres soient `done` : elle ne s'est jamais ouverte, le
  planificateur n'a plus trouvé de tâche prête, et le run est resté `running`

package/src/runtime/delegation.test.js

@@ -47,11 +47,11 @@ function preparedDelegation(taskId) {
 
 function runningSession(runId = 'run-conversational') {
   return {
-    workspace: 'juno',
+    workspace: 'demo',
     activities: {},
     agentEvents: [],
     headlessPlan: null,
-    _currentRunIdentity: { runId, workspace: 'juno' },
+    _currentRunIdentity: { runId, workspace: 'demo' },
   };
 }
 
@@ -98,9 +98,9 @@ test('une demande de build délègue dans le run courant, sans en démarrer un s
   const session = runningSession('run-fr-build');
   const started = [];
 
-  const result = await delegateWithinRun(session, 'construis les livrables du workspace juno', {
+  const result = await delegateWithinRun(session, 'build the deliverables of the demo workspace', {
     prepare: async ({ objective }) => {
-      assert.match(objective, /construis les livrables/);
+      assert.match(objective, /build the deliverables/);
       return preparedDelegation('build-fr');
     },
     registry: registryDouble(),
@@ -118,10 +118,10 @@ test('une demande de build délègue dans le run courant, sans en démarrer un s
 test('la délégation interne exige un run actif', async () => {
   // Hors run, il n'y a pas d'exécution à transformer : c'est un vrai démarrage
   // de run, et il doit passer par le chemin normal plutôt que par ici.
-  const session = { workspace: 'juno', agentEvents: [] };
+  const session = { workspace: 'demo', agentEvents: [] };
 
   await assert.rejects(
-    () => delegateWithinRun(session, 'construis les livrables', {
+    () => delegateWithinRun(session, 'build the deliverables', {
       prepare: async () => preparedDelegation(),
       registry: registryDouble(),
     }),
@@ -184,12 +184,12 @@ test('une demande française délègue une fois et bascule, sans jamais duplique
   const { runRuntimeAgenticWorkflow } = await import('./runner.js');
   const runId = 'run-fr-integration';
   const session = {
-    workspace: 'juno',
+    workspace: 'demo',
     activities: {},
     agentEvents: [],
     headlessPlan: null,
     // Posée par executeRun avant l'appel au workflow, comme en production.
-    _currentRunIdentity: { runId, workspace: 'juno' },
+    _currentRunIdentity: { runId, workspace: 'demo' },
     llm: { async completeWithTools() { assert.fail('aucune évaluation ne doit avoir lieu ici'); } },
   };
   const fiveTasks = {
@@ -205,7 +205,7 @@ test('une demande française délègue une fois et bascule, sans jamais duplique
     async invoke({ session: turnSession }) {
       conversationalTurns += 1;
       // Le tour conversationnel appelle l'outil de délégation, comme Donna.
-      const result = await delegateWithinRun(turnSession, 'construis les livrables du workspace juno', {
+      const result = await delegateWithinRun(turnSession, 'build the deliverables of the demo workspace', {
         prepare: async () => {
           delegations += 1;
           return { ...preparedDelegation(), fragment: fiveTasks };
@@ -242,7 +242,7 @@ test('une demande française délègue une fois et bascule, sans jamais duplique
   // Borne l'attente d'approbation comme en headless : un test ne doit jamais
   // pouvoir se figer sur une décision humaine qui ne viendra pas.
   session._approvalTimeoutMs = 200;
-  await runRuntimeAgenticWorkflow(agent, session, 'construis les livrables du workspace juno', {
+  await runRuntimeAgenticWorkflow(agent, session, 'build the deliverables of the demo workspace', {
     runId,
     timeoutMs: 2000,
     maxTurns: 4,
@@ -272,7 +272,7 @@ test('un run qui porte déjà un plan validé refuse une seconde délégation',
   session.headlessPlan = [task('build-a')];
 
   await assert.rejects(
-    () => delegateWithinRun(session, 'construis les livrables', {
+    () => delegateWithinRun(session, 'build the deliverables', {
       prepare: async () => preparedDelegation(),
       registry: registryDouble(),
     }),

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/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/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 };
@@ -344,6 +344,11 @@ 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".
@@ -396,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/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/wiki-workspace

@@ -343,6 +343,24 @@ agents_compose() {
       if [[ -n "$CACERT_PATH" ]]; then
         up_args+=(--force-recreate)
       fi
+      # Same lifecycle as the 7788 runtime: an agentic gateway already serving
+      # on the port is REUSED — a container started over it cannot bind, and
+      # the whole `up` would fail. Reuse applies only when the serving process
+      # is EXTERNAL to this compose project (a native runner): if the compose
+      # gateway container is the one running, the normal `up` leaves it alone.
+      # Only an EXPLICIT `agents up gateway` asks for the container; then a
+      # bind conflict is the honest answer.
+      local gateway_scale=()
+      local requested_list="${only_services[*]:-}"
+      local gateway_container_running=false
+      if _agents_dc ps --format '{{.Service}}' 2>/dev/null | grep -qx 'gateway'; then
+        gateway_container_running=true
+      fi
+      if gateway_enabled && ! $gateway_container_running && ! [[ " $requested_list " == *" gateway "* ]] && gateway_serving; then
+        printf 'Agentic gateway: already serving on :%s — reusing the existing runner (no container started).\n' "${GATEWAY_PORT:-7789}"
+        gateway_scale=(--scale gateway=0)
+      fi
+      up_args+=(${gateway_scale[@]+"${gateway_scale[@]}"})
       up_args+=(${only_services[@]+"${only_services[@]}"})
       _agents_dc "${up_args[@]}"
       printf 'Workspaces root: %s\n' "$workspaces_root"
@@ -574,6 +592,22 @@ gateway_enabled() {
   esac
 }
 
+# Same lifecycle discipline as the 7788 runtime: an agentic gateway ALREADY
+# serving on the port is REUSED, never shadowed by a container that cannot
+# bind. A native `node bin/wiki-agentic-gateway.js` answers without auth
+# (dev); a token-configured gateway (the container, or a native one with
+# GATEWAY_AUTH_TOKEN) answers only to the Bearer — probe both.
+gateway_serving() {
+  local port="${GATEWAY_PORT:-7789}"
+  local token url
+  url="http://localhost:${port}/health"
+  token="$(env_value "$MANAGER_ENV_FILE" GATEWAY_AUTH_TOKEN "")"
+  if [[ -n "$token" ]]; then
+    curl -fsS -m 3 -H "Authorization: Bearer $token" "$url" >/dev/null 2>&1 && return 0
+  fi
+  curl -fsS -m 3 "$url" >/dev/null 2>&1
+}
+
 ensure_endpoints_file() {
   # Without mcp.endpoints.json the shell never connects to the agents it
   # just started (and `agents status` refuses to run). Seed it from the