@dotdrelle/wiki-manager 0.15.66 → 0.15.71

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

@@ -70,7 +70,9 @@ export function formatRuntimeLogPayload(payload = {}, ts = null) {
   const time = timeLabel(ts);
   const event = eventLabel(payload.event);
   const fields = ORDERED_FIELDS
-    .map((key) => formatField(FIELD_ALIASES[key], payload[key]))
+    .map((key) => (key === 'taskId'
+      ? formatField(FIELD_ALIASES[key], shortTaskLabel(payload[key]))
+      : formatField(FIELD_ALIASES[key], payload[key])))
     .filter(Boolean);
   if (payload.status != null) fields.push(formatField('status', payload.status));
   if (payload.percent != null) fields.push(formatField('percent', payload.percent));
@@ -90,11 +92,43 @@ function shortenUuids(text) {
   return String(text ?? '').replace(UUID_RE, (uuid) => `${uuid.slice(0, 8)}…`);
 }
 
+// A structured taskId is `<runId-uuid>:<slug>-<hash8>`. The UUID and the hash
+// carry no meaning for a reader; keep the human-readable slug in between so
+// `task=…` in a runtime log line names the work instead of an opaque id. A
+// plain id that is neither prefixed nor hash-suffixed (`task-build`, `a`, a
+// legacy step number) is left exactly as it is — only the UUID is collapsed.
+const TASK_HASH_SUFFIX = /-[0-9a-f]{8,}$/i;
+
+export function shortTaskLabel(value) {
+  const raw = String(value ?? '').trim();
+  if (!raw) return raw;
+  const hasColon = raw.includes(':');
+  if (!hasColon && !TASK_HASH_SUFFIX.test(raw)) return shortenUuids(raw);
+  const tail = hasColon ? raw.slice(raw.indexOf(':') + 1) : raw;
+  const pretty = tail.replace(TASK_HASH_SUFFIX, '').replace(/[-_]+/g, ' ').trim();
+  return pretty || shortenUuids(raw);
+}
+
 export function shortLogId(value, { maxLength = 40 } = {}) {
   const shortened = shortenUuids(value);
   return shortened.length > maxLength ? `${shortened.slice(0, maxLength - 1)}…` : shortened;
 }
 
+// A line emitted by formatRuntimeLogPayload for a structured event: optional
+// HH:MM:SS, then the ALL-CAPS event token eventLabel() produces from the LAST
+// dotted segment ('job.accepted' → 'ACCEPTED', 'capability.resolving' →
+// 'RESOLVING', 'agent_status' → 'AGENT_STATUS'). These are the dispatch
+// plumbing. A business line the reducer writes starts with a ▸/✓/✗/↻ glyph or
+// a capitalised word ("Plan received", "Run failed:") — never an all-caps
+// token — so this one shape separates the two without an event-name list
+// (which is what an earlier enumeration got wrong: it only ever matched the
+// two underscore-form events and missed every dotted one).
+const DISPATCH_PLUMBING_LINE = /^(?:\d{1,2}:\d{2}(?::\d{2})?\s+)?[A-Z][A-Z0-9_]{2,}(?:\s|$)/;
+
+export function isDispatchPlumbingLine(line) {
+  return DISPATCH_PLUMBING_LINE.test(String(line ?? ''));
+}
+
 export function runtimeLogMatchesFilter(line, filter = '') {
   const query = String(filter ?? '').trim();
   if (!query) return true;

package/src/core/runtimeLog.test.js

@@ -2,7 +2,7 @@ import assert from 'node:assert/strict';
 import test from 'node:test';
 
 import { createAgentEvent, dispatchAgentEvent } from './agentEvents.js';
-import { compactRuntimeLogForDisplay, formatRuntimeLogPayload, shortLogId } from './runtimeLog.js';
+import { compactRuntimeLogForDisplay, formatRuntimeLogPayload, isDispatchPlumbingLine, shortLogId } from './runtimeLog.js';
 import { emitRuntimeLog } from '../runtime/supervisor.js';
 
 const CYCLE_EVENTS = [
@@ -112,12 +112,37 @@ test('long UUIDs collapse to a short prefix so log lines stay on one line', () =
   }, '2026-07-08T14:42:18.000Z');
 
   assert.match(line, /run=7fadad27…/);
-  assert.match(line, /task=7fadad27…:taxonomy-synthesis/);
+  // The taskId's UUID prefix and hash suffix are dropped entirely: the field
+  // names the work ("taxonomy synthesis"), not an opaque id.
+  assert.match(line, /task="taxonomy synthesis"/);
   assert.match(line, /attempt=attempt-7fadad27…/);
   assert.match(line, /agentInstance=production-7fadad27…/);
   assert.doesNotMatch(line, /7fadad27-0be6-4d08-96e5-664fe7ee841e/);
 });
 
+test('isDispatchPlumbingLine recognises every formatted event token, dotted ones included', () => {
+  // eventLabel() keeps only the last dotted segment, so these are the tokens
+  // that actually reach the panel — an event-name enumeration missed them.
+  for (const event of ['job.accepted', 'agent.selected', 'capability.resolving', 'runtime.accepted', 'agent_status', 'agent_execute', 'task.result_returned']) {
+    const line = formatRuntimeLogPayload({ event, runId: 'r1', taskId: 't1' }, '2026-07-08T14:42:18.000Z');
+    assert.equal(isDispatchPlumbingLine(line), true, `expected plumbing: ${line}`);
+  }
+});
+
+test('isDispatchPlumbingLine leaves the business flow lines for the Runtime tab', () => {
+  for (const line of [
+    '14:42:18 ▸ Polish proposition — started  (knowledge.polish  → agent-production)',
+    '14:42:19 ✓ Polish proposition — done (1 output)',
+    '14:42:19 ✗ Ingest DSI — failed: dependency_failed',
+    '14:42:20 ↻ Build overview — retry 2/3 (rate_limit)',
+    '14:42:21 Run failed: No agent provides capability workspace.restore.',
+    '14:42:22 Plan validated for run r1',
+    '14:42:23 Control message: où en est le build ?',
+  ]) {
+    assert.equal(isDispatchPlumbingLine(line), false, `expected business flow: ${line}`);
+  }
+});
+
 test('shortLogId caps an over-long task slug while shortening embedded UUIDs', () => {
   const long = `${'x'.repeat(48)}-deadbeef`;
   assert.match(shortLogId(long), /…$/);

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/skillInvocation.test.js

@@ -18,7 +18,7 @@ test('matchSkillInvocation resolves only a real workspace skill', () => {
 
 test('parseSkillArguments preserves one free-form argument and parses quoted multi params', () => {
   assert.deepEqual(parseSkillArguments({ params: ['files'] }, 'document A.md document B.md'), { files: 'document A.md document B.md' });
-  assert.deepEqual(parseSkillArguments({ params: ['deliverable', 'polish'] }, '"architecture-juno" "améliorer la sécurité réseau"'), { deliverable: 'architecture-juno', polish: 'améliorer la sécurité réseau' });
+  assert.deepEqual(parseSkillArguments({ params: ['deliverable', 'polish'] }, '"architecture-demo" "improve the network security"'), { deliverable: 'architecture-demo', polish: 'improve the network security' });
 });
 
 test('legacy placeholders remain supported and are reported', () => {

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/core/wikiSetup.js

@@ -115,6 +115,31 @@ export async function startAgents(options = {}) {
       profiles: composeContext.profiles,
     };
   } catch (err) {
+    // One optional agent failing to start (today: the agentic gateway, whose
+    // image is not pulled yet) makes `docker compose up` exit non-zero — but
+    // the base stack usually DID come up. Aborting here turned `/start all`
+    // into "gateway image missing ⇒ workspace never starts", which is the
+    // optional tail wagging the whole dog. If the base agents are up, degrade
+    // loudly instead of failing: the caller continues, and the absent agent
+    // announces itself through its own check (/status, preflight, discovery).
+    const verification = await verifyAgentsStarted({
+      context: composeContext,
+      agentsCheck: options.agentsCheck,
+    }).catch(() => null);
+    if (verification?.ok) {
+      return {
+        output: [
+          (options.services ?? []).length > 0
+            ? 'A requested agent failed to start — the rest of the stack is up.'
+            : 'The agents stack started degraded — one optional agent failed (see /status).',
+          err instanceof Error ? (err.message ?? String(err)) : String(err),
+        ].filter(Boolean).join('\n').trim(),
+        missingImages: [],
+        profiles: composeContext.profiles,
+        degraded: true,
+        degradedError: wrapDockerError(err),
+      };
+    }
     throw wrapDockerError(err);
   }
 }

package/src/core/wikiSetup.test.js

@@ -85,3 +85,38 @@ test('the manager .env values override stale blank process values for agents up'
   }));
   assert.equal(childEnv.GOOGLE_OAUTH_CLIENT_SECRET, 'fresh-secret');
 });
+
+test('an optional agent that refuses to start degrades instead of failing /start all', async () => {
+  // The gateway image not being pulled yet makes `docker compose up` exit
+  // non-zero while the base stack still comes up. Aborting there made
+  // `/start all` stop before the workspace services — the optional tail
+  // wagging the whole dog. With the base agents verified up, the start
+  // returns a degraded result the caller can continue from.
+  const result = await startAgents(startOptions({
+    exec: async () => {
+      const err = new Error('pull access denied for dotdrelle/wiki-agentic-gateway:latest');
+      err.code = 1;
+      throw err;
+    },
+    agentsCheck: async () => null,
+  }));
+
+  assert.equal(result.degraded, true);
+  assert.match(result.output, /started degraded/);
+  assert.match(result.output, /wiki-agentic-gateway/);
+  assert.deepEqual(result.profiles, ['connectors']);
+});
+
+test('a docker failure that leaves the base agents down still fails the start', async () => {
+  await assert.rejects(
+    startAgents(startOptions({
+      exec: async () => {
+        const err = new Error('Cannot connect to the Docker daemon');
+        err.code = 1;
+        throw err;
+      },
+      agentsCheck: async () => ({ kind: 'agents', context: { downServices: ['cme', 'documents'] } }),
+    })),
+    /Docker daemon is not running/,
+  );
+});

package/src/core/wikirc.test.js

@@ -273,7 +273,7 @@ test('finalizeCreatedWorkspace seeds a new workspace from the one in use', async
     return workspacePath;
   };
 
-  makeWorkspace('acpi', [
+  makeWorkspace('acme', [
     'language: en',
     'llm:',
     '  provider: ai-gateway',
@@ -287,7 +287,7 @@ test('finalizeCreatedWorkspace seeds a new workspace from the one in use', async
   ].join('\n'));
 
   // Exactly what the scaffold writes: placeholders everywhere.
-  const targetPath = makeWorkspace('nouveau', [
+  const targetPath = makeWorkspace('fresh', [
     'language: en',
     'llm:',
     '  provider: openai-compatible',
@@ -300,15 +300,15 @@ test('finalizeCreatedWorkspace seeds a new workspace from the one in use', async
     '',
   ].join('\n'));
 
-  mkdirSync(join(agentsData, 'cme', 'acpi', 'cme'), { recursive: true });
-  writeFileSync(join(agentsData, 'cme', 'acpi', 'cme', 'app_data.json'), '{"pat":"x"}', 'utf8');
+  mkdirSync(join(agentsData, 'cme', 'acme', 'cme'), { recursive: true });
+  writeFileSync(join(agentsData, 'cme', 'acme', 'cme', 'app_data.json'), '{"pat":"x"}', 'utf8');
 
   const previousDir = process.env.WIKI_WORKSPACES_DIR;
   const previousData = process.env.AGENTS_DATA_DIR;
   process.env.WIKI_WORKSPACES_DIR = registryRoot;
   process.env.AGENTS_DATA_DIR = agentsData;
   try {
-    const { inherited } = await finalizeCreatedWorkspace('nouveau', { inheritFrom: 'acpi' });
+    const { inherited } = await finalizeCreatedWorkspace('fresh', { inheritFrom: 'acme' });
     const parsed = YAML.parse(readFileSync(join(targetPath, '.wikirc.yaml'), 'utf8'));
 
     assert.equal(parsed.llm.baseUrl, 'https://itsdonna.events/v1');
@@ -320,7 +320,7 @@ test('finalizeCreatedWorkspace seeds a new workspace from the one in use', async
     assert.ok(inherited.includes('llm.baseUrl'));
     assert.ok(inherited.includes('cme.app_data.json'));
     assert.equal(
-      readFileSync(join(agentsData, 'cme', 'nouveau', 'cme', 'app_data.json'), 'utf8'),
+      readFileSync(join(agentsData, 'cme', 'fresh', 'cme', 'app_data.json'), 'utf8'),
       '{"pat":"x"}',
     );
   } finally {

package/src/core/workspaceInherit.test.js

@@ -146,36 +146,36 @@ test('nothing to inherit yields an empty patch', () => {
 
 test('CME credentials are copied, and the source manifest is not', async () => {
   const root = mkdtempSync(join(tmpdir(), 'cme-inherit-'));
-  const sourceDir = join(root, 'cme', 'acpi', 'cme');
+  const sourceDir = join(root, 'cme', 'acme', 'cme');
   mkdirSync(sourceDir, { recursive: true });
   writeFileSync(join(sourceDir, 'app_data.json'), '{"auth":{"pat":"secret"}}', 'utf8');
   // Export scope is what makes a workspace different — it must NOT travel.
-  writeFileSync(join(root, 'cme', 'acpi', 'sources-manifest.yaml'), 'sources: []\n', 'utf8');
+  writeFileSync(join(root, 'cme', 'acme', 'sources-manifest.yaml'), 'sources: []\n', 'utf8');
 
-  const copied = await copyCmeCredentials(root, 'acpi', 'nouveau');
+  const copied = await copyCmeCredentials(root, 'acme', 'fresh');
 
-  assert.equal(copied, cmeCredentialsPath(root, 'nouveau'));
+  assert.equal(copied, cmeCredentialsPath(root, 'fresh'));
   assert.equal(readFileSync(copied, 'utf8'), '{"auth":{"pat":"secret"}}');
-  assert.equal(existsSync(join(root, 'cme', 'nouveau', 'sources-manifest.yaml')), false);
+  assert.equal(existsSync(join(root, 'cme', 'fresh', 'sources-manifest.yaml')), false);
 });
 
 test('existing CME credentials on the target are never clobbered', async () => {
   const root = mkdtempSync(join(tmpdir(), 'cme-inherit-keep-'));
-  mkdirSync(join(root, 'cme', 'acpi', 'cme'), { recursive: true });
-  mkdirSync(join(root, 'cme', 'nouveau', 'cme'), { recursive: true });
-  writeFileSync(join(root, 'cme', 'acpi', 'cme', 'app_data.json'), '{"from":"source"}', 'utf8');
-  writeFileSync(join(root, 'cme', 'nouveau', 'cme', 'app_data.json'), '{"from":"target"}', 'utf8');
+  mkdirSync(join(root, 'cme', 'acme', 'cme'), { recursive: true });
+  mkdirSync(join(root, 'cme', 'fresh', 'cme'), { recursive: true });
+  writeFileSync(join(root, 'cme', 'acme', 'cme', 'app_data.json'), '{"from":"source"}', 'utf8');
+  writeFileSync(join(root, 'cme', 'fresh', 'cme', 'app_data.json'), '{"from":"target"}', 'utf8');
 
-  assert.equal(await copyCmeCredentials(root, 'acpi', 'nouveau'), null);
+  assert.equal(await copyCmeCredentials(root, 'acme', 'fresh'), null);
   assert.equal(
-    readFileSync(cmeCredentialsPath(root, 'nouveau'), 'utf8'),
+    readFileSync(cmeCredentialsPath(root, 'fresh'), 'utf8'),
     '{"from":"target"}',
   );
 });
 
 test('copying is a no-op without a source, a target, or a source file', async () => {
   const root = mkdtempSync(join(tmpdir(), 'cme-inherit-noop-'));
-  assert.equal(await copyCmeCredentials(root, 'absent', 'nouveau'), null);
-  assert.equal(await copyCmeCredentials(root, null, 'nouveau'), null);
-  assert.equal(await copyCmeCredentials(root, 'acpi', 'acpi'), null);
+  assert.equal(await copyCmeCredentials(root, 'absent', 'fresh'), null);
+  assert.equal(await copyCmeCredentials(root, null, 'fresh'), null);
+  assert.equal(await copyCmeCredentials(root, 'acme', 'acme'), null);
 });

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/agentRegistry.test.js

@@ -144,7 +144,7 @@ test('a failed re-discovery keeps the orchestrator agent, never erases its capab
   */
   const events = [];
   const session = {
-    workspace: 'acpi',
+    workspace: 'acme',
     mcp: {
       production: { status: 'connected', tools: [{ name: 'agent_describe' }] },
     },
@@ -216,7 +216,7 @@ test('a stopped agent is reported once, not on every re-scan', async () => {
   // until it answers again.
   const events = [];
   const session = {
-    workspace: 'acpi',
+    workspace: 'acme',
     mcp: { production: { status: 'connected', tools: [{ name: 'agent_describe' }] } },
     _onAgentEvent: (event) => events.push(event),
   };
@@ -260,7 +260,7 @@ test('discovery sends the workspace only to agents whose schema declares it', as
   });
 
   await registry.discover({
-    workspace: 'acpi',
+    workspace: 'acme',
     mcp: {
       // Declares workspace: gets it, and can scope its vocabulary.
       cme: {
@@ -293,9 +293,9 @@ test('discovery sends the workspace only to agents whose schema declares it', as
     },
   });
 
-  assert.deepEqual(seen.cme, { workspace: 'acpi' });
+  assert.deepEqual(seen.cme, { workspace: 'acme' });
   assert.deepEqual(seen.production, {});
-  assert.deepEqual(seen.connectors, { workspace: 'acpi' });
+  assert.deepEqual(seen.connectors, { workspace: 'acme' });
   assert.deepEqual(seen.legacyish, {});
 });
 
@@ -374,7 +374,7 @@ test('markPersistedAgentsStale invalide aussi l’instantané routable', () => {
 
 test('un agent redevient sélectionnable après un agent_describe réussi', async () => {
   const session = {
-    workspace: 'juno',
+    workspace: 'demo',
     agentEvents: [],
     agents: [{ agentInstanceId: 'production-main', serverName: 'production', health: 'available', description: { contractVersion: '1', capabilities: [{ id: 'knowledge.update', version: '1' }] } }],
     mcp: {