@dotdrelle/wiki-manager 0.14.6 → 0.14.7

package/.env.example

@@ -59,6 +59,9 @@ DOCUMENTS_MCP_AUTH_TOKEN=
 # Tool calls are retried on transient HTTP/MCP errors before the run fails.
 # WIKI_MANAGER_MCP_RETRY_MAX_ATTEMPTS=2
 # WIKI_MANAGER_MCP_RETRY_BACKOFF_MS=500
+# Outbound MCP control budget, separate from .wikirc LLM requestsPerMinute.
+# Default: 45 RPM (headroom for MCP servers limited to 50 RPM).
+# WIKI_MANAGER_MCP_REQUESTS_PER_MINUTE=45
 
 # ── Runtime evaluator (optional) ───────────────────────────────────────────────
 

package/README.md

@@ -498,6 +498,10 @@ Copy `mcp.endpoints.example.json` to `mcp.endpoints.json` and set the matching
 token variables in `.env`.
 
 MCP `tools/call` requests retry transient HTTP/MCP failures before the run fails.
+They also share a per-endpoint outbound control budget (45 RPM by default,
+configurable with `WIKI_MANAGER_MCP_REQUESTS_PER_MINUTE`). This budget is
+independent from `.wikirc` `requestsPerMinute`, which remains reserved for LLM,
+embedding, and reranking provider calls.
 Set global defaults with `WIKI_MANAGER_MCP_RETRY_MAX_ATTEMPTS` and
 `WIKI_MANAGER_MCP_RETRY_BACKOFF_MS`, or override them per endpoint with `retry`
 and per tool with `toolRetries`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotdrelle/wiki-manager",
-  "version": "0.14.6",
+  "version": "0.14.7",
   "description": "Agentic shell and orchestration cockpit for llm-wiki workspaces.",
   "license": "PolyForm-Noncommercial-1.0.0",
   "author": "dotrelle",

package/src/agent/graph.js

@@ -711,7 +711,12 @@ async function handleRuntimeControlTool(session, tool, args = {}) {
       if (!objective) return 'Delegation rejected: missing objective.';
       const result = await postRuntimeDelegate(objective, { url, workspace });
       return result?.runId
-        ? `Action lancée (${String(result.runId).slice(0, 8)}) après validation du plan réel : ${result.delegation?.tasks ?? 0} tâche(s), ${result.delegation?.agent ?? 'agent résolu'}. Exécution en cours.`
+        ? JSON.stringify({
+            delegated: true,
+            runId: result.runId,
+            summary: result.delegation ?? null,
+            message: `Action lancée (${String(result.runId).slice(0, 8)}) après validation du plan réel : ${result.delegation?.tasks ?? 0} tâche(s), ${result.delegation?.agent ?? 'agent résolu'}. Exécution en cours.`,
+          })
         : `Délégation refusée : ${result?.error ?? JSON.stringify(result)}`;
     }
     if (tool === 'enqueue') {

package/src/agent/graph.test.js

@@ -372,17 +372,24 @@ test('Donna delegates the objective without choosing technical identifiers', asy
             }],
           };
         }
+        const delegateResult = (messages ?? []).filter((message) => message.role === 'tool').at(-1);
+        const parsedDelegateResult = JSON.parse(String(delegateResult?.content ?? '{}'));
+        assert.equal(parsedDelegateResult.delegated, true);
+        assert.equal(parsedDelegateResult.runId, 'run-1');
+        assert.equal(parsedDelegateResult.summary.tasks, 5);
         return { content: 'Plan validé.', message: { role: 'assistant', content: 'Plan validé.' }, tool_calls: null };
       },
     },
   });
 
   try {
-    await createAgentGraph().invoke({ input: 'ingère tout', session });
+    const result = await createAgentGraph().invoke({ input: 'ingère tout', session });
     assert.match(request.url, /\/delegate/);
     assert.deepEqual(request.body, { objective: 'Ingérer tous les fichiers en attente', workspace: 'docs' });
     assert.equal('capability' in request.body, false);
     assert.equal('operation' in request.body, false);
+    assert.equal(result.response, 'Plan validé.');
+    assert.doesNotMatch(result.response, /delegated|run-1|production/);
   } finally {
     globalThis.fetch = originalFetch;
   }

package/src/cli/wiki-manager.js

@@ -13,7 +13,7 @@ import { listWikircProfiles } from '../core/wikirc.js';
 import { callMcpTool, formatMcpToolResult } from '../core/mcp.js';
 import { extractActivity, parseJsonText, sessionActivities, terminalFailures } from '../core/activity.js';
 import { syncActivitiesToPlan, formatPlanStatus } from '../core/plan.js';
-import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
+import { createAgentEvent, dispatchAgentEvent, reduceAgentEvents } from '../core/agentEvents.js';
 import { runAgentTurn, runAgenticLoop } from '../core/agentLoop.js';
 import { resolveCapabilityConcurrency } from '../orchestrator/scheduler.js';
 import { capabilityRegistryForSession } from '../orchestrator/capabilityRegistry.js';
@@ -57,6 +57,40 @@ function createSession() {
   };
 }
 
+export function createInteractiveSession(context, { runtimeUrl, turnId, signal = null } = {}) {
+  const source = context.session;
+  const session = createSession();
+  for (const key of [
+    'workspace', 'workspacePath', 'workspaceEnvFile', 'workspaceEnv',
+    'wikirc', 'wikircConfig', 'language', 'llm', 'mcp', 'commands',
+    'packageJson', 'queueStore', 'systemPrompt',
+  ]) {
+    if (source[key] !== undefined) session[key] = source[key];
+  }
+  session.runtime = runtimeUrl ? { url: runtimeUrl } : null;
+  session.headless = true;
+  session.chatMode = false;
+  session.chatAccess = null;
+  session.conversations = { [session.workspace || '__global__']: [] };
+  session.agentEvents = [];
+  session.activities = {};
+  session.productionActivity = null;
+  session.jobQueue = [];
+  session.headlessPlan = null;
+  session.turnId = turnId ?? null;
+  session._abortSignal = signal;
+  return session;
+}
+
+export function ensureInteractiveAssistantMessage(session, response, { turnId, workspace } = {}) {
+  const content = String(response ?? '').trim();
+  if (!content || session.agentEvents.some((event) => event.type === 'assistant_message')) return false;
+  dispatchAgentEvent(session, createAgentEvent('assistant_message', {
+    origin: 'runtime_turn', turnId, workspace, payload: { content: String(response) },
+  }));
+  return true;
+}
+
 export async function forwardRuntimeApproval(getWorkspaceContext, request = {}) {
   const context = await getWorkspaceContext(request.workspace ?? null);
   return context.approvalManager?.approve(request) ?? { approved: false };
@@ -455,7 +489,7 @@ async function runRuntime(argv, agent) {
   const { resolveRuntimeAuthToken } = await import('../runtime/auth.js');
   const { createSqliteQueueStore } = await import('../runtime/queueStore.js');
   const { createApprovalManager } = await import('../runtime/approvals.js');
-  const { runRuntimeAgenticWorkflow } = await import('../runtime/runner.js');
+  const { conversationSeed, runRuntimeAgenticWorkflow } = await import('../runtime/runner.js');
 
   const host = valueAfter(argv, '--host') ?? process.env.WIKI_MANAGER_RUNTIME_HOST ?? '127.0.0.1';
   const port = Number(valueAfter(argv, '--port') ?? process.env.WIKI_MANAGER_RUNTIME_PORT ?? 7788);
@@ -465,6 +499,8 @@ async function runRuntime(argv, agent) {
   if (!Number.isInteger(port) || port <= 0 || port > 65535) {
     throw new Error(`Invalid runtime port: ${port}`);
   }
+  const selfRuntimeUrl = process.env.WIKI_MANAGER_RUNTIME_URL
+    ?? `http://${host === '0.0.0.0' ? '127.0.0.1' : host}:${port}`;
 
   const store = openRuntimeStore({ stateDir });
   let serverHandle = null;
@@ -480,6 +516,7 @@ async function runRuntime(argv, agent) {
       session.headless = true;
       session.chatMode = false;
       session.packageJson = packageJson;
+      session.runtime = { url: selfRuntimeUrl };
 
       if (requestedWorkspace) {
         const result = await handleSlashCommand(`/use ${requestedWorkspace}`, { packageJson, session });
@@ -968,6 +1005,48 @@ async function runRuntime(argv, agent) {
     }
   }
 
+  async function executeInteractiveTurn(context, body, { signal, turnId } = {}) {
+    const input = String(body.input ?? body.prompt ?? '').trim();
+    if (!input) throw new Error('Missing input.');
+    const ephemeral = createInteractiveSession(context, { runtimeUrl: selfRuntimeUrl, turnId, signal });
+    // Seed from a freshly reduced COPY of persisted events. Interactive turn
+    // events deliberately do not mutate the canonical run projection, so the
+    // canonical session alone is not a reliable conversation-history source.
+    const persistedProjection = reduceAgentEvents(store.listEvents({
+      workspace: context.workspace ?? ephemeral.workspace ?? null,
+    }));
+    const messages = conversationSeed({ agentProjection: persistedProjection }, input);
+    ephemeral._onAgentEvent = (event) => {
+      const interactiveEvent = {
+        ...event,
+        origin: 'runtime_turn',
+        turnId,
+        runId: null,
+        workspace: context.workspace ?? ephemeral.workspace ?? null,
+      };
+      store.persistEvent(interactiveEvent);
+      serverHandle?.publish(interactiveEvent);
+    };
+    ephemeral._onStep = (message) => dispatchAgentEvent(ephemeral, createAgentEvent('runtime_log', {
+      origin: 'runtime_turn',
+      turnId,
+      workspace: context.workspace ?? null,
+      payload: { message },
+    }));
+    dispatchAgentEvent(ephemeral, createAgentEvent('user_message', {
+      origin: 'runtime_turn',
+      turnId,
+      workspace: context.workspace ?? null,
+      payload: { content: input },
+    }));
+    const response = await runAgentTurn(agent, ephemeral, input, { messages, signal });
+    ensureInteractiveAssistantMessage(ephemeral, response, {
+      turnId,
+      workspace: context.workspace ?? null,
+    });
+    return response;
+  }
+
   serverHandle = await startRuntimeServer({
     host,
     port,
@@ -977,6 +1056,7 @@ async function runRuntime(argv, agent) {
       .filter((context) => context?.running)
       .map((context) => ({ workspace: context.workspace ?? null, runId: context.currentRunId ?? null })),
     run: executeRun,
+    turn: executeInteractiveTurn,
     delegate: prepareDelegation,
     cancel: (context) => emitRuntimeLog(context.session, 'runtime: cancel requested'),
     resume: ({ workspace }) => recoverRuntime({ workspace, manual: true }),

package/src/core/buildInfo.json

@@ -1,4 +1,4 @@
 {
-  "version": "0.14.6",
-  "commit": "d1163a1"
+  "version": "0.14.7",
+  "commit": "f17765a"
 }

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.14.6';
+const WIKI_MANAGER_VERSION = '0.14.7';
 
 function envValue(key) {
   const filePath = managerEnvFile();
@@ -125,6 +125,14 @@ const DEFAULT_MCP_RETRY_POLICY = {
   backoffMs: 500,
 };
 
+// MCP control traffic has its own budget. It must never consume or reduce the
+// provider RPM configured in .wikirc, which is reserved for LLM/vector calls.
+// Keep a little headroom below the commonly deployed 50 RPM MCP limit for
+// initialize/list-tools and other non-tool-call requests.
+const DEFAULT_MCP_REQUESTS_PER_MINUTE = 45;
+const mcpThrottleQueues = new Map();
+const mcpThrottleStarts = new Map();
+
 export function buildMcpStatus(session) {
   // Attach the /chat read-tool policy to the session alongside MCP status.
   // Only /chat (repl.js) reads session.chatAccess; /agent ignores it.
@@ -304,6 +312,7 @@ export async function callMcpTool(mcpStatus, serverName, toolName, args = {}, si
   const timeoutMs = serverName === 'documents' && toolName === 'documents_convert_to_markdown' ? 600_000 : 8000;
   const retry = resolveRetryPolicy(endpoint, toolName, options.retry);
   return withRetry(async () => {
+    await throttleMcpRequestStart(endpoint, signal);
     const payload = await mcpRequest(endpoint, 'tools/call', {
       name: toolName,
       arguments: toolArgs,
@@ -315,6 +324,47 @@ export async function callMcpTool(mcpStatus, serverName, toolName, args = {}, si
   }, retry, { signal, onRetry: options.onRetry });
 }
 
+async function throttleMcpRequestStart(endpoint, signal) {
+  const configured = Number(
+    endpoint.requestsPerMinute
+      ?? endpoint.rateLimit?.requestsPerMinute
+      ?? envValue('WIKI_MANAGER_MCP_REQUESTS_PER_MINUTE'),
+  );
+  const requestsPerMinute = Number.isFinite(configured) && configured > 0
+    ? Math.floor(configured)
+    : DEFAULT_MCP_REQUESTS_PER_MINUTE;
+  const configuredWindowMs = Number(envValue('WIKI_MANAGER_MCP_RATE_LIMIT_WINDOW_MS'));
+  const windowMs = Number.isFinite(configuredWindowMs) && configuredWindowMs > 0
+    ? configuredWindowMs
+    : 60_000;
+  const key = String(endpoint.url ?? endpoint.name ?? 'mcp');
+  const previous = mcpThrottleQueues.get(key) ?? Promise.resolve();
+  const next = previous.catch(() => {}).then(async () => {
+    while (true) {
+      if (signal?.aborted) throw signal.reason ?? new Error('MCP request aborted.');
+      const now = Date.now();
+      const starts = (mcpThrottleStarts.get(key) ?? []).filter((at) => now - at < windowMs);
+      if (starts.length < requestsPerMinute) {
+        starts.push(now);
+        mcpThrottleStarts.set(key, starts);
+        return;
+      }
+      await retryDelay(Math.max(1, windowMs - (now - starts[0])), signal);
+    }
+  });
+  mcpThrottleQueues.set(key, next);
+  try {
+    await next;
+  } finally {
+    if (mcpThrottleQueues.get(key) === next) mcpThrottleQueues.delete(key);
+  }
+}
+
+export function resetMcpThrottleForTests() {
+  mcpThrottleQueues.clear();
+  mcpThrottleStarts.clear();
+}
+
 export function formatMcpToolResult(result) {
   if (!result) return 'No result.';
   const content = result.content;

package/src/core/mcp.test.js

@@ -8,6 +8,7 @@ import {
   callMcpTool,
   discoverMcpTools,
   formatMcpToolsForAgent,
+  resetMcpThrottleForTests,
   resolveRetryPolicy,
   resolveToolCallName,
   truncateToolResult,
@@ -361,6 +362,44 @@ test('callMcpTool sends configured endpoint headers', async () => {
   }
 });
 
+test('callMcpTool throttles MCP traffic independently per endpoint', async () => {
+  const originalFetch = globalThis.fetch;
+  const originalWindow = process.env.WIKI_MANAGER_MCP_RATE_LIMIT_WINDOW_MS;
+  const starts = [];
+  globalThis.fetch = async () => {
+    starts.push(Date.now());
+    return {
+      ok: true,
+      status: 200,
+      headers: { get: () => null },
+      text: async () => JSON.stringify({ result: { content: [{ type: 'text', text: '{"ok":true}' }] } }),
+    };
+  };
+  process.env.WIKI_MANAGER_MCP_RATE_LIMIT_WINDOW_MS = '30';
+  resetMcpThrottleForTests();
+
+  try {
+    const status = {
+      production: {
+        status: 'connected',
+        url: 'http://127.0.0.1:3000/mcp/',
+        requestsPerMinute: 1,
+      },
+    };
+    await Promise.all([
+      callMcpTool(status, 'production', 'agent_status', { jobId: 'a' }),
+      callMcpTool(status, 'production', 'agent_status', { jobId: 'b' }),
+    ]);
+    assert.equal(starts.length, 2);
+    assert.ok(starts[1] - starts[0] >= 20, `expected throttling delay, got ${starts[1] - starts[0]}ms`);
+  } finally {
+    globalThis.fetch = originalFetch;
+    if (originalWindow == null) delete process.env.WIKI_MANAGER_MCP_RATE_LIMIT_WINDOW_MS;
+    else process.env.WIKI_MANAGER_MCP_RATE_LIMIT_WINDOW_MS = originalWindow;
+    resetMcpThrottleForTests();
+  }
+});
+
 test('callMcpTool retries transient MCP failures', async () => {
   const originalFetch = globalThis.fetch;
   let attempts = 0;
@@ -528,4 +567,3 @@ test('truncateToolResult keeps short results intact and bounds long ones head+ta
   assert.match(bounded, /-END$/);
   assert.match(bounded, /caractères tronqués/);
 });
-

package/src/runtime/server.js

@@ -15,6 +15,7 @@ export function startRuntimeServer({
   session = null,
   getContext,
   run,
+  turn,
   delegate,
   cancel,
   resume,
@@ -276,6 +277,73 @@ export function startRuntimeServer({
         }
         return;
       }
+      if (request.method === 'POST' && url.pathname === '/turn') {
+        const { body, context } = await resolveBodyContext(request, url);
+        const input = String(body.input ?? body.prompt ?? '').trim();
+        if (!input) {
+          sendJson(response, 400, { error: 'Missing input.' });
+          return;
+        }
+        if (context.running) {
+          const result = await handleControlMessage(context, store, input, {
+            intent: body.intent,
+            startNextControlRequest,
+            cancel,
+            approve,
+          });
+          sendJson(response, result.statusCode, result.body);
+          return;
+        }
+        if (typeof turn !== 'function') {
+          sendJson(response, 501, { error: 'Runtime interactive turns are unavailable.' });
+          return;
+        }
+        const turnId = `turn-${randomUUID()}`;
+        const controller = new AbortController();
+        const previous = context.interactiveTurn ?? Promise.resolve();
+        const current = previous.catch(() => {}).then(async () => {
+          // A preceding serialized turn may have delegated and started a run
+          // after this request was accepted. Reclassify against the fresh
+          // state instead of starting another interactive decision in parallel.
+          if (context.running) {
+            const result = await handleControlMessage(context, store, input, {
+              intent: body.intent,
+              startNextControlRequest,
+              cancel,
+              approve,
+            });
+            publish(createAgentEvent('assistant_message', {
+              origin: 'runtime_turn',
+              turnId,
+              workspace: context.workspace ?? null,
+              payload: { content: result.body?.explanation ?? 'Runtime control request processed.' },
+            }));
+            return result.body;
+          }
+          return turn(context, { ...body, input }, {
+            signal: controller.signal,
+            turnId,
+          });
+        });
+        context.interactiveTurn = current;
+        void current.catch((err) => {
+          publish(createAgentEvent('assistant_message', {
+            origin: 'runtime_turn',
+            turnId,
+            workspace: context.workspace ?? null,
+            payload: { content: `Runtime turn failed: ${err instanceof Error ? err.message : String(err)}` },
+          }));
+        }).finally(() => {
+          if (context.interactiveTurn === current) context.interactiveTurn = null;
+        });
+        sendJson(response, 202, {
+          accepted: true,
+          kind: 'turn',
+          turnId,
+          workspace: context.workspace ?? null,
+        });
+        return;
+      }
       if (request.method === 'POST' && url.pathname === '/delegate') {
         const { body, context } = await resolveBodyContext(request, url);
         const objective = String(body.objective ?? '').trim();

package/src/runtime/server.test.js

@@ -1,8 +1,45 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
 import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
+import { createInteractiveSession, ensureInteractiveAssistantMessage } from '../cli/wiki-manager.js';
 import { startRuntimeServer } from './server.js';
 
+test('interactive runtime sessions isolate canonical run state', () => {
+  const mcp = { wiki: { status: 'connected' } };
+  const session = createInteractiveSession({ session: {
+    workspace: 'demo', workspacePath: '/workspace/demo', mcp,
+    llm: { invoke() {} }, commands: ['status'], packageJson: {}, queueStore: {},
+    _currentRunIdentity: { runId: 'run-1' }, headlessPlan: [{ id: 'task-1' }],
+    agentProjection: { status: 'running' }, _agentProjectionState: {},
+    controlQueue: [{}], planPatches: [{}], _requestApproval() {}, agents: [{}], agentRegistry: {},
+  } }, { runtimeUrl: 'http://127.0.0.1:7788', turnId: 'turn-1' });
+
+  assert.equal(session.mcp, mcp);
+  assert.deepEqual(session.runtime, { url: 'http://127.0.0.1:7788' });
+  assert.equal(session.headlessPlan, null);
+  assert.deepEqual(session.activities, {});
+  assert.deepEqual(session.jobQueue, []);
+  for (const key of [
+    '_currentRunIdentity', 'agentProjection', '_agentProjectionState', 'controlQueue',
+    'planPatches', '_requestApproval', 'agents', 'agentRegistry',
+  ]) assert.equal(Object.hasOwn(session, key), false, `${key} must not leak`);
+});
+
+test('interactive turns publish a fallback assistant message exactly once', () => {
+  const published = [];
+  const session = { agentEvents: [], _onAgentEvent: (event) => published.push(event) };
+  assert.equal(ensureInteractiveAssistantMessage(session, 'Réponse concise.', {
+    turnId: 'turn-1', workspace: 'demo',
+  }), true);
+  assert.equal(ensureInteractiveAssistantMessage(session, 'Réponse dupliquée.', {
+    turnId: 'turn-1', workspace: 'demo',
+  }), false);
+  assert.equal(published.length, 1);
+  assert.equal(published[0].type, 'assistant_message');
+  assert.equal(published[0].origin, 'runtime_turn');
+  assert.equal(published[0].payload.content, 'Réponse concise.');
+});
+
 test('runtime server checks bearer and x-runtime-token credentials', async (t) => {
   let handle;
   try {
@@ -1397,6 +1434,50 @@ test('runtime server answers control messages posted to /run during an active ru
   }
 });
 
+test('runtime server accepts an interactive turn without starting a run', async (t) => {
+  const context = { workspace: 'demo', session: {}, running: false };
+  let received = null;
+  let handle;
+  try {
+    handle = await startRuntimeServer({
+      host: '127.0.0.1',
+      port: 0,
+      token: 'runtime-secret',
+      store: {
+        dbPath: ':memory:',
+        getState: () => ({ status: 'idle' }),
+        listEvents: () => [],
+      },
+      getContext: async () => context,
+      run: async () => assert.fail('/turn must not start a runtime run'),
+      turn: async (_context, body, meta) => { received = { body, meta }; },
+    });
+  } catch (err) {
+    if (err?.code === 'EPERM') {
+      t.skip('network listen is not permitted in this sandbox');
+      return;
+    }
+    throw err;
+  }
+  try {
+    const response = await fetch(`http://127.0.0.1:${handle.port}/turn`, {
+      method: 'POST',
+      headers: { authorization: 'Bearer runtime-secret', 'content-type': 'application/json' },
+      body: JSON.stringify({ input: 'Quels documents sont en attente ?', workspace: 'demo' }),
+    });
+    assert.equal(response.status, 202);
+    const body = await response.json();
+    assert.equal(body.kind, 'turn');
+    assert.match(body.turnId, /^turn-/);
+    await context.interactiveTurn;
+    assert.equal(received.body.input, 'Quels documents sont en attente ?');
+    assert.equal(received.meta.turnId, body.turnId);
+    assert.equal(context.running, false);
+  } finally {
+    await handle.close();
+  }
+});
+
 test('runtime health reports active runs across workspaces', async (t) => {
   let handle;
   try {