@dotdrelle/wiki-manager 0.15.29 → 0.15.34

package/src/orchestrator/agentRegistry.test.js

@@ -112,3 +112,76 @@ test('agentRegistry marks unavailable boot agents and emits health changes on re
   assert.equal(events[1].payload.health, 'available');
   assert.equal(registry.snapshot()[0].health, 'available');
 });
+
+test('discovery sends the workspace only to agents whose schema declares it', async () => {
+  const seen = {};
+  const registry = createAgentRegistry({
+    callTool: async (_mcp, server, _tool, args) => {
+      seen[server] = args;
+      return { content: [{ type: 'text', text: JSON.stringify(description()) }] };
+    },
+  });
+
+  await registry.discover({
+    workspace: 'acpi',
+    mcp: {
+      // Declares workspace: gets it, and can scope its vocabulary.
+      cme: {
+        status: 'connected',
+        tools: [{
+          name: 'agent_describe',
+          inputSchema: { type: 'object', properties: { workspace: { type: 'string' } }, additionalProperties: false },
+        }],
+      },
+      // Strict schema without workspace: sending it would be REJECTED, the
+      // agent would drop out of the registry, and its capabilities would
+      // silently vanish from objective resolution.
+      production: {
+        status: 'connected',
+        tools: [{
+          name: 'agent_describe',
+          inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+        }],
+      },
+      // Open schema: tolerant, so the workspace is worth sending.
+      connectors: {
+        status: 'connected',
+        tools: [{ name: 'agent_describe', inputSchema: { type: 'object', properties: {} } }],
+      },
+      // No schema published at all: assume nothing.
+      legacyish: {
+        status: 'connected',
+        tools: [{ name: 'agent_describe' }],
+      },
+    },
+  });
+
+  assert.deepEqual(seen.cme, { workspace: 'acpi' });
+  assert.deepEqual(seen.production, {});
+  assert.deepEqual(seen.connectors, { workspace: 'acpi' });
+  assert.deepEqual(seen.legacyish, {});
+});
+
+test('discovery sends no workspace argument when no workspace is active', async () => {
+  const seen = [];
+  const registry = createAgentRegistry({
+    callTool: async (_mcp, _server, _tool, args) => {
+      seen.push(args);
+      return { content: [{ type: 'text', text: JSON.stringify(description()) }] };
+    },
+  });
+
+  await registry.discover({
+    mcp: {
+      cme: {
+        status: 'connected',
+        tools: [{
+          name: 'agent_describe',
+          inputSchema: { type: 'object', properties: { workspace: { type: 'string' } } },
+        }],
+      },
+    },
+  });
+
+  assert.deepEqual(seen, [{}]);
+});

package/src/orchestrator/dispatcher.js

@@ -243,10 +243,15 @@ export function normalizeTaskError(rawError, { fallbackCode = null, fallbackMess
       retryable: transientError(fallbackCode),
     };
   }
+  // The agent gave a real reason. `fallbackMessage` describes only WHERE the
+  // failure was observed ("agent_execute rejected task"), so letting it win
+  // here replaced the one actionable sentence we have with a generic one —
+  // and Donna, left with nothing to explain, invented a cause. The fallback
+  // is a last resort, never an override.
   const code = String(rawError);
   return {
     code,
-    message: String(fallbackMessage ?? code),
+    message: code,
     retryable: transientError(code),
   };
 }

package/src/orchestrator/dispatcher.test.js

@@ -1,6 +1,6 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
-import { createDispatcher } from './dispatcher.js';
+import { createDispatcher, normalizeTaskError } from './dispatcher.js';
 
 test('dispatcher returns a retryable logical failure when agent_execute reports workspace_busy', async () => {
   const session = {
@@ -159,3 +159,26 @@ test('dispatcher keeps a null error when a terminal status reports none', async
   assert.equal(result.ok, true);
   assert.equal(result.error, null);
 });
+
+test('normalizeTaskError keeps the agent reason as the message, never the fallback', () => {
+  // Regression: the fallback describes only WHERE the failure was seen
+  // ("agent_execute rejected task"). Letting it win discarded the one
+  // actionable sentence — and left Donna to invent a cause.
+  const error = normalizeTaskError("Error: source 'acpi' not found", {
+    fallbackCode: 'execution_rejected',
+    fallbackMessage: 'agent_execute rejected task',
+  });
+
+  assert.equal(error.code, "Error: source 'acpi' not found");
+  assert.equal(error.message, "Error: source 'acpi' not found");
+});
+
+test('normalizeTaskError falls back only when the agent reports no reason at all', () => {
+  const error = normalizeTaskError('', {
+    fallbackCode: 'execution_rejected',
+    fallbackMessage: 'agent_execute rejected task',
+  });
+
+  assert.equal(error.code, 'execution_rejected');
+  assert.equal(error.message, 'agent_execute rejected task');
+});

package/src/runtime/auth.test.js

@@ -4,7 +4,7 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import test from 'node:test';
 import { resolveRuntimeAuthToken } from './auth.js';
-import { assertRuntimeNode, runtimeNodeExecutable, shutdownOwnedRuntime } from './lifecycle.js';
+import { assertRuntimeNode, runtimeNodeExecutable } from './lifecycle.js';
 
 test('resolveRuntimeAuthToken: loopback host does not require token', () => {
   const result = resolveRuntimeAuthToken({ host: '127.0.0.1', explicitToken: null });
@@ -27,67 +27,3 @@ test('runtime lifecycle uses a Node executable with node:sqlite support', async
   assert.ok(runtimeNode.executable);
   assert.ok(Number(runtimeNode.version.split('.')[0]) >= 22);
 });
-
-test('shutdownOwnedRuntime reports progress and stops an idle owned runtime', async () => {
-  const originalFetch = globalThis.fetch;
-  const calls = [];
-  const logs = [];
-  globalThis.fetch = async (url, options = {}) => {
-    calls.push({ url: String(url), method: options.method ?? 'GET' });
-    return new Response(JSON.stringify(calls.length === 1 ? { activeRuns: [] } : { shutdown: true }), {
-      status: calls.length === 1 ? 200 : 202,
-      headers: { 'content-type': 'application/json' },
-    });
-  };
-  try {
-    const result = await shutdownOwnedRuntime(
-      { url: 'http://127.0.0.1:7788', started: true, token: null },
-      { log: (message) => logs.push(message), timeoutMs: 100 },
-    );
-    assert.equal(result.action, 'shutdown');
-    assert.deepEqual(calls.map((call) => call.method), ['GET', 'POST']);
-    assert.match(logs.join('\n'), /runtime arrêté/);
-  } finally {
-    globalThis.fetch = originalFetch;
-  }
-});
-
-test('shutdownOwnedRuntime also stops an idle reused runtime', async () => {
-  const originalFetch = globalThis.fetch;
-  const calls = [];
-  globalThis.fetch = async (_url, options = {}) => {
-    calls.push(options.method ?? 'GET');
-    return new Response(JSON.stringify(calls.length === 1 ? { activeRuns: [] } : { shutdown: true }), {
-      status: calls.length === 1 ? 200 : 202,
-      headers: { 'content-type': 'application/json' },
-    });
-  };
-  try {
-    const result = await shutdownOwnedRuntime(
-      { url: 'http://127.0.0.1:7788', started: false, token: null },
-      { timeoutMs: 100 },
-    );
-    assert.equal(result.action, 'shutdown');
-    assert.deepEqual(calls, ['GET', 'POST']);
-  } finally {
-    globalThis.fetch = originalFetch;
-  }
-});
-
-test('shutdownOwnedRuntime bounds an unresponsive shutdown', async () => {
-  const originalFetch = globalThis.fetch;
-  const logs = [];
-  globalThis.fetch = async (_url, { signal } = {}) => new Promise((_resolve, reject) => {
-    signal?.addEventListener('abort', () => reject(new DOMException('aborted', 'AbortError')), { once: true });
-  });
-  try {
-    const result = await shutdownOwnedRuntime(
-      { url: 'http://127.0.0.1:7788', started: true, token: null },
-      { log: (message) => logs.push(message), timeoutMs: 5 },
-    );
-    assert.equal(result.action, 'timeout');
-    assert.match(logs.join('\n'), /délai de fermeture/);
-  } finally {
-    globalThis.fetch = originalFetch;
-  }
-});

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

@@ -146,7 +146,8 @@ test('CME setup and source configuration stay outside export orchestration', asy
   const calledTools = [];
   globalThis.fetch = async (_url, options = {}) => {
     const body = JSON.parse(String(options.body ?? '{}'));
-    calledTools.push(body.params?.name);
+    // Record tool calls only — the MCP session handshake is not a tool call.
+    if (body.method === 'tools/call') calledTools.push(body.params?.name);
     return {
       ok: true,
       status: 200,

package/src/runtime/lifecycle.js

@@ -139,36 +139,3 @@ export async function runtimeHealthOrNull(url = runtimeUrlFromEnv(), token = run
     return null;
   }
 }
-
-// Close the runtime attached to the shell when it is idle, including a process
-// reused at startup. Restricting cleanup to `started: true` left ownerless
-// runtimes occupying port 7788 with another manager directory/token.
-// An active run still survives the shell.
-export async function shutdownOwnedRuntime(runtime, { log = (_message) => {}, timeoutMs = 3000 } = {}) {
-  if (!runtime?.url) return { action: 'kept', reason: 'unavailable' };
-  const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), Math.max(1, Number(timeoutMs) || 3000));
-  try {
-    const health = await runtimeHealthOrNull(runtime.url, runtime.token, controller.signal);
-    if (!health) return { action: 'kept', reason: 'unreachable' };
-    const activeRuns = Array.isArray(health.activeRuns) ? health.activeRuns : [];
-    if (activeRuns.length > 0) {
-      const labels = activeRuns
-        .map((run) => [run.workspace, run.runId ? String(run.runId).slice(0, 8) : null].filter(Boolean).join('/'))
-        .join(', ');
-      log(`runtime laissé actif : run en cours (${labels}) — il survivra à ce shell ; relance wiki-manager pour le retrouver.`);
-      return { action: 'kept', reason: 'run_active', activeRuns };
-    }
-    await postRuntimeShutdown({ url: runtime.url, token: runtime.token, signal: controller.signal });
-    log('runtime arrêté (aucun run en cours).');
-    return { action: 'shutdown' };
-  } catch (err) {
-    if (controller.signal.aborted) {
-      log('délai de fermeture du runtime dépassé — le shell termine sans attendre davantage.');
-      return { action: 'timeout', reason: 'shutdown_timeout' };
-    }
-    return { action: 'error', reason: err instanceof Error ? err.message : String(err) };
-  } finally {
-    clearTimeout(timeout);
-  }
-}

package/src/runtime/runner.test.js

@@ -401,7 +401,16 @@ test('replanRuntimeRun requires runtime approval for mutating replanned work', a
 test('runRuntimeAgenticWorkflow replans after terminal activity error', async () => {
   const originalFetch = globalThis.fetch;
   let pollAttempts = 0;
-  globalThis.fetch = async () => {
+  globalThis.fetch = async (_url, init) => {
+    // Count polls, not the one-off MCP session handshake.
+    if (JSON.parse(init.body).method === 'initialize') {
+      return {
+        ok: true,
+        status: 200,
+        headers: { get: () => null },
+        text: async () => '{"jsonrpc":"2.0","id":0,"result":{"protocolVersion":"2025-06-18"}}',
+      };
+    }
     pollAttempts += 1;
     return {
       ok: true,

package/src/runtime/supervisor.test.js

@@ -93,7 +93,17 @@ test('pollActivitiesOnce does not repeat an unchanged retry state when retryAt m
 test('pollActivitiesOnce retries transient MCP poll failures', async () => {
   const originalFetch = globalThis.fetch;
   let attempts = 0;
-  globalThis.fetch = async () => {
+  globalThis.fetch = async (_url, init) => {
+    // The session handshake is not the thing under test: answer it, and make
+    // the first *poll* the transient failure.
+    if (JSON.parse(init.body).method === 'initialize') {
+      return {
+        ok: true,
+        status: 200,
+        headers: { get: () => null },
+        text: async () => '{"jsonrpc":"2.0","id":0,"result":{"protocolVersion":"2025-06-18"}}',
+      };
+    }
     attempts += 1;
     if (attempts === 1) {
       return {