@dotdrelle/wiki-manager 0.15.49 → 0.15.50

package/README.md

@@ -637,9 +637,15 @@ with `"replans": 1` in the `/run` body.
 Runtime approvals are bounded to a run, plan revision and approval class.
 Mutating orchestrated tasks **wait for approval by default**, including tasks
 created by a skill or a directly selected capability such as ingest or
-pipeline. Approve them by replying "valide tout", running `/approve`, or
-clicking Approve in either UI (Shell right-pane banner, or the `serve` banner
-above the composer). `POST /approve` also accepts an explicit run scope.
+pipeline. Approve them by running `/approve`, or clicking Approve in either UI:
+the Shell right-pane banner, or the `serve` banner.
+
+In `serve` that banner is a **fixed overlay, visible in every centre view**. It
+used to sit inside the composer, which the layout hides in the wiki, connectors
+and execution views — so a restore launched from `/history` waited on an
+approval nobody could see, and the Execution view, the one meant for monitoring,
+could not show it either. The Shell never had that gap because its plan pane is
+always on screen. `POST /approve` also accepts an explicit run scope.
 
 An explicitly launched skill is also approval-gated. For an orchestrated skill,
 the scheduler blocks each uncovered mutating task; for a `direct` skill, the
@@ -907,10 +913,35 @@ The shared `docker-compose.yml` starts one workspace stack:
 Use `wiki-workspace` whenever possible so Compose receives the right project
 name, env file, ports, and volume mounts.
 
+`PRODUCTION_ALLOWED_STEPS` gates what `production-mcp` will accept, and an
+omission from it is **silent**: `agent_plan` simply leaves the step's task out of
+the fragment instead of failing. `taxonomy` was missing from the shipped default
+for several releases, so every compose-deployed ingest ran without the taxonomy
+barrier and left the published map stale. Keep the variable in step with the
+in-code default of `production_mcp_server.py`: a test here asserts `taxonomy` is
+present, and one in `agent-wiki-production` compares the whole list against that
+in-code reference. Remember that an explicit value in your `.env` overrides the
+default entirely.
+
 Runtime split: the host manager/runtime uses Node.js 22+ for `node:sqlite`; the
 interactive OpenTUI shell uses Bun 1.2+; workspace Docker services run from the
 published images and do not depend on host `node_modules`.
 
+Two consequences worth knowing before debugging anything:
+
+- **The runtime is not a container.** `runtime/lifecycle.js` spawns it locally,
+  detached, from the manager sources — no Compose file declares it. Changing
+  runtime or shell code therefore needs a **restart**, never an image rebuild;
+  changing `llm-wiki` or an agent needs the image rebuilt.
+- **The runtime starts before the workspace containers.** Its first agent
+  discovery legitimately finds them absent. `agentRegistry` keeps a known
+  agent's capabilities when a probe fails — it only refreshes `lastSeenAt`, and
+  says so in the runtime log — and the periodic re-scan re-probes the MCP
+  endpoints instead of reusing a cached status. Without both, a capability the
+  agent really has stayed missing from the registry until the next successful
+  discovery, and the only symptom was a run failing much later with
+  `No agent provides capability …`.
+
 As of 0.11.4, the host runtime store carries a minimal format guard:
 `PRAGMA user_version = 1` in SQLite plus `.wiki/meta.json` with
 `schemaVersion: 1`. Unknown future versions stop startup with a clear error.

package/docker-compose.yml

@@ -124,7 +124,13 @@ services:
       - WORKSPACE_NAME=${WORKSPACE_NAME:-workspace}
       - WIKI_WORKSPACE_PATH=/workspace
       - WIKI_CONFIG_PATH=${WIKI_CONFIG_PATH:-}
-      - PRODUCTION_ALLOWED_STEPS=${PRODUCTION_ALLOWED_STEPS:-doctor,ingest,ingest_plan,ingest_apply,build,export,polish,restore,pipeline}
+      # `taxonomy` belongs here, and its absence is SILENT: agent_plan drops the
+      # taxonomy task from an ingest fragment when the step is not allowed
+      # (production_mcp_server.py, "taxonomy" in _ALLOWED_STEPS), without an
+      # error. Every compose-deployed ingest then ran without the Lot 4 barrier
+      # and left the published map stale — the very defect that work fixed.
+      # `copy` stays out on purpose: it is the legacy step, opt-in only.
+      - PRODUCTION_ALLOWED_STEPS=${PRODUCTION_ALLOWED_STEPS:-doctor,ingest,ingest_plan,ingest_apply,taxonomy,build,export,polish,restore,pipeline}
       - PRODUCTION_REQUIRE_CONFIRMATION=${PRODUCTION_REQUIRE_CONFIRMATION:-false}
       # Parallelism levers — effective concurrency ≈ recommendedConcurrency.
       # Intermediate defaults (4/8). Low profile 2/4, high profile 8/16.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotdrelle/wiki-manager",
-  "version": "0.15.49",
+  "version": "0.15.50",
   "description": "Agentic shell and orchestration cockpit for llm-wiki workspaces.",
   "license": "PolyForm-Noncommercial-1.0.0",
   "author": "dotrelle",

package/src/agent/graph.js

@@ -26,7 +26,7 @@ import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
 import { enqueueProductionJob, ensureJobQueue, formatQueue, productionLockBusy } from '../core/jobQueue.js';
 import { loadWorkspaceProfile, updateWorkspaceProfilePreference } from '../core/profile.js';
 import { capabilityRegistryForSession } from '../orchestrator/capabilityRegistry.js';
-import { fetchRuntimeState, postRuntimeApprove, postRuntimeCancel, postRuntimeControl, postRuntimeDelegate, postRuntimeKill, postRuntimeSkill } from '../runtime/client.js';
+import { fetchRuntimeState, postRuntimeCancel, postRuntimeControl, postRuntimeDelegate, postRuntimeKill, postRuntimeSkill } from '../runtime/client.js';
 import { controlLanguage } from '../runtime/controlMessages.js';
 
 const MAX_TOOL_ITERATIONS = 80;
@@ -46,7 +46,7 @@ const MAX_SPINNER_ARG_LENGTH = 96;
 const INTERNAL_TOOL_SERVERS = {
   wiki: ['plan_set', 'plan_done'],
   shell: ['run_command', 'read_command', 'profile_update'],
-  runtime: ['kill', 'cancel', 'status', 'approve', 'enqueue', 'delegate', 'run_skill'],
+  runtime: ['kill', 'cancel', 'status', 'enqueue', 'delegate', 'run_skill'],
 };
 
 const AGENT_SLASH_COMMANDS = new Set([
@@ -164,15 +164,6 @@ const RUNTIME_STATUS_TOOL = {
   },
 };
 
-const RUNTIME_APPROVE_TOOL = {
-  type: 'function',
-  function: {
-    name: 'runtime__approve',
-    description: 'Grant the pending approval of the active runtime run (mutating tasks wait on it). Use when the user consents in ANY phrasing: "vas-y", "ok pour l\'export", "approuve", "valide". Confirm what was approved.',
-    parameters: { type: 'object', additionalProperties: false, properties: {} },
-  },
-};
-
 const RUNTIME_ENQUEUE_TOOL = {
   type: 'function',
   function: {
@@ -364,7 +355,6 @@ function toolDefinitionForCall(session, callName) {
     RUNTIME_STATUS_TOOL,
     RUNTIME_CANCEL_TOOL,
     RUNTIME_KILL_TOOL,
-    RUNTIME_APPROVE_TOOL,
     RUNTIME_ENQUEUE_TOOL,
     RUNTIME_DELEGATE_TOOL,
     RUNTIME_RUN_SKILL_TOOL,
@@ -852,28 +842,6 @@ export async function handleRuntimeControlTool(session, tool, args = {}) {
       const result = await postRuntimeCancel({ url, workspace });
       return result.cancelled ? 'Runtime run cancellation requested.' : `No active run to cancel${result.reason ? ` (${result.reason})` : ''}.`;
     }
-    if (tool === 'approve') {
-      const state = await fetchRuntimeState({ url, workspace });
-      const pending = (Array.isArray(state?.approvals) ? state.approvals : [])
-        .filter((approval) => approval.status === 'pending_approval');
-      const runId = state?.runId
-        ?? state?.runs?.find((run) => ['running', 'pending_approval'].includes(run.status))?.id
-        ?? null;
-      if (!runId || pending.length === 0) return 'No pending approval found.';
-      const approvalClasses = [...new Set(pending.flatMap((approval) => {
-        const value = approval.approvalClasses ?? approval.approvalClass ?? [];
-        return Array.isArray(value) ? value : [value];
-      }).map(String).filter(Boolean))];
-      const result = await postRuntimeApprove({
-        url,
-        workspace,
-        runId,
-        scope: 'run',
-        planRevision: state?.planRevision ?? null,
-        approvalClasses: approvalClasses.length > 0 ? approvalClasses : ['default'],
-      });
-      return result?.approved ? 'Current validated plan approved.' : 'No pending approval found.';
-    }
     if (tool === 'delegate') {
       const objective = String(args.objective ?? '').trim();
       if (!objective) return 'Delegation rejected: missing objective.';
@@ -1250,7 +1218,7 @@ export function buildAgentSystemPrompt(state) {
     workspaceProfile
       ? `Workspace profile (.wiki/profile.md) — durable user preferences, apply these to every reply (tone, tutoiement/vouvoiement, formatting, etc.):\n${workspaceProfile}`
       : null,
-    'Runtime control: you have runtime__status, runtime__cancel, runtime__kill, runtime__approve and runtime__enqueue. When the user asks to stop, remove, clean or kill the current run, its jobs or the queue ("supprime le job et la queue", "arr\u00eate tout"), call runtime__kill (or runtime__cancel for a soft stop of just the run) and confirm what was stopped. When the user explicitly asks to delete, reset, abandon or replace the current plan, call runtime__kill with purge=true; never set purge=true for a simple stop. For questions about what is running or queued, call runtime__status and answer from its data. When the user consents to a pending approval in any phrasing ("vas-y", "ok pour l\'export"), call runtime__approve. When the user asks for a NEW action while a run is active, do not execute it: propose runtime__enqueue (run it after) or, if they insist it replaces the current work, runtime__kill then the new action.',
+    'Runtime control: you have runtime__status, runtime__cancel, runtime__kill and runtime__enqueue. When the user asks to stop, remove, clean or kill the current run, its jobs or the queue ("supprime le job et la queue", "arr\u00eate tout"), call runtime__kill (or runtime__cancel for a soft stop of just the run) and confirm what was stopped. When the user explicitly asks to delete, reset, abandon or replace the current plan, call runtime__kill with purge=true; never set purge=true for a simple stop. For questions about what is running or queued, call runtime__status and answer from its data. You have no approval tool: a pending approval is granted only by the user through the approval button or the /approve command. Never grant, claim or report an approval yourself; when the user asks to proceed with pending mutations, tell them to use those controls. When the user asks for a NEW action while a run is active, do not execute it: propose runtime__enqueue (run it after) or, if they insist it replaces the current work, runtime__kill then the new action.',
     'When the user asks to refresh, show, or update the displayed plan or status, call runtime__status. This is a state refresh request, not a new business capability, and must never be delegated.',
     'Report every runtime control outcome exactly as the tool returned it \u2014 never embellish. If runtime__kill reports 0 run(s)/0 task(s)/0 purged, say there was nothing active to stop or purge; do NOT claim a run, plan, pending approval or queue item was removed. If runtime__status returns an error or could not be read, say the runtime state could not be retrieved and do not describe a state you never obtained. Never assert that something was cleaned, cancelled, approved or purged unless that specific tool result confirms it.',
     'Durable profile updates are actions in this stabilized version: delegate them instead of writing directly.',
@@ -1285,7 +1253,7 @@ export function formatLlmUnavailableMessage(reason) {
 
 function toolsForClassification(classification, writeTools, session = null) {
   const controlTools = session?.runtime?.url
-    ? [RUNTIME_STATUS_TOOL, RUNTIME_CANCEL_TOOL, RUNTIME_KILL_TOOL, RUNTIME_APPROVE_TOOL, RUNTIME_ENQUEUE_TOOL]
+    ? [RUNTIME_STATUS_TOOL, RUNTIME_CANCEL_TOOL, RUNTIME_KILL_TOOL, RUNTIME_ENQUEUE_TOOL]
     : [];
   // Provider discovery and validation belong to the runtime. Hiding
   // delegation while the shell snapshot is temporarily empty forced Donna

package/src/agent/graph.test.js

@@ -782,67 +782,25 @@ test('runtime status does not manufacture a plan', async () => {
   }
 });
 
-test('one Donna approval grants the complete validated run revision', async () => {
-  const originalFetch = globalThis.fetch;
-  const requests = [];
-  globalThis.fetch = async (url, options = {}) => {
-    requests.push({ url: String(url), method: options.method ?? 'GET', body: options.body ? JSON.parse(options.body) : null });
-    if ((options.method ?? 'GET') === 'GET') {
-      return {
-        ok: true,
-        status: 200,
-        json: async () => ({
-          running: true,
-          runId: 'run-approval',
-          planRevision: 3,
-          approvals: [
-            { status: 'pending_approval', approvalClasses: ['workspace'] },
-            { status: 'pending_approval', approvalClasses: ['workspace'] },
-          ],
-        }),
-      };
-    }
-    return { ok: true, status: 202, json: async () => ({ approved: true, runId: 'run-approval' }) };
-  };
-  let calls = 0;
+test('Donna has no self-approval tool during an active run', async () => {
+  // Donna must never grant her own pending approval (the recurring "spontaneous
+  // approval" regression). Approval is the user's action, expressed through the
+  // banner button or /approve — never through an LLM tool call.
+  let seenTools = [];
   const session = sessionBase({
     runtime: { url: 'http://runtime.test' },
     agentProjection: { status: 'running', conversation: [], activities: [] },
     llm: {
-      async completeWithTools() {
-        calls += 1;
-        if (calls === 1) {
-          return {
-            content: null,
-            message: { role: 'assistant', content: null },
-            tool_calls: [{
-              id: 'approve-run',
-              type: 'function',
-              function: { name: 'runtime__approve', arguments: '{}' },
-            }],
-          };
-        }
-        return { content: 'Plan approuvé.', message: { role: 'assistant', content: 'Plan approuvé.' }, tool_calls: null };
+      async completeWithTools({ tools }) {
+        seenTools = tools.map((tool) => tool.function.name);
+        return { content: 'ok', message: { role: 'assistant', content: 'ok' }, tool_calls: null };
       },
     },
   });
 
-  try {
-    const result = await createAgentGraph().invoke({ input: 'oui', session });
-    assert.equal(result.response, 'Plan approuvé.');
-    const approval = requests.find((request) => request.url.includes('/approve'));
-    assert.deepEqual(approval.body, {
-      workspace: 'docs',
-      runId: 'run-approval',
-      itemId: null,
-      approvalId: null,
-      scope: 'run',
-      planRevision: 3,
-      approvalClasses: ['workspace'],
-    });
-  } finally {
-    globalThis.fetch = originalFetch;
-  }
+  await createAgentGraph().invoke({ input: 'oui', session });
+  assert.ok(seenTools.includes('runtime__status'), 'control tools still bound during an active run');
+  assert.ok(!seenTools.includes('runtime__approve'), 'no runtime__approve tool for Donna');
 });
 
 test('agent graph binds the full toolset for a "remember my preference" request, not just read-only tools', async () => {
@@ -1773,7 +1731,7 @@ test('agent graph lets Donna handle ambiguous input during a run with the contro
   assert.match(result.response, /mettre en file/);
   assert.ok(seenTools.includes('runtime__enqueue'));
   assert.ok(seenTools.includes('runtime__status'));
-  assert.ok(seenTools.includes('runtime__approve'));
+  assert.ok(!seenTools.includes('runtime__approve'), 'no self-approval tool for Donna');
   assert.ok(!seenTools.includes('production__production_start_job'), 'no write MCP tools during an active run for ambiguous intents');
 });
 

package/src/cli/wiki-manager.js

@@ -567,6 +567,7 @@ async function waitForRuntimeRun(session, log, { timeoutMs, pollMs = 1500, autoA
             scope: 'run',
             planRevision,
             approvalClasses: approvalClasses.length > 0 ? approvalClasses : ['default'],
+            caller: 'headless-auto-approve',
           });
           const line = `runtime-wait: auto-approved run ${currentRun.id} (revision ${planRevision})${result?.approved ? '' : ' [no pending approval matched]'}`;
           log.push(line); console.log(line);
@@ -845,6 +846,7 @@ export async function waitForRuntimeChain(session, log, {
             scope: 'run',
             planRevision,
             approvalClasses: approvalClasses.length > 0 ? approvalClasses : ['default'],
+            caller: 'chain-wait-auto-approve',
           });
           const line = `chain-wait: auto-approved run ${active.runId} (revision ${planRevision})`;
           log.push(line); console.log(line);
@@ -978,11 +980,12 @@ async function runRuntime(argv, agent) {
           payload: { message: `runtime: expired ${staleControl.length} stale queued control request(s) from a previous session` },
         }));
       }
-      session._onRuntimeError = (err) => {
+      session._onRuntimeError = (err, runId = null) => {
         const message = err instanceof Error ? err.message : String(err);
         dispatchAgentEvent(session, createAgentEvent('run_error', {
           origin: 'runtime',
-          payload: { message, workspace },
+          ...(runId ? { runId } : {}),
+          payload: { message, workspace, ...(runId ? { runId } : {}) },
         }));
       };
       context.approvalManager = createApprovalManager(session, {
@@ -991,7 +994,9 @@ async function runRuntime(argv, agent) {
           : undefined,
       });
       session._requestApproval = (request) => context.approvalManager.requestApproval(request);
-      context.supervisor = startActivitySupervisor(session);
+      context.supervisor = startActivitySupervisor(session, {
+        refreshMcp: () => refreshMcpRuntimeStatus(session),
+      });
       contexts.set(key, context);
       if (workspace && workspace !== key) contexts.set(workspace, context);
       return context;
@@ -1422,7 +1427,26 @@ async function runRuntime(argv, agent) {
         const provider = agents.find((item) => (item.description?.capabilities ?? [])
           .some((capability) => capability.id === body.capabilityPlan.capability));
         if (!provider?.serverName) {
-          throw new Error(`No agent provides capability ${body.capabilityPlan.capability}.`);
+          /*
+           Say what WAS seen, not only what was missing.
+
+           "No agent provides capability X." leaves three very different causes
+           indistinguishable: no agent registered at all, the right agent
+           registered but advertising a narrower set (an operation excluded by
+           PRODUCTION_ALLOWED_STEPS drops its whole capability from
+           agent_describe, silently), or a name mismatch. Listing the registry
+           turns the next occurrence into its own diagnosis instead of a guess.
+          */
+          const seen = agents.map((item) => {
+            const ids = (item.description?.capabilities ?? []).map((capability) => capability.id);
+            return `${item.serverName ?? '?'}[${ids.join(', ') || 'none'}]`;
+          });
+          throw new Error(
+            `No agent provides capability ${body.capabilityPlan.capability}. `
+            + (seen.length
+              ? `Registered agents: ${seen.join('; ')}.`
+              : 'No agent is registered: none answered agent_describe.'),
+          );
         }
         const fragment = parseJsonText(formatMcpToolResult(await callMcpTool(session.mcp, provider.serverName, 'agent_plan', {
           capability: body.capabilityPlan.capability,

package/src/commands/slash.js

@@ -1402,7 +1402,7 @@ export async function handleSlashCommand(line, context) {
           },
         });
         if (result?.runId) {
-          return { output: `▶ Run de capability accepté (${String(result.runId).slice(0, 8)}) — le plan de l'agent sera intégré et dispatché en parallèle ; approbation demandée avant les mutations (« valide tout » ou /approve).` };
+          return { output: `▶ Run de capability accepté (${String(result.runId).slice(0, 8)}) — le plan de l'agent sera intégré et dispatché en parallèle ; approbation demandée avant les mutations (/approve).` };
         }
         return { output: `Run non démarré: ${result?.explanation ?? result?.error ?? JSON.stringify(result)}` };
       }

package/src/core/agentEvents.js

@@ -561,7 +561,18 @@ function applyEvent(state, event) {
       return;
     case 'run_error':
       state.status = 'error';
-      state.logs.push(String(event.payload?.message ?? 'Agent run failed.'));
+      /*
+       "Run failed:" is part of the line, not decoration.
+
+       The serve journal keeps only the entries matching a keyword list
+       (failed, error, done, approval…). A run killed by a message that uses
+       none of those words — "No agent provides capability workspace.restore."
+       — was therefore filtered out as unimportant, and the panel showed "No
+       essential run event yet" over a run that had just died with its reason
+       already in hand. What ends a run is essential by construction; the
+       prefix states that instead of hoping the wording says so.
+      */
+      state.logs.push(`Run failed: ${String(event.payload?.message ?? 'Agent run failed.')}`);
       // A dead run must not leave "pending" plan steps and spinning
       // activities in the persisted projection: they reappeared as ghosts
       // at every relaunch ("des trucs dans le plan qui n'existent pas") and

package/src/core/agentEvents.test.js

@@ -675,3 +675,24 @@ test('a stream resumed after a discard carries only the final text', () => {
   assert.equal(projection.conversation[1].content, '12 pages.');
   assert.equal(projection.conversation[1].streaming, undefined, 'le message doit être figé');
 });
+
+test('run_error names the failure so the essential journal cannot filter it out', () => {
+  // La liste de mots-clés du journal serve (failed, error, done, approval…)
+  // rejetait un message qui n'en contient aucun — « No agent provides
+  // capability workspace.restore. » — et le panneau affichait « No essential
+  // run event yet » au-dessus d'un run mort avec sa raison déjà connue.
+  const state = reduceAgentEvents([
+    createAgentEvent('run_error', {
+      origin: 'runtime',
+      runId: 'run-1',
+      payload: { message: 'No agent provides capability workspace.restore.' },
+    }),
+  ]);
+
+  assert.equal(state.status, 'error');
+  const line = state.logs.at(-1);
+  assert.match(line, /^Run failed: /);
+  assert.match(line, /workspace\.restore/);
+  // Le mot qui rend l'entrée « essentielle » pour le journal serve.
+  assert.match(line, /failed/i);
+});

package/src/core/buildInfo.json

@@ -1,4 +1,4 @@
 {
-  "version": "0.15.49",
-  "commit": "a0da71c"
+  "version": "0.15.50",
+  "commit": "844cf7e"
 }

package/src/core/dockerCompose.test.js

@@ -27,6 +27,24 @@ test('workspace production agent enables restore by default', async () => {
   assert.match(String(allowed), /(?:^|,)restore(?:,|})/);
 });
 
+test('every shipped default allows the taxonomy step', async () => {
+  /*
+   L'absence de `taxonomy` est SILENCIEUSE.
+
+   `agent_plan` retire la tâche taxonomique du fragment d'ingestion quand
+   l'étape n'est pas autorisée (`"taxonomy" in _ALLOWED_STEPS`), sans erreur ni
+   avertissement. Un déploiement par compose ingérait donc sans jamais publier
+   de taxonomie, et la carte restait périmée — exactement le défaut que le Lot 4
+   avait corrigé côté moteur. Le défaut de Python porte `taxonomy` ; un compose
+   POSITIONNE toujours la variable, donc ce défaut ne s'applique jamais là.
+  */
+  const raw = await readFile(new URL('../../docker-compose.yml', import.meta.url), 'utf8');
+  const compose = YAML.parse(raw);
+  const allowed = compose.services['production-mcp'].environment
+    .find((entry) => String(entry).startsWith('PRODUCTION_ALLOWED_STEPS='));
+  assert.match(String(allowed), /(?:^|,)taxonomy(?:,|})/);
+});
+
 test('shipped compose files never carry a build context', async () => {
   // Ces deux fichiers partent dans le paquet npm, où les dépôts frères
   // (`../agent-external/…`) n'existent pas : un `build:` y rend toute commande

package/src/core/mcp.js

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { managerEnvFile, managerMcpEndpointsFile, readEnvFile } from './env.js';
 
-const WIKI_MANAGER_VERSION = '0.15.49';
+const WIKI_MANAGER_VERSION = '0.15.50';
 
 function envValue(key) {
   const filePath = managerEnvFile();

package/src/orchestrator/.fuse_hidden0000001c00000001

@@ -0,0 +1,316 @@
+import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
+import { callMcpTool, formatMcpToolResult } from '../core/mcp.js';
+import { normalizeRuntimeLog } from '../core/runtimeLog.js';
+import { assertContract } from '../contracts/schemas.js';
+
+const AVAILABLE = 'available';
+const UNAVAILABLE = 'unavailable';
+/**
+ * Santé d'un agent restauré depuis le journal, tant qu'aucun `agent_describe`
+ * n'a réussi dans le processus courant.
+ *
+ * Ni `available` ni `unavailable` : on ne SAIT pas. Le distinguer de
+ * `unavailable` a une conséquence pratique — un agent inconnu redevient
+ * disponible en silence dès le premier scan réussi, là où un agent déclaré
+ * indisponible mériterait d'être signalé comme tel à l'utilisateur.
+ */
+const UNKNOWN = 'unknown';
+
+/**
+ * Un agent persisté n'est pas un agent joignable.
+ *
+ * Au redémarrage, `hydrateSession` rejoue le journal d'événements et
+ * reconstruit les agents avec la santé qu'ils avaient AU MOMENT où l'événement
+ * a été écrit. `cme-main` réapparaissait donc `available` alors que son
+ * endpoint n'existe plus, était retenu comme fournisseur, et la tâche partait
+ * vers un agent absent — la panne observée le 2026-08-04.
+ *
+ * La persistance dit ce qui a existé, pas ce qui répond maintenant. Seul un
+ * `agent_describe` réussi dans ce processus autorise à parler de disponibilité.
+ */
+export function markPersistedAgentsStale(session) {
+  if (!session || typeof session !== 'object') return [];
+  const stale = (agent) => ({
+    ...agent,
+    health: UNKNOWN,
+    stale: true,
+    // La santé d'origine est conservée : elle raconte ce qu'on savait avant
+    // l'arrêt, ce qui aide à lire un journal, sans jamais servir au routage.
+    healthBeforeRestart: agent?.health ?? null,
+  });
+  /*
+   TOUTES les représentations restaurées, `agentRegistrySnapshot` compris.
+
+   J'avais d'abord épargné le snapshot, au motif qu'il pouvait porter un scan
+   vivant. C'était une inversion : à l'hydratation, aucun scan n'a encore eu
+   lieu — l'ordre est hydrate → invalidate → discover, et rien ne s'exécute
+   entre les deux premiers. Le snapshot vient donc de la même projection
+   persistée que `session.agents`. L'épargner laissait `cme-main` routable avec
+   son endpoint éteint, ce que la validation à chaud a montré.
+
+   Le seul scan qui compte est celui qui suivra : `discover()` réécrit le
+   snapshot en entier à partir des `agent_describe` réussis.
+  */
+  session.agents = (session.agents ?? []).map(stale);
+  session.agentRegistrySnapshot = (session.agentRegistrySnapshot ?? []).map(stale);
+  return session.agentRegistrySnapshot;
+}
+
+export function createAgentRegistry({
+  callTool = callMcpTool,
+  now = () => new Date(),
+} = {}) {
+  const agentsByInstance = new Map();
+  const instanceByServer = new Map();
+
+  return {
+    async discover(session, { signal = null } = {}) {
+      const discovered = [];
+      const endpoints = Object.entries(session?.mcp ?? {});
+      const activeServers = new Set(endpoints.map(([serverName]) => serverName));
+      for (const [serverName, endpoint] of endpoints) {
+        const agent = await discoverServerAgent(session, serverName, endpoint, { callTool, signal, now });
+        discovered.push(registerAgent(session, agent, { agentsByInstance, instanceByServer }));
+      }
+      for (const [serverName, instanceId] of instanceByServer) {
+        if (activeServers.has(serverName)) continue;
+        const previous = agentsByInstance.get(instanceId);
+        instanceByServer.delete(serverName);
+        agentsByInstance.delete(instanceId);
+        if (previous) dispatchRegistryEvent(session, 'agent.unregistered', {
+          agentInstanceId: instanceId,
+          serverName,
+        });
+      }
+      session.agentRegistry = this;
+      session.agentRegistrySnapshot = this.snapshot();
+      return discovered;
+    },
+    snapshot() {
+      return [...agentsByInstance.values()]
+        .map((agent) => cloneAgent(agent))
+        .sort((a, b) => a.agentInstanceId.localeCompare(b.agentInstanceId));
+    },
+    get(agentInstanceId) {
+      const agent = agentsByInstance.get(String(agentInstanceId));
+      return agent ? cloneAgent(agent) : null;
+    },
+  };
+}
+
+async function discoverServerAgent(session, serverName, endpoint = {}, { callTool, signal, now }) {
+  const lastSeenAt = now().toISOString();
+  if (endpoint.status !== 'connected') {
+    return legacyAgent(serverName, endpoint, { health: UNAVAILABLE, lastSeenAt });
+  }
+
+  const tool = findAgentDescribeTool(serverName, endpoint.tools ?? []);
+  if (!tool) {
+    return legacyAgent(serverName, endpoint, { health: AVAILABLE, lastSeenAt });
+  }
+  const toolName = tool.name;
+
+  try {
+    const result = await callTool(
+      session.mcp,
+      serverName,
+      toolName,
+      describeArguments(tool, session?.workspace),
+      signal,
+    );
+    const description = assertContract('agentDescription', parseToolJsonResult(result));
+    return {
+      serverName,
+      toolName,
+      agentInstanceId: description.agentInstanceId,
+      description,
+      health: description.health?.status ?? AVAILABLE,
+      firstSeenAt: lastSeenAt,
+      lastSeenAt,
+      legacy: false,
+      orchestrable: true,
+    };
+  } catch (error) {
+    return legacyAgent(serverName, endpoint, {
+      health: UNAVAILABLE,
+      lastSeenAt,
+      toolName,
+      error: error instanceof Error ? error.message : String(error),
+    });
+  }
+}
+
+function registerAgent(session, agent, { agentsByInstance, instanceByServer }) {
+  const previousInstanceId = instanceByServer.get(agent.serverName);
+  const previous = previousInstanceId ? agentsByInstance.get(previousInstanceId) : null;
+
+  /*
+   A failed discovery must not erase a known orchestrator agent.
+
+   When the endpoint is transiently unreachable — the runtime boots before its
+   containers (the normal boot order), or a single probe times out —
+   `discoverServerAgent` falls back to a legacy agent with no capabilities. The
+   old code replaced the orchestrator agent with that fallback, so every
+   capability silently vanished from the registry and did not come back until a
+   LATER successful discovery. Keep the orchestrator agent and only refresh its
+   probe timestamp: its capabilities are still real, only the endpoint is down.
+  */
+  if (agent.legacy && previous && !previous.legacy) {
+    agentsByInstance.set(previous.agentInstanceId, { ...previous, lastSeenAt: agent.lastSeenAt });
+    /*
+     Preserving is right; preserving in silence is what caused the hunt.
+
+     Every defect this registry produced was invisible: capabilities vanished
+     without an event, and the resolver could only report the consequence ("no
+     agent provides X") long afterwards. Keeping the agent fixes the loss, not
+     the blindness — a probe that failed is a fact worth stating, once, where
+     the panels and the shell already read.
+
+     Deliberately NOT a health change: the endpoint is down but the agent stays
+     usable by design here, and moving `health` would make `capabilityResolver`
+     refuse it — trading a silent loss for a silent refusal.
+    */
+    dispatchRuntimeLog(session, `agent-registry: ${agent.serverName} did not answer agent_describe`
+      + `${agent.error ? ` (${agent.error})` : ''}; keeping its known capabilities`
+      + ` (${(previous.description?.capabilities ?? []).map((capability) => capability.id).join(', ') || 'none'}).`);
+    return cloneAgent(previous);
+  }
+
+  const firstSeenAt = previous?.firstSeenAt ?? agent.firstSeenAt ?? agent.lastSeenAt;
+  const next = {
+    ...agent,
+    firstSeenAt,
+  };
+
+  if (previous && previous.agentInstanceId !== next.agentInstanceId) {
+    agentsByInstance.delete(previous.agentInstanceId);
+  }
+  agentsByInstance.set(next.agentInstanceId, next);
+  instanceByServer.set(next.serverName, next.agentInstanceId);
+
+  if (!previous || previous.agentInstanceId !== next.agentInstanceId) {
+    dispatchRegistryEvent(session, 'agent.registered', { agent: next });
+  } else if (previous.health !== next.health) {
+    dispatchRegistryEvent(session, 'agent.health_changed', {
+      agent: next,
+      agentInstanceId: next.agentInstanceId,
+      previousHealth: previous.health,
+      health: next.health,
+    });
+  }
+  return cloneAgent(next);
+}
+
+/**
+ * Runtime log line, emitted without importing the supervisor.
+ *
+ * `emitRuntimeLog` lives in `runtime/supervisor.js`, which already imports THIS
+ * module: importing it back would close a cycle for one log line. The event
+ * shape is the contract, not the helper, so we build it from the same
+ * normalizer the supervisor uses.
+ */
+function dispatchRuntimeLog(session, message) {
+  if (!session) return;
+  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,
+  }));
+}
+
+function dispatchRegistryEvent(session, type, payload) {
+  if (!session) return;
+  dispatchAgentEvent(session, createAgentEvent(type, {
+    origin: 'agent_registry',
+    workspace: session.workspace ?? null,
+    payload,
+  }));
+}
+
+function findAgentDescribeTool(serverName, tools) {
+  const named = tools.filter((tool) => String(tool?.name ?? ''));
+  const byName = (predicate) => named.find((tool) => predicate(String(tool.name)));
+  return byName((name) => name === 'agent_describe')
+    ?? byName((name) => name === `${serverName}__agent_describe`)
+    ?? byName((name) => name.endsWith('__agent_describe'))
+    ?? null;
+}
+
+// Parts of a contract are workspace-scoped — typically the closed vocabulary of
+// an argument (the sources declared in THIS workspace). Published as a bare
+// string, such a field is unverifiable and a planner fills it with any noun
+// from the objective, so it is worth telling the agent which workspace we are
+// asking about.
+//
+// But the orchestrator must not assume an agent accepts an argument it never
+// declared: an agent whose agent_describe schema is `additionalProperties:
+// false` REJECTS the call, drops out of the registry, and its capabilities
+// silently vanish — the objective then resolves to whatever agent is left.
+// Send the workspace only to agents whose own schema says they can take it.
+function describeArguments(tool, workspace) {
+  if (!workspace) return {};
+  const schema = tool?.inputSchema;
+  if (!schema || typeof schema !== 'object') return {};
+  const declaresWorkspace = Object.hasOwn(schema.properties ?? {}, 'workspace');
+  const acceptsExtra = schema.additionalProperties !== false;
+  return declaresWorkspace || acceptsExtra ? { workspace: String(workspace) } : {};
+}
+
+function parseToolJsonResult(result) {
+  if (result && typeof result === 'object' && !Array.isArray(result) && !Array.isArray(result.content)) {
+    return result;
+  }
+  const text = formatMcpToolResult(result);
+  return JSON.parse(text);
+}
+
+function legacyAgent(serverName, endpoint = {}, { health, lastSeenAt, toolName = null, error = null }) {
+  const displayName = endpoint.displayName ?? serverName;
+  const description = {
+    contractVersion: 'legacy',
+    agentType: serverName,
+    agentInstanceId: `${serverName}-legacy`,
+    displayName,
+    capabilities: [],
+    orchestration: {
+      canPlan: false,
+      canExpandPlan: false,
+      canExecute: false,
+      canCancel: false,
+      canResume: false,
+      supportsIdempotency: false,
+      supportsParallelWorkers: false,
+    },
+    limits: {
+      recommendedConcurrency: 0,
+      maxConcurrency: 0,
+    },
+    health: { status: health },
+  };
+  return {
+    serverName,
+    toolName,
+    agentInstanceId: description.agentInstanceId,
+    description,
+    health,
+    firstSeenAt: lastSeenAt,
+    lastSeenAt,
+    legacy: true,
+    orchestrable: false,
+    error,
+  };
+}
+
+function cloneAgent(agent) {
+  return {
+    ...agent,
+    description: cloneJson(agent.description),
+  };
+}
+
+function cloneJson(value) {
+  return value == null ? value : JSON.parse(JSON.stringify(value));
+}

package/src/orchestrator/agentRegistry.js

@@ -1,5 +1,6 @@
 import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
 import { callMcpTool, formatMcpToolResult } from '../core/mcp.js';
+import { normalizeRuntimeLog } from '../core/runtimeLog.js';
 import { assertContract } from '../contracts/schemas.js';
 
 const AVAILABLE = 'available';
@@ -142,6 +143,39 @@ async function discoverServerAgent(session, serverName, endpoint = {}, { callToo
 function registerAgent(session, agent, { agentsByInstance, instanceByServer }) {
   const previousInstanceId = instanceByServer.get(agent.serverName);
   const previous = previousInstanceId ? agentsByInstance.get(previousInstanceId) : null;
+
+  /*
+   A failed discovery must not erase a known orchestrator agent.
+
+   When the endpoint is transiently unreachable — the runtime boots before its
+   containers (the normal boot order), or a single probe times out —
+   `discoverServerAgent` falls back to a legacy agent with no capabilities. The
+   old code replaced the orchestrator agent with that fallback, so every
+   capability silently vanished from the registry and did not come back until a
+   LATER successful discovery. Keep the orchestrator agent and only refresh its
+   probe timestamp: its capabilities are still real, only the endpoint is down.
+  */
+  if (agent.legacy && previous && !previous.legacy) {
+    agentsByInstance.set(previous.agentInstanceId, { ...previous, lastSeenAt: agent.lastSeenAt });
+    /*
+     Preserving is right; preserving in silence is what caused the hunt.
+
+     Every defect this registry produced was invisible: capabilities vanished
+     without an event, and the resolver could only report the consequence ("no
+     agent provides X") long afterwards. Keeping the agent fixes the loss, not
+     the blindness — a probe that failed is a fact worth stating, once, where
+     the panels and the shell already read.
+
+     Deliberately NOT a health change: the endpoint is down but the agent stays
+     usable by design here, and moving `health` would make `capabilityResolver`
+     refuse it — trading a silent loss for a silent refusal.
+    */
+    dispatchRuntimeLog(session, `agent-registry: ${agent.serverName} did not answer agent_describe`
+      + `${agent.error ? ` (${agent.error})` : ''}; keeping its known capabilities`
+      + ` (${(previous.description?.capabilities ?? []).map((capability) => capability.id).join(', ') || 'none'}).`);
+    return cloneAgent(previous);
+  }
+
   const firstSeenAt = previous?.firstSeenAt ?? agent.firstSeenAt ?? agent.lastSeenAt;
   const next = {
     ...agent,
@@ -167,6 +201,26 @@ function registerAgent(session, agent, { agentsByInstance, instanceByServer }) {
   return cloneAgent(next);
 }
 
+/**
+ * Runtime log line, emitted without importing the supervisor.
+ *
+ * `emitRuntimeLog` lives in `runtime/supervisor.js`, which already imports THIS
+ * module: importing it back would close a cycle for one log line. The event
+ * shape is the contract, not the helper, so we build it from the same
+ * normalizer the supervisor uses.
+ */
+function dispatchRuntimeLog(session, message) {
+  if (!session) return;
+  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,
+  }));
+}
+
 function dispatchRegistryEvent(session, type, payload) {
   if (!session) return;
   dispatchAgentEvent(session, createAgentEvent(type, {

package/src/orchestrator/agentRegistry.test.js

@@ -134,6 +134,81 @@ test('agentRegistry marks unavailable boot agents and emits health changes on re
   assert.equal(registry.snapshot()[0].health, 'available');
 });
 
+test('a failed re-discovery keeps the orchestrator agent, never erases its capabilities', async () => {
+  /*
+   Boot order: the runtime starts before its containers. The first scan sees the
+   production endpoint "unavailable" and would register a legacy placeholder —
+   and the old code replaced the orchestrator agent with it, silently dropping
+   every capability until a LATER successful discovery. The agent must survive a
+   transient probe failure, because its capabilities did not change.
+  */
+  const events = [];
+  const session = {
+    workspace: 'acpi',
+    mcp: {
+      production: { status: 'connected', tools: [{ name: 'agent_describe' }] },
+    },
+    _onAgentEvent: (event) => events.push(event),
+  };
+  const registry = createAgentRegistry({
+    callTool: async () => ({ content: [{ type: 'text', text: JSON.stringify(description()) }] }),
+  });
+
+  await registry.discover(session);
+  assert.equal(registry.snapshot()[0].agentInstanceId, 'production-main');
+
+  // The endpoint goes down: discovery now falls back to a legacy placeholder.
+  session.mcp.production.status = 'unavailable';
+  await registry.discover(session);
+
+  const [agent] = registry.snapshot();
+  assert.equal(agent.agentInstanceId, 'production-main');
+  assert.equal(agent.legacy, false);
+  assert.equal(agent.description.capabilities.length, 1);
+  // And it is still routable: the capability was not erased.
+  const capability = createCapabilityRegistry({ agents: registry.snapshot() });
+  assert.equal(capability.providersFor('knowledge.update').length, 1);
+
+  /*
+   Preserving must not be silent.
+
+   Every defect this registry produced was invisible, and that is what turned a
+   boot-order race into a debugging session: the capability vanished with no
+   event, and the only report came much later, from the resolver, as "no agent
+   provides X". A probe that failed is a fact, and it belongs where the shell
+   and the panels already read.
+  */
+  const kept = events.find((event) => event.type === 'runtime_log'
+    && String(event.payload?.message ?? '').includes('agent-registry:'));
+  assert.ok(kept, 'a preserved agent must leave a runtime log');
+  assert.match(String(kept.payload.message), /did not answer agent_describe/);
+  assert.match(String(kept.payload.message), /knowledge\.update/);
+});
+
+test('a failed re-discovery keeps a degraded orchestrator agent too', async () => {
+  // Same protection, but when the agent was discovered healthy then the probe
+  // throws (endpoint "connected" but agent_describe fails mid-flight).
+  const session = {
+    mcp: { production: { status: 'connected', tools: [{ name: 'agent_describe' }] } },
+  };
+  let fail = false;
+  const registry = createAgentRegistry({
+    callTool: async () => {
+      if (fail) throw new Error('agent_describe timeout');
+      return { content: [{ type: 'text', text: JSON.stringify(description()) }] };
+    },
+  });
+
+  await registry.discover(session);
+  fail = true;
+  await registry.discover(session);
+
+  const [agent] = registry.snapshot();
+  assert.equal(agent.agentInstanceId, 'production-main');
+  assert.equal(agent.legacy, false);
+  assert.equal(agent.description.capabilities.length, 1);
+});
+
 test('discovery sends the workspace only to agents whose schema declares it', async () => {
   const seen = {};
   const registry = createAgentRegistry({

package/src/runtime/client.js

@@ -261,6 +261,7 @@ export async function postRuntimeApprove({
   scope = null,
   planRevision = null,
   approvalClasses = null,
+  caller = null,
 } = {}) {
   const endpoint = runtimeEndpoint(url, '/approve', workspace);
   const parsed = new URL(endpoint);
@@ -278,6 +279,7 @@ export async function postRuntimeApprove({
       scope,
       planRevision,
       approvalClasses,
+      caller,
     }),
   });
   if (!response.ok) throw new Error(`Runtime approve failed: HTTP ${response.status}`);

package/src/runtime/delegation.js

@@ -94,7 +94,7 @@ export function integratePreparedDelegation({
     session,
     approval.approved
       ? `approval: run ${runId} auto-approved (autoApprove opt-in)`
-      : `approval: run ${runId} awaiting explicit approval before mutations (/approve or « valide tout »)`,
+      : `approval: run ${runId} awaiting explicit approval before mutations (/approve)`,
   );
   return { integrated, approval };
 }

package/src/runtime/runner.js

@@ -407,8 +407,8 @@ export async function runRuntimeParallelPlan(agent, session, input, {
   sanitizeSessionPlanForExecution(session, runId);
   ensurePlanProjection(session, runId);
   emitRuntimeLog(session, `scheduler: parallel plan enabled (concurrency ${limit}; agent=${concurrencyDetail.agentLimit ?? 'n/a'}, ceiling=${concurrencyDetail.ceiling ?? 'none'}${concurrencyDetail.cappedByCeiling ? ' → capped by manager ceiling' : ''})`);
-  // Interactive approvals do NOT expire: the user has /approve, "valide
-  // tout", /cancel and /run kill — an arbitrary timer only created mystery
+  // Interactive approvals do NOT expire: the user has /approve, /cancel and
+  // /run kill — an arbitrary timer only created mystery
   // failures. A deadline exists only when explicitly configured (headless
   // runs, CI) via the session or the env escape hatch.
   const configuredApprovalWait = Number(session._approvalTimeoutMs) > 0
@@ -572,7 +572,7 @@ export async function runRuntimeParallelPlan(agent, session, input, {
                   `⏸ Approbation requise avant exécution : ${newlyRequested.length} tâche(s) mutante(s) en attente.`,
                   ...newlyRequested.slice(0, 5).map((step) => `  - ${step.description ?? step.id}`),
                   newlyRequested.length > 5 ? `  … et ${newlyRequested.length - 5} autre(s).` : null,
-                  'Réponds « valide tout » (ou tape /approve) pour lancer, « annule » pour abandonner.',
+                  'Tape /approve (ou clique sur « Approuver ») pour lancer, « annule » pour abandonner.',
                 ].filter(Boolean).join('\n'),
               },
             }));

package/src/runtime/server.js

@@ -642,6 +642,7 @@ export function startRuntimeServer({
           groupId: url.searchParams.get('groupId') ?? body.groupId ?? null,
           planRevision: readOptionalNumber(url.searchParams.get('planRevision') ?? body.planRevision),
           approvalClasses: readOptionalList(body.approvalClasses ?? body.approvalClass ?? url.searchParams.get('approvalClass')),
+          caller: body.caller ?? url.searchParams.get('caller') ?? null,
         });
         sendJson(response, result?.approved ? 202 : 404, result ?? { approved: false });
         return;
@@ -805,7 +806,10 @@ export function startRuntimeServer({
     runPromise
       .catch((err) => {
         rejectReady?.(err);
-        context.session?._onRuntimeError?.(err);
+        // The runId travels with the failure: without it `finishControlByRun`
+        // had nothing to match, so a queued restore stayed "pending" forever
+        // while the run that carried it was already dead.
+        context.session?._onRuntimeError?.(err, runId);
       })
       .finally(() => {
         context.running = false;
@@ -1371,9 +1375,6 @@ function classifyControlMessage(input, status, forcedIntent = null) {
   if (explicit) {
     return { kind: explicit, confidence: 1, reason: 'explicit_intent' };
   }
-  if (/\b(valide tout|approve all|approve|approuve|valid[eé]|ok pour tout|go pour tout)\b/i.test(lower)) {
-    return { kind: 'approve', confidence: 0.86, reason: 'approval_request' };
-  }
   if (/\b(cancel|annule|stop|arr[eê]te|interromps|abort)\b/i.test(lower)) {
     return { kind: 'cancel', confidence: 0.86, reason: 'cancel_request' };
   }

package/src/runtime/server.test.js

@@ -1082,6 +1082,7 @@ test('runtime server exposes approval endpoint', async (t) => {
       groupId: null,
       planRevision: null,
       approvalClasses: [],
+      caller: null,
     });
     assert.deepEqual(await response.json(), { approved: true, runId: 'run-1', itemId: 'item-1' });
   } finally {
@@ -1307,11 +1308,21 @@ test('runtime server control message handles approve and cancel intents during a
     const approveResponse = await fetch(`http://127.0.0.1:${handle.port}/control?workspace=acme`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ action: 'message', input: 'valide tout' }),
+      body: JSON.stringify({ action: 'message', input: 'valide tout', intent: 'approve' }),
     });
     assert.equal(approveResponse.status, 200);
     assert.equal((await approveResponse.json()).kind, 'approve');
 
+    // Free-text approval phrasing is NOT honored anymore: approval is an
+    // explicit /approve (or the approval button), never a keyword match.
+    const freeTextResponse = await fetch(`http://127.0.0.1:${handle.port}/control?workspace=acme`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ action: 'message', input: 'valide tout' }),
+    });
+    assert.equal(freeTextResponse.status, 200);
+    assert.notEqual((await freeTextResponse.json()).kind, 'approve');
+
     const cancelResponse = await fetch(`http://127.0.0.1:${handle.port}/control?workspace=acme`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },

package/src/runtime/supervisor.js

@@ -13,6 +13,7 @@ export function startActivitySupervisor(session, {
   agentRegistryIntervalMs = registryIntervalFromEnv(),
   agentRegistry = null,
   callTool = callMcpTool,
+  refreshMcp = null,
 } = {}) {
   const pollBusy = new Set();
   let stopped = false;
@@ -32,8 +33,24 @@ export function startActivitySupervisor(session, {
     }
   }, queueIntervalMs);
 
+  /*
+   The re-scan must probe the endpoints again, not trust a stale status.
+
+   The first discovery ran while the containers were still coming up, so the
+   production endpoint was marked "not connected" and its agent fell back to a
+   legacy placeholder. Re-scanning against that cached status kept the fallback
+   forever. `refreshMcp` re-resolves the endpoint states (and their tools)
+   before each discovery, so a container that came up is actually discovered.
+  */
   const agentRegistryTimer = agentRegistryIntervalMs > 0
-    ? setInterval(() => {
+    ? setInterval(async () => {
+      if (refreshMcp) {
+        try {
+          await refreshMcp(session);
+        } catch {
+          /* the discovery below still runs on the cached status */
+        }
+      }
       void discoverAgentsOnce(session, { registry, signal: runSignal });
     }, agentRegistryIntervalMs)
     : null;

package/src/runtime/supervisor.test.js

@@ -246,6 +246,49 @@ test('startActivitySupervisor periodically re-scans the agent registry', async (
   }
 });
 
+test('startActivitySupervisor refreshes MCP before each periodic re-scan', async () => {
+  /*
+   Without the refresh, the re-scan re-reads a cached "not connected" endpoint
+   status and keeps a legacy placeholder forever, so an agent whose container
+   came up after boot is never discovered. The refresh probes the endpoints
+   again before the scan.
+  */
+  const session = {
+    mcp: {},
+    activities: {},
+    headlessPlan: null,
+    jobQueue: [],
+  };
+  let refreshes = 0;
+  let discoveries = 0;
+  const registry = {
+    async discover() {
+      discoveries += 1;
+      return [];
+    },
+    snapshot() {
+      return [];
+    },
+  };
+
+  const supervisor = startActivitySupervisor(session, {
+    intervalMs: 1000,
+    queueIntervalMs: 1000,
+    agentRegistryIntervalMs: 10,
+    agentRegistry: registry,
+    refreshMcp: async () => {
+      refreshes += 1;
+    },
+  });
+
+  try {
+    await waitFor(() => refreshes >= 2);
+    assert.ok(discoveries >= 2);
+  } finally {
+    supervisor.stop();
+  }
+});
+
 test('discoverAgentsOnce uses the session registry and returns discovered agents', async () => {
   const expected = [{ agentInstanceId: 'a' }];
   const registry = {

package/src/shell/LeftPane.tsx

@@ -822,14 +822,17 @@ export function LeftPane(props: {
   const showWelcome = () => props.showWelcome && props.messages.length === 0;
   return (
     <box width={props.width} height="100%" flexDirection="column" padding={1} overflow="hidden">
-      <box height={3} flexDirection="column">
+      {/*
+        The header keeps what changes the MEANING of what is typed — the mode,
+        and the transient hint. Workspace, version and connection states moved
+        to the foot of the pane: they are an ambient state one glances at, not
+        something read before every message, and at the top they pushed the
+        conversation down by a line for standing information.
+      */}
+      <box height={2} flexDirection="column">
         <box height={1} flexDirection="row" backgroundColor={modeColor()} paddingX={1}>
           <text fg="#0B1020">{modeLabel()}</text>
         </box>
-        <box height={1} flexDirection="row">
-          <text fg="#D6DEE8">{props.title}</text>
-          <text fg="#7F8C8D">  {props.statusLine}</text>
-        </box>
         <box height={1} flexDirection="row">
           {props.hintLine ? <text fg="#FBBF24">[ {props.hintLine} ]</text> : null}
         </box>
@@ -860,6 +863,15 @@ export function LeftPane(props: {
         onSubmit={props.submit}
         onHeightChange={props.onInputHeightChange}
       />
+      {/*
+        Status foot. One line, as in the header before it, so the row budget of
+        `conversationRows` (height - 5 - input) is unchanged: the line moved,
+        it was not added.
+      */}
+      <box height={1} flexDirection="row">
+        <text fg="#D6DEE8">{props.title}</text>
+        <text fg="#7F8C8D">  {props.statusLine}</text>
+      </box>
     </box>
   );
 }

package/src/shell/StartupScreen.tsx

@@ -249,7 +249,15 @@ export function StartupScreen(props: {
     return `${workspace} / ${profile}`;
   });
 
-  const innerWidth = createMemo(() => Math.max(40, panelWidth() - 6));
+  /*
+   Usable width inside the panel.
+
+   The panel has no border any more, only `padding={2}`: 4 columns, not 6. The
+   two extra columns were the border's, and keeping them would leave the text
+   measured for a frame that is no longer drawn — every `fit()` truncating two
+   characters early for nothing.
+  */
+  const innerWidth = createMemo(() => Math.max(40, panelWidth() - 4));
   const shortcutHint = createMemo(() => {
     const count = currentLength();
     const quick = count === 1 ? '1 quick select' : `1-${count} quick select`;
@@ -267,9 +275,6 @@ export function StartupScreen(props: {
         top={top()}
         width={panelWidth()}
         height={panelHeight()}
-        border
-        borderStyle="rounded"
-        borderColor="#8BD5CA"
         backgroundColor="#111318"
         padding={2}
         flexDirection="column"

package/src/shell/repl.js

@@ -2115,6 +2115,7 @@ async function runTuiShell({ agent, packageJson, session, runtime = null }) {
               url: runtime.url,
               workspace: session.workspace ?? null,
               ...(kind === 'item' ? { itemId: id } : kind === 'approval' ? { approvalId: id } : { runId: id }),
+              caller: 'shell-/approve',
             });
             conversationMessages(session).push({ role: 'command', content: `Approval ${result.approved ? 'accepted' : 'not found'}: ${id}` });
             syncRuntimeState();