@dotdrelle/wiki-manager 0.15.74 → 0.15.78

package/README.md

@@ -23,11 +23,10 @@ deterministic dispatcher executes bounded tasks with idempotency, bounded
 approvals, per-run budgets and automatic recovery after restart. The chat
 stays available while runs execute; additional requests are queued.
 
-Scope note: this is a single-user deployment baseline. The multi-user model is
-specified in `llm-wiki/docs/industrialisation.md` and planned next. Until
-then, do not expose the runtime as a shared write surface; it binds to
-`127.0.0.1` by default, and `--host 0.0.0.0` must be an explicit deployment
-choice with bearer-token and network protection.
+Scope note: this is a single-user deployment baseline. Do not expose the
+runtime as a shared write surface; it binds to `127.0.0.1` by default, and
+`--host 0.0.0.0` must be an explicit deployment choice with bearer-token and
+network protection.
 
 ---
 
@@ -170,7 +169,7 @@ Projects compared: [OpenWiki](https://github.com/langchain-ai/openwiki),
   territory.
 - Serve a true multi-user instance with per-user identity and an attributed
   audit trail. This is a single-user deployment baseline (see the scope note
-  above); multi-user is specified and planned next.
+  above).
 - Expose a graph-query API over the corpus the way GraphRAG does; retrieval is
   BM25 plus a vector index feeding generation.
 - Ship or host the multi-provider AI gateway — routing to several providers is

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotdrelle/wiki-manager",
-  "version": "0.15.74",
+  "version": "0.15.78",
   "description": "Agentic shell and orchestration cockpit for llm-wiki workspaces.",
   "repository": {
     "type": "git",

package/src/cli/wiki-manager.js

@@ -702,8 +702,8 @@ async function runHeadless(argv, agent) {
     session._onStep = step;
 
     let input = prompt;
-    // Plan §24: headless must resolve executable skills through the same
-    // runtime resolver as the Shell and serve. Injecting the skill body into a
+    // Headless must resolve executable skills through the same runtime resolver
+    // as the Shell and serve. Injecting the skill body into a
     // local prompt bypasses the compiler, so a multi-capability skill such as
     // wiki-sync would collapse into a single run here while producing two
     // everywhere else — and the rewritten bodies are business intentions, not

package/src/cli/wiki-manager.test.js

@@ -396,8 +396,8 @@ test('argument extraction keeps a value the vocabulary allows', async () => {
 });
 
 test('headless waits for every run of a skill chain, not just the first', async () => {
-  // wiki-sync compiles into two sequential runs: returning as soon as the
-  // export finishes would report success before the ingest had started.
+  // A multi-step user skill compiles into sequential runs: returning as soon as
+  // the first finishes would report success before the rest had started.
   const client = chainClient([
     { controlQueue: [chainItem(0, 'running', { runId: 'run-a' }), chainItem(1, 'queued')] },
     { controlQueue: [chainItem(0, 'done'), chainItem(1, 'running', { runId: 'run-b' })] },

package/src/commands/slash.js

@@ -894,7 +894,7 @@ function componentInstallAction(missingImages) {
   return missingImages.length > 0 ? 'downloaded-and-installed-missing-components' : null;
 }
 
-export function localizedOperationResult({ operation, target, status = 'succeeded', componentAction = null, images = [], detail = null }) {
+export function localizedOperationResult({ operation, target, status = 'succeeded', componentAction = null, images = [], detail = null, style = 'compact' }) {
   const facts = JSON.stringify({
     operation,
     target,
@@ -902,15 +902,21 @@ export function localizedOperationResult({ operation, target, status = 'succeede
     ...(componentAction ? { componentAction, images } : {}),
     ...(detail ? { detail } : {}),
   });
+  const instructions = style === 'report'
+    ? [
+        'Formule le résultat structuré suivant dans la langue et le ton demandés par le profil du workspace.',
+        "Décris ce qui a été fait : ce qui a été démarré, et l'état actuel de chaque service (en marche, en échec ou inconnu).",
+        'Réponds en deux ou trois phrases. Ne cite aucune commande, syntaxe shell, chemin de fichier, sortie docker ou identifiant.',
+      ]
+    : [
+        'Formule le résultat structuré suivant dans la langue et le ton demandés par le profil du workspace.',
+        'Réponds par une seule phrase humaine et naturelle.',
+        'Ne mentionne aucune commande, syntaxe shell, étape suivante ou détail technique.',
+      ];
   return {
     output: facts,
     rawOutput: true,
-    agentTrigger: [
-      'Formule le résultat structuré suivant dans la langue et le ton demandés par le profil du workspace.',
-      'Réponds par une seule phrase humaine et naturelle.',
-      'Ne mentionne aucune commande, syntaxe shell, étape suivante ou détail technique.',
-      `Résultat: ${facts}`,
-    ].join('\n'),
+    agentTrigger: [...instructions, `Résultat: ${facts}`].join('\n'),
   };
 }
 
@@ -1197,6 +1203,7 @@ export async function handleSlashCommand(line, context) {
       const startsAgents = service === 'all';
       const target = service === 'services' ? undefined : service;
       try {
+        let agentsResult = null;
         if (startsAgents) {
           // Validate the workspace half before mutating the global agents
           // stack. Otherwise `/start all` with no active workspace starts the
@@ -1204,18 +1211,48 @@ export async function handleSlashCommand(line, context) {
           if (!context.session.workspace || !context.session.workspacePath || !context.session.workspaceEnv?.WORKSPACE_NAME) {
             throw new Error('No workspace loaded. Use /use <workspace>.');
           }
-          const agentsResult = await runAgentCommand(startAgents, 'start');
+          agentsResult = await runAgentCommand(startAgents, 'start');
           if (agentsResult?.failed) return agentsResult;
         }
         step(`Services: starting ${target ?? 'workspace services'}…`);
-        const missingImages = await collectMissingImages(step, (opts) => startService(context.session, target, opts));
+        const started = [];
+        const missingImages = await collectMissingImages(step, async (opts) => {
+          const result = await startService(context.session, target, opts);
+          if (Array.isArray(result?.targets)) started.push(...result.targets);
+        });
         step('Services: refreshing MCP runtime…');
         await refreshMcpRuntimeStatus(context.session);
+        // The report is about what was done, so it names what started and how
+        // each service ended up. A failed state check says so instead of
+        // leaving every state "unknown" without a word.
+        let states = null;
+        try {
+          states = await serviceStates(context.session);
+        } catch (err) {
+          step(`Services: state check after start unavailable — ${rawFailureText(err)}`);
+        }
+        const agentsFacts = agentsResult ? parseJsonText(agentsResult.output) : null;
+        const detail = {
+          ...(agentsFacts && typeof agentsFacts === 'object' && !Array.isArray(agentsFacts) ? { agents: agentsFacts } : {}),
+          ...(started.length > 0
+            ? {
+                services: {
+                  started,
+                  states: started.map((name) => ({
+                    service: name,
+                    running: states?.[name] ? states[name].running : null,
+                  })),
+                },
+              }
+            : {}),
+        };
         return localizedOperationResult({
           operation: 'start',
           target: startsAgents ? 'all-services-and-agents' : (target || 'workspace-services'),
           componentAction: componentInstallAction(missingImages),
           images: missingImages,
+          detail: Object.keys(detail).length > 0 ? detail : null,
+          style: 'report',
         });
       } catch (err) {
         step(formatActivityError('services', 'start', err));

package/src/commands/slash.test.js

@@ -128,6 +128,34 @@ test('a started agent stack reloads the env and the MCP endpoints the script rew
   assert.match(runAgent, /await refreshMcpRuntimeStatus\(context\.session\)/);
 });
 
+test('start report style asks Donna to describe what was done, not a bare sentence', () => {
+  const result = localizedOperationResult({
+    operation: 'start',
+    target: 'wiki',
+    style: 'report',
+    detail: { services: { started: ['wiki'], states: [{ service: 'wiki', running: true }] } },
+  });
+  assert.deepEqual(JSON.parse(result.output).detail, {
+    services: { started: ['wiki'], states: [{ service: 'wiki', running: true }] },
+  });
+  assert.match(result.agentTrigger, /Décris ce qui a été fait/);
+  assert.match(result.agentTrigger, /en marche, en échec ou inconnu/);
+  assert.doesNotMatch(result.agentTrigger, /une seule phrase/);
+  assert.doesNotMatch(result.agentTrigger, /\/start|Docker|compose/);
+});
+
+test('/start captures what actually started and their resulting states', async () => {
+  const { readFile } = await import('node:fs/promises');
+  const source = await readFile(new URL('./slash.js', import.meta.url), 'utf8');
+  const start = source.slice(source.indexOf("case 'start': {"), source.indexOf("case 'stop': {"));
+
+  assert.match(start, /const started = \[\];/);
+  assert.match(start, /result\?\.targets/);
+  assert.match(start, /states = await serviceStates\(context\.session\)/);
+  assert.match(start, /running: states\?\.\[name\] \? states\[name\]\.running : null/);
+  assert.match(start, /style: 'report'/);
+});
+
 test('/start completes to the three documented targets', async () => {
   const { completionDescription } = await import('../shell/repl.js');
   const { matches } = completionContext('/start ', {});

package/src/core/buildInfo.json

@@ -1,4 +1,4 @@
 {
-  "version": "0.15.74",
-  "commit": "4ca493b"
+  "version": "0.15.78",
+  "commit": "6c0c150"
 }

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.74';
+const WIKI_MANAGER_VERSION = '0.15.78';
 
 function envValue(key) {
   const filePath = managerEnvFile();
@@ -272,7 +272,14 @@ function clarifyToolDescription(_serverName, _toolName, description) {
 
 async function listMcpTools(endpoint) {
   if (!endpoint.url) throw new Error('missing endpoint URL');
-  const payload = await mcpRequest(endpoint, 'tools/list', {});
+  // Opt-in only, unlike callMcpTool: this probe runs inside discoverMcpTools's
+  // Promise.all on every re-scan/delegation, so an endpoint with no explicit
+  // `retry` in mcp.endpoints.json must keep costing exactly one 8s timeout
+  // when unreachable, not silently inherit the global 2-attempt default and
+  // double that cost for every unconfigured server. Only an endpoint that
+  // explicitly declares `retry` gets more than one attempt here.
+  const retry = endpoint.retry ? resolveRetryPolicy(endpoint) : { maxAttempts: 1, backoffMs: 0 };
+  const payload = await withRetry(() => mcpRequest(endpoint, 'tools/list', {}), retry);
   return payload?.result?.tools ?? [];
 }
 
@@ -756,8 +763,7 @@ export function parseToolCallName(name) {
 // tool name, route to it and report `normalized: true`; otherwise return
 // `server: null` with the list of candidate servers so the caller can raise
 // an explicit error. This is name normalization, never fuzzy matching — do
-// not extend it to description/similarity-based selection (plan directeur
-// §20 forbids that).
+// not extend it to description/similarity-based selection.
 export function resolveToolCallName(mcpStatus, name, extraServers = {}) {
   const parsed = parseToolCallName(name);
   if (parsed.server) return { ...parsed, normalized: false, candidates: [] };

package/src/core/runtimeLog.js

@@ -177,6 +177,17 @@ export function isDispatchPlumbingLine(line) {
   return DISPATCH_PLUMBING_LINE.test(String(line ?? '').replace(/^runtime\s+/, ''));
 }
 
+// The agent's own reasoning traces — "Agent: planning next action…",
+// "Agent: classified input as …", "Agent: streaming final answer…" — describe
+// how the agent works, not what the business run does. They belong with the
+// dispatch plumbing in the Agent status tab; the Runtime tab keeps the
+// business flow (plan, task transitions, failures).
+const AGENT_TRACE_LINE = /^(?:runtime\s+)?(?:\d{1,2}:\d{2}(?::\d{2})?\s*(?:·\s*)?)?Agent:\s/;
+
+export function isAgentTraceLine(line) {
+  return AGENT_TRACE_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, isDispatchPlumbingLine, shortLogId } from './runtimeLog.js';
+import { compactRuntimeLogForDisplay, formatRuntimeLogPayload, isAgentTraceLine, isDispatchPlumbingLine, shortLogId } from './runtimeLog.js';
 import { emitRuntimeLog } from '../runtime/supervisor.js';
 
 const CYCLE_EVENTS = [
@@ -156,6 +156,34 @@ test('isDispatchPlumbingLine recognises the shell-tagged "runtime " lines for th
   assert.equal(isDispatchPlumbingLine('runtime 14:42:22 Plan validated for run r1'), false);
 });
 
+test('isAgentTraceLine recognises the "Agent:" traces for the Agent status tab', () => {
+  // The agent's own reasoning traces were rendered in the Runtime tab,
+  // indistinguishable from the business flow. They describe the agent's
+  // working, so the Agent status tab shows them with the dispatch plumbing.
+  for (const line of [
+    '14:42:18 Agent: planning next action…',
+    '14:42:19 Agent: classified input as enqueue',
+    '14:42:20 Agent: streaming final answer…',
+    'runtime 14:42:18 Agent: planning next action…',
+  ]) {
+    assert.equal(isAgentTraceLine(line), true, `expected an agent trace: ${line}`);
+  }
+});
+
+test('isAgentTraceLine leaves every other line 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:21 Run failed: No agent provides capability workspace.restore.',
+    '14:42:22 Plan validated for run r1',
+    '14:42:23 Agentic runtime: no capabilities available',
+    '14:42:24 Plan: 3 task(s) declared from production fragment',
+    'runtime 14:42:21 Run failed: Agent was not ready',
+  ]) {
+    assert.equal(isAgentTraceLine(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/skillCompiler.test.js

@@ -30,8 +30,8 @@ test('validation rejects technical routing details', () => {
   assert.throws(() => validateCompiledObjectives([{ text: 'agent: cme' }]), { code: 'skill_compile_failed' });
 });
 
-test('scaffold skills preserve existing capabilities and split only wiki-sync', async () => {
-  const expected = { pipeline: 1, 'wiki-ingest': 1, 'wiki-build': 1, deliver: 1, diagnose: 1, status: 1, 'new-template': 1, 'wiki-sync': 2 };
+test('every shipped scaffold skill compiles to a single intention', async () => {
+  const expected = { pipeline: 1, 'wiki-sync': 1, 'wiki-ingest': 1, 'wiki-build': 1, deliver: 1, diagnose: 1, status: 1, 'new-template': 1 };
   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);
@@ -53,7 +53,7 @@ test('every objective of a chain carries the user parameters, not just the last'
   // Appending the parameters before splitting attached `source` to the ingest
   // step and left the export step — the one that consumes it — without it.
   const skill = {
-    name: 'wiki-sync',
+    name: 'collect-then-ingest',
     params: ['source'],
     body: 'Export the requested source.\n\nThen ingest what was exported.',
   };

package/src/core/wikiSetup.js

@@ -6,7 +6,7 @@ import { promisify } from 'node:util';
 import YAML from 'yaml';
 import { checkMissingDockerImages } from './dockerImages.js';
 import { loadWikircProfile, patchWikircProfile } from './wikirc.js';
-import { buildInheritedWikircPatch, copyCmeCredentials } from './workspaceInherit.js';
+import { buildInheritedWikircPatch } from './workspaceInherit.js';
 import { resolveAgentsComposeContext } from './agentsCompose.js';
 import { managerEnvFile, managerMcpEndpointsFile, resolveAgentsDataDir } from './env.js';
 import { createWorkspace, findWorkspace, isValidWorkspaceName, listWorkspaces, managerRoot, workspacesDir } from './workspaces.js';
@@ -245,9 +245,11 @@ export async function createNewWorkspace(name, targetPath, options = {}) {
 }
 
 /**
- * @param options.inheritFrom name of the workspace to copy LLM config and CME
- *   credentials from — normally the session's current workspace. Omitted, or
- *   unknown, means "scaffold defaults only", the previous behaviour.
+ * @param options.inheritFrom name of the workspace to copy LLM config from —
+ *   normally the session's current workspace. Omitted, or unknown, means
+ *   "scaffold defaults only", the previous behaviour. Confluence credentials
+ *   are NOT inherited: agent-cme stores them agent-wide (shared across all
+ *   workspaces), so a new workspace already sees them.
  */
 export async function finalizeCreatedWorkspace(name, options = {}) {
   const workspace = findWorkspace(name);
@@ -282,13 +284,6 @@ export async function inheritWorkspaceSetup(workspace, sourceName) {
     // Unreadable or absent profile on either side — nothing to inherit.
   }
 
-  try {
-    const copied = await copyCmeCredentials(resolveAgentsDataDir(), source.name, workspace.name);
-    if (copied) inherited.push('cme.app_data.json');
-  } catch {
-    // Credentials are a convenience, not a prerequisite.
-  }
-
   return inherited;
 }
 

package/src/core/wikirc.test.js

@@ -1,5 +1,5 @@
 import assert from 'node:assert/strict';
-import { mkdirSync, mkdtempSync, readFileSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import test from 'node:test';
@@ -300,6 +300,9 @@ test('finalizeCreatedWorkspace seeds a new workspace from the one in use', async
     '',
   ].join('\n'));
 
+  // Confluence credentials are agent-wide now — a stale per-workspace
+  // app_data.json from a legacy layout must NOT be copied into the new
+  // workspace, and must not be reported as inherited.
   mkdirSync(join(agentsData, 'cme', 'acme', 'cme'), { recursive: true });
   writeFileSync(join(agentsData, 'cme', 'acme', 'cme', 'app_data.json'), '{"pat":"x"}', 'utf8');
 
@@ -318,11 +321,8 @@ test('finalizeCreatedWorkspace seeds a new workspace from the one in use', async
     // The workspace keeps ITS own MCP credential, written just before.
     assert.equal(parsed.mcp.accessKey, token);
     assert.ok(inherited.includes('llm.baseUrl'));
-    assert.ok(inherited.includes('cme.app_data.json'));
-    assert.equal(
-      readFileSync(join(agentsData, 'cme', 'fresh', 'cme', 'app_data.json'), 'utf8'),
-      '{"pat":"x"}',
-    );
+    assert.ok(!inherited.includes('cme.app_data.json'));
+    assert.equal(existsSync(join(agentsData, 'cme', 'fresh', 'cme', 'app_data.json')), false);
   } finally {
     if (previousDir === undefined) delete process.env.WIKI_WORKSPACES_DIR;
     else process.env.WIKI_WORKSPACES_DIR = previousDir;

package/src/core/workflow.js

@@ -14,13 +14,11 @@ import { isTerminal } from '../orchestrator/taskStatuses.js';
 
 const RUNNING_STATUSES = new Set(['running', 'starting', 'queued', 'waiting', 'pending_approval']);
 
-// Canonical workflow projection for 0.9.6.
+// Canonical workflow projection.
 //
-// Decision: projectWorkflow consumes the existing event-sourced agentProjection
-// instead of replacing it in this release. agentProjection remains the
-// compatibility reducer/hydration format; workflow is the canonical read model
-// for Serve and ShellTUI. Future releases can move the reducer internals behind
-// this module without changing UI contracts.
+// projectWorkflow consumes the existing event-sourced agentProjection instead
+// of replacing it: agentProjection remains the compatibility reducer/hydration
+// format; workflow is the canonical read model for Serve and ShellTUI.
 export function projectWorkflow(state = {}, events = []) {
   const run = currentRun(state, events);
   const plan = Array.isArray(state.plan) ? state.plan : [];

package/src/core/workspaceInherit.js

@@ -1,5 +1,3 @@
-import { copyFile, mkdir } from 'node:fs/promises';
-import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 
 /**
@@ -121,29 +119,3 @@ export function buildInheritedWikircPatch(sourceConfig, targetConfig) {
   if (Object.keys(vector).length > 0) patch.retrieval = { vector };
   return { patch, inherited };
 }
-
-export function cmeCredentialsPath(agentsDataDir, workspaceName) {
-  return join(agentsDataDir, 'cme', workspaceName, 'cme', 'app_data.json');
-}
-
-/**
- * Carry the Confluence credentials of an existing workspace over to a new one.
- *
- * `app_data.json` only — NOT `sources-manifest.yaml`. The credentials are a
- * property of the operator's Confluence account and are identical everywhere;
- * which spaces and pages a workspace exports is precisely what makes it a
- * different workspace, and copying that would silently re-export someone
- * else's scope on the first run.
- */
-export async function copyCmeCredentials(agentsDataDir, sourceWorkspace, targetWorkspace) {
-  if (!agentsDataDir || !sourceWorkspace || !targetWorkspace) return null;
-  if (sourceWorkspace === targetWorkspace) return null;
-  const from = cmeCredentialsPath(agentsDataDir, sourceWorkspace);
-  const to = cmeCredentialsPath(agentsDataDir, targetWorkspace);
-  if (!existsSync(from)) return null;
-  // An existing target file is a real configuration; never clobber it.
-  if (existsSync(to)) return null;
-  await mkdir(join(agentsDataDir, 'cme', targetWorkspace, 'cme'), { recursive: true });
-  await copyFile(from, to);
-  return to;
-}

package/src/core/workspaceInherit.test.js

@@ -1,14 +1,10 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, readFileSync, writeFileSync, existsSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
+import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import {
   PLACEHOLDER_VALUE_RE,
   buildInheritedWikircPatch,
-  cmeCredentialsPath,
-  copyCmeCredentials,
   isRealValue,
 } from './workspaceInherit.js';
 
@@ -144,38 +140,14 @@ test('nothing to inherit yields an empty patch', () => {
   assert.deepEqual(inherited, []);
 });
 
-test('CME credentials are copied, and the source manifest is not', async () => {
-  const root = mkdtempSync(join(tmpdir(), 'cme-inherit-'));
-  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', 'acme', 'sources-manifest.yaml'), 'sources: []\n', 'utf8');
-
-  const copied = await copyCmeCredentials(root, 'acme', 'fresh');
-
-  assert.equal(copied, cmeCredentialsPath(root, 'fresh'));
-  assert.equal(readFileSync(copied, 'utf8'), '{"auth":{"pat":"secret"}}');
-  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', '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, 'acme', 'fresh'), null);
-  assert.equal(
-    readFileSync(cmeCredentialsPath(root, 'fresh'), 'utf8'),
-    '{"from":"target"}',
+test('Confluence credentials are not part of workspace inheritance', () => {
+  // agent-cme stores credentials agent-wide since the shared-config change:
+  // a new workspace sees them without any copy. Inheritance must not smuggle
+  // an app_data.json (or a sources manifest) into per-workspace state.
+  const { patch, inherited } = buildInheritedWikircPatch(
+    { llm: WORKING_LLM },
+    { llm: SCAFFOLD_LLM },
   );
-});
-
-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', 'fresh'), null);
-  assert.equal(await copyCmeCredentials(root, null, 'fresh'), null);
-  assert.equal(await copyCmeCredentials(root, 'acme', 'acme'), null);
+  assert.equal(patch['cme.app_data.json'], undefined);
+  assert.ok(!inherited.some((key) => key.toLowerCase().includes('cme')));
 });

package/src/orchestrator/agentRegistry.js

@@ -72,8 +72,19 @@ export function createAgentRegistry({
       const discovered = [];
       const endpoints = Object.entries(session?.mcp ?? {});
       const activeServers = new Set(endpoints.map(([serverName]) => serverName));
-      for (const [serverName, endpoint] of endpoints) {
-        const agent = await discoverServerAgent(session, serverName, endpoint, { callTool, signal, now });
+      // Each probe is an independent network call (agent_describe against one
+      // server); none reads another server's result. Probing them concurrently
+      // turns the wall-clock cost from the SUM of every server's probe latency
+      // into the latency of the SLOWEST one — the sequential version made every
+      // delegation get linearly slower as more MCP servers were connected.
+      // registerAgent still runs afterward in the original endpoint order, one
+      // at a time, so event ordering and the shared-map mutations it performs
+      // are unchanged.
+      const probed = await Promise.all(
+        endpoints.map(([serverName, endpoint]) =>
+          discoverServerAgent(session, serverName, endpoint, { callTool, signal, now })),
+      );
+      for (const agent of probed) {
         discovered.push(registerAgent(session, agent, { agentsByInstance, instanceByServer, lastProbeFailed }));
       }
       for (const [serverName, instanceId] of instanceByServer) {

package/src/orchestrator/objectiveResolver.test.js

@@ -92,7 +92,7 @@ test('resolveObjective disambiguates "export" of a Confluence source via alias,
   assert.equal(result.provider.agentInstanceId, 'cme-1');
 });
 
-test('resolveObjective resolves the ingest step of wiki-sync deterministically despite notification and guardrails', async () => {
+test('resolveObjective resolves an ingest objective deterministically despite notification and guardrails', async () => {
   const session = sessionWith([
     provider('production-1', knowledge),
     provider('production-2', publish),

package/src/orchestrator/providers/runtimeProviders.js

@@ -22,35 +22,37 @@ export async function discoverRuntimeProviderAgents(runtimeProviders) {
   const providers = Array.isArray(runtimeProviders)
     ? runtimeProviders
     : (runtimeProviders?.list?.() ?? []);
-  const agents = [];
-  const unavailable = [];
-  // Configured-but-not-served capabilities, per runtime (deepagents providers
-  // fill `lastDiscovery`). A drift is not an outage: the runtime stays
-  // available with the capabilities it really serves, and the difference is
-  // reported so an operator can see WHY agent.research is not routable.
-  const drift = [];
 
-  for (const entry of providers) {
+  // One provider's describe()/discoverCapabilities() never reads another
+  // provider's result, so probe them concurrently (same reasoning as
+  // agentRegistry.discover()) instead of paying the sum of every runtime's
+  // latency in sequence. Each entry still produces its own ordered
+  // {agents, unavailable, drift} slice, flattened below in the original
+  // `providers` order so output ordering is unchanged.
+  const results = await Promise.all(providers.map(async (entry) => {
     const provider = entry?.provider ?? entry;
     const runtimeId = String(entry?.id ?? provider?.runtime ?? 'external-runtime');
+    const agents = [];
+    const unavailable = [];
+    const drift = [];
     let description;
     try {
       assertRuntimeProvider(provider);
       description = await provider.describe();
     } catch (error) {
       unavailable.push({ runtimeId, error: error instanceof Error ? error.message : String(error) });
-      continue;
+      return { agents, unavailable, drift };
     }
     if (description?.health === 'unavailable') {
       unavailable.push({ runtimeId, error: description?.error ?? 'runtime reports unavailable' });
-      continue;
+      return { agents, unavailable, drift };
     }
     let capabilities;
     try {
       capabilities = await provider.discoverCapabilities();
     } catch (error) {
       unavailable.push({ runtimeId, error: error instanceof Error ? error.message : String(error) });
-      continue;
+      return { agents, unavailable, drift };
     }
     const health = ['available', 'degraded'].includes(description?.health)
       ? description.health
@@ -62,7 +64,16 @@ export async function discoverRuntimeProviderAgents(runtimeProviders) {
     if (discovery && Array.isArray(discovery.missing) && discovery.missing.length > 0) {
       drift.push({ runtimeId, missing: [...discovery.missing], served: [...(discovery.served ?? [])] });
     }
-  }
+    return { agents, unavailable, drift };
+  }));
+
+  // Configured-but-not-served capabilities, per runtime (deepagents providers
+  // fill `lastDiscovery`). A drift is not an outage: the runtime stays
+  // available with the capabilities it really serves, and the difference is
+  // reported so an operator can see WHY agent.research is not routable.
+  const agents = results.flatMap((r) => r.agents);
+  const unavailable = results.flatMap((r) => r.unavailable);
+  const drift = results.flatMap((r) => r.drift);
 
   return { agents, unavailable, drift };
 }

package/src/runtime/server.js

@@ -1422,9 +1422,8 @@ function rejectPlanPatch(context, store, patchId, reason) {
   };
 }
 
-// Classifier for control §4.2 of the plan directeur. The plan expects an
-// LLM-backed classification — "the classification LLM se trompera" — and this
-// is that, now: the only deterministic matches left are the runtime's own
+// Classifier for the control lane's free-text messages. The classification is
+// LLM-backed: the only deterministic matches left are the runtime's own
 // control verbs (cancel, an explicit "later/queue", status and plan-change
 // wording). Deciding "is this a NEW task to queue vs plain conversation" is a
 // semantic judgement about the workspace's domain, so it is never a keyword

package/src/runtime/server.test.js

@@ -1606,7 +1606,7 @@ test('runtime server handle drains a pre-existing hydrated control request', asy
 test('POST /run compiles a workspace skill into a sequential runtime chain', async (t) => {
   const root = mkdtempSync(join(tmpdir(), 'runtime-skill-'));
   mkdirSync(join(root, '.wiki', 'skills'), { recursive: true });
-  writeFileSync(join(root, '.wiki', 'skills', 'wiki-sync.md'), '---\nname: wiki-sync\nparams:\n  - source\n---\nExport the source.\n\nThen ingest the files.');
+  writeFileSync(join(root, '.wiki', 'skills', 'sync-ingest.md'), '---\nname: sync-ingest\nparams:\n  - source\n---\nExport the source.\n\nThen ingest the files.');
   const session = { workspace: 'acme', workspacePath: root, controlQueue: [] };
   const context = { workspace: 'acme', session, running: false, currentAbortController: null };
   let startedBody = null;
@@ -1623,7 +1623,7 @@ test('POST /run compiles a workspace skill into a sequential runtime chain', asy
     throw err;
   }
   try {
-    const response = await fetch(`http://127.0.0.1:${handle.port}/run?workspace=acme`, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ input: '/wiki-sync docs' }) });
+    const response = await fetch(`http://127.0.0.1:${handle.port}/run?workspace=acme`, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ input: '/sync-ingest docs' }) });
     const body = await response.json();
     assert.equal(response.status, 202);
     assert.equal(body.kind, 'skill_chain');
@@ -1633,15 +1633,15 @@ test('POST /run compiles a workspace skill into a sequential runtime chain', asy
     assert.equal(session.controlQueue[1].status, 'queued');
     assert.equal(session.controlQueue[0].chainId, session.controlQueue[1].chainId);
     assert.equal('capabilityPlan' in session.controlQueue[0], false);
-    assert.equal(session.controlQueue[0].input, '/wiki-sync source="docs"');
+    assert.equal(session.controlQueue[0].input, '/sync-ingest source="docs"');
     assert.equal(session.controlQueue[0].skillExecution, 'orchestrated');
     assert.match(startedBody.input, /Export the source/);
-    assert.equal(startedBody.publicInput, '/wiki-sync source="docs"');
+    assert.equal(startedBody.publicInput, '/sync-ingest source="docs"');
     assert.equal(startedBody.skillChain.execution, 'orchestrated');
     assert.equal(startedBody.requireApproval, true);
     assert.notEqual(startedBody.autoApprove, true);
     assert.deepEqual(session.agentProjection.conversation, [
-      { role: 'user', content: '/wiki-sync docs' },
+      { role: 'user', content: '/sync-ingest docs' },
     ]);
     assert.doesNotMatch(JSON.stringify(session.agentEvents), /Export the source|Then ingest the files/);
   } finally {

package/src/runtime/skillChain.e2e.test.js

@@ -132,26 +132,31 @@ test('E2E-001 pipeline: one objective, one run, internal plan left untouched', a
   assert.equal(env.chain().length, 1);
 });
 
-test('E2E-002 wiki-sync: two objectives, two ordered runs, one chainId', async (t) => {
-  const env = await harness(t, { skills: { 'wiki-sync': null } });
+test('E2E-002 multi-step skill: two objectives, two ordered runs, one chainId', async (t) => {
+  // No shipped skill splits any more (each is one intention); a user-authored
+  // body with a strong connector still must.
+  const env = await harness(t, {
+    skills: {
+      'sync-ingest': '---\nname: sync-ingest\nparams: []\n---\nExport every configured Confluence source.\n\nThen ingest the exported Markdown into the wiki.',
+    },
+  });
   if (!env) return;
 
-  const { body } = await env.post('/run?workspace=acme', { input: '/wiki-sync' });
+  const { body } = await env.post('/run?workspace=acme', { input: '/sync-ingest' });
   await env.settle();
 
   assert.equal(body.objectives, 2);
   assert.equal(env.runs.length, 2, 'the second objective must run after the first');
   assert.match(env.runs[0].input, /^Export every configured Confluence source/);
-  assert.match(env.runs[1].input, /^Run the production pipeline step ingest over the newly exported Markdown/);
-  // CME first, Production second — the skill carries no source parameter, so
-  // no run may receive a source selector (the export step must stay "all").
+  assert.match(env.runs[1].input, /^Ingest the exported Markdown/);
+  // The skill carries no parameter, so no run may receive a selector.
   for (const run of env.runs) assert.doesNotMatch(run.input, /User parameters:/);
   const items = env.chain();
   assert.equal(items.length, 2);
   assert.equal(items[0].chainId, items[1].chainId);
   assert.equal(items[0].chainId, body.chainId);
   assert.deepEqual(items.map((item) => item.status), ['done', 'done']);
-  assert.deepEqual(items.map((item) => item.skillName), ['wiki-sync', 'wiki-sync']);
+  assert.deepEqual(items.map((item) => item.skillName), ['sync-ingest', 'sync-ingest']);
 });
 
 test('E2E-002b parameters reach every objective of a multi-step skill', async (t) => {
@@ -220,13 +225,13 @@ test('E2E-003 cancel: the running step and its chain stop, unrelated queue survi
 // that silently fragments would show up as extra runs, not as extra objectives.
 const PERFORMANCE_TABLE = {
   pipeline: 1,
+  'wiki-sync': 1,
   'wiki-ingest': 1,
   'wiki-build': 1,
   deliver: 1,
   diagnose: 1,
   status: 1,
   'new-template': 1,
-  'wiki-sync': 2,
 };
 
 for (const [name, expected] of Object.entries(PERFORMANCE_TABLE)) {

package/src/shell/RightPane.tsx

@@ -1,6 +1,6 @@
 /** @jsxImportSource @opentui/solid */
 import { createMemo, createSignal, Index, Show } from 'solid-js';
-import { compactRuntimeLogForDisplay, filterRuntimeLogs, isDispatchPlumbingLine } from '../core/runtimeLog.js';
+import { compactRuntimeLogForDisplay, filterRuntimeLogs, isAgentTraceLine, isDispatchPlumbingLine } from '../core/runtimeLog.js';
 import { fit } from './textFit';
 
 type PlanStep = { step: number; description: string; status: string };
@@ -409,13 +409,14 @@ export function LogPanel(props: { logs: string[]; width: number; filter?: string
   const [activeLogTab, setActiveLogTab] = createSignal<'flow' | 'agent-status'>('flow');
   const lineWidth = () => Math.max(8, props.width - 2);
   // "Agent status" collects the dispatch plumbing — capability resolution,
-  // agent selection, agent_execute/agent_status polling, job acceptance — so
-  // the "Runtime" tab is left with the readable business flow (plan + the
-  // ▸/✓/✗/↻ task lines). isDispatchPlumbingLine (shared with agentEvents'
-  // dedup) recognises the formatRuntimeLogPayload shape structurally; the old
-  // token enumeration only ever matched agent_status/agent_execute and missed
-  // every dotted event ('job.accepted' → 'ACCEPTED', …).
-  const isAgentStatus = (line: string) => isDispatchPlumbingLine(line);
+  // agent selection, agent_execute/agent_status polling, job acceptance — and
+  // the agent's own reasoning traces ("Agent: …"), so the "Runtime" tab is
+  // left with the readable business flow (plan + the ▸/✓/✗/↻ task lines).
+  // isDispatchPlumbingLine (shared with agentEvents' dedup) recognises the
+  // formatRuntimeLogPayload shape structurally; the old token enumeration
+  // only ever matched agent_status/agent_execute and missed every dotted
+  // event ('job.accepted' → 'ACCEPTED', …).
+  const isAgentStatus = (line: string) => isDispatchPlumbingLine(line) || isAgentTraceLine(line);
   // Filtering preserves the runtime history order. logRenderLines performs
   // the single block-level reversal shared by both tabs.
   const filteredLogs = () => filterRuntimeLogs(props.logs, props.filter ?? '')

package/src/shell/repl.test.js

@@ -101,6 +101,13 @@ test('ShellUI renders newest-first order in both Runtime and Agent status', asyn
   assert.match(filteredLogs, /activeLogTab\(\) === 'agent-status'/);
   assert.match(filteredLogs, /isAgentStatus\(line\)/);
   assert.doesNotMatch(filteredLogs, /\.reverse\(\)/);
+  const logPanelBody = source.slice(
+    source.indexOf('export function LogPanel'),
+    source.indexOf('const filteredLogs ='),
+  );
+  // Agent reasoning traces route to the Agent status tab with the dispatch
+  // plumbing — the Runtime tab keeps the business flow.
+  assert.match(logPanelBody, /isDispatchPlumbingLine\(line\) \|\| isAgentTraceLine\(line\)/);
   const renderedLogs = source.slice(
     source.indexOf('function logRenderLines'),
     source.indexOf('function logEntryLines'),