@dotdrelle/wiki-manager 0.12.1 → 0.12.8

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.8",
+  "commit": "eefd59f"
+}

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/env.js

@@ -1,5 +1,6 @@
-import { existsSync, readFileSync } from 'node:fs';
+import { copyFileSync, existsSync, readFileSync } from 'node:fs';
 import { dirname, isAbsolute, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
 
 export function userManagerDir() {
   return process.cwd();
@@ -31,6 +32,34 @@ export function managerMcpEndpointsFile() {
   return join(managerStateDir(), 'mcp.endpoints.json');
 }
 
+const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..', '..');
+
+// First-run scaffolding: a fresh install directory has neither
+// mcp.endpoints.json nor .env, so the external agents (cme, mailer,
+// documents) silently never connect — /status shows no agents and Donna has
+// no CME tools to configure anything with. Copy the packaged examples so a
+// fresh directory works out of the box with the default agent ports; the
+// user only has to fill in tokens/keys.
+export function ensureManagerScaffold({ log = () => {} } = {}) {
+  const created = [];
+  const endpointsFile = managerMcpEndpointsFile();
+  const endpointsExample = join(packageRoot, 'mcp.endpoints.example.json');
+  if (!existsSync(endpointsFile) && existsSync(endpointsExample)) {
+    copyFileSync(endpointsExample, endpointsFile);
+    created.push('mcp.endpoints.json');
+  }
+  const envFile = managerEnvFile();
+  const envExample = join(packageRoot, '.env.example');
+  if (!existsSync(envFile) && existsSync(envExample)) {
+    copyFileSync(envExample, envFile);
+    created.push('.env');
+  }
+  if (created.length > 0) {
+    log(`scaffold: created ${created.join(' and ')} in ${managerStateDir()} from packaged example(s) — fill in tokens/keys (WIKI_WORKSPACES_DIR, *_MCP_AUTH_TOKEN…) before starting agents.`);
+  }
+  return created;
+}
+
 // Single source of truth for where `.agents-data` lives, shared by the
 // manager's own document intake and by the host path it mounts into agent
 // containers — keeping them in sync avoids the two silently drifting apart.

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.1';
+const WIKI_MANAGER_VERSION = '0.12.8';
 
 function envValue(key) {
   const filePath = managerEnvFile();
@@ -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) {

package/src/core/mcp.test.js

@@ -10,6 +10,7 @@ import {
   formatMcpToolsForAgent,
   resolveRetryPolicy,
   resolveToolCallName,
+  truncateToolResult,
 } from './mcp.js';
 
 const resolveFixtureStatus = {
@@ -516,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

@@ -18,8 +18,8 @@ const CONTROL_MESSAGES = {
     fr: 'Modification de plan proposée. Approuvez-la explicitement pour l’appliquer au plan actif.',
   },
   ambiguous_control: {
-    en: 'The runtime cannot safely classify this message.',
-    fr: 'Le runtime ne peut pas classer ce message de façon sûre.',
+    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.',

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)) ?? {};

package/src/runtime/recoveryManager.test.js

@@ -160,3 +160,76 @@ function recoverySession() {
     }],
   };
 }
+
+test('recoveryManager fails unresolvable-capability tasks and interrupts the run', async () => {
+  const { store, root, runId, taskId } = storeWithActiveTask();
+  const session = recoverySession();
+  // A registry that DOES know capabilities, but not the task's one: the plan
+  // came from a hallucinated capability (the 0.12.1 incident) — re-attaching
+  // it would recreate a forever-waiting queue on every boot.
+  session.agentRegistrySnapshot = [{
+    agentInstanceId: 'production-main',
+    serverName: 'production',
+    health: 'available',
+    description: {
+      agentType: 'production',
+      contractVersion: '1',
+      capabilities: [{ id: 'knowledge.pipeline', version: '1' }],
+    },
+  }];
+  store.hydrateSession(session, { workspace: 'docs' });
+  const statusCalls = [];
+
+  try {
+    const result = await recoverActiveRuns({
+      store,
+      session,
+      workspace: 'docs',
+      callTool: async (_mcp, serverName, toolName, args) => {
+        statusCalls.push({ serverName, toolName, args });
+        return { content: [{ type: 'text', text: '{}' }] };
+      },
+    });
+
+    assert.equal(result.ok, true);
+    assert.equal(result.recovered.length, 0);
+    assert.equal(result.rescheduled.length, 0);
+    assert.equal(result.interrupted.length, 1);
+    assert.match(result.interrupted[0].reason, /unresolvable capability: document\.build/);
+    assert.deepEqual(statusCalls, [], 'no agent_status poll for an unresolvable task');
+    assert.equal(store.listTasks({ runId })[0].status, 'failed');
+    // The run must not come back as a zombie on the next boot.
+    assert.deepEqual(store.listRecoverableRuns({ workspace: 'docs' }), []);
+  } finally {
+    store.close();
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+test('recoveryManager keeps recovering when the registry has no capability information', async () => {
+  const { store, root, runId, taskId } = storeWithActiveTask();
+  const session = recoverySession(); // snapshot without capability lists
+  store.hydrateSession(session, { workspace: 'docs' });
+
+  try {
+    const result = await recoverActiveRuns({
+      store,
+      session,
+      workspace: 'docs',
+      callTool: async (_mcp, _serverName, _toolName, args) => ({
+        content: [{ type: 'text', text: JSON.stringify({
+          jobId: args.jobId,
+          taskId,
+          status: 'done',
+          result: { status: 'succeeded', outputRefs: [], metrics: {} },
+        }) }],
+      }),
+    });
+
+    assert.equal(result.recovered.length, 1, 'uninformative registry must not block recovery');
+    assert.equal(store.listTasks({ runId })[0].status, 'done');
+  } finally {
+    store.close();
+    rmSync(root, { recursive: true, force: true });
+  }
+});