@dotdrelle/wiki-manager 0.15.66 → 0.15.70

package/src/core/runtimeEventAdapter.js

@@ -0,0 +1,81 @@
+/**
+ * Adapter RuntimeEvent -> événements natifs du manager (RFC § 16).
+ *
+ * Le flux d'événements d'un runtime externe est traduit ici dans le
+ * vocabulaire du reducer (`core/agentEvents.js`) SANS aucune refonte de l'UI :
+ *
+ * - `message` devient un `assistant_message` : c'est ce que Donna affiche ;
+ * - les événements d'action (`tool_*`, `subagent_*`, `approval_required`)
+ *   deviennent des lignes de journal structurées (`runtime_log`) ;
+ * - le raisonnement privé (`agent_thinking`) n'est jamais ré-émis (RFC § 15) ;
+ * - les événements terminaux (`run_completed`/`run_failed`/`run_cancelled`)
+ *   ne sont pas ré-émis : ils sont déjà portés par le poll `status()` du
+ *   dispatcher, qui construit le résultat de tâche à partir de là.
+ *
+ * La fonction est pure et déterministe : un événement produit zéro ou
+ * plusieurs descripteurs `{ type, payload }`. Le dispatcher porte l'identité
+ * run/task au moment de la dépêche.
+ */
+export function mapRuntimeEvent(event) {
+  const type = String(event?.type ?? '');
+  switch (type) {
+    case 'message': {
+      const content = String(event?.content ?? event?.message ?? '').trim();
+      return content ? [{ type: 'assistant_message', payload: { content } }] : [];
+    }
+    case 'tool_started':
+      return log(`tool ${toolLabel(event)} started`);
+    case 'tool_finished': {
+      const duration = Number.isFinite(Number(event?.durationMs))
+        ? ` (${Math.round(Number(event.durationMs))}ms)`
+        : '';
+      const summary = String(event?.resultSummary ?? '').trim();
+      const error = String(event?.error ?? '').trim();
+      if (error) return log(`tool ${toolLabel(event)} failed: ${error}${duration}`);
+      return log(`tool ${toolLabel(event)} done${duration}${summary ? ` — ${summary}` : ''}`);
+    }
+    case 'subagent_started':
+      return log(`subagent ${subagentLabel(event)} started`);
+    case 'subagent_finished':
+      return log(`subagent ${subagentLabel(event)} finished`);
+    case 'approval_required': {
+      // Human-in-the-loop du runtime (RFC § 14) : l'analyse pré-exécution
+      // devient une demande d'approbation native. Les mutations annoncées
+      // deviennent les classes d'approbation ; le dispatcher attend qu'un
+      // grant humain les couvre avant de débloquer le runtime.
+      const proposal = event?.proposal && typeof event.proposal === 'object' ? event.proposal : {};
+      const mutations = Array.isArray(proposal?.mutations) ? proposal.mutations : [];
+      const classes = [...new Set(mutations.map((mutation) => String(mutation?.kind ?? '').trim()).filter(Boolean))];
+      return [{
+        type: 'approval.requested',
+        payload: {
+          approvalId: String(event?.approvalId ?? 'runtime-approval'),
+          scope: 'run',
+          approvalClasses: classes,
+          reason: String(event?.reason ?? proposal?.summary ?? ''),
+          proposal,
+        },
+      }];
+    }
+    case 'run_started':
+    case 'run_created':
+    case 'agent_thinking':
+    case 'run_completed':
+    case 'run_failed':
+    case 'run_cancelled':
+    default:
+      return [];
+  }
+}
+
+function log(message) {
+  return [{ type: 'runtime_log', payload: { message } }];
+}
+
+function toolLabel(event) {
+  return String(event?.tool ?? event?.name ?? 'tool');
+}
+
+function subagentLabel(event) {
+  return String(event?.subagent ?? event?.tool ?? event?.name ?? 'subagent');
+}

package/src/core/runtimeEventAdapter.test.js

@@ -0,0 +1,61 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { mapRuntimeEvent } from './runtimeEventAdapter.js';
+
+test('message becomes an assistant_message', () => {
+  const mapped = mapRuntimeEvent({ type: 'message', content: 'analysis complete' });
+  assert.deepEqual(mapped, [{ type: 'assistant_message', payload: { content: 'analysis complete' } }]);
+});
+
+test('an empty message produces nothing', () => {
+  assert.deepEqual(mapRuntimeEvent({ type: 'message', content: '  ' }), []);
+});
+
+test('tool_started and tool_finished become structured log lines', () => {
+  const started = mapRuntimeEvent({ type: 'tool_started', tool: 'wiki_search' });
+  assert.equal(started.length, 1);
+  assert.equal(started[0].type, 'runtime_log');
+  assert.match(started[0].payload.message, /wiki_search started/);
+
+  const finished = mapRuntimeEvent({ type: 'tool_finished', tool: 'wiki_search', durationMs: 842, resultSummary: '17 documents found' });
+  assert.match(finished[0].payload.message, /wiki_search done \(842ms\) — 17 documents found/);
+});
+
+test('a failed tool is reported as such, not as a success', () => {
+  const mapped = mapRuntimeEvent({ type: 'tool_finished', tool: 'wiki_read', error: 'permission denied' });
+  assert.match(mapped[0].payload.message, /wiki_read failed: permission denied/);
+});
+
+test('subagent events surface as logs', () => {
+  assert.match(mapRuntimeEvent({ type: 'subagent_started', subagent: 'reviewer' })[0].payload.message, /subagent reviewer started/);
+});
+
+test('approval_required becomes an approval.requested with the proposal classes', () => {
+  const mapped = mapRuntimeEvent({
+    type: 'approval_required',
+    approvalId: 'prop-1',
+    reason: 'analysis complete',
+    proposal: {
+      summary: 'analyse',
+      mutations: [{ kind: 'send_email' }, { kind: 'plan_expansion' }],
+    },
+  });
+
+  assert.equal(mapped.length, 1);
+  assert.equal(mapped[0].type, 'approval.requested');
+  assert.equal(mapped[0].payload.approvalId, 'prop-1');
+  assert.equal(mapped[0].payload.scope, 'run');
+  assert.deepEqual(mapped[0].payload.approvalClasses, ['send_email', 'plan_expansion']);
+});
+
+test('private reasoning and terminal events are never re-emitted', () => {
+  assert.deepEqual(mapRuntimeEvent({ type: 'agent_thinking', content: 'secret chain of thought' }), []);
+  assert.deepEqual(mapRuntimeEvent({ type: 'run_started' }), []);
+  assert.deepEqual(mapRuntimeEvent({ type: 'run_completed' }), []);
+  assert.deepEqual(mapRuntimeEvent({ type: 'run_failed' }), []);
+  assert.deepEqual(mapRuntimeEvent({ type: 'run_cancelled' }), []);
+});
+
+test('an unknown event type produces nothing', () => {
+  assert.deepEqual(mapRuntimeEvent({ type: 'made_up' }), []);
+});

package/src/core/skillChainView.test.js

@@ -54,9 +54,9 @@ test('the selection reason is humanized, not leaked as an audit enum', () => {
   assert.equal(selectionKindLabel('description_match'), 'description match');
   assert.equal(selectionKindLabel(null), null);
   const [chain] = projectSkillChains([
-    { id: 'c0', chainId: 'k', chainSequence: 0, skillName: 'wiki-taxonomy', selectionKind: 'explicit_name', status: 'running', input: '/wiki-taxonomy' },
+    { id: 'c0', chainId: 'k', chainSequence: 0, skillName: 'wiki-build', selectionKind: 'explicit_name', status: 'running', input: '/wiki-build' },
   ]);
   assert.equal(chain.selectionKind, 'explicit_name');
   assert.equal(chain.selectionLabel, 'explicit name');
-  assert.equal(renderSkillChain(chain).split('\n')[0], 'wiki-taxonomy · explicit name');
+  assert.equal(renderSkillChain(chain).split('\n')[0], 'wiki-build · explicit name');
 });

package/src/core/skillCompiler.test.js

@@ -31,7 +31,7 @@ test('validation rejects technical routing details', () => {
 });
 
 test('scaffold skills preserve existing capabilities and split only wiki-sync', async () => {
-  const expected = { pipeline: 1, 'wiki-ingest': 2, 'wiki-build': 1, deliver: 1, diagnose: 1, status: 1, 'new-template': 1, 'wiki-sync': 2 };
+  const expected = { pipeline: 1, 'wiki-ingest': 1, 'wiki-build': 1, deliver: 1, diagnose: 1, status: 1, 'new-template': 1, 'wiki-sync': 2 };
   for (const [name, count] of Object.entries(expected)) {
     const raw = readFileSync(resolve('../llm-wiki/scaffold/workspace/.wiki/skills', `${name}.md`), 'utf8');
     const { meta, body } = parseFrontmatter(raw);

package/src/core/skillInvocation.js

@@ -24,11 +24,12 @@ export function explicitSkillReference(input, skillName, language = null) {
  elle ?
 
  Le corps d'une compétence est compilé en intentions métier, et une intention
- décrit forcément ce que fait une compétence voisine : la deuxième intention de
- `/wiki-ingest` est mot pour mot le corps de `/wiki-rebuild-concepts`. Le
- sélecteur par description la reconnaissait donc et relançait la compétence
- voisine, qui relançait la suivante — concepts et taxonomie produits plusieurs
- fois pour un seul `/wiki-ingest`.
+ décrit forcément ce que fait une compétence voisine : c'est ainsi qu'un seul
+ `/wiki-ingest` relançait autrefois la compétence sœur qui reconstruisait la
+ grille de concepts, qui relançait la suivante — concepts et taxonomie produits
+ plusieurs fois pour une seule demande. (Ces compétences sœurs ont disparu avec
+ la simplification 0.15.66 ; la garde contre la sélection par description
+ reste, c'est elle que ces règles verrouillent.)
 
  La composition volontaire reste possible : un corps qui écrit `/deliver` ou
  « the deliver skill » nomme sa cible, et se distingue ainsi d'une intention
@@ -44,8 +45,8 @@ export function objectiveNamesSkill(input, skillName) {
   if (text.toLowerCase() === raw.toLowerCase()) return true;
   /*
    Le nom seul ne suffit pas : plusieurs compétences du scaffold portent un nom
-   qui est aussi un mot courant. « Run the production pipeline steps concepts,
-   reclassify-concepts and taxonomy » nomme ainsi la compétence `pipeline`, qui
+   qui est aussi un mot courant. « Run the production pipeline steps ingest,
+   build, export and polish » nomme ainsi la compétence `pipeline`, qui
    relance ingest + build + export + polish — bien pire que la cascade qu'on
    corrige. Le nom doit donc être cité EN TANT QUE compétence : forme slash, ou
    tournure explicite. La borne droite est écrite à la main, `\b` ne bornant pas
@@ -61,7 +62,11 @@ export function objectiveNamesSkill(input, skillName) {
   const keyword = '(?:skill|workflow|compétence)';
   return [
     new RegExp(`(?:^|[^A-Za-z0-9_-])/${name}${slashEnd}`, 'i'),
-    new RegExp(`\\b${keyword}\\s+/?${name}${end}`, 'i'),
+    // Same path-vs-invocation distinction as the slash form above: unlike
+    // the third pattern below, nothing after this one forces a following
+    // whitespace, so a trailing `/` here would otherwise satisfy `end` and
+    // let "the skill /wiki-build/export-context" match `wiki-build`.
+    new RegExp(`\\b${keyword}\\s+/?${name}${slashEnd}`, 'i'),
     new RegExp(`(?:^|[^A-Za-z0-9_-])/?${name}${end}\\s+${keyword}\\b`, 'i'),
     new RegExp(`/skills\\s+run\\s+${name}${end}`, 'i'),
   ].some((pattern) => pattern.test(text));

package/src/core/startupCheck.js

@@ -8,6 +8,7 @@ import { resolveAgentsComposeContext } from './agentsCompose.js';
 import { buildMcpStatus, discoverMcpTools } from './mcp.js';
 import { listWikircProfiles, loadWikircProfile, summarizeWikircConfig } from './wikirc.js';
 import { listWorkspaces, managerRoot, workspacesDir } from './workspaces.js';
+import { loadAgentRuntimesConfig, resolveRuntimeProviders } from '../orchestrator/providers/runtimeProviders.js';
 
 const execFileAsync = promisify(execFile);
 const DEFAULT_CONNECTIVITY_URL = 'https://registry.npmjs.org/-/ping';
@@ -326,6 +327,58 @@ export async function checkMcpConnections(workspace, {
   };
 }
 
+// Agentic runtime gateway (GATEWAY_ENABLED / agent-runtimes.json). HTTP
+// probe, independent of Docker: the gateway may be a host-native service.
+// Nothing declared or enabled = skipped, never degraded — an optional engine
+// must not gate the startup of the manager it complements.
+export async function checkAgenticRuntimes({
+  loadConfig = loadAgentRuntimesConfig,
+  resolve = resolveRuntimeProviders,
+  env = process.env,
+} = {}) {
+  let config;
+  try {
+    config = loadConfig({ env });
+  } catch (err) {
+    return {
+      ok: false,
+      detail: 'Agentic runtime configuration invalid',
+      context: { error: commandError(err), runtimes: [] },
+    };
+  }
+  const { providers, skipped } = resolve(config);
+  if (providers.length === 0 && skipped.length === 0) {
+    return { ok: true, skipped: true, detail: 'No agentic runtime enabled', context: { runtimes: [] } };
+  }
+  const runtimes = [];
+  for (const item of skipped) {
+    runtimes.push({ name: item.id || '(unnamed)', status: 'skipped', reason: item.reason });
+  }
+  for (const { id, provider } of providers) {
+    try {
+      const description = await provider.describe();
+      runtimes.push({
+        name: id,
+        status: description.health === 'unavailable' ? 'failed' : 'connected',
+        capabilities: (description.capabilities ?? [])
+          .map((capability) => capability?.name ?? capability?.id ?? '')
+          .filter(Boolean),
+        reason: description.health === 'unavailable' ? (description.error ?? 'unavailable') : null,
+      });
+    } catch (err) {
+      runtimes.push({ name: id, status: 'failed', reason: commandError(err) });
+    }
+  }
+  const connected = runtimes.filter((runtime) => runtime.status === 'connected');
+  const failed = runtimes.filter((runtime) => runtime.status === 'failed');
+  return {
+    ok: failed.length === 0,
+    pending: failed.length > 0,
+    detail: `${connected.length} connected${failed.length ? `, ${failed.length} pending` : ''}`,
+    context: { runtimes, command: '/status' },
+  };
+}
+
 function preflightStatus(gaps, checks) {
   const setupRequired = gaps.some((gap) => gap.kind === 'workspace' || gap.kind === 'llm');
   if (setupRequired) return 'setup_required';
@@ -360,6 +413,7 @@ export async function runChecks({
   dockerCheck = checkDockerAvailability,
   internetCheck = checkInternetConnectivity,
   agentsCheck = checkAgents,
+  agenticRuntimesCheck = checkAgenticRuntimes,
   workspaceContainersCheck = checkWorkspaceContainers,
   mcpCheck = checkMcpConnections,
   onCheck = () => {},
@@ -398,6 +452,10 @@ export async function runChecks({
           : 'Running',
     context: { ...(agents?.context ?? {}), command: 'wiki-workspace agents up' },
   });
+  // The gateway is an HTTP probe, independent of Docker: it may be a
+  // host-native service. Nothing enabled = skipped, never degraded.
+  const agenticRuntimes = await agenticRuntimesCheck();
+  onCheck({ kind: 'agentic', ...agenticRuntimes });
   const workspaceGap = checkWorkspace(workspaces);
   if (workspaceGap) {
     gaps.push(workspaceGap);

package/src/core/startupCheck.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 { checkAgents, checkInternetConnectivity, checkMcpConnections, runChecks, runPreflightChecks, withRuntimePreflight } from './startupCheck.js';
+import { checkAgents, checkAgenticRuntimes, checkInternetConnectivity, checkMcpConnections, runChecks, runPreflightChecks, withRuntimePreflight } from './startupCheck.js';
 
 async function withWorkspace(wikircLines, fn) {
   const root = await mkdtemp(join(tmpdir(), 'wiki-manager-startup-check-'));
@@ -299,3 +299,31 @@ test('checkInternetConnectivity uses a fresh Node process with proxy and CA envi
     else process.env.NODE_USE_ENV_PROXY = previousProxyFlag;
   }
 });
+
+test('checkAgenticRuntimes skips when nothing is enabled', async () => {
+  const result = await checkAgenticRuntimes({ loadConfig: () => [], env: {} });
+  assert.equal(result.ok, true);
+  assert.equal(result.skipped, true);
+  assert.equal(result.context.runtimes.length, 0);
+});
+
+test('checkAgenticRuntimes reports a healthy runtime as connected', async () => {
+  const result = await checkAgenticRuntimes({
+    loadConfig: () => [{ id: 'fake', type: 'fake', enabled: true }],
+    env: {},
+  });
+  assert.equal(result.ok, true);
+  assert.equal(result.pending, false);
+  assert.equal(result.context.runtimes[0].status, 'connected');
+});
+
+test('checkAgenticRuntimes reports a down runtime as failed', async () => {
+  const result = await checkAgenticRuntimes({
+    loadConfig: () => [{ id: 'down', type: 'fake', available: false, enabled: true }],
+    env: {},
+  });
+  assert.equal(result.ok, false);
+  assert.equal(result.pending, true);
+  assert.equal(result.context.runtimes[0].status, 'failed');
+  assert.match(result.detail, /pending/);
+});

package/src/orchestrator/agentRegistry.js

@@ -1,6 +1,5 @@
-import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
+import { createAgentEvent, dispatchAgentEvent, dispatchRuntimeLog } from '../core/agentEvents.js';
 import { callMcpTool, formatMcpToolResult } from '../core/mcp.js';
-import { normalizeRuntimeLog } from '../core/runtimeLog.js';
 import { assertContract } from '../contracts/schemas.js';
 
 const AVAILABLE = 'available';
@@ -220,26 +219,6 @@ function registerAgent(session, agent, { agentsByInstance, instanceByServer, las
   return cloneAgent(next);
 }
 
-/**
- * Runtime log line, emitted without importing the supervisor.
- *
- * `emitRuntimeLog` lives in `runtime/supervisor.js`, which already imports THIS
- * module: importing it back would close a cycle for one log line. The event
- * shape is the contract, not the helper, so we build it from the same
- * normalizer the supervisor uses.
- */
-function dispatchRuntimeLog(session, message) {
-  if (!session) return;
-  const payload = normalizeRuntimeLog(message, { session });
-  dispatchAgentEvent(session, createAgentEvent('runtime_log', {
-    origin: 'runtime',
-    runId: payload.runId ?? null,
-    taskId: payload.taskId ?? null,
-    workspace: payload.workspaceId ?? null,
-    payload,
-  }));
-}
-
 function dispatchRegistryEvent(session, type, payload) {
   if (!session) return;
   dispatchAgentEvent(session, createAgentEvent(type, {

package/src/orchestrator/assignmentManager.js

@@ -1,4 +1,4 @@
-import { createCapabilityRegistry } from './capabilityRegistry.js';
+import { capabilityRegistryForSession } from './capabilityRegistry.js';
 import { CapabilityUnavailableError, resolve } from './capabilityResolver.js';
 
 export function createAssignmentManager({
@@ -27,9 +27,7 @@ export async function assign(task, {
   if (!capability) {
     throw new CapabilityUnavailableError(capability, 'task_missing_required_capability', { taskId: task?.id ?? task?.step });
   }
-  const effectiveRegistry = registry ?? session?.capabilityRegistry ?? createCapabilityRegistry({
-    agents: session?.agentRegistrySnapshot ?? session?.agents ?? [],
-  });
+  const effectiveRegistry = registry ?? capabilityRegistryForSession(session);
   const effectiveWorkspaceConfig = workspaceConfig ?? session?.wikircConfig ?? session?.wikirc?.config ?? {};
   const retryAssignment = task?.retryAssignment;
   if (retryAssignment?.agentInstanceId) {
@@ -46,6 +44,14 @@ export async function assign(task, {
       capability,
       operation: task?.operation ?? null,
       serverName: agent?.serverName ?? provider?.serverName ?? null,
+      // Mirrors the primary resolution branch below: without this, retrying a
+      // task assigned to an external-runtime provider drops the routing
+      // discriminator and the dispatcher misroutes it to the MCP path, which
+      // throws "No MCP server found" since external-runtime agents carry no
+      // serverName.
+      providerKind: provider?.providerKind ?? 'mcp-agent',
+      runtimeProvider: provider?.runtimeProvider ?? null,
+      runtimeId: provider?.runtimeId ?? null,
       agent,
       retry: true,
       previousAgentInstanceId: retryAssignment.previousAgentInstanceId ?? null,
@@ -62,6 +68,12 @@ export async function assign(task, {
     capability,
     operation: task?.operation ?? null,
     serverName: agent?.serverName ?? provider?.serverName ?? null,
+    // External runtime providers (RFC § 8) resolve through the same registry
+    // as MCP agents; the assignment carries the routing discriminator so the
+    // dispatcher can hand the task to the runtime instead of agent_execute.
+    providerKind: provider?.providerKind ?? 'mcp-agent',
+    runtimeProvider: provider?.runtimeProvider ?? null,
+    runtimeId: provider?.runtimeId ?? null,
     agent,
   };
 }

package/src/orchestrator/capabilityRegistry.js

@@ -19,6 +19,11 @@ export function createCapabilityRegistry({ agents = [], compatibleContractVersio
         capability,
         description: agent.description,
         lastSeenAt: agent.lastSeenAt ?? null,
+        // External runtime providers (RFC § 8) ride the same registry as MCP
+        // agents. These fields are null for every ordinary MCP agent.
+        providerKind: agent.providerKind ?? null,
+        runtimeId: agent.runtimeId ?? null,
+        runtimeProvider: agent.runtimeProvider ?? null,
       };
       const list = providers.get(key) ?? [];
       list.push(entry);
@@ -54,7 +59,9 @@ export function capabilityRegistryForSession(session) {
     ?? session?.agentRegistrySnapshot
     ?? session?.agents
     ?? [];
-  if (agents.length > 0) return createCapabilityRegistry({ agents });
+  const runtimeAgents = session?.runtimeProviderAgents ?? [];
+  const merged = [...agents, ...runtimeAgents];
+  if (merged.length > 0) return createCapabilityRegistry({ agents: merged });
   if (session?.capabilityRegistry?.providersFor) return session.capabilityRegistry;
   return createCapabilityRegistry();
 }