@dotdrelle/wiki-manager 0.15.66 → 0.15.71

package/src/core/agentEvents.js

@@ -1,7 +1,7 @@
 import { normalizeActivity } from './activity.js';
 import { attachActivityToExistingPlan, syncActivitiesToPlan } from './plan.js';
 import { applyPlanPatch, normalizePlanPatch, normalizePlanRevision, rebasePlanPatch } from './planPatch.js';
-import { formatRuntimeLogPayload } from './runtimeLog.js';
+import { formatRuntimeLogPayload, isDispatchPlumbingLine, normalizeRuntimeLog, shortTaskLabel } from './runtimeLog.js';
 import { projectSkillChains, TERMINAL as CONTROL_TERMINAL_STATUSES } from './skillChainView.js';
 import { projectWorkflow } from './workflow.js';
 import { validateContractInDev } from '../contracts/schemas.js';
@@ -108,6 +108,23 @@ export function dispatchAgentEvent(session, event) {
   return normalized;
 }
 
+// Shared `runtime_log` shaping — was independently reimplemented byte-for-byte
+// in runtime/supervisor.js, orchestrator/agentRegistry.js and
+// orchestrator/providers/runtimeProviders.js (each citing the same "avoid a
+// cycle with supervisor.js" reason, even where no such cycle existed). This
+// module already sits below all three, so it is the one safe common home.
+export function dispatchRuntimeLog(session, message) {
+  if (!session) return;
+  const payload = normalizeRuntimeLog(message, { session });
+  return dispatchAgentEvent(session, createAgentEvent('runtime_log', {
+    origin: 'runtime',
+    runId: payload.runId ?? null,
+    taskId: payload.taskId ?? null,
+    workspace: payload.workspaceId ?? null,
+    payload,
+  }));
+}
+
 // Full in-memory projection reset for a session. The runtime keeps the live
 // projection in memory (session.agentProjection) and serves it from /state, so
 // interrupting runs is not enough to clear the PLAN/ACTIVITY/LOGS panels — the
@@ -312,16 +329,13 @@ function applyEvent(state, event) {
         : state.planRevision + 1;
       return;
     case 'plan.received':
-      state.logs.push(`Plan received for run ${String(event.runId ?? event.payload?.runId ?? '')}`.trim());
-      state.logs = state.logs.slice(-200);
+      appendLog(state, `${logTime(event.ts)} Plan received for run ${String(event.runId ?? event.payload?.runId ?? '')}`.trim());
       return;
     case 'plan.validated':
-      state.logs.push(`Plan validated for run ${String(event.runId ?? event.payload?.runId ?? '')}`.trim());
-      state.logs = state.logs.slice(-200);
+      appendLog(state, `${logTime(event.ts)} Plan validated for run ${String(event.runId ?? event.payload?.runId ?? '')}`.trim());
       return;
     case 'plan.rejected':
-      state.logs.push(`Plan rejected: ${formatPlanErrors(event.payload?.errors)}`);
-      state.logs = state.logs.slice(-200);
+      appendLog(state, `${logTime(event.ts)} Plan rejected: ${formatPlanErrors(event.payload?.errors)}`.trim());
       return;
     case 'task_group.created':
       return;
@@ -329,28 +343,24 @@ function applyEvent(state, event) {
       appendCreatedTask(state, event.payload?.task);
       return;
     case 'task.assigned':
-      state.logs.push(`Task assigned: ${String(event.taskId ?? event.payload?.taskId ?? '')}`.trim());
-      state.logs = state.logs.slice(-200);
+      appendLog(state, taskLogLine(state, event, 'assigned'));
       return;
     case 'task.started':
-      state.logs.push(`Task started: ${String(event.taskId ?? event.payload?.taskId ?? '')}`.trim());
-      state.logs = state.logs.slice(-200);
+      // Silent: always follows `task.assigned` (same task, milliseconds apart),
+      // which already printed the "started" line.
       return;
     case 'task.retry_scheduled':
-      state.logs.push(`Task retry scheduled: ${String(event.taskId ?? event.payload?.taskId ?? '')}`.trim());
-      state.logs = state.logs.slice(-200);
+      appendLog(state, taskLogLine(state, event, 'retry'));
       return;
     case 'task.result_returned':
-      state.logs.push(`Task result returned: ${String(event.taskId ?? event.payload?.taskId ?? '')}`.trim());
-      state.logs = state.logs.slice(-200);
+      // Silent: an internal transition immediately followed by
+      // `task.completed`/`task.failed`, which carry the same result.
       return;
     case 'task.completed':
-      state.logs.push(`Task completed: ${String(event.taskId ?? event.payload?.taskId ?? '')}`.trim());
-      state.logs = state.logs.slice(-200);
+      appendLog(state, taskLogLine(state, event, 'completed'));
       return;
     case 'task.failed':
-      state.logs.push(`Task failed: ${String(event.taskId ?? event.payload?.taskId ?? '')}`.trim());
-      state.logs = state.logs.slice(-200);
+      appendLog(state, taskLogLine(state, event, 'failed'));
       return;
     case 'plan.revision_changed':
       if (Array.isArray(event.payload?.tasks)) {
@@ -364,12 +374,11 @@ function applyEvent(state, event) {
         // référence au state : `updatePlanStep` reste une fonction sur un
         // plan, et le journal reste la responsabilité de l'appelant.
         const anomaly = updatePlanStep(state.plan, event.payload ?? {});
-        if (anomaly) state.logs.push(anomaly);
+        if (anomaly) appendLog(state, `${logTime(event.ts)} ${anomaly}`.trim());
       }
       return;
     case 'control_message_received':
-      state.logs.push(`Control message: ${String(event.payload?.input ?? '')}`);
-      state.logs = state.logs.slice(-200);
+      appendLog(state, `${logTime(event.ts)} Control message: ${String(event.payload?.input ?? '')}`.trim());
       return;
     case 'plan_patch_proposed':
       upsertPlanPatch(state, {
@@ -551,7 +560,7 @@ function applyEvent(state, event) {
       return;
     case 'run_cancelled':
       state.status = 'cancelled';
-      state.logs.push(String(event.payload?.message ?? 'Agent run cancelled.'));
+      appendLog(state, `${logTime(event.ts)} ${String(event.payload?.message ?? 'Agent run cancelled.')}`.trim());
       // 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.
@@ -573,7 +582,7 @@ function applyEvent(state, event) {
        already in hand. What ends a run is essential by construction; the
        prefix states that instead of hoping the wording says so.
       */
-      state.logs.push(`Run failed: ${String(event.payload?.message ?? 'Agent run failed.')}`);
+      appendLog(state, `${logTime(event.ts)} Run failed: ${String(event.payload?.message ?? 'Agent run failed.')}`.trim());
       // A dead run must not leave "pending" plan steps and spinning
       // activities in the persisted projection: they reappeared as ghosts
       // at every relaunch ("des trucs dans le plan qui n'existent pas") and
@@ -650,7 +659,7 @@ function applyEvent(state, event) {
       }, event.ts);
       return;
     case 'runtime_log':
-      state.logs.push(formatRuntimeLogPayload(event.payload ?? {}, event.ts));
+      appendLog(state, formatRuntimeLogPayload(event.payload ?? {}, event.ts));
       return;
     default:
       return;
@@ -1035,6 +1044,111 @@ function formatPlanErrors(errors) {
     : 'unknown';
 }
 
+const LOG_TIME_PREFIX = /^\d{2}:\d{2}:\d{2}\s+/;
+const LOG_REPEAT_SUFFIX = / \(×\d+\)$/;
+
+/*
+ The single writer into `state.logs` — every push goes through here.
+
+ Two jobs the ad-hoc `push(...); logs = logs.slice(-200)` pairs did unevenly:
+ the 200-entry cap is now applied on every path (the `runtime_log` case never
+ capped and grew without bound during a long run), and a *plumbing* entry
+ (isDispatchPlumbingLine) identical to the one before it — once the HH:MM:SS
+ prefix is dropped — is collapsed into a `(×N)` counter instead of being
+ printed again. `agent_status` polling and repeated progress ticks otherwise
+ bury every readable event under dozens of identical rows. A business line (a
+ ▸/✓/✗/↻ transition, "Run failed:", a control message) is never collapsed, so
+ a second genuine failure and its timing are never folded away.
+*/
+function appendLog(state, line) {
+  const text = String(line ?? '').trim();
+  if (!text) return;
+  const last = state.logs.at(-1);
+  if (last != null && isDispatchPlumbingLine(text) && isDispatchPlumbingLine(last)) {
+    const bare = (value) => String(value).replace(LOG_TIME_PREFIX, '').replace(LOG_REPEAT_SUFFIX, '');
+    if (bare(last) === bare(text)) {
+      const count = Number(String(last).match(/ \(×(\d+)\)$/)?.[1] ?? '1') + 1;
+      // Keep the LATEST timestamp so the panel shows when it last repeated.
+      state.logs[state.logs.length - 1] = `${text.replace(LOG_REPEAT_SUFFIX, '')} (×${count})`;
+      return;
+    }
+  }
+  state.logs.push(text);
+  if (state.logs.length > 200) state.logs = state.logs.slice(-200);
+}
+
+function logTime(ts) {
+  const date = ts ? new Date(ts) : new Date();
+  return Number.isNaN(date.getTime()) ? '' : date.toISOString().slice(11, 19);
+}
+
+function planTaskById(state, taskId) {
+  const id = String(taskId ?? '');
+  if (!id) return null;
+  return (state.plan ?? []).find((step) => String(step.id ?? step.step) === id) ?? null;
+}
+
+/*
+ The persisted taskId is `<runId-uuid>:<slug>-<hash8>` — neither the UUID nor
+ the trailing hash means anything to a reader. Prefer the plan step's business
+ label ("Polish deliverable: proposition/presentation"), then its description,
+ and only fall back to a de-slugified task name when the plan carries neither.
+*/
+function taskLabelFor(state, taskId) {
+  const step = planTaskById(state, taskId);
+  const label = step?.label ?? step?.description ?? null;
+  if (label && !/^Step \d+$/.test(label)) return label;
+  return shortTaskLabel(taskId) || String(taskId ?? '') || 'task';
+}
+
+// One readable line per real task transition. `task.started` and
+// `task.result_returned` are deliberately silent in the reducer — each is an
+// internal step between two lines this function already prints (`assigned`
+// then `completed`/`failed`), and printing them doubled every task in the
+// Runtime panel.
+function taskLogLine(state, event, kind) {
+  const payload = event.payload ?? {};
+  const taskId = event.taskId ?? payload.taskId ?? '';
+  const label = taskLabelFor(state, taskId);
+  const time = logTime(event.ts);
+  const step = planTaskById(state, taskId);
+  const capability = payload.assignment?.capability ?? step?.requiredCapability ?? null;
+  const agent = payload.assignment?.agentInstanceId
+    ?? payload.agentInstanceId
+    ?? payload.result?.assignment?.agentInstanceId
+    ?? payload.assignment?.agentId
+    ?? null;
+
+  if (kind === 'assigned') {
+    const context = [capability, agent && `→ ${agent}`].filter(Boolean).join('  ');
+    return `${time} ▸ ${label} — started${context ? `  (${context})` : ''}`.trim();
+  }
+  if (kind === 'retry') {
+    const attempt = payload.attempts ?? payload.attempt ?? null;
+    const max = payload.maxAttempts ?? null;
+    const reason = payload.reason
+      ?? payload.error?.code
+      ?? payload.error?.message
+      ?? 'retryable error';
+    const nth = attempt != null ? ` ${attempt}${max ? `/${max}` : ''}` : '';
+    return `${time} ↻ ${label} — retry${nth} (${reason})`.trim();
+  }
+
+  const result = payload.result ?? {};
+  if (kind === 'failed') {
+    const error = result.error?.code
+      ?? result.error?.message
+      ?? payload.error?.code
+      ?? payload.error?.message
+      ?? (result.status && result.status !== 'succeeded' ? result.status : null);
+    return `${time} ✗ ${label} — failed${error ? `: ${error}` : ''}`.trim();
+  }
+  // completed
+  const outputs = result.outputRefs ?? result.result?.outputRefs ?? [];
+  const count = Array.isArray(outputs) ? outputs.length : 0;
+  return `${time} ✓ ${label} — done${count ? ` (${count} output${count > 1 ? 's' : ''})` : ''}`.trim();
+}
+
 function cloneRef(value) {
   return value && typeof value === 'object' && !Array.isArray(value) ? { ...value } : String(value);
 }

package/src/core/agentEvents.test.js

@@ -720,8 +720,33 @@ test('run_error names the failure so the essential journal cannot filter it out'
 
   assert.equal(state.status, 'error');
   const line = state.logs.at(-1);
-  assert.match(line, /^Run failed: /);
+  assert.match(line, /^\d{2}:\d{2}:\d{2} Run failed: /);
   assert.match(line, /workspace\.restore/);
   // Le mot qui rend l'entrée « essentielle » pour le journal serve.
   assert.match(line, /failed/i);
 });
+
+test('appendLog collapses repeated dispatch plumbing but never a repeated business failure', () => {
+  const ev = (type, payload, ts, taskId = null) => ({ id: `${type}-${ts}`, ts, type, payload, taskId });
+  // Two identical agent_status polls, seconds apart → one (×2) row.
+  const polling = reduceAgentEvents([
+    ev('runtime_log', { event: 'agent_status', runId: 'r', taskId: 't', detail: 'production_status' }, '2026-07-08T14:00:01.000Z'),
+    ev('runtime_log', { event: 'agent_status', runId: 'r', taskId: 't', detail: 'production_status' }, '2026-07-08T14:00:04.000Z'),
+  ]);
+  assert.equal(polling.logs.length, 1);
+  assert.match(polling.logs[0], / \(×2\)$/);
+  assert.match(polling.logs[0], /^14:00:04 /, 'the counter keeps the most recent timestamp');
+
+  // A retry that fails the SAME way twice produces two byte-identical failure
+  // lines (bar the timestamp) — both must stay visible, a degradation must
+  // announce itself (root CLAUDE.md). The guard is that ✗ lines are not
+  // plumbing, not that the text differs.
+  const failPayload = { taskId: 'a', result: { status: 'failed', error: { code: 'rate_limit' } } };
+  const failures = reduceAgentEvents([
+    ev('task.failed', failPayload, '2026-07-08T14:00:01.000Z', 'a'),
+    ev('task.failed', failPayload, '2026-07-08T14:05:09.000Z', 'a'),
+  ]);
+  const failLines = failures.logs.filter((l) => /✗ a — failed: rate_limit/.test(l));
+  assert.equal(failLines.length, 2);
+  assert.equal(failLines.some((l) => / \(×\d+\)$/.test(l)), false);
+});

package/src/core/buildInfo.json

@@ -1,4 +1,4 @@
 {
-  "version": "0.15.66",
-  "commit": "d9639a4"
+  "version": "0.15.71",
+  "commit": "d5f51af"
 }

package/src/core/commandFailure.test.js

@@ -28,7 +28,7 @@ test('the fallback hint drops the command echo, compose warnings and host paths'
     message: [
       COMPOSE_COMMAND,
       'time="2026-07-28T11:37:41+02:00" level=warning msg="The \\"CONNECTORS_MCP_PORT\\" variable is not set."',
-      'error while creating mount source path /mnt/c/Users/p/Documents/docker/llm-wiki/workspaces/juno: denied',
+      'error while creating mount source path /mnt/c/Users/p/Documents/docker/llm-wiki/workspaces/demo: denied',
     ].join('\n'),
   };
 
@@ -39,7 +39,7 @@ test('the fallback hint drops the command echo, compose warnings and host paths'
   // Only the basename survives: absolute paths describe this machine's install
   // layout and mean nothing to the person reading the answer.
   assert.doesNotMatch(hint, /\/mnt\/c/);
-  assert.match(hint, /juno/);
+  assert.match(hint, /demo/);
 });
 
 test('a failed operation reaches Donna as facts, never as docker output', () => {

package/src/core/currentArtifact.test.js

@@ -38,10 +38,10 @@ test('artifactFromToolCall ignores read tools and tools without a path', () => {
 });
 
 test('currentArtifactFor is workspace-scoped', () => {
-  const artifact = { workspace: 'acpi', path: 'templates/notes/basic.md', kind: 'template' };
-  assert.equal(currentArtifactFor({ workspace: 'acpi', currentArtifact: artifact }), artifact);
+  const artifact = { workspace: 'acme', path: 'templates/notes/basic.md', kind: 'template' };
+  assert.equal(currentArtifactFor({ workspace: 'acme', currentArtifact: artifact }), artifact);
   assert.equal(currentArtifactFor({ workspace: 'other', currentArtifact: artifact }), null);
-  assert.equal(currentArtifactFor({ workspace: 'acpi' }), null);
+  assert.equal(currentArtifactFor({ workspace: 'acme' }), null);
 });
 
 test('currentArtifactPromptLine names the artifact for follow-up edits', () => {
@@ -52,10 +52,10 @@ test('currentArtifactPromptLine names the artifact for follow-up edits', () => {
 });
 
 test('rememberArtifact records a workspace-scoped artifact and ignores empty paths', () => {
-  const session = { workspace: 'acpi' };
+  const session = { workspace: 'acme' };
   rememberArtifact(session, { path: 'templates/notes/basic.md', kind: 'template' });
   assert.equal(session.currentArtifact.path, 'templates/notes/basic.md');
-  assert.equal(session.currentArtifact.workspace, 'acpi');
+  assert.equal(session.currentArtifact.workspace, 'acme');
   assert.equal(session.currentArtifact.kind, 'template');
   rememberArtifact(session, { path: '   ', kind: 'template' });
   assert.equal(session.currentArtifact.path, 'templates/notes/basic.md');

package/src/core/dockerCompose.test.js

@@ -27,52 +27,20 @@ test('workspace production agent enables restore by default', async () => {
   assert.match(String(allowed), /(?:^|,)restore(?:,|})/);
 });
 
-test('every shipped default allows the taxonomy step', async () => {
+test('the shipped default carries no step the engine retired in 0.15.66', async () => {
   /*
-   L'absence de `taxonomy` est SILENCIEUSE.
-
-   `agent_plan` retire la tâche taxonomique du fragment d'ingestion quand
-   l'étape n'est pas autorisée (`"taxonomy" in _ALLOWED_STEPS`), sans erreur ni
-   avertissement. Un déploiement par compose ingérait donc sans jamais publier
-   de taxonomie, et la carte restait périmée — exactement le défaut que le Lot 4
-   avait corrigé côté moteur. Le défaut de Python porte `taxonomy` ; un compose
-   POSITIONNE toujours la variable, donc ce défaut ne s'applique jamais là.
+   0.15.66 a retiré du moteur llm-wiki les commandes `wiki concepts`,
+   `reclassify-concepts` et `taxonomy` (simplification : le concept EST le
+   dossier). Un défaut livré qui les autoriserait encore ferait échouer le
+   pipeline à la première de ces étapes — `unknown command 'concepts'` — sans
+   jamais les exécuter. Ces trois étapes ne doivent donc figurer dans AUCUN
+   défaut livré, ni ici ni dans agent-production.
   */
   const raw = await readFile(new URL('../../docker-compose.yml', import.meta.url), 'utf8');
   const compose = YAML.parse(raw);
   const allowed = compose.services['production-mcp'].environment
     .find((entry) => String(entry).startsWith('PRODUCTION_ALLOWED_STEPS='));
-  assert.match(String(allowed), /(?:^|,)taxonomy(?:,|})/);
-});
-
-test('every shipped default allows the concepts step', async () => {
-  /*
-   Same silent-omission risk as `taxonomy` above, one lot earlier: without
-   `concepts`, `wiki concepts --apply` (which writes wiki/concepts-grid.md) is
-   never reachable through /wiki-sync, /pipeline, or any orchestrated flow.
-   Every ingest then files every concept page under the reserved
-   `unclassified` class forever, with nothing surfacing why.
-  */
-  const raw = await readFile(new URL('../../docker-compose.yml', import.meta.url), 'utf8');
-  const compose = YAML.parse(raw);
-  const allowed = compose.services['production-mcp'].environment
-    .find((entry) => String(entry).startsWith('PRODUCTION_ALLOWED_STEPS='));
-  assert.match(String(allowed), /(?:^|,)concepts(?:,|})/);
-});
-
-test('every shipped default allows the reclassify-concepts step', async () => {
-  /*
-   One step further than `concepts`: without `reclassify-concepts`, a page
-   already stuck under wiki/concepts/unclassified stays there even after a
-   grid exists — re-ingesting its source is not a reliable fix, since the
-   ingest prompt updates an existing leaf at its existing path instead of
-   moving it.
-  */
-  const raw = await readFile(new URL('../../docker-compose.yml', import.meta.url), 'utf8');
-  const compose = YAML.parse(raw);
-  const allowed = compose.services['production-mcp'].environment
-    .find((entry) => String(entry).startsWith('PRODUCTION_ALLOWED_STEPS='));
-  assert.match(String(allowed), /(?:^|,)reclassify-concepts(?:,|})/);
+  assert.doesNotMatch(String(allowed), /(?:^|,)(?:concepts|reclassify-concepts|taxonomy)(?:,|})/);
 });
 
 test('shipped compose files never carry a build context', async () => {

package/src/core/env.js

@@ -49,6 +49,10 @@ export function managerMcpEndpointsFile() {
   return join(managerStateDir(), 'mcp.endpoints.json');
 }
 
+export function managerAgentRuntimesFile() {
+  return join(managerStateDir(), 'agent-runtimes.json');
+}
+
 // User-owned compose overrides, one per stack. `.wiki/compose` is persistent
 // operator configuration; `.wiki/runtime` is generated state rewritten by
 // compose commands. Keeping those directories separate makes the lifecycle
@@ -164,6 +168,16 @@ export function ensureManagerScaffold({ log = () => {} } = {}) {
       }
     }
   }
+  // External agent runtimes (RFC § 37) are optional and DISABLED in the
+  // packaged example: seeding a live endpoint would make every fresh install
+  // probe a runtime that does not ship. Copy once, never rewrite — an existing
+  // file is the operator's.
+  const runtimesFile = managerAgentRuntimesFile();
+  const runtimesExample = join(packageRoot, 'agent-runtimes.example.json');
+  if (existsSync(runtimesExample) && !existsSync(runtimesFile)) {
+    copyFileSync(runtimesExample, runtimesFile);
+    created.push('agent-runtimes.json');
+  }
   const envFile = managerEnvFile();
   const envExample = join(packageRoot, '.env.example');
   if (!existsSync(envFile) && existsSync(envExample)) {

package/src/core/env.test.js

@@ -37,6 +37,25 @@ test('scaffold copies the packaged examples into a fresh directory', () => {
   });
 });
 
+test('scaffold seeds an enabled agent-runtimes example and never rewrites an existing one', () => {
+  withTempManagerDir((dir) => {
+    const created = ensureManagerScaffold();
+    assert.ok(created.includes('agent-runtimes.json'));
+    const runtimes = JSON.parse(readFileSync(join(dir, 'agent-runtimes.json'), 'utf8'));
+    assert.ok(Array.isArray(runtimes.runtimes));
+    assert.equal(runtimes.runtimes[0].enabled, true, 'the scaffold ships the gateway enabled (GATEWAY_ENABLED=true)');
+
+    // Operator-owned: once present, the file is never touched again.
+    writeFileSync(join(dir, 'agent-runtimes.json'), JSON.stringify({ runtimes: [] }));
+    const second = ensureManagerScaffold();
+    assert.ok(!second.includes('agent-runtimes.json'));
+    assert.deepEqual(
+      JSON.parse(readFileSync(join(dir, 'agent-runtimes.json'), 'utf8')),
+      { runtimes: [] },
+    );
+  });
+});
+
 test('an install predating the required runtime host receives it on its placeholder', () => {
   withTempManagerDir((dir) => {
     const envFile = join(dir, '.env');

package/src/core/googleGrants.test.js

@@ -5,7 +5,7 @@ import { fileURLToPath } from 'node:url';
 import { GOOGLE_GRANTS, GOOGLE_GRANT_LABELS, defaultGoogleGrants } from './googleGrants.js';
 
 // `agent-connectors` n'est pas cloné par le CI du manager, qui ne tire que
-// llm-wiki, agent-wiki-production, agent-cme et agent-wiki-documents (voir
+// llm-wiki, agent-production, agent-cme et agent-documents (voir
 // check-versions.js). Les contrôles de cohérence croisée ci-dessous lisent la
 // source de l'agent connectors : sans elle, on les saute plutôt que d'échouer
 // sur un ENOENT. Le flux de release complet (build-and-push.sh) la fournit,

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

package/src/core/mcp.test.js

@@ -830,7 +830,7 @@ test('callMcpTool re-negotiates and replays once when the agent drops the sessio
 
   try {
     const endpoint = { status: 'connected', url: 'http://127.0.0.1:3336/mcp/' };
-    const result = await callMcpTool({ cme: endpoint }, 'cme', 'cme_status', { workspace: 'juno' });
+    const result = await callMcpTool({ cme: endpoint }, 'cme', 'cme_status', { workspace: 'demo' });
 
     assert.equal(result.content[0].text, 'status: configured');
     assert.deepEqual(requests, [

package/src/core/otherWorkspacesRunning.test.js

@@ -27,25 +27,25 @@ function workspaceEntry(root, name) {
 
 test('the current workspace is never counted as another one', async () => {
   const root = mkdtempSync(join(tmpdir(), 'ws-running-self-'));
-  const acpi = workspaceEntry(root, 'acpi');
+  const acme = workspaceEntry(root, 'acme');
 
-  const busy = await otherWorkspacesRunning({ workspace: 'acpi' }, [acpi]);
+  const busy = await otherWorkspacesRunning({ workspace: 'acme' }, [acme]);
 
   assert.deepEqual(busy, [], 'stopping a workspace must not be blocked by itself');
 });
 
 test('an unqueryable workspace does not hold the shared agents hostage', async () => {
   const root = mkdtempSync(join(tmpdir(), 'ws-running-unknown-'));
-  const workspaces = [workspaceEntry(root, 'acpi'), workspaceEntry(root, 'stale')];
+  const workspaces = [workspaceEntry(root, 'acme'), workspaceEntry(root, 'stale')];
 
-  const busy = await otherWorkspacesRunning({ workspace: 'acpi' }, workspaces);
+  const busy = await otherWorkspacesRunning({ workspace: 'acme' }, workspaces);
 
   assert.deepEqual(busy, []);
 });
 
 test('a single workspace, or none at all, never blocks', async () => {
-  assert.deepEqual(await otherWorkspacesRunning({ workspace: 'acpi' }, []), []);
+  assert.deepEqual(await otherWorkspacesRunning({ workspace: 'acme' }, []), []);
   assert.deepEqual(await otherWorkspacesRunning({}, []), []);
   // Entries without a name are registry noise, not workspaces.
-  assert.deepEqual(await otherWorkspacesRunning({ workspace: 'acpi' }, [{}, null]), []);
+  assert.deepEqual(await otherWorkspacesRunning({ workspace: 'acme' }, [{}, null]), []);
 });

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');
+}