@dotdrelle/wiki-manager 0.15.76 → 0.15.78

package/package.json

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

package/src/core/buildInfo.json

@@ -1,4 +1,4 @@
 {
-  "version": "0.15.76",
-  "commit": "2504dc9"
+  "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.76';
+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 ?? [];
 }
 

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/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/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/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/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'),