@dotdrelle/wiki-manager 0.15.49 → 0.15.52

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 = {