@dotdrelle/wiki-manager 0.15.29 → 0.15.32

package/.env.example

@@ -56,8 +56,11 @@ CONNECTORS_MCP_AUTH_TOKEN=
 # Enable the opt-in agent-connectors service:
 CONNECTORS_ENABLED=false
 #
-# The public wikiLLM Desktop/PKCE Client ID is built into agent-connectors.
-# Optional advanced/self-hosted override:
+# The wikiLLM Google OAuth application is baked into the agent-connectors image
+# at build time, from agent-external/agent-connectors/.env.build.local. When you
+# build the image locally, that file must exist — otherwise the container starts
+# with empty credentials.
+# Optional runtime override (no rebuild needed):
 # GOOGLE_OAUTH_CLIENT_ID=
 # Optional confidential-client compatibility override:
 # GOOGLE_OAUTH_CLIENT_SECRET=

package/agents.docker-compose.yml

@@ -100,6 +100,16 @@ services:
     build:
       context: ../agent-external/agent-connectors
       dockerfile: Dockerfile
+      args:
+        # Without these the ARGs stay unset and the image ships empty
+        # WIKILLM_GOOGLE_OAUTH_* values, so the container ends up with no Google
+        # client at all. `wiki-workspace agents up` exports them from the
+        # connectors repo's .env.build.local before invoking Compose.
+        # Deliberately value-less: Compose then forwards each host variable only
+        # when it is defined. Never write `${VAR:-}` here — an empty
+        # --build-arg pins the ARG to the empty string.
+        WIKILLM_GOOGLE_OAUTH_CLIENT_ID:
+        WIKILLM_GOOGLE_OAUTH_CLIENT_SECRET:
     image: dotdrelle/agent-connectors:latest
     user: "${UID:-1000}:${GID:-1000}"
     ports:

package/bin/wiki-manager.js

@@ -80,7 +80,7 @@ async function main() {
   // Fallback for already-bootstrapped direct invocations; the shell wrapper
   // exports these before Bun starts.
   if (parsed.cacert) Object.assign(process.env, cacertEnvVars(parsed.cacert));
-  const interactive = process.stdout.isTTY && process.stdin.isTTY && argv[0] !== 'runtime' && !argv.includes('--setup-wizard') && !argv.includes('--headless') && !argv.includes('--once') && !argv.includes('--version') && !argv.includes('-v') && !argv.includes('--help') && !argv.includes('-h');
+  const interactive = process.stdout.isTTY && process.stdin.isTTY && argv[0] !== 'runtime' && !argv.includes('--refresh') && !argv.includes('--setup-wizard') && !argv.includes('--headless') && !argv.includes('--once') && !argv.includes('--version') && !argv.includes('-v') && !argv.includes('--help') && !argv.includes('-h');
   if (interactive || argv.includes('--setup-wizard')) await import('@opentui/solid/preload');
   if (interactive) process.stdout.write('Starting wiki-manager…\r');
   const { runCli } = await import('../src/cli/wiki-manager.js');

package/docker-compose.override.example.yml

@@ -40,6 +40,7 @@
 #     services:
 #       serve:
 #         environment:
+#           - NODE_USE_ENV_PROXY=${NODE_USE_ENV_PROXY:-1}
 #           - HTTP_PROXY=${HTTP_PROXY:-}
 #           - HTTPS_PROXY=${HTTPS_PROXY:-}
 #           - http_proxy=${HTTP_PROXY:-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotdrelle/wiki-manager",
-  "version": "0.15.29",
+  "version": "0.15.32",
   "description": "Agentic shell and orchestration cockpit for llm-wiki workspaces.",
   "license": "PolyForm-Noncommercial-1.0.0",
   "author": "dotrelle",

package/src/agent/graph.test.js

@@ -203,8 +203,10 @@ function toolCallingLlm() {
 test('agent graph waits for run-level approval before first MCP action', async () => {
   const originalFetch = globalThis.fetch;
   let fetchCalls = 0;
-  globalThis.fetch = async () => {
-    fetchCalls += 1;
+  globalThis.fetch = async (_url, init) => {
+    // Count tool traffic only: the MCP session handshake is transport
+    // plumbing, not an action the user needs to approve or observe.
+    if (JSON.parse(init.body).method === 'tools/call') fetchCalls += 1;
     return {
       ok: true,
       status: 200,
@@ -488,6 +490,15 @@ test('Donna refuses to delegate connector authentication to an export capability
   globalThis.fetch = async (url, options = {}) => {
     fetchedUrls.push(String(url));
     const body = JSON.parse(String(options.body ?? '{}'));
+    // MCP session handshake: answer it, then assert on the real tool call.
+    if (body.method === 'initialize') {
+      return {
+        ok: true,
+        status: 200,
+        headers: { get: () => null },
+        text: async () => '{"jsonrpc":"2.0","id":0,"result":{"protocolVersion":"2025-06-18"}}',
+      };
+    }
     assert.equal(body.params?.name, 'connectors_google_oauth_start');
     assert.deepEqual(body.params?.arguments, { workspace: 'docs' });
     return {
@@ -1302,8 +1313,10 @@ test('agent graph executes action inputs inside a runtime run instead of asking
   // returned a canned clarification — "lance l'ingestion" did nothing.
   const originalFetch = globalThis.fetch;
   let fetchCalls = 0;
-  globalThis.fetch = async () => {
-    fetchCalls += 1;
+  globalThis.fetch = async (_url, init) => {
+    // Count tool traffic only: the MCP session handshake is transport
+    // plumbing, not an action the user needs to approve or observe.
+    if (JSON.parse(init.body).method === 'tools/call') fetchCalls += 1;
     return {
       ok: true,
       status: 200,

package/src/cli/runtimeStartup.test.js

@@ -12,3 +12,17 @@ test('runtime startup is not blocked by optional Docker image maintenance', asyn
   assert.match(runtimeBranch, /await runRuntime\(argv\.slice\(1\), agent\)/);
   assert.doesNotMatch(runtimeBranch, /refreshRunningContainers/);
 });
+
+test('shell exit leaves the shared runtime alive and refresh is explicit', async () => {
+  const cli = await readFile(new URL('./wiki-manager.js', import.meta.url), 'utf8');
+  const tui = await readFile(new URL('../shell/tui.tsx', import.meta.url), 'utf8');
+  const bin = await readFile(new URL('../../bin/wiki-manager.js', import.meta.url), 'utf8');
+
+  assert.doesNotMatch(cli, /await shutdownOwnedRuntime\(runtime/);
+  assert.doesNotMatch(tui, /shutdownOwnedRuntime/);
+  assert.match(tui, /shell closed; shared runtime left running/);
+  assert.match(tui, /process\.exit\(0\)/);
+  assert.match(cli, /argv\.includes\('--refresh'\)/);
+  assert.match(cli, /spawnSync\(workspaceCliPath, \['refresh'\]/);
+  assert.match(bin, /!argv\.includes\('--refresh'\)/);
+});

package/src/cli/wiki-manager.js

@@ -1,4 +1,5 @@
 import { randomUUID } from 'node:crypto';
+import { spawnSync } from 'node:child_process';
 import { readFileSync } from 'node:fs';
 import { mkdir, writeFile } from 'node:fs/promises';
 import { dirname, join, resolve } from 'node:path';
@@ -25,6 +26,7 @@ import { listWorkspaces } from '../core/workspaces.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const packageJsonPath = resolve(__dirname, '../../package.json');
+const workspaceCliPath = resolve(__dirname, '../../wiki-workspace');
 const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
 const SHELL_COMMANDS = ['help', 'version', 'exit', 'workspace', 'new', 'use', 'config', 'status', 'services', 'start', 'stop', 'logs', 'mcp', 'connector', 'wiki', 'skills', 'clear', 'chat', 'agent', 'approve'];
 
@@ -106,7 +108,13 @@ export function buildExecutorOnlyFragment({ objective, workspace, selection }) {
  * then a JSON-text completion, then no arguments — the executor uses its own
  * defaults. It never throws and never invents identifiers.
  */
-export async function resolveExecutorArguments({ llm, objective, capability, signal } = {}) {
+export async function resolveExecutorArguments({
+  llm,
+  objective,
+  capability,
+  workspace,
+  signal,
+} = {}) {
   const schema = capability?.inputSchema;
   const objectiveText = String(objective ?? '').trim();
   if (
@@ -121,10 +129,22 @@ export async function resolveExecutorArguments({ llm, objective, capability, sig
   ) {
     return {};
   }
+  const workspaceName = String(workspace ?? '').trim();
   const system = [
     'Extract structured arguments for a task from the user objective.',
     'Only fill a field when the objective explicitly states or clearly implies its value.',
     'Omit every field that is not stated. Never invent identifiers, queries, filters or counts.',
+    // The objective almost always names the workspace ("export the pages of
+    // workspace acpi"), and the orchestrator already binds it out of band. With
+    // one free-text field in the schema and no field for the workspace, a model
+    // reliably misbinds the two — that is how a workspace name ended up as a
+    // source name and failed the task.
+    ...(workspaceName
+      ? [
+        `The task already runs against workspace "${workspaceName}"; the orchestrator supplies it separately.`,
+        `Never use "${workspaceName}" as the value of any field. If the objective only names the workspace, return {}.`,
+      ]
+      : []),
     'Return the arguments object only.',
   ].join('\n');
   const tool = {
@@ -150,9 +170,9 @@ export async function resolveExecutorArguments({ llm, objective, capability, sig
     });
     const call = (result?.tool_calls ?? []).find((item) => item?.function?.name === 'set_task_arguments');
     const fromCall = call ? safeParseArgumentObject(call.function?.arguments) : null;
-    if (fromCall) return pruneArgumentsToSchema(fromCall, schema);
+    if (fromCall) return pruneArgumentsToSchema(fromCall, schema, workspaceName);
     const fromText = safeParseArgumentObject(result?.content);
-    if (fromText) return pruneArgumentsToSchema(fromText, schema);
+    if (fromText) return pruneArgumentsToSchema(fromText, schema, workspaceName);
   } catch {
     // Fall through to the tool-less path.
   }
@@ -164,13 +184,36 @@ export async function resolveExecutorArguments({ llm, objective, capability, sig
       signal,
     });
     const fromText = safeParseArgumentObject(result?.content);
-    if (fromText) return pruneArgumentsToSchema(fromText, schema);
+    if (fromText) return pruneArgumentsToSchema(fromText, schema, workspaceName);
   } catch {
     // Give up: the executor will use its own defaults.
   }
   return {};
 }
 
+// The system prompt above is advice a model may ignore; this is not. A value
+// that merely echoes the workspace name carries no information the orchestrator
+// does not already hold, so dropping it can only widen the task to the
+// executor's own default — never narrow it to something wrong. (A source
+// genuinely named after its workspace degrades to "process everything", which
+// still includes it.)
+function echoesWorkspace(key, value, workspaceName) {
+  if (!workspaceName || typeof value !== 'string') return false;
+  if (/workspace/i.test(key)) return false;
+  return value.trim().toLowerCase() === String(workspaceName).trim().toLowerCase();
+}
+
+// A field with an `enum` declares a closed vocabulary, so an extracted value
+// outside it is checkably wrong — not a judgement call about meaning. This is
+// the only class of hallucinated identifier the orchestrator can reject
+// without knowing anything about the business domain, which is exactly why
+// agents must publish the vocabulary instead of a bare string.
+function violatesEnum(schemaEntry, value) {
+  const values = schemaEntry?.enum;
+  if (!Array.isArray(values) || values.length === 0) return false;
+  return !values.some((allowed) => allowed === value);
+}
+
 export function missingRequiredArguments(schema, args) {
   const required = Array.isArray(schema?.required) ? schema.required.map(String) : [];
   const values = args && typeof args === 'object' && !Array.isArray(args) ? args : {};
@@ -194,12 +237,14 @@ function safeParseArgumentObject(text) {
   }
 }
 
-function pruneArgumentsToSchema(value, schema) {
+function pruneArgumentsToSchema(value, schema, workspaceName = '') {
   const allowed = schema.properties ?? {};
   const acceptsExtra = schema.additionalProperties !== false;
   const out = {};
   for (const [key, entry] of Object.entries(value)) {
     if (entry === undefined || entry === null) continue;
+    if (echoesWorkspace(key, entry, workspaceName)) continue;
+    if (violatesEnum(allowed[key], entry)) continue;
     if (Object.hasOwn(allowed, key) || acceptsExtra) out[key] = entry;
   }
   return out;
@@ -260,6 +305,12 @@ export function ensureInteractiveAssistantMessage(session, response, { turnId, w
   return true;
 }
 
+export function mcpStatusNeedsRefresh(mcpStatus) {
+  return Object.values(mcpStatus ?? {}).some(
+    (endpoint) => endpoint?.url && endpoint.status !== 'connected',
+  );
+}
+
 export async function forwardRuntimeApproval(getWorkspaceContext, request = {}) {
   const context = await getWorkspaceContext(request.workspace ?? null);
   return context.approvalManager?.approve(request) ?? { approved: false };
@@ -1023,6 +1074,7 @@ async function runRuntime(argv, agent) {
         llm: session.llm,
         objective,
         capability: provider.capability,
+        workspace: session.workspace ?? context.workspace ?? '',
         signal: session._abortSignal,
       });
       const missingArguments = missingRequiredArguments(
@@ -1255,6 +1307,14 @@ async function runRuntime(argv, agent) {
   async function executeInteractiveTurn(context, body, { signal, turnId } = {}) {
     const input = String(body.input ?? body.prompt ?? '').trim();
     if (!input) throw new Error('Missing input.');
+    // The runtime may start while optional agents are still stopped. `/start
+    // agents` happens in the shell process, so its refreshed MCP snapshot does
+    // not mutate this long-lived runtime context. Re-probe only while at least
+    // one configured endpoint is disconnected; once connected, mcpRequest's
+    // stale-session recovery handles later server restarts cheaply.
+    if (mcpStatusNeedsRefresh(context.session.mcp)) {
+      await refreshMcpRuntimeStatus(context.session);
+    }
     const ephemeral = createInteractiveSession(context, { runtimeUrl: selfRuntimeUrl, turnId, signal });
     // Seed from a freshly reduced COPY of persisted events. Interactive turn
     // events deliberately do not mutate the canonical run projection, so the
@@ -1387,6 +1447,18 @@ function logImageRefreshErrors(imageRefresh) {
 }
 
 export async function runCli(argv) {
+  if (argv.includes('--refresh')) {
+    if (argv.length !== 1) throw new Error('--refresh does not accept other options.');
+    const result = spawnSync(workspaceCliPath, ['refresh'], {
+      cwd: process.cwd(),
+      env: process.env,
+      stdio: 'inherit',
+    });
+    if (result.error) throw result.error;
+    if (result.status !== 0) throw new Error(`Refresh failed with exit code ${result.status ?? 1}.`);
+    return;
+  }
+
   if (argv[0] === 'runtime') {
     const scaffolded = ensureManagerScaffold({ log: (message) => console.log(`[wiki-manager] ${message}`) });
     if (scaffolded.length > 0) loadManagerEnv();
@@ -1506,10 +1578,8 @@ export async function runCli(argv) {
       console.error(`Runtime unavailable: ${runtime.error}`);
     }
     preflight = withRuntimePreflight(preflight, runtime);
-    // The owned-runtime shutdown happens inside the TUI's own exit paths
-    // (see tui.tsx onShellExit): render() resolves at MOUNT, so anything
-    // after this await would run while the shell is still on screen —
-    // 0.12.9 shipped exactly that bug and killed the runtime under the user.
+    // render() resolves at mount; the TUI owns renderer teardown. The shared
+    // runtime deliberately survives shell exit because `serve` may use it.
     await runOpenTuiShell({
       agent,
       packageJson,
@@ -1531,10 +1601,6 @@ export async function runCli(argv) {
     }
   }
   await runShell({ agent, packageJson, runtime });
-  if (runtime?.url) {
-    const { shutdownOwnedRuntime } = await import('../runtime/lifecycle.js');
-    await shutdownOwnedRuntime(runtime, { log: (message) => console.log(`[wiki-manager] ${message}`) });
-  }
 }
 
 // Missing/stopped agents are status information, never a reason to interrupt

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

@@ -3,6 +3,7 @@ import test from 'node:test';
 import {
   buildExecutorOnlyFragment,
   forwardRuntimeApproval,
+  mcpStatusNeedsRefresh,
   missingRequiredArguments,
   resolveExecutorArguments,
   resolvePreparedDelegationApproval,
@@ -33,6 +34,20 @@ test('startup never opens the setup wizard just because agents are stopped', ()
   assert.deepEqual(startupWizardGaps([{ kind: 'agents' }]), []);
 });
 
+test('interactive runtime refreshes configured MCP endpoints that started late', () => {
+  assert.equal(mcpStatusNeedsRefresh({
+    wiki: { url: 'http://127.0.0.1:3201/mcp', status: 'connected' },
+    cme: { url: 'http://127.0.0.1:3336/mcp/', status: 'configured' },
+  }), true);
+  assert.equal(mcpStatusNeedsRefresh({
+    wiki: { url: 'http://127.0.0.1:3201/mcp', status: 'connected' },
+    cme: { url: 'http://127.0.0.1:3336/mcp/', status: 'connected' },
+  }), false);
+  assert.equal(mcpStatusNeedsRefresh({
+    disabled: { url: null, status: 'missing' },
+  }), false);
+});
+
 test('executor-only capabilities receive one manager-authored executable task', () => {
   const fragment = buildExecutorOnlyFragment({
     objective: 'donne-moi mes derniers mails',
@@ -191,3 +206,145 @@ test('prepared delegation only approves when autoApprove is explicitly true', ()
     result: { approved: true },
   });
 });
+
+const EXPORT_CAPABILITY = {
+  description: 'Export configured sources to workspace markdown files.',
+  inputSchema: {
+    type: 'object',
+    additionalProperties: true,
+    properties: { source_name: { type: 'string' } },
+  },
+};
+
+test('argument extraction drops a value that only echoes the active workspace', async () => {
+  // Regression: "exporter les pages Confluence du workspace acpi" against a
+  // schema whose single free-text field is source_name. The model binds the
+  // workspace name to it, and the executor fails with "source 'acpi' not
+  // found". The workspace is already bound out of band, so the echo is noise.
+  const llm = {
+    completeWithTools: async () => ({
+      tool_calls: [{
+        function: { name: 'set_task_arguments', arguments: JSON.stringify({ source_name: 'acpi' }) },
+      }],
+    }),
+  };
+
+  assert.deepEqual(
+    await resolveExecutorArguments({
+      llm,
+      objective: 'exporter les pages Confluence du workspace acpi',
+      capability: EXPORT_CAPABILITY,
+      workspace: 'acpi',
+    }),
+    {},
+  );
+});
+
+test('argument extraction keeps a real value that is not the workspace name', async () => {
+  const llm = {
+    completeWithTools: async () => ({
+      tool_calls: [{
+        function: {
+          name: 'set_task_arguments',
+          arguments: JSON.stringify({ source_name: 'EAS_Avant_projet_ACPI' }),
+        },
+      }],
+    }),
+  };
+
+  assert.deepEqual(
+    await resolveExecutorArguments({
+      llm,
+      objective: 'exporter la source EAS_Avant_projet_ACPI',
+      capability: EXPORT_CAPABILITY,
+      workspace: 'acpi',
+    }),
+    { source_name: 'EAS_Avant_projet_ACPI' },
+  );
+});
+
+test('argument extraction tells the model the workspace is already bound', async () => {
+  let seenSystem = '';
+  const llm = {
+    completeWithTools: async ({ system }) => {
+      seenSystem = system;
+      return { tool_calls: [] };
+    },
+  };
+
+  await resolveExecutorArguments({
+    llm,
+    objective: 'exporter les pages du workspace acpi',
+    capability: EXPORT_CAPABILITY,
+    workspace: 'acpi',
+  });
+
+  assert.match(seenSystem, /already runs against workspace "acpi"/);
+});
+
+test('argument extraction rejects a value outside the closed vocabulary', async () => {
+  // Regression: "exporter les pages Confluence du workspace juno" — the
+  // workspace guard removes "juno", so the model reaches for the next noun and
+  // emits "Confluence". Only the agent knows the valid names; once it publishes
+  // them as an enum, the orchestrator can check without guessing at meaning.
+  const capability = {
+    description: 'Export configured sources.',
+    inputSchema: {
+      type: 'object',
+      additionalProperties: true,
+      properties: {
+        source_name: { type: 'string', enum: ['EAS_Avant_projet_ACPI'] },
+      },
+    },
+  };
+  const llm = {
+    completeWithTools: async () => ({
+      tool_calls: [{
+        function: { name: 'set_task_arguments', arguments: JSON.stringify({ source_name: 'Confluence' }) },
+      }],
+    }),
+  };
+
+  assert.deepEqual(
+    await resolveExecutorArguments({
+      llm,
+      objective: 'exporter les pages Confluence du workspace juno',
+      capability,
+      workspace: 'juno',
+    }),
+    {},
+  );
+});
+
+test('argument extraction keeps a value the vocabulary allows', async () => {
+  const capability = {
+    description: 'Export configured sources.',
+    inputSchema: {
+      type: 'object',
+      additionalProperties: true,
+      properties: {
+        source_name: { type: 'string', enum: ['EAS_Avant_projet_ACPI', 'autre'] },
+      },
+    },
+  };
+  const llm = {
+    completeWithTools: async () => ({
+      tool_calls: [{
+        function: {
+          name: 'set_task_arguments',
+          arguments: JSON.stringify({ source_name: 'EAS_Avant_projet_ACPI' }),
+        },
+      }],
+    }),
+  };
+
+  assert.deepEqual(
+    await resolveExecutorArguments({
+      llm,
+      objective: 'exporter la source EAS_Avant_projet_ACPI',
+      capability,
+      workspace: 'acpi',
+    }),
+    { source_name: 'EAS_Avant_projet_ACPI' },
+  );
+});

package/src/commands/slash.js

@@ -432,6 +432,14 @@ export function compactMcpStatus(mcpStatus) {
   return entries
     .sort(([left], [right]) => left.localeCompare(right))
     .map(([name, endpoint]) => {
+      // `configured` covers two very different situations: an endpoint we
+      // never probed (service stopped) and one whose probe failed. Reporting
+      // both as "configured" is what makes a live agent look unconfigured —
+      // surface the failure as its own state, with the cause one command away
+      // (`/mcp status` prints the full toolsError).
+      if (endpoint.status !== 'connected' && endpoint.toolError) {
+        return `✕ ${name}  :${mcpPort(endpoint)}  unreachable (/mcp status)`;
+      }
       const marker = endpoint.status === 'connected'
         ? '●'
         : endpoint.status === 'configured'
@@ -684,6 +692,7 @@ Usage:
 Options:
   -v, --version        Print version
   -h, --help           Print help
+  --refresh            Stop runtime and project containers; remove project images
   --cacert <path>      Trust a local CA; Docker must be able to read this host path
   --once <prompt>      Run one agent turn and exit
   --headless           Run a workspace task non-interactively

package/src/core/buildInfo.json

@@ -1,4 +1,4 @@
 {
-  "version": "0.15.29",
-  "commit": "2be3fe0"
+  "version": "0.15.32",
+  "commit": "8b6b1aa"
 }