@dotdrelle/wiki-manager 0.12.0 → 0.12.7

package/src/core/agentEvents.js

@@ -39,6 +39,7 @@ const SESSION_PROJECTION_EVENTS = new Set([
   'approval.rejected',
   'control_enqueued',
   'control_started',
+  'control_cancelled',
   'agent.registered',
   'agent.health_changed',
   'run_done',
@@ -479,6 +480,11 @@ function applyEvent(state, event) {
     case 'run_cancelled':
       state.status = 'cancelled';
       state.logs.push(String(event.payload?.message ?? 'Agent run cancelled.'));
+      // A cancelled run must not leave its plan steps "running/pending" and
+      // its activities spinning in the panels: mark every non-terminal one
+      // cancelled so the display reflects reality immediately.
+      cancelPendingPlanSteps(state.plan);
+      cancelActiveActivities(state.activities, event.ts);
       finishControlByRun(state.controlQueue, event.runId ?? event.payload?.runId ?? null, 'cancelled', event.ts);
       return;
     case 'run_error':
@@ -505,6 +511,14 @@ function applyEvent(state, event) {
         updatedAt: event.ts,
       });
       return;
+    case 'control_cancelled':
+      upsertControlItem(state.controlQueue, {
+        id: event.payload?.id ?? null,
+        status: 'cancelled',
+        finishedAt: event.payload?.finishedAt ?? event.ts,
+        updatedAt: event.ts,
+      });
+      return;
     case 'agent.registered':
       upsertAgent(state, event.payload?.agent, event.ts);
       return;
@@ -652,6 +666,22 @@ function markCoveredApprovalsApproved(approvals, grant, ts) {
   }
 }
 
+function cancelPendingPlanSteps(plan) {
+  for (const step of plan ?? []) {
+    if (!['done', 'failed', 'cancelled'].includes(String(step.status ?? ''))) step.status = 'cancelled';
+  }
+}
+
+function cancelActiveActivities(activities, ts) {
+  for (const activity of Object.values(activities ?? {})) {
+    if (activity && activity.terminal !== true) {
+      activity.status = 'cancelled';
+      activity.terminal = true;
+      activity.updatedAt = ts ?? activity.updatedAt;
+    }
+  }
+}
+
 function finishPendingPlanSteps(plan) {
   for (const step of plan ?? []) {
     if (step.status === 'running' || step.status === 'pending') {

package/src/core/agentEvents.test.js

@@ -279,6 +279,16 @@ test('reduceAgentEvents: control queue is event sourced and follows run status',
         createdAt: '2026-01-01T00:00:00.000Z',
       },
     }),
+    createAgentEvent('control_enqueued', {
+      origin: 'runtime',
+      workspace: 'docs',
+      payload: {
+        id: 'control-2',
+        workspace: 'docs',
+        input: 'Never run',
+        createdAt: '2026-01-01T00:00:01.000Z',
+      },
+    }),
     createAgentEvent('control_started', {
       origin: 'runtime',
       runId: 'run-control-1',
@@ -290,12 +300,19 @@ test('reduceAgentEvents: control queue is event sourced and follows run status',
       runId: 'run-control-1',
       workspace: 'docs',
     }),
+    createAgentEvent('control_cancelled', {
+      origin: 'runtime',
+      workspace: 'docs',
+      payload: { id: 'control-2' },
+    }),
   ]);
 
-  assert.equal(projection.controlQueue.length, 1);
+  assert.equal(projection.controlQueue.length, 2);
   assert.equal(projection.controlQueue[0].id, 'control-1');
   assert.equal(projection.controlQueue[0].status, 'done');
   assert.equal(projection.controlQueue[0].runId, 'run-control-1');
+  assert.equal(projection.controlQueue[1].id, 'control-2');
+  assert.equal(projection.controlQueue[1].status, 'cancelled');
 });
 
 test('reduceAgentEvents: activity-owned plan is used when no orchestrator plan exists', () => {
@@ -399,3 +416,27 @@ test('reduceAgentEvents: plan patches are proposed, approved and applied with re
   assert.equal(projection.plan[1].status, 'pending');
   assert.equal(projection.planPatches[0].status, 'applied');
 });
+
+test('streamed narration split across tool iterations yields separate conversation entries', () => {
+  // graph.js finalizes the streaming entry (assistant_message content:'')
+  // before each tool batch so per-iteration narrations do not glue together
+  // into one wall of text.
+  const session = {};
+  dispatchAgentEvent(session, createAgentEvent('assistant_delta', { origin: 'llm', payload: { delta: 'Analyse des jobs récents.' } }));
+  dispatchAgentEvent(session, createAgentEvent('assistant_message', { origin: 'llm', payload: { content: '' } }));
+  dispatchAgentEvent(session, createAgentEvent('assistant_delta', { origin: 'llm', payload: { delta: 'Voyons les logs.' } }));
+  dispatchAgentEvent(session, createAgentEvent('assistant_message', { origin: 'llm', payload: { content: 'Voyons les logs.' } }));
+
+  const conversation = session.agentProjection.conversation;
+  assert.equal(conversation.length, 2);
+  assert.equal(conversation[0].content, 'Analyse des jobs récents.');
+  assert.equal(conversation[0].streaming ?? false, false);
+  assert.equal(conversation[1].content, 'Voyons les logs.');
+});
+
+test('empty assistant_message finalize is a no-op without a streaming entry', () => {
+  const session = {};
+  dispatchAgentEvent(session, createAgentEvent('assistant_message', { origin: 'llm', payload: { content: 'Réponse finale.' } }));
+  dispatchAgentEvent(session, createAgentEvent('assistant_message', { origin: 'llm', payload: { content: '' } }));
+  assert.equal(session.agentProjection.conversation.length, 1);
+});

package/src/core/buildInfo.js

@@ -0,0 +1,58 @@
+import { execFileSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const here = dirname(fileURLToPath(import.meta.url));
+const packageRoot = resolve(here, '..', '..');
+
+let cachedCommit;
+
+// Short git commit identifying the code actually running. Resolution order:
+// 1. Live git HEAD when running from the development repository — accurate
+//    even between releases (dirty trees still show the base commit).
+// 2. buildInfo.json generated at pack time (scripts/check-versions.js) —
+//    what a published/global install carries.
+// 3. null — displayed as "+dev" so an untraceable build is visible at a
+//    glance instead of silently pretending to match the repo.
+export function buildCommit() {
+  if (cachedCommit !== undefined) return cachedCommit;
+  cachedCommit = liveGitCommit() ?? packagedCommit();
+  return cachedCommit;
+}
+
+export function versionWithBuild(packageJson) {
+  const version = String(packageJson?.version ?? '').trim();
+  const commit = buildCommit();
+  return commit ? `${version}+${commit}` : `${version}+dev`;
+}
+
+function liveGitCommit() {
+  try {
+    // Guard against walking up into an unrelated parent repository when the
+    // package is installed under a directory that happens to be git-tracked.
+    const toplevel = git(['rev-parse', '--show-toplevel']);
+    if (!toplevel || resolve(toplevel) !== packageRoot) return null;
+    return git(['rev-parse', '--short', 'HEAD']);
+  } catch {
+    return null;
+  }
+}
+
+function git(args) {
+  const output = execFileSync('git', args, {
+    cwd: packageRoot,
+    stdio: ['ignore', 'pipe', 'ignore'],
+    timeout: 2000,
+  }).toString().trim();
+  return output || null;
+}
+
+function packagedCommit() {
+  try {
+    const info = JSON.parse(readFileSync(join(here, 'buildInfo.json'), 'utf8'));
+    return info?.commit ? String(info.commit) : null;
+  } catch {
+    return null;
+  }
+}

package/src/core/buildInfo.json

@@ -0,0 +1,4 @@
+{
+  "version": "0.12.7",
+  "commit": "0bab10f"
+}

package/src/core/buildInfo.test.js

@@ -0,0 +1,14 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { buildCommit, versionWithBuild } from './buildInfo.js';
+
+test('versionWithBuild always exposes a provenance suffix', () => {
+  const formatted = versionWithBuild({ version: '9.9.9' });
+  // From the development repo the live git short sha is used; from a packed
+  // install the buildInfo.json commit; '+dev' only when neither is available.
+  assert.match(formatted, /^9\.9\.9\+(?:[0-9a-f]{4,40}|dev)$/);
+});
+
+test('buildCommit is stable across calls (cached)', () => {
+  assert.equal(buildCommit(), buildCommit());
+});

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.12.0';
+const WIKI_MANAGER_VERSION = '0.12.7';
 
 function envValue(key) {
   const filePath = managerEnvFile();
@@ -174,7 +174,7 @@ function clarifyToolDescription(serverName, toolName, description) {
   if (serverName === 'production' && toolName === 'production_start_job') {
     return compactDescription([
       base,
-      'Production export means wiki deliverable/publication export only. Do not use type=export for Confluence/CME/source export; use cme_export_run instead.',
+      'Production export means wiki deliverable/publication export only. Do not use type=export for Confluence/CME/source export; use cme__cme_export_run instead.',
     ].filter(Boolean).join(' '));
   }
   return base;
@@ -302,6 +302,26 @@ export function formatMcpToolResult(result) {
     .trim() || 'No result.';
 }
 
+const DEFAULT_TOOL_RESULT_MAX_CHARS = 16000;
+
+function toolResultMaxChars() {
+  const parsed = Number(process.env.WIKI_MANAGER_TOOL_RESULT_MAX_CHARS);
+  return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : DEFAULT_TOOL_RESULT_MAX_CHARS;
+}
+
+// Bound what a tool result injects into the LLM context and the conversation
+// display. Apply this ONLY at those two exit points — never before payload
+// parsing (extractActivity/_activity detection needs the full text).
+// Head + tail are kept because errors and job ids often live at either end.
+export function truncateToolResult(text, maxChars = toolResultMaxChars()) {
+  const full = String(text ?? '');
+  if (full.length <= maxChars) return full;
+  const headLength = Math.floor(maxChars * 0.7);
+  const tailLength = Math.floor(maxChars * 0.2);
+  const omitted = full.length - headLength - tailLength;
+  return `${full.slice(0, headLength)}\n\n[… ${omitted} caractères tronqués — résultat complet dans les logs runtime …]\n\n${full.slice(-tailLength)}`;
+}
+
 let _cachedEnvRetryPolicy = null;
 function getEnvRetryPolicy() {
   if (!_cachedEnvRetryPolicy) {
@@ -469,7 +489,9 @@ export function formatMcpToolsForAgent(mcpStatus) {
       sections.push(`${name}: connected, tools not discovered yet`);
       continue;
     }
-    sections.push(`${name}: ${tools.map((tool) => tool.name).join(', ')}`);
+    // Always advertise the qualified call name (server__tool): showing bare
+    // tool names here is what teaches the model to emit unqualified calls.
+    sections.push(`${name}: ${tools.map((tool) => `${name}__${tool.name}`).join(', ')}`);
   }
   return sections.length > 0 ? sections.join('\n') : 'No connected MCP tools discovered yet.';
 }
@@ -498,6 +520,31 @@ export function parseToolCallName(name) {
   return { server: name.slice(0, sep), tool: name.slice(sep + 2) };
 }
 
+// Deterministic recovery for unqualified tool-call names emitted by the LLM
+// (e.g. "cme_status" instead of "cme__cme_status"). Exact-name match only:
+// if exactly one connected server (or extra pseudo-server) exposes the bare
+// tool name, route to it and report `normalized: true`; otherwise return
+// `server: null` with the list of candidate servers so the caller can raise
+// an explicit error. This is name normalization, never fuzzy matching — do
+// not extend it to description/similarity-based selection (plan directeur
+// §20 forbids that).
+export function resolveToolCallName(mcpStatus, name, extraServers = {}) {
+  const parsed = parseToolCallName(name);
+  if (parsed.server) return { ...parsed, normalized: false, candidates: [] };
+  const candidates = [];
+  for (const [serverName, toolNames] of Object.entries(extraServers)) {
+    if (toolNames.includes(parsed.tool)) candidates.push(serverName);
+  }
+  for (const [serverName, value] of Object.entries(mcpStatus ?? {})) {
+    if (value.status !== 'connected') continue;
+    if ((value.tools ?? []).some((tool) => tool.name === parsed.tool)) candidates.push(serverName);
+  }
+  if (candidates.length === 1) {
+    return { server: candidates[0], tool: parsed.tool, normalized: true, candidates };
+  }
+  return { server: null, tool: parsed.tool, normalized: false, candidates };
+}
+
 export function mcpStatusMarker(status) {
   if (status === 'connected') return '●';
   if (status === 'configured') return '◐';

package/src/core/mcp.test.js

@@ -3,7 +3,76 @@ import assert from 'node:assert/strict';
 import { mkdtemp, writeFile } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
-import { buildMcpStatus, callMcpTool, discoverMcpTools, resolveRetryPolicy } from './mcp.js';
+import {
+  buildMcpStatus,
+  callMcpTool,
+  discoverMcpTools,
+  formatMcpToolsForAgent,
+  resolveRetryPolicy,
+  resolveToolCallName,
+  truncateToolResult,
+} from './mcp.js';
+
+const resolveFixtureStatus = {
+  production: {
+    status: 'connected',
+    tools: [{ name: 'production_start_job' }, { name: 'agent_status' }],
+  },
+  cme: {
+    status: 'connected',
+    tools: [{ name: 'cme_status' }, { name: 'agent_status' }],
+  },
+  documents: {
+    status: 'configured', // not connected: must never be a candidate
+    tools: [{ name: 'cme_status' }],
+  },
+};
+
+test('resolveToolCallName passes qualified names through untouched', () => {
+  const resolved = resolveToolCallName(resolveFixtureStatus, 'cme__cme_status');
+  assert.deepEqual(
+    { server: resolved.server, tool: resolved.tool, normalized: resolved.normalized },
+    { server: 'cme', tool: 'cme_status', normalized: false },
+  );
+});
+
+test('resolveToolCallName normalizes a bare name with exactly one connected match', () => {
+  const resolved = resolveToolCallName(resolveFixtureStatus, 'cme_status');
+  assert.deepEqual(
+    { server: resolved.server, tool: resolved.tool, normalized: resolved.normalized },
+    { server: 'cme', tool: 'cme_status', normalized: true },
+  );
+});
+
+test('resolveToolCallName refuses ambiguous bare names and reports candidates', () => {
+  const resolved = resolveToolCallName(resolveFixtureStatus, 'agent_status');
+  assert.equal(resolved.server, null);
+  assert.equal(resolved.normalized, false);
+  assert.deepEqual([...resolved.candidates].sort(), ['cme', 'production']);
+});
+
+test('resolveToolCallName returns no server for unknown bare names', () => {
+  const resolved = resolveToolCallName(resolveFixtureStatus, 'does_not_exist');
+  assert.equal(resolved.server, null);
+  assert.deepEqual(resolved.candidates, []);
+});
+
+test('resolveToolCallName resolves internal pseudo-server tools via extraServers', () => {
+  const resolved = resolveToolCallName(resolveFixtureStatus, 'plan_set', { wiki: ['plan_set', 'plan_done'] });
+  assert.deepEqual(
+    { server: resolved.server, tool: resolved.tool, normalized: resolved.normalized },
+    { server: 'wiki', tool: 'plan_set', normalized: true },
+  );
+});
+
+test('formatMcpToolsForAgent advertises qualified server__tool names only', () => {
+  const listing = formatMcpToolsForAgent(resolveFixtureStatus);
+  assert.match(listing, /cme__cme_status/);
+  assert.match(listing, /production__production_start_job/);
+  // No bare tool name outside a qualified form.
+  assert.doesNotMatch(listing, /(?<![\w])cme_status(?![\w])/);
+  assert.doesNotMatch(listing, /(?<![\w])production_start_job(?![\w])/);
+});
 
 test('buildMcpStatus reads external MCP endpoints from mcp.endpoints.json', async () => {
   const originalCwd = process.cwd();
@@ -448,3 +517,27 @@ test('callMcpTool parses SSE responses after keepalive comments', async () => {
     globalThis.fetch = originalFetch;
   }
 });
+
+test('truncateToolResult keeps short results intact and bounds long ones head+tail', () => {
+  assert.equal(truncateToolResult('short result', 100), 'short result');
+
+  const long = `START-${'x'.repeat(50000)}-END`;
+  const bounded = truncateToolResult(long, 1000);
+  assert.ok(bounded.length < 1200, `bounded length ${bounded.length} should stay near the cap`);
+  assert.match(bounded, /^START-/);
+  assert.match(bounded, /-END$/);
+  assert.match(bounded, /caractères tronqués/);
+});
+
+test('truncateToolResult honours WIKI_MANAGER_TOOL_RESULT_MAX_CHARS', () => {
+  const previous = process.env.WIKI_MANAGER_TOOL_RESULT_MAX_CHARS;
+  process.env.WIKI_MANAGER_TOOL_RESULT_MAX_CHARS = '500';
+  try {
+    const bounded = truncateToolResult('y'.repeat(5000));
+    assert.ok(bounded.length < 700);
+    assert.match(bounded, /caractères tronqués/);
+  } finally {
+    if (previous === undefined) delete process.env.WIKI_MANAGER_TOOL_RESULT_MAX_CHARS;
+    else process.env.WIKI_MANAGER_TOOL_RESULT_MAX_CHARS = previous;
+  }
+});

package/src/core/runtimeLog.js

@@ -61,7 +61,12 @@ export function normalizeRuntimeLog(input, { session = null } = {}) {
 }
 
 export function formatRuntimeLogPayload(payload = {}, ts = null) {
-  if (payload?.message != null && !payload.event) return String(payload.message);
+  // Plain messages get the same time prefix as structured events: untimed
+  // lines ended up visually glued at the bottom of Logs/Trace, out of
+  // chronology with the shell's own timestamped lines.
+  if (payload?.message != null && !payload.event) {
+    return [timeLabel(ts), String(payload.message)].filter(Boolean).join(' ');
+  }
   const time = timeLabel(ts);
   const event = eventLabel(payload.event);
   const fields = ORDERED_FIELDS

package/src/core/runtimeLog.test.js

@@ -80,5 +80,7 @@ test('emitRuntimeLog accepts structured payloads and preserves legacy strings',
   assert.match(session.agentProjection.logs[0], /ASSIGNED/);
   assert.match(session.agentProjection.logs[0], /run=run-structured/);
   assert.match(session.agentProjection.logs[0], /workspace=docs/);
-  assert.equal(session.agentProjection.logs[1], 'legacy line');
+  // Legacy plain messages now carry the same HH:MM:SS prefix as structured
+  // events so the Logs/Trace panel stays chronologically readable.
+  assert.match(session.agentProjection.logs[1], /^\d{2}:\d{2}:\d{2} legacy line$/);
 });

package/src/runtime/client.js

@@ -10,6 +10,14 @@ function runtimeEndpoint(url, path, workspace = null) {
   return endpoint.toString();
 }
 
+function runtimeEndpointWithParams(url, path, params = {}) {
+  const endpoint = new URL(`${base(url)}${path}`);
+  for (const [key, value] of Object.entries(params)) {
+    if (value != null && value !== '') endpoint.searchParams.set(key, String(value));
+  }
+  return endpoint.toString();
+}
+
 export function runtimeUrlFromEnv() {
   return process.env.WIKI_MANAGER_RUNTIME_URL ?? 'http://127.0.0.1:7788';
 }
@@ -97,6 +105,20 @@ export async function postRuntimeCancel({
   return response.json();
 }
 
+export async function postRuntimeKill({
+  url = runtimeUrlFromEnv(),
+  token = runtimeToken(),
+  workspace = null,
+  runId = null,
+} = {}) {
+  const response = await fetch(runtimeEndpointWithParams(url, '/kill', { workspace, runId }), {
+    method: 'POST',
+    headers: runtimeHeaders(token),
+  });
+  if (!response.ok && response.status !== 501) throw new Error(`Runtime kill failed: HTTP ${response.status}`);
+  return response.json();
+}
+
 export async function postRuntimeShutdown({
   url = runtimeUrlFromEnv(),
   token = runtimeToken(),

package/src/runtime/controlMessages.js

@@ -0,0 +1,43 @@
+// Deterministic, localized messages for the runtime control lane.
+//
+// Control-lane acknowledgements (run queued, ambiguous input, conversation
+// fallback…) are intentionally NOT generated by Donna: spending an LLM turn
+// to say "your request is queued" would reintroduce exactly the per-message
+// cost the orchestration refactor removed. But they are user-facing, so they
+// must follow the session's configured reply language. This catalog is the
+// single source for those strings — never hardcode a control-lane message in
+// the shell or the server directly.
+
+const CONTROL_MESSAGES = {
+  queued_for_future_run: {
+    en: 'Request added to the queue — it will start automatically after the current run.',
+    fr: 'Demande ajoutée à la file — elle démarrera automatiquement à la fin du run en cours.',
+  },
+  plan_patch_proposed: {
+    en: 'Plan patch proposed. Approve it explicitly to apply it to the active plan.',
+    fr: 'Modification de plan proposée. Approuvez-la explicitement pour l’appliquer au plan actif.',
+  },
+  ambiguous_control: {
+    en: 'A run is already active, and this looks like a new action. Say "queue it" to run it after the current run, "modify the run" to change the active plan, "cancel" to stop the current run first — or wait for it to finish.',
+    fr: 'Un run est déjà actif et ta demande ressemble à une nouvelle action. Dis « mets en file » pour l\'exécuter après le run en cours, « modifie le run » pour changer le plan actif, « annule » pour arrêter le run actuel — ou attends la fin.',
+  },
+  converse_while_running: {
+    en: 'Runtime run is still active. This message was treated as conversation and did not create a queued run.',
+    fr: 'Un run est toujours actif. Ce message a été traité comme conversation et n’a pas créé de run en file.',
+  },
+  converse_while_idle: {
+    en: 'Runtime is idle. This message was treated as conversation and did not create a run.',
+    fr: 'Le runtime est inactif. Ce message a été traité comme conversation et n’a pas créé de run.',
+  },
+};
+
+export function controlLanguage(session) {
+  const raw = String(session?.language ?? 'en').toLowerCase();
+  return raw.startsWith('fr') ? 'fr' : 'en';
+}
+
+export function controlMessage(session, key) {
+  const entry = CONTROL_MESSAGES[key];
+  if (!entry) throw new Error(`Unknown control message key: ${key}`);
+  return entry[controlLanguage(session)] ?? entry.en;
+}

package/src/runtime/controlMessages.test.js

@@ -0,0 +1,21 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { controlLanguage, controlMessage } from './controlMessages.js';
+
+test('controlLanguage maps fr locales to fr and everything else to en', () => {
+  assert.equal(controlLanguage({ language: 'fr-FR' }), 'fr');
+  assert.equal(controlLanguage({ language: 'fr' }), 'fr');
+  assert.equal(controlLanguage({ language: 'en-US' }), 'en');
+  assert.equal(controlLanguage({ language: null }), 'en');
+  assert.equal(controlLanguage(null), 'en');
+});
+
+test('controlMessage returns the localized queued acknowledgement', () => {
+  assert.match(controlMessage({ language: 'fr-FR' }, 'queued_for_future_run'), /ajoutée à la file/);
+  assert.match(controlMessage({ language: 'en-US' }, 'queued_for_future_run'), /added to the queue/);
+});
+
+test('controlMessage falls back to en for unknown locales and throws on unknown keys', () => {
+  assert.match(controlMessage({ language: 'de-DE' }, 'queued_for_future_run'), /added to the queue/);
+  assert.throws(() => controlMessage({ language: 'fr-FR' }, 'nope'), /Unknown control message key/);
+});

package/src/runtime/donna-contract.test.js

@@ -531,7 +531,7 @@ function toolResult(payload) {
 }
 
 test('Recipe #7 — "où en es-tu ?" during an active run: status in conversation, run continues, no new run', async (t) => {
-  const session = { workspace: 'juno', controlQueue: [] };
+  const session = { workspace: 'acme', controlQueue: [] };
   let runCount = 0;
   let handle;
   try {
@@ -550,7 +550,7 @@ test('Recipe #7 — "où en es-tu ?" during an active run: status in conversatio
         listEvents: () => [],
       },
       getContext: async () => ({
-        workspace: 'juno',
+        workspace: 'acme',
         session,
         running: true,
         currentAbortController: new AbortController(),
@@ -566,7 +566,7 @@ test('Recipe #7 — "où en es-tu ?" during an active run: status in conversatio
   }
 
   try {
-    const response = await fetch(`http://127.0.0.1:${handle.port}/control?workspace=juno`, {
+    const response = 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: 'où en es-tu ?' }),

package/src/runtime/recoveryManager.js

@@ -1,6 +1,7 @@
 import { parseJsonText } from '../core/activity.js';
 import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
 import { formatMcpToolResult, callMcpTool as defaultCallMcpTool } from '../core/mcp.js';
+import { createCapabilityRegistry } from '../orchestrator/capabilityRegistry.js';
 import { accept as acceptResult } from '../orchestrator/resultAggregator.js';
 
 const ACTIVE_TASK_STATUSES = new Set(['running', 'queued', 'starting', 'assigned']);
@@ -24,9 +25,11 @@ export async function recoverActiveRuns({
   for (const run of runs) {
     const tasks = store.listTasks?.({ runId: run.id }) ?? [];
     const activeTasks = tasks.filter((task) => ACTIVE_TASK_STATUSES.has(String(task.status ?? '').toLowerCase()));
+    const runOutcomes = [];
     for (const task of activeTasks) {
       try {
         const outcome = await recoverTask({ store, session, run, task, callTool, resultAggregator });
+        runOutcomes.push(outcome ?? null);
         if (outcome?.status === 'recovered') recovered.push(outcome);
         else if (outcome?.status === 'rescheduled') rescheduled.push(outcome);
         else if (outcome?.status === 'interrupted') interrupted.push(outcome);
@@ -34,6 +37,21 @@ export async function recoverActiveRuns({
         errors.push({ runId: run.id, taskId: task.id, error: error instanceof Error ? error.message : String(error) });
       }
     }
+    // A run in which nothing was recovered or rescheduled can never progress:
+    // leaving it 'running' in the store would re-attach it as a zombie on
+    // every subsequent boot. Close it for good.
+    if (activeTasks.length > 0 && runOutcomes.length === activeTasks.length
+      && runOutcomes.every((outcome) => outcome?.status === 'interrupted')) {
+      const changed = store.interruptRuns?.({ workspace: run.workspace ?? null, runId: run.id, reason: 'Recovery found no recoverable task.' }) ?? 0;
+      if (changed > 0) {
+        dispatch(session, store, 'runtime_log', {
+          origin: 'recovery_manager',
+          runId: run.id,
+          workspace: run.workspace ?? workspaceFromSession(session),
+          payload: { message: `recovery: run ${run.id} interrupted (no recoverable task)` },
+        });
+      }
+    }
   }
 
   return {
@@ -46,6 +64,28 @@ export async function recoverActiveRuns({
 }
 
 async function recoverTask({ store, session, run, task, callTool, resultAggregator }) {
+  // A task whose capability no longer resolves can never be dispatched:
+  // re-attaching it would recreate the forever-waiting queue it came from.
+  // Fail it explicitly instead. No registry information at all (discovery
+  // not run yet) keeps the current behavior.
+  if (task.requiredCapability && !capabilityResolvable(session, task.requiredCapability)) {
+    dispatch(session, store, 'plan_step_updated', {
+      origin: 'recovery_manager',
+      runId: run.id,
+      taskId: task.id,
+      workspace: run.workspace ?? workspaceFromSession(session),
+      payload: {
+        taskId: task.id,
+        status: 'failed',
+        recovery: {
+          reason: 'unresolvable_capability',
+          capability: task.requiredCapability,
+        },
+      },
+    });
+    return interruptTask({ store, session, run, task, reason: `unresolvable capability: ${task.requiredCapability}` });
+  }
+
   const attempt = latestAttempt(store.listTaskAttempts?.({ taskId: task.id }) ?? []);
   const assignment = latestAssignment(store.listTaskAssignments?.({ taskId: task.id }) ?? [], attempt?.attemptId);
   if (!attempt?.jobId || !assignment?.agentInstanceId) {
@@ -126,6 +166,20 @@ function isTerminal(status) {
   return TERMINAL_STATUSES.has(String(status ?? '').toLowerCase());
 }
 
+function capabilityResolvable(session, capability) {
+  const registry = session.capabilityRegistry
+    ?? ((session.agentRegistrySnapshot ?? []).length > 0
+      ? createCapabilityRegistry({ agents: session.agentRegistrySnapshot })
+      : null);
+  if (!registry || typeof registry.providersFor !== 'function') return true;
+  // Only trust a registry that actually knows about capabilities. An empty
+  // one (discovery not finished, or agents described without capability
+  // lists) cannot distinguish "nothing provides X" from "no information".
+  const snapshot = typeof registry.snapshot === 'function' ? registry.snapshot() : {};
+  if (Object.keys(snapshot ?? {}).length === 0) return true;
+  return registry.providersFor(capability).length > 0;
+}
+
 function parseToolPayload(result) {
   if (result && typeof result === 'object' && !Array.isArray(result) && !Array.isArray(result.content)) return result;
   return parseJsonText(formatMcpToolResult(result)) ?? {};