@dotdrelle/wiki-manager 0.15.28 → 0.15.32

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,48 @@ 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 : {};
+  return required.filter((key) => {
+    const value = values[key];
+    if (value === undefined || value === null) return true;
+    if (typeof value === 'string') return value.trim() === '';
+    if (Array.isArray(value)) return value.length === 0;
+    return false;
+  });
+}
+
 function safeParseArgumentObject(text) {
   const cleaned = String(text ?? '').trim().replace(/^```(?:json)?\s*/i, '').replace(/\s*```$/, '');
   if (!cleaned) return null;
@@ -182,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;
@@ -248,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 };
@@ -1011,8 +1074,16 @@ async function runRuntime(argv, agent) {
         llm: session.llm,
         objective,
         capability: provider.capability,
+        workspace: session.workspace ?? context.workspace ?? '',
         signal: session._abortSignal,
       });
+      const missingArguments = missingRequiredArguments(
+        provider.capability?.inputSchema,
+        extractedArguments,
+      );
+      if (missingArguments.length > 0) {
+        throw new Error(`Delegation requires input: ${missingArguments.join(', ')}`);
+      }
       fragment = buildExecutorOnlyFragment({
         objective,
         workspace: session.workspace ?? context.workspace ?? 'workspace',
@@ -1236,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
@@ -1368,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();
@@ -1434,12 +1525,17 @@ export async function runCli(argv) {
     // in a random cwd must not litter files.
     const scaffolded = ensureManagerScaffold({ log: (message) => console.log(`[wiki-manager] ${message}`) });
     if (scaffolded.length > 0) loadManagerEnv();
-    const reportCheck = ({ kind, ok, detail, context, skipped, pending }) => {
+    const reportCheck = ({ kind, ok, detail, context, skipped, pending, requested }) => {
       // "waiting" checks (containers not up yet, MCP not connected yet) are the
       // normal state at launch — the shell starts them and reports the real
       // status afterwards, so echoing them here is pure noise. Only what is
       // ready or actually broken is printed.
-      if (!ok && (pending || skipped)) return;
+      //
+      // `pending` alone cannot express this: a service the operator explicitly
+      // asked for (`requested`) is still "pending" right after /start, and that
+      // one MUST be shown — silence there is how a failed start reads as a
+      // success. Boot silence applies to unrequested checks only.
+      if (!ok && (pending || skipped) && !requested) return;
       const labels = { docker: 'Docker', internet: 'Internet', agents: 'Agent containers', workspace: 'Workspaces', containers: 'Workspace containers', mcp: 'MCP' };
       const label = labels[kind] ?? kind;
       const instruction = !ok && context?.command ? ` — command: ${context.command}` : '';
@@ -1452,10 +1548,12 @@ export async function runCli(argv) {
       console.log(`${color}${icon} configuration: ${label} ${state}${suffix}${instruction}\x1b[0m`);
     };
     let preflight = await runPreflightChecks({ onCheck: reportCheck });
-    if (preflight.gaps.length > 0) {
-      await runStartupWizard(preflight.gaps);
-      // The wizard may have created a workspace, started agents or repaired
-      // configuration. Re-read everything before drawing the home screen.
+    const wizardGaps = startupWizardGaps(preflight.gaps);
+    if (wizardGaps.length > 0) {
+      await runStartupWizard(wizardGaps);
+      // The wizard may have created a workspace or repaired configuration.
+      // Agents are deliberately excluded: starting them is an explicit console
+      // action through /start agents or /start all.
       preflight = await runPreflightChecks();
     }
     const dockerReady = preflight.checks.some((check) => check.kind === 'docker' && check.ok);
@@ -1480,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,
@@ -1505,8 +1601,11 @@ 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
+// startup with a confirmation screen. The operator owns their lifecycle from
+// the console (`/start agents`, `/start all`, `/stop agents`).
+export function startupWizardGaps(gaps = []) {
+  return gaps.filter((gap) => gap?.kind !== 'agents');
 }

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

@@ -3,8 +3,11 @@ import test from 'node:test';
 import {
   buildExecutorOnlyFragment,
   forwardRuntimeApproval,
+  mcpStatusNeedsRefresh,
+  missingRequiredArguments,
   resolveExecutorArguments,
   resolvePreparedDelegationApproval,
+  startupWizardGaps,
 } from './wiki-manager.js';
 
 const COLLECT_CAPABILITY = {
@@ -19,6 +22,32 @@ const COLLECT_CAPABILITY = {
   },
 };
 
+test('startup never opens the setup wizard just because agents are stopped', () => {
+  const workspace = { kind: 'workspace', context: {} };
+  assert.deepEqual(
+    startupWizardGaps([
+      { kind: 'agents', context: { downServices: ['cme', 'documents'] } },
+      workspace,
+    ]),
+    [workspace],
+  );
+  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',
@@ -96,6 +125,27 @@ test('argument extraction stays agnostic and safe when it cannot extract', async
   );
 });
 
+test('required executor arguments become a conversational blocker before plan validation', () => {
+  const schema = {
+    type: 'object',
+    required: ['to', 'subject', 'body'],
+    properties: {
+      to: { type: 'string' },
+      subject: { type: 'string' },
+      body: { type: 'string' },
+    },
+  };
+  assert.deepEqual(missingRequiredArguments(schema, {}), ['to', 'subject', 'body']);
+  assert.deepEqual(
+    missingRequiredArguments(schema, { to: 'a@example.test', subject: 'Hello', body: 'Message' }),
+    [],
+  );
+  assert.deepEqual(
+    missingRequiredArguments(schema, { to: [], subject: ' ', body: 'Message' }),
+    ['to', 'subject'],
+  );
+});
+
 test('runtime approval bridge preserves the complete run-scoped grant', async () => {
   let forwarded = null;
   const request = {
@@ -156,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' },
+  );
+});