@dotdrelle/wiki-manager 0.15.55 → 0.15.57

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotdrelle/wiki-manager",
-  "version": "0.15.55",
+  "version": "0.15.57",
   "description": "Agentic shell and orchestration cockpit for llm-wiki workspaces.",
   "repository": {
     "type": "git",

package/src/agent/graph.js

@@ -1026,11 +1026,18 @@ export function connectorConfigurationTarget(session, objective) {
     .filter((message) => message?.role === 'user')
     .map((message) => String(message?.content ?? ''))
     .join(' ');
-  const text = `${recentContext} ${String(objective ?? '')}`.trim().toLowerCase();
-  // `connect` used to match the noun "connector" as a substring. Production
-  // skills mention an optional messaging connector, so that broad match could
-  // misclassify a business run as connector setup and reject delegation.
-  if (!/(?:configur|\bconnect(?:ed|ing|ion|ions)?\b|authent|oauth|setup|sign[ -]?in|\bpat\b|api[ _-]?token|credential|identifiant|mot de passe|password)/i.test(text)) return null;
+  const objectiveText = String(objective ?? '').trim().toLowerCase();
+  // The configuration keyword must describe the objective being delegated NOW,
+  // not something the user said earlier in the session. Matching it against
+  // recent conversation context made a stale "configurer le CME" message poison
+  // every later delegation — an unrelated `/wiki-ingest` objective was rejected
+  // as connector setup. Recent context is used only to resolve WHICH connector
+  // the current objective refers to. (`connect` used to match the noun
+  // "connector" as a substring, and production skills mention an optional
+  // messaging connector; the narrowed word-boundary form keeps that from
+  // misclassifying a business run as connector setup.)
+  if (!/(?:configur|\bconnect(?:ed|ing|ion|ions)?\b|authent|oauth|setup|sign[ -]?in|\bpat\b|api[ _-]?token|credential|identifiant|mot de passe|password)/i.test(objectiveText)) return null;
+  const contextText = `${recentContext} ${objectiveText}`.trim().toLowerCase();
   for (const [serverName, server] of Object.entries(session?.mcp ?? {})) {
     if (server?.status !== 'connected' || !Array.isArray(server.tools) || server.tools.length === 0) continue;
     const genericAliasParts = new Set([
@@ -1043,7 +1050,7 @@ export function connectorConfigurationTarget(session, objective) {
     ]
       .flatMap((value) => String(value).toLowerCase().split(/[^a-z0-9]+/))
       .filter((part) => part.length >= 3 && !genericAliasParts.has(part));
-    if (!aliases.some((alias) => text.includes(alias))) continue;
+    if (!aliases.some((alias) => contextText.includes(alias))) continue;
     const setupTool = server.tools.find((tool) => {
       const name = String(tool?.name ?? '').toLowerCase();
       const description = String(tool?.description ?? '').toLowerCase();
@@ -1182,7 +1189,7 @@ export function buildAgentSystemPrompt(state) {
     skills,
     '</skill_catalog>',
     runningSkillStack.length > 0
-      ? `You are already executing the compiled objective of workspace skill ${JSON.stringify(runningSkillStack.at(-1))}. Execute the objective in the current user message with the available direct tools${runningSkillExecution === 'direct' ? ' and stop after its requested direct mutation; delegation and nested skills are forbidden for this workflow' : ' or capability delegation'}. Do not select or call that skill again, with or without a leading slash. A skill run is not successful until its requested mutation has an affirmative tool result; never infer success from the runtime merely becoming idle or done.`
+      ? `You are already executing the compiled objective of workspace skill ${JSON.stringify(runningSkillStack.at(-1))}. The current user message IS that objective: execute it directly${runningSkillExecution === 'direct' ? ' and stop after its requested direct mutation; delegation and nested skills are forbidden for this workflow' : ' by delegating it with runtime__delegate (or a matching direct tool)'}. Do not select or call that skill again, with or without a leading slash — the runtime refuses the re-invocation with skill_recursion_blocked, and that refusal means act on the objective yourself, not report an error. A skill run is not successful until its requested mutation has an affirmative tool result; never infer success from the runtime merely becoming idle or done, and never end the run with an empty reply or a bare "{}".`
       : null,
     'In interactive agent mode, call only tools actually provided to you. Any directly offered tool stays direct; never substitute an orchestration-contract tool yourself.',
     'When the user asks for an action that can be performed with connected MCP tools or safe primitives, do not answer with future intent such as "I will call...", "I am going to run...", or "launching..." unless you also call the tool in the same turn. Either call the tool now, ask for the exact missing required arguments, or explain the concrete blocker.',
@@ -1219,6 +1226,7 @@ export function buildAgentSystemPrompt(state) {
     'When an action fails or is refused for lack of an authorization grant or scope (rather than a missing capability), say exactly that and name the primitive that grants it. Do not describe the feature as unavailable.',
     'For an action with no matching direct tool, call runtime__delegate with the user objective only. The runtime chooses the capability, operation, agent and plan, including a validated single task for executor-only agents. Never choose those identifiers yourself. Never call <provider>__agent_plan, <provider>__agent_execute, legacy production__production_start_job, wiki__plan_set, or wiki__plan_done from interactive chat.',
     'Do not ask the user which sources, files, connectors, or templates to use for an ingest, build, or export: the specialized agent discovers them from the workspace. When the objective is clear (e.g. "lance une ingestion"), delegate it as stated, without a clarifying question.',
+    'Templates are instruction-only specs and deliverables are regenerated from them. When asked to change what a generated document says, edit the underlying wiki content (wiki_write_page) or the template\'s [[INSTRUCTION: ...]] sections — never write finished prose into a template, because a build copies it verbatim and it can no longer be refreshed from the wiki. template_write refuses prose outside an instruction block, so keep every sentence inside one.',
     'Promise only what the resolved capability actually exposes in its declared contract (the input schema the specialized agent publishes for that capability). When the user requests an execution parameter — a batch or chunk size, a count "N at a time", concurrency, ordering, priority, or any tuning knob — apply it only if that parameter exists in the target capability\'s published input schema. Otherwise do not confirm or promise it: delegate the objective, and if the user explicitly asked for that parameter, say plainly in one line that you started the work but do not control that aspect (the runtime and the specialized agent decide it). Never state or imply a parameter was applied when the agent contract cannot enforce it.',
     'If runtime__delegate returns a blocker or no specialized provider is available, report only that concrete blocker concisely. Never replace the missing execution path with a suggested slash command, skill, MCP tool name, manual file move, administrator escalation, or alternative workflow unless the user explicitly asks for alternatives.',
     'For workspace inventory and page listings, use the connected wiki MCP read tools. Never invent or call a /wiki shell command through shell__run_command. Use /workspace init <name> [path] for low-level non-interactive workspace creation; in the interactive TUI, /new <name> opens the setup wizard.',

package/src/agent/graph.test.js

@@ -62,6 +62,27 @@ test('a connection problem still routes to connector configuration', () => {
   assert.deepEqual(target, { serverName: 'acme', setupTool: 'acme_auth' });
 });
 
+test('a stale configure-connector message does not poison a later business delegation', () => {
+  const target = connectorConfigurationTarget({
+    agentProjection: {
+      conversation: [
+        { role: 'user', content: 'donne moi la config du cme' },
+        { role: 'user', content: 'liste les pages wiki configurer pour l’agent cme' },
+      ],
+    },
+    mcp: {
+      cme: {
+        status: 'connected',
+        tools: [
+          { name: 'cme_setup', description: 'Configure Confluence credentials.' },
+          { name: 'cme_export_run', description: 'Run export.' },
+        ],
+      },
+    },
+  }, 'Ingest pending staged Markdown files from raw/untracked into the wiki.');
+  assert.equal(target, null);
+});
+
 test('Donna cannot answer an explicit action with manual instructions instead of delegating', async () => {
   const originalFetch = globalThis.fetch;
   let delegated = false;

package/src/commands/slash.js

@@ -29,6 +29,7 @@ import { createWorkspace, findWorkspace, listWorkspaces } from '../core/workspac
 import { findSkill, inspectSkills, listSkills } from '../core/skills.js';
 import { extractActivity, formatActivityError, formatActivityLine, formatActivitySummary, parseJsonText } from '../core/activity.js';
 import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
+import { emitRuntimeLog } from '../runtime/supervisor.js';
 import {
   cancelQueueItem,
   clearFinishedQueueItems,
@@ -612,20 +613,53 @@ function publishDocumentActivity(session, activity) {
   return publishPayloadActivity(session, { _activity: activity }, { server: 'documents', tool: 'documents_convert_to_markdown' });
 }
 
-export async function refreshMcpRuntimeStatus(session) {
-  session.mcp = buildMcpStatus(session);
-  if (!session.workspacePath) return null;
+export async function refreshMcpRuntimeStatus(session, deps = {}) {
+  const getStates = deps.serviceStates ?? serviceStates;
+  const discover = deps.discoverMcpTools ?? discoverMcpTools;
+  const previousMcp = session.mcp;
+  const base = buildMcpStatus(session);
+  if (!session.workspacePath) {
+    session.mcp = base;
+    return null;
+  }
+  // Build the next status in local variables and assign `session.mcp` only at
+  // the end. Assigning `buildMcpStatus` first (status "configured", no tools)
+  // and then awaiting `serviceStates`/`discoverMcpTools` exposed a window in
+  // which a background re-scan had downgraded `production` to "configured",
+  // and the dispatcher — reading `session.mcp` mid-refresh — refused the next
+  // `agent_execute` with "MCP is not connected: production" while the agent
+  // was actually up.
   try {
-    const states = await serviceStates(session);
-    session.mcp = applyMcpRuntimeStatus(session.mcp, states);
-    session.mcp = await discoverMcpTools(session.mcp);
+    const states = await getStates(session);
+    session.mcp = await discover(applyMcpRuntimeStatus(base, states), previousMcp);
+    reportNewlyDegradedMcp(session, previousMcp);
     return states;
   } catch {
-    session.mcp = await discoverMcpTools(session.mcp);
+    session.mcp = await discover(base, previousMcp);
+    reportNewlyDegradedMcp(session, previousMcp);
     return null;
   }
 }
 
+/**
+ * "Degraded" (`discoverMcpTools`, mcp.js) means an endpoint is reporting
+ * "connected" only because a prior cycle was, not because Docker or the
+ * latest probe confirm it now — the preservation that endpoint's
+ * `keepConnected` branch exists for, deliberately not reverted here since a
+ * transient probe blip must not flip a live run's endpoint away. But
+ * preserving it in silence is exactly the "stale status kept forever"
+ * pattern already fixed once in agentRegistry.js: report it, edge-triggered
+ * on the transition into the degraded state, so it does not repeat every
+ * re-scan while it persists.
+ */
+function reportNewlyDegradedMcp(session, previousMcp) {
+  for (const [name, entry] of Object.entries(session.mcp ?? {})) {
+    if (!entry?.degraded || previousMcp?.[name]?.degraded) continue;
+    emitRuntimeLog(session, `mcp: ${name} still reports "connected" only from a prior probe`
+      + ` (${entry.toolError ?? 'no detail'}); Docker/the latest probe no longer confirm it.`);
+  }
+}
+
 async function statusText(session) {
   const states = await refreshMcpRuntimeStatus(session);
   const workspaceStats = collectWorkspaceStats(session);
@@ -1557,7 +1591,12 @@ export async function handleSlashCommand(line, context) {
           const wikiArgs = args.slice(2);
           if (wikiArgs.length === 0) return { output: 'Usage: /wiki run <args...>' };
           step(`Wiki: running ${wikiArgs.join(' ')}…`);
+          // Steps that drive LLM work (taxonomy, build, ingest, export, polish)
+          // legitimately run for minutes: the production agent gives them a
+          // 600s LLM timeout, so the raw hatch must not cut them at 180s.
+          const longRunning = new Set(['taxonomy', 'build', 'ingest', 'export', 'polish', 'pipeline']);
           const output = await runWikiCli(context.session, wikiArgs, {
+            timeout: longRunning.has(wikiArgs[0] ?? '') ? 600_000 : 180_000,
             onOutput: (line) => step(`Wiki: ${line}`),
           });
           const activity = formatActivitySummary('wiki', wikiArgs[0] ?? 'run', output);

package/src/commands/slash.test.js

@@ -4,7 +4,7 @@ import { mkdtemp } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import test from 'node:test';
-import { agentConcurrencySections, compactBaseUrl, compactMcpStatus, handleSlashCommand, localizedOperationResult } from './slash.js';
+import { agentConcurrencySections, compactBaseUrl, compactMcpStatus, handleSlashCommand, localizedOperationResult, refreshMcpRuntimeStatus } from './slash.js';
 import { completionContext } from '../shell/repl.js';
 
 test('deterministic operation results ask Donna to localize compact facts without leaking commands', () => {
@@ -437,3 +437,59 @@ test('/queue cancel reports unknown ids that are not runtime-managed', async ()
   });
   assert.match(result.output ?? '', /Unknown queue item/i);
 });
+
+test('refreshMcpRuntimeStatus does not expose an intermediate configured status', async () => {
+  const session = {
+    workspacePath: '/tmp/ws',
+    workspaceEnv: { PRODUCTION_MCP_PORT: '3202', PRODUCTION_MCP_AUTH_TOKEN: 'token' },
+    wikircConfig: {},
+    mcp: { production: { status: 'connected', tools: [{ name: 'production__agent_execute' }] } },
+  };
+  const originalMcp = session.mcp;
+  let resolveStates;
+  const statesPromise = new Promise((resolve) => { resolveStates = resolve; });
+  const pending = refreshMcpRuntimeStatus(session, {
+    serviceStates: () => statesPromise,
+    discoverMcpTools: async (mcp) => mcp,
+  });
+  // While serviceStates is still in flight, the dispatcher-facing status must
+  // keep the previous connected snapshot — never the fresh "configured" base.
+  assert.equal(session.mcp, originalMcp, 'session.mcp reassigned mid-refresh');
+  resolveStates({ 'production-mcp': { running: true } });
+  await pending;
+  assert.equal(session.mcp.production.status, 'connected');
+});
+
+test('refreshMcpRuntimeStatus reports a degraded MCP endpoint once, not on every re-scan', async () => {
+  const session = {
+    workspacePath: '/tmp/ws',
+    workspaceEnv: { PRODUCTION_MCP_PORT: '3202', PRODUCTION_MCP_AUTH_TOKEN: 'token' },
+    wikircConfig: {},
+    mcp: { production: { status: 'connected', tools: [] } },
+  };
+  const degradedRuns = (n) => async () => ({
+    production: { status: 'connected', tools: [], toolError: `probe ${n} failed`, degraded: true },
+  });
+  const deps = { serviceStates: async () => ({}) };
+
+  await refreshMcpRuntimeStatus(session, { ...deps, discoverMcpTools: degradedRuns(1) });
+  await refreshMcpRuntimeStatus(session, { ...deps, discoverMcpTools: degradedRuns(2) });
+  await refreshMcpRuntimeStatus(session, { ...deps, discoverMcpTools: degradedRuns(3) });
+
+  const reports = (session.agentEvents ?? []).filter((event) => event.type === 'runtime_log'
+    && String(event.payload?.message ?? '').includes('mcp: production'));
+  assert.equal(reports.length, 1, 'a degraded endpoint is reported once, not once per re-scan');
+
+  // Recovers, then degrades again: reported a second time.
+  await refreshMcpRuntimeStatus(session, {
+    ...deps,
+    discoverMcpTools: async () => ({ production: { status: 'connected', tools: [], degraded: false } }),
+  });
+  await refreshMcpRuntimeStatus(session, { ...deps, discoverMcpTools: degradedRuns(4) });
+  assert.equal(
+    (session.agentEvents ?? []).filter((event) => event.type === 'runtime_log'
+      && String(event.payload?.message ?? '').includes('mcp: production')).length,
+    2,
+  );
+});
+

package/src/core/buildInfo.json

@@ -1,4 +1,4 @@
 {
-  "version": "0.15.55",
-  "commit": "31eddf4"
+  "version": "0.15.57",
+  "commit": "8c83b75"
 }

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.55';
+const WIKI_MANAGER_VERSION = '0.15.57';
 
 function envValue(key) {
   const filePath = managerEnvFile();
@@ -585,7 +585,7 @@ function retryDelay(ms, signal) {
   });
 }
 
-export async function discoverMcpTools(mcpStatus) {
+export async function discoverMcpTools(mcpStatus, previous = null) {
   const next = {};
   await Promise.all(Object.entries(mcpStatus ?? {}).map(async ([name, value]) => {
     if (value.status === 'missing') {
@@ -607,11 +607,26 @@ export async function discoverMcpTools(mcpStatus) {
       };
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
+      // A transient probe failure during a background re-scan must not degrade
+      // a live endpoint. Docker service state (applyMcpRuntimeStatus) is the
+      // authority on whether the container is up; this probe is only a tool
+      // refresh, so keep last-known-good status and tools instead of flipping
+      // an in-flight run's endpoint to "not connected".
+      const prior = previous?.[name];
+      const freshlyConnected = value.status === 'connected';
+      const keepConnected = freshlyConnected || prior?.status === 'connected';
+      // `degraded` marks the case Docker itself no longer confirms as
+      // connected (freshlyConnected is false) and only prior history keeps
+      // this endpoint reporting "connected" — the preservation this whole
+      // branch exists for, worth surfacing rather than masking indefinitely.
+      // `refreshMcpRuntimeStatus` (slash.js) owns the edge-triggered log, by
+      // comparing this flag against the previous cycle's.
       next[name] = {
         ...value,
-        status: value.status === 'connected' ? 'configured' : value.status,
-        tools: [],
+        status: keepConnected ? 'connected' : value.status,
+        tools: keepConnected ? (prior?.tools ?? []) : [],
         toolError: message,
+        degraded: keepConnected && !freshlyConnected,
       };
     }
   }));

package/src/core/mcp.test.js

@@ -501,7 +501,7 @@ test('resolveRetryPolicy supports endpoint and tool overrides', () => {
   assert.deepEqual(policy, { maxAttempts: 4, backoffMs: 100 });
 });
 
-test('discoverMcpTools downgrades connected endpoint when tool discovery fails', async () => {
+test('discoverMcpTools keeps a connected endpoint connected when tool discovery fails', async () => {
   const originalFetch = globalThis.fetch;
   globalThis.fetch = async () => ({
     ok: false,
@@ -519,7 +519,7 @@ test('discoverMcpTools downgrades connected endpoint when tool discovery fails',
       },
     });
 
-    assert.equal(status.wiki.status, 'configured');
+    assert.equal(status.wiki.status, 'connected');
     assert.equal(status.wiki.tools.length, 0);
     assert.match(status.wiki.toolError, /401/);
   } finally {
@@ -527,6 +527,68 @@ test('discoverMcpTools downgrades connected endpoint when tool discovery fails',
   }
 });
 
+test('discoverMcpTools preserves last-known-good status and tools across a failed re-probe', async () => {
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = async () => ({
+    ok: false,
+    status: 502,
+    headers: { get: () => null },
+    text: async () => 'Bad gateway',
+  });
+
+  try {
+    const status = await discoverMcpTools(
+      {
+        production: {
+          status: 'configured',
+          url: 'http://127.0.0.1:3202/mcp/',
+          token: 'token',
+        },
+      },
+      {
+        production: {
+          status: 'connected',
+          tools: [{ name: 'production__agent_execute' }, { name: 'production__agent_status' }],
+        },
+      },
+    );
+
+    assert.equal(status.production.status, 'connected');
+    assert.deepEqual(status.production.tools.map((tool) => tool.name), [
+      'production__agent_execute',
+      'production__agent_status',
+    ]);
+    assert.match(status.production.toolError, /502/);
+    // Docker (`value.status`) no longer confirms this endpoint; only prior
+    // history keeps it "connected". `degraded` is what lets the caller
+    // (refreshMcpRuntimeStatus) tell this apart from a genuinely fresh probe
+    // success, so it can report the preservation instead of masking it.
+    assert.equal(status.production.degraded, true);
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test('discoverMcpTools does not mark a fresh probe failure on an already-connected endpoint as degraded', async () => {
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = async () => ({
+    ok: false,
+    status: 401,
+    headers: { get: () => null },
+    text: async () => '{"error":"invalid or missing bearer token"}',
+  });
+
+  try {
+    const status = await discoverMcpTools({
+      wiki: { status: 'connected', url: 'http://127.0.0.1:3201/mcp', token: 'token' },
+    });
+    assert.equal(status.wiki.status, 'connected');
+    assert.equal(status.wiki.degraded, false);
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
 // A stateful server may reject any cold request, and every SDK words that
 // rejection differently ("No valid session" for the Node SDK, "Missing session
 // ID" for the Python one CME runs). The client must never read that prose: it

package/src/orchestrator/agentRegistry.js

@@ -62,6 +62,11 @@ export function createAgentRegistry({
 } = {}) {
   const agentsByInstance = new Map();
   const instanceByServer = new Map();
+  // Whether the LAST probe of an instance failed. The "did not answer
+  // agent_describe" log is edge-triggered: it is emitted once when an instance
+  // stops answering, not on every re-scan while it stays down. A stopped agent
+  // is not an error to repeat every minute.
+  const lastProbeFailed = new Map();
 
   return {
     async discover(session, { signal = null } = {}) {
@@ -70,13 +75,18 @@ export function createAgentRegistry({
       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 }));
+        discovered.push(registerAgent(session, agent, { agentsByInstance, instanceByServer, lastProbeFailed }));
       }
       for (const [serverName, instanceId] of instanceByServer) {
         if (activeServers.has(serverName)) continue;
         const previous = agentsByInstance.get(instanceId);
         instanceByServer.delete(serverName);
         agentsByInstance.delete(instanceId);
+        // Same cleanup as the two maps above: without it, a long-running
+        // process that sees many renamed/reconnected connectors (the
+        // Connectors panel supports exactly this) accumulates one stale
+        // entry per retired instance for the process lifetime.
+        lastProbeFailed.delete(instanceId);
         if (previous) dispatchRegistryEvent(session, 'agent.unregistered', {
           agentInstanceId: instanceId,
           serverName,
@@ -140,7 +150,7 @@ async function discoverServerAgent(session, serverName, endpoint = {}, { callToo
   }
 }
 
-function registerAgent(session, agent, { agentsByInstance, instanceByServer }) {
+function registerAgent(session, agent, { agentsByInstance, instanceByServer, lastProbeFailed }) {
   const previousInstanceId = instanceByServer.get(agent.serverName);
   const previous = previousInstanceId ? agentsByInstance.get(previousInstanceId) : null;
 
@@ -166,13 +176,21 @@ function registerAgent(session, agent, { agentsByInstance, instanceByServer }) {
      the blindness — a probe that failed is a fact worth stating, once, where
      the panels and the shell already read.
 
+     "Once" is the operative word: the re-scan runs every minute, and a stopped
+     agent is not an error to repeat each time it is scanned. The log is
+     edge-triggered on the transition from answering to not answering.
+
      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'}).`);
+     */
+    const wasAnswering = lastProbeFailed.get(previous.agentInstanceId) !== true;
+    lastProbeFailed.set(previous.agentInstanceId, true);
+    if (wasAnswering) {
+      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);
   }
 
@@ -187,6 +205,7 @@ function registerAgent(session, agent, { agentsByInstance, instanceByServer }) {
   }
   agentsByInstance.set(next.agentInstanceId, next);
   instanceByServer.set(next.serverName, next.agentInstanceId);
+  if (lastProbeFailed) lastProbeFailed.set(next.agentInstanceId, false);
 
   if (!previous || previous.agentInstanceId !== next.agentInstanceId) {
     dispatchRegistryEvent(session, 'agent.registered', { agent: next });

package/src/orchestrator/agentRegistry.test.js

@@ -209,6 +209,47 @@ test('a failed re-discovery keeps a degraded orchestrator agent too', async () =
   assert.equal(agent.description.capabilities.length, 1);
 });
 
+test('a stopped agent is reported once, not on every re-scan', async () => {
+  // The re-scan runs every minute; a deliberately stopped agent must not flood
+  // the log with the same "did not answer" line. The message is edge-triggered:
+  // emitted on the transition from answering to not answering, then silent
+  // until it answers again.
+  const events = [];
+  const session = {
+    workspace: 'acpi',
+    mcp: { production: { status: 'connected', tools: [{ name: 'agent_describe' }] } },
+    _onAgentEvent: (event) => events.push(event),
+  };
+  let down = false;
+  const registry = createAgentRegistry({
+    callTool: async () => {
+      if (down) throw new Error('fetch failed');
+      return { content: [{ type: 'text', text: JSON.stringify(description()) }] };
+    },
+  });
+
+  await registry.discover(session);
+  down = true;
+  await registry.discover(session);
+  await registry.discover(session);
+  await registry.discover(session);
+
+  const reports = events.filter((event) => event.type === 'runtime_log'
+    && String(event.payload?.message ?? '').includes('agent-registry:'));
+  assert.equal(reports.length, 1, 'the down agent is reported once, not once per scan');
+
+  // It answers again, then drops again: the next failure is reported again.
+  down = false;
+  await registry.discover(session);
+  down = true;
+  await registry.discover(session);
+  assert.equal(
+    events.filter((event) => event.type === 'runtime_log'
+      && String(event.payload?.message ?? '').includes('agent-registry:')).length,
+    2,
+  );
+});
+
 test('discovery sends the workspace only to agents whose schema declares it', async () => {
   const seen = {};
   const registry = createAgentRegistry({

package/src/orchestrator/scheduler.test.js

@@ -245,6 +245,82 @@ function task(id, overrides = {}) {
   };
 }
 
+/*
+  Cas observé le 2026-08-22 (workspace acpi) : `/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 » :
+  `approvalClasses: []`, `planRevision: null`. Après la fin des 13 ingest_plan,
+  le scheduler a déclaré `no_ready_plan_task` au lieu de démarrer les apply.
+
+  Ce test verrouille la couverture du grant nu : les apply `waiting_approval`
+  DOIVENT redevenir ready quand le grant run-scope (même sans classes ni
+  révision) les couvre.
+*/
+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',
+    planRevision: 1,
+    tasks: [
+      // 13 ingest_plan du groupe ingest, tous done.
+      ...Array.from({ length: 13 }, (_, i) => task(`ingest-plan-${i}`, {
+        groupId: 'ingest',
+        status: 'done',
+        requiredCapability: 'knowledge.update',
+        operation: 'ingest_plan',
+      })),
+      // 13 apply : groupe apply, barrière ingest, lock workspace-write.
+      ...Array.from({ length: 13 }, (_, i) => task(`ingest-apply-${i}`, {
+        groupId: 'apply',
+        dependsOnGroup: 'ingest',
+        barrier: true,
+        dependsOn: [`ingest-plan-${i}`],
+        status: 'waiting_approval',
+        requiredCapability: 'knowledge.update',
+        operation: 'ingest_apply',
+        locks: ['workspace-write'],
+        parallelizable: false,
+        requiresApproval: true,
+        approvalClass: 'mutation',
+        priority: i + 1,
+      })),
+      task('taxonomy', {
+        dependsOnGroup: 'apply',
+        barrier: true,
+        status: 'waiting_approval',
+        requiredCapability: 'knowledge.update',
+        operation: 'taxonomy',
+        requiresApproval: true,
+        approvalClass: 'mutation',
+      }),
+    ],
+  };
+
+  // Sans grant : rien n'est ready.
+  assert.deepEqual(readyTasks(plan).map((item) => item.id), []);
+
+  // Grant run-scope « nu » — exactement ce que le bouton Approve émet.
+  // La couverture ne bloque pas : les 13 apply sont tous prêts.
+  const ready = readyTasks(plan, {
+    approvals: [{
+      status: 'approved',
+      scope: 'run',
+      runId: 'run-1',
+      workspaceId: 'acpi',
+      planRevision: null,
+      approvalClasses: [],
+    }],
+  });
+
+  assert.deepEqual(ready.map((item) => item.id), [
+    'ingest-apply-0', 'ingest-apply-1', 'ingest-apply-2', 'ingest-apply-3',
+    'ingest-apply-4', 'ingest-apply-5', 'ingest-apply-6', 'ingest-apply-7',
+    'ingest-apply-8', 'ingest-apply-9', 'ingest-apply-10', 'ingest-apply-11',
+    'ingest-apply-12',
+  ]);
+});
+
 /*
  Cas observé le 2026-08-04 (workspace juno) : une ingestion de dix fichiers,
  neuf réussis, le dixième en échec sur du JSON malformé. La barrière de groupe

package/src/runtime/runner.js

@@ -7,7 +7,7 @@ import { createAssignmentManager } from '../orchestrator/assignmentManager.js';
 import { createAttemptManager } from '../orchestrator/attemptManager.js';
 import { createBudgetManager, BudgetExceededError } from '../orchestrator/budgetManager.js';
 import { createDispatcher } from '../orchestrator/dispatcher.js';
-import { approvalRequestForTask } from '../orchestrator/approvalPolicy.js';
+import { approvalCovered, approvalRequestForTask } from '../orchestrator/approvalPolicy.js';
 import { blockedByFailedDependency, tasksAwaitingApproval } from '../orchestrator/dependencyResolver.js';
 import { isFailed, isPending, isSkipped, isSuccessful, isTerminal, isUnknownStatus } from '../orchestrator/taskStatuses.js';
 import { assertValidatedFragment } from '../orchestrator/planValidator.js';
@@ -616,8 +616,26 @@ export async function runRuntimeParallelPlan(agent, session, input, {
         // Any genuine approval-only block returned above. Remaining tasks are
         // unschedulable for another reason.
         const reason = 'no_ready_plan_task';
-        emitRuntimeLog(session, `scheduler: stalled (${reason})`);
-        return { ok: false, stalled: true, reason, completed: sessionActivities(session), failures };
+        const diagnostics = stallDiagnostics(session.headlessPlan ?? [], {
+          approvals: session.agentProjection?.approvals ?? session.approvals ?? [],
+          registry: session.capabilityRegistry ?? null,
+          lockManager: attempts,
+          runId,
+          workspaceId: session.workspace ?? null,
+          planRevision: session.planRevision ?? session.agentProjection?.planRevision ?? null,
+        });
+        emitRuntimeLog(session, `scheduler: stalled (${reason}) — ${diagnostics.length} pending task(s)`);
+        for (const line of diagnostics) {
+          emitRuntimeLog(session, `scheduler: stalled-detail ${line}`);
+        }
+        return {
+          ok: false,
+          stalled: true,
+          reason,
+          completed: sessionActivities(session),
+          failures,
+          stallDiagnostics: diagnostics,
+        };
       }
 
       const settled = await Promise.race([...active.values()].map((entry) => entry.promise));
@@ -687,6 +705,70 @@ export async function runRuntimeParallelPlan(agent, session, input, {
  exemple —, on s'arrête. Sans lui, une incohérence de statut se paierait en
  boucle infinie, c'est-à-dire en run figé : exactement ce qu'on répare.
 */
+/**
+ * Diagnostic au moment d'un stall `no_ready_plan_task`.
+ *
+ * Le scheduler sait seulement « plus aucune tâche prête ». Pour distinguer
+ * « dépendance en attente » de « approbation non couverte » de « lock tenu »
+ * de « capability non résolue », on relit ici l'état RÉEL de chaque tâche
+ * pendante : statut, statut de chaque dépendance, état de la barrière de
+ * groupe, état des locks, couverture d'approbation, présence d'un fournisseur
+ * de capability. Une ligne par tâche, lisible dans les logs SSE et reportée
+ * dans le message du `run_error`.
+ */
+function stallDiagnostics(plan, {
+  approvals = [],
+  registry = null,
+  lockManager = null,
+  runId = null,
+  workspaceId = null,
+  planRevision = null,
+} = {}) {
+  const byId = new Map((plan ?? []).map((task) => [String(task.id ?? task.step), task]));
+  const lines = [];
+  for (const task of plan ?? []) {
+    if (!isPending(task.status)) continue;
+    const id = shortLogId(String(task.id ?? task.step ?? '?'));
+    const parts = [`status=${task.status}`];
+
+    const deps = Array.isArray(task.dependsOn) ? task.dependsOn : [];
+    if (deps.length > 0) {
+      parts.push(`dependsOn=${deps.map((dep) => {
+        const depTask = byId.get(String(dep));
+        return `${shortLogId(String(dep))}=${depTask ? depTask.status : 'missing'}`;
+      }).join(',')}`);
+    }
+
+    if (task.dependsOnGroup) {
+      const members = (plan ?? []).filter((candidate) => (candidate.groupId ?? candidate.group) === task.dependsOnGroup);
+      const terminal = members.filter((candidate) => isTerminal(candidate.status)).length;
+      parts.push(`dependsOnGroup=${shortLogId(String(task.dependsOnGroup))}(${terminal}/${members.length} terminal)`);
+    }
+
+    if (Array.isArray(task.locks) && task.locks.length > 0) {
+      const free = lockManager && typeof lockManager.canAcquire === 'function'
+        ? lockManager.canAcquire(task)
+        : 'n/a';
+      parts.push(`locks=[${task.locks.join(',')}] free=${free}`);
+    }
+
+    if (task.requiresApproval) {
+      const covered = approvalCovered(task, approvals, { runId, workspaceId, planRevision });
+      parts.push(`requiresApproval covered=${covered}`);
+    }
+
+    if (task.requiredCapability) {
+      const providers = registry && typeof registry.providersFor === 'function'
+        ? (registry.providersFor(task.requiredCapability) ?? [])
+        : [];
+      parts.push(`capability=${task.requiredCapability} providers=${providers.length}`);
+    }
+
+    lines.push(`${id}: ${parts.join(' | ')}`);
+  }
+  return lines;
+}
+
 export function skipImpossibleTasks(session, runId, { maxPasses = 50 } = {}) {
   let total = 0;
   for (let pass = 0; pass < maxPasses; pass += 1) {
@@ -1340,9 +1422,12 @@ function replanTriggerFromLoopResult(result) {
     if (blocking.length > 0 && blocking.every(isBusyFailure)) {
       return null;
     }
+    const diagnostics = Array.isArray(result.stallDiagnostics) && result.stallDiagnostics.length > 0
+      ? ` ${result.stallDiagnostics.join(' · ')}`
+      : '';
     return {
       kind: 'plan_stalled',
-      reason: `Plan is stalled: ${result.reason ?? 'no ready task'} (pending steps exist but none have their dependencies satisfied).`,
+      reason: `Plan is stalled: ${result.reason ?? 'no ready task'} (pending steps exist but none have their dependencies satisfied).${diagnostics}`,
       suggestedAction: 'Drop or replace the unsatisfiable dependency.',
       activity: null,
     };