@dotdrelle/wiki-manager 0.11.10 → 0.12.1

package/src/agent/graph.js

@@ -5,11 +5,11 @@ import {
   callMcpTool,
   formatMcpToolResult,
   formatMcpToolsForAgent,
-  parseToolCallName,
+  resolveToolCallName,
 } from '../core/mcp.js';
 import { formatSkillsForAgent, readOptionalText } from '../core/skills.js';
 import { handleSlashCommand } from '../commands/slash.js';
-import { extractActivity, formatActivitySummary, parseJsonText } from '../core/activity.js';
+import { extractActivity, formatActivitySummary, parseJsonText, sessionActivities } from '../core/activity.js';
 import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
 import { enqueueProductionJob, ensureJobQueue, formatQueue, productionLockBusy } from '../core/jobQueue.js';
 import { updateWorkspaceProfilePreference } from '../core/profile.js';
@@ -18,6 +18,14 @@ const MAX_TOOL_ITERATIONS = 80;
 const MAX_SPINNER_ARG_LENGTH = 96;
 const MAX_PROFILE_CHARS = 4000;
 
+// Pseudo-servers handled directly by the tool executor (not present in
+// session.mcp). Listed so unqualified names like "plan_set" resolve the same
+// way as MCP tools in resolveToolCallName.
+const INTERNAL_TOOL_SERVERS = {
+  wiki: ['plan_set', 'plan_done'],
+  shell: ['run_command', 'read_command', 'profile_update'],
+};
+
 const AGENT_SLASH_COMMANDS = new Set([
   'help',
   'version',
@@ -124,17 +132,16 @@ const WIKI_PLAN_SET_TOOL = {
                 properties: {
                   id: { type: 'string' },
                   description: { type: 'string' },
+                  requiredCapability: { type: ['string', 'null'] },
                   status: { type: 'string', enum: ['pending', 'queued', 'running', 'waiting', 'pending_approval', 'done', 'failed', 'cancelled', 'stalled', 'added_during_run'] },
                   dependsOn: { type: 'array', items: { type: 'string' } },
-                  executor: { type: ['string', 'null'] },
-                  executorQuery: { type: ['object', 'null'], additionalProperties: true },
                   outputRefs: { type: 'array', items: { type: 'string' } },
                 },
                 required: ['description'],
               },
             ],
           },
-          description: 'Ordered steps. Backward-compatible strings are accepted; structured steps may include id, dependsOn, executor, executorQuery, outputRefs.',
+          description: 'Ordered steps. Backward-compatible strings are accepted; structured steps may include id, requiredCapability, dependsOn, outputRefs.',
         },
       },
       required: ['steps'],
@@ -180,6 +187,7 @@ const AgentState = Annotation.Root({
   }),
   toolIterations: Annotation({ default: () => 0 }),
   pendingToolCalls: Annotation(),
+  inputClassification: Annotation(),
   readyToStream: Annotation(),
   streamContext: Annotation(),
   streamedInline: Annotation(),
@@ -460,7 +468,7 @@ function handleWikiTool(session, tool, args) {
   return `Unknown wiki tool: ${tool}`;
 }
 
-function normalizeDeclaredPlanStep(raw, index, session) {
+function normalizeDeclaredPlanStep(raw, index) {
   const item = raw && typeof raw === 'object' && !Array.isArray(raw)
     ? raw
     : { description: String(raw) };
@@ -471,8 +479,9 @@ function normalizeDeclaredPlanStep(raw, index, session) {
     description,
     status: item.status ?? 'pending',
     dependsOn: Array.isArray(item.dependsOn) ? item.dependsOn.map(String) : [],
-    executor: item.executor ?? selectExecutorForStep(description, session),
-    executorQuery: item.executorQuery ?? null,
+    requiredCapability: item.requiredCapability != null ? String(item.requiredCapability) : null,
+    executor: null,
+    executorQuery: null,
     outputRefs: Array.isArray(item.outputRefs) ? item.outputRefs.map(String) : [],
   };
 }
@@ -488,23 +497,6 @@ function slugStepId(description, index) {
   return slug || `task-${index + 1}`;
 }
 
-function selectExecutorForStep(description, session) {
-  const text = String(description ?? '').toLowerCase();
-  let fallback = null;
-  for (const [serverName, value] of Object.entries(session.mcp ?? {})) {
-    if (value.status !== 'connected') continue;
-    for (const tool of value.tools ?? []) {
-      const executor = `${serverName}.${tool.name}`;
-      fallback ??= executor;
-      const haystack = `${serverName} ${tool.name} ${tool.description ?? ''}`.toLowerCase();
-      if (text.split(/[^a-z0-9]+/).filter((token) => token.length >= 4).some((token) => haystack.includes(token))) {
-        return executor;
-      }
-    }
-  }
-  return fallback;
-}
-
 // The manager runs on the same host filesystem as the workspace directory
 // (this is the same local file wiki__profile_update writes to via its
 // volume-mounted container), so read it fresh on every turn instead of
@@ -535,6 +527,7 @@ export function buildAgentSystemPrompt(state) {
     `Current workspace: ${workspace}.`,
     `Current wikirc profile: ${wikirc}.`,
     `Available primitives: ${commandList(state.session)}.`,
+    'Only announce or call slash commands that appear exactly in Available primitives. Do not invent command names, subcommands, or arguments.',
     'Connected MCP tools (use the server__tool naming convention for tool calls):',
     mcpTools,
     'Current local MCP job queue:',
@@ -556,8 +549,8 @@ export function buildAgentSystemPrompt(state) {
       '',
       'Task startup:',
       '  1. If the next MCP tool returns _activity.plan.steps, call that tool directly; the shell will create the visible plan from the returned activity.',
-      '  2. If the tool cannot declare its own plan, call wiki__plan_set before executing the first step. Prefer structured steps: {id, description, dependsOn, executor, executorQuery, outputRefs}; a legacy list of strings is still accepted.',
-      '     Multi-tool example: wiki__plan_set(steps=[{id:"cme-export",description:"CME export",dependsOn:[],executor:"cme.cme_export_run",outputRefs:["raw/untracked"]},{id:"production",description:"Production pipeline",dependsOn:["cme-export"],executor:"production.production_start_job",outputRefs:["deliverables"]}])',
+      '  2. If the tool cannot declare its own plan, call wiki__plan_set before executing the first step. Prefer structured steps: {id, description, requiredCapability, dependsOn, outputRefs}; a legacy list of strings is still accepted.',
+      '     Multi-tool example: wiki__plan_set(steps=[{id:"cme-export",description:"CME export",requiredCapability:"external-source.export",dependsOn:[],outputRefs:["raw/untracked"]},{id:"production",description:"Production pipeline",requiredCapability:"knowledge.pipeline",dependsOn:["cme-export"],outputRefs:["deliverables"]}])',
       '  3. Immediately execute the first step using the appropriate MCP tool. Do not start step 2 in the same turn unless one async pipeline tool owns and declares the whole sequence.',
       '  For synchronous steps (result is immediate, no _activity polling), call wiki__plan_done(step=1) after confirming success.',
       '  For async MCP jobs (returns _activity with poll), the orchestrator tracks completion automatically.',
@@ -575,13 +568,13 @@ export function buildAgentSystemPrompt(state) {
       '',
       'On failure: if a completed activity is failed/error/cancelled, call wiki__plan_done(step=N, status="failed") then stop with a clear error report.',
     ].filter(Boolean).join('\n'),
-    'For service actions, recommend /services, /start, /stop or /logs with the exact service name.',
+    'For service actions, recommend only available service primitives from Available primitives, with the exact service name when the primitive supports one.',
     'Disambiguate export requests carefully.',
-    'Confluence/CME/source export means exporting external Confluence sources into raw/untracked: use cme MCP tools (`cme_export_run`, then `cme_export_status`). Never use production `type=export` for Confluence source export.',
-    'Wiki/deliverable/publication export means exporting generated deliverables from the wiki: use production MCP tools (`production_start_job` with `type:"export"` or pipeline steps). Require the deliverable path when exporting deliverables.',
-    'For ingest/build/export/polish/pipeline workflows, use production MCP tools. Do not route these through direct /wiki shortcuts. To chain multiple sequential steps (e.g. build then polish), always use a single production_start_job call with type="pipeline" and steps=["build","polish"] — never start them as separate jobs: the first job is asynchronous and the second would run before it completes. For existing deliverables where content stability matters, pass stabilize:true so the build step preserves unchanged sections; keep polish in the pipeline when publication output is requested. Do not ask the user to confirm between steps; start the pipeline call directly.',
+    'Confluence/CME/source export means exporting external Confluence sources into raw/untracked: use cme MCP tools (`cme__cme_export_run`, then `cme__cme_export_status`). Never use production `type=export` for Confluence source export.',
+    'Wiki/deliverable/publication export means exporting generated deliverables from the wiki: use production MCP tools (`production__production_start_job` with `type:"export"` or pipeline steps). Require the deliverable path when exporting deliverables.',
+    'For ingest/build/export/polish/pipeline workflows, use production MCP tools. Do not route these through direct /wiki shortcuts. To chain multiple sequential steps (e.g. build then polish), always use a single production__production_start_job call with type="pipeline" and steps=["build","polish"] — never start them as separate jobs: the first job is asynchronous and the second would run before it completes. For existing deliverables where content stability matters, pass stabilize:true so the build step preserves unchanged sections; keep polish in the pipeline when publication output is requested. Do not ask the user to confirm between steps; start the pipeline call directly.',
     'Long-running MCP jobs: do not call the same status tool more than once consecutively. When chaining jobs sequentially: (1) start the job, report job/activity id and status; (2) check status once — if done, proceed to the next step immediately; (3) if still running, report status, list the remaining steps, and return control; (4) when re-invoked, check status first, then proceed. Do not spin-poll (status → status → status with no new action between). The shell activity panel monitors non-terminal jobs automatically.',
-    'If production_start_job is returned as queued/waiting by the manager, report that it is waiting in the local queue and return control. Do not continue as if the production job has started.',
+    'If production__production_start_job is returned as queued/waiting by the manager, report that it is waiting in the local queue and return control. Do not continue as if the production job has started.',
     'For diagnostics, use /wiki run doctor when the user asks for doctor. Use /workspace init <name> [path] for low-level non-interactive workspace creation. In the interactive TUI, /new <name> opens the setup wizard. Use /wiki for index, or /wiki run index through the explicit backup hatch. Use /wiki run init only for explicit current-workspace llm-wiki init.',
     'If an action requires tools or skills not available yet, explain the limitation and name the expected primitive.',
     workspaceProfile
@@ -617,6 +610,36 @@ export function formatLlmUnavailableMessage(reason) {
   return `⚠ LLM injoignable : ${clean || 'raison inconnue'}`;
 }
 
+function classifyAgentInput(input, session) {
+  const lower = String(input ?? '').toLowerCase();
+  const hasActiveRun = session?.agentProjection?.status === 'running'
+    || sessionActivities(session).some((activity) => !activity.terminal);
+  if (/\b(valide tout|approve all|approve|approuve|valid[eé]|ok pour tout|go pour tout)\b/i.test(lower)) {
+    return { kind: 'approve', confidence: 0.86, reason: 'approval_request', activeRun: hasActiveRun };
+  }
+  if (/\b(cancel|annule|stop|arr[eê]te|interromps|abort)\b/i.test(lower)) {
+    return { kind: 'cancel', confidence: 0.86, reason: 'cancel_request', activeRun: hasActiveRun };
+  }
+  if (/\b(plus tard|later|ensuite|apr[eè]s ce run|enqueue|mets en file|met en file|futur|next run|future run)\b/i.test(lower)) {
+    return { kind: 'enqueue_run', confidence: 0.8, reason: 'future_run_request', activeRun: hasActiveRun };
+  }
+  if (/\b(o[uù] en es[t-]|status|statut|progress|progression|run|job|queue|logs?|explique|explain|inspect|show|montre|quoi de neuf)\b/i.test(lower)) {
+    return { kind: 'observe', confidence: 0.86, reason: 'status_or_explanation_request', activeRun: hasActiveRun };
+  }
+  if (hasActiveRun && /\b(ajoute|add|change|modifie|modify|remplace|replace|retire|remove|skip|ignore|plan|step|t[aâ]che)\b/i.test(lower)) {
+    return { kind: 'modify_run', confidence: 0.78, reason: 'active_run_change_request', activeRun: hasActiveRun };
+  }
+  if (hasActiveRun && /\b(lance|run|g[eé]n[eè]re|build|export|cr[eé]e|create|send|envoie|ingest|convert|importe|import)\b/i.test(lower)) {
+    return { kind: 'ambiguous', confidence: 0.45, reason: 'active_run_action_is_ambiguous', activeRun: hasActiveRun };
+  }
+  return { kind: 'converse', confidence: 0.62, reason: 'plain_conversation', activeRun: hasActiveRun };
+}
+
+function toolsForClassification(classification, writeTools) {
+  if (classification.activeRun && ['converse', 'observe'].includes(classification.kind)) return [SHELL_READ_COMMAND_TOOL];
+  return [SHELL_READ_COMMAND_TOOL, ...writeTools];
+}
+
 export function createAgentGraph(options = {}) {
   async function orchestratorNode(state) {
     const llm = state.session.llm ?? options.llm ?? null;
@@ -640,15 +663,33 @@ export function createAgentGraph(options = {}) {
       state.session._onStep?.('Agent: planning next action…');
     }
 
-    const allTools = [
+    const classification = iterations === 0
+      ? classifyAgentInput(state.input, state.session)
+      : (state.inputClassification ?? { kind: 'modify_run', confidence: 1, reason: 'tool_iteration' });
+    if (iterations === 0) {
+      state.session._onStep?.(`Agent: classified input as ${classification.kind}`);
+      emitAgentEvent(state.session, 'control_message_received', 'agent_classifier', {
+        input: state.input,
+        classification,
+      });
+    }
+    if (iterations === 0 && classification.kind === 'ambiguous') {
+      return {
+        response: 'Je peux répondre sur le run en cours, modifier ce run, mettre une nouvelle demande en file, approuver, ou annuler. Peux-tu préciser ce que tu veux faire ?',
+        pendingToolCalls: null,
+        readyToStream: false,
+        inputClassification: classification,
+      };
+    }
+
+    const writeTools = [
       SHELL_RUN_COMMAND_TOOL,
-      SHELL_READ_COMMAND_TOOL,
       SHELL_PROFILE_UPDATE_TOOL,
       WIKI_PLAN_SET_TOOL,
       WIKI_PLAN_DONE_TOOL,
       ...buildLlmTools(state.session.mcp),
     ];
-    const tools = allTools;
+    const tools = toolsForClassification(classification, writeTools);
     const system = buildAgentSystemPrompt(state);
 
     // On iteration 0: prior history is in state.messages, user input must be appended.
@@ -690,6 +731,7 @@ export function createAgentGraph(options = {}) {
           messages: newMessages,
           toolIterations: iterations + 1,
           readyToStream: false,
+          inputClassification: classification,
         };
       }
 
@@ -705,6 +747,7 @@ export function createAgentGraph(options = {}) {
           readyToStream: false,
           streamedInline: true,
           messages: newMessages,
+          inputClassification: classification,
         };
       }
 
@@ -736,11 +779,19 @@ export function createAgentGraph(options = {}) {
     const toolResultMessages = [];
 
     for (const call of toolCalls) {
-      const { server, tool } = parseToolCallName(call.function.name);
+      const resolved = resolveToolCallName(state.session.mcp, call.function.name, INTERNAL_TOOL_SERVERS);
+      const { server, tool } = resolved;
       const argsSummary = summarizeToolArguments(call.function.arguments);
       const isInternalWikiTool = server === 'wiki' && (tool === 'plan_set' || tool === 'plan_done');
       const serverLabel = server === 'shell' ? 'Shell' : isInternalWikiTool ? 'Plan' : 'MCP';
-      const toolName = `${server}.${tool}`;
+      const toolName = server ? `${server}.${tool}` : call.function.name;
+      if (resolved.normalized) {
+        // Keep normalizations visible: the defensive routing must not hide
+        // prompt/skill regressions that reintroduce unqualified names.
+        state.session._onStep?.(
+          `tool name normalized: ${call.function.name} -> ${server}__${tool}`,
+        );
+      }
       state.session._onStep?.(
         `[${state.toolIterations}/${MAX_TOOL_ITERATIONS}] ${serverLabel} ${toolName}${argsSummary ? ` (${argsSummary})` : ''}`,
       );
@@ -761,6 +812,18 @@ export function createAgentGraph(options = {}) {
       let resultText;
       let ok = true;
       try {
+        if (!server) {
+          if (resolved.candidates.length > 1) {
+            throw new Error(
+              `Ambiguous unqualified tool name "${call.function.name}": several connected servers expose it. `
+              + `Use the <server>__<tool> form: ${resolved.candidates.map((s) => `${s}__${tool}`).join(', ')}.`,
+            );
+          }
+          throw new Error(
+            `Unqualified tool call name "${call.function.name}". Tool calls must use the <server>__<tool> `
+            + `naming convention (e.g. production__production_start_job); no connected server exposes a tool named "${tool}".`,
+          );
+        }
         let args = JSON.parse(call.function.arguments ?? '{}');
         if (server === 'production' && tool === 'production_start_job' && state.session.workspace && !args.callerLabel) {
           args = { ...args, callerLabel: `${state.session.workspace}/wiki-manager` };
@@ -834,7 +897,7 @@ export function createAgentGraph(options = {}) {
           err.name === 'ApprovalError'
         ) throw err;
         ok = false;
-        resultText = `Error [${server}.${tool}]: ${err instanceof Error ? err.message : String(err)}`;
+        resultText = `Error [${toolName}]: ${err instanceof Error ? err.message : String(err)}`;
         if (minimalPlanActive && state.session.headlessPlan?.[0]?._activityKey === null) {
           emitAgentEvent(state.session, 'plan_step_updated', 'tool', { step: 1, status: 'failed' });
         }

package/src/agent/graph.test.js

@@ -300,7 +300,7 @@ test('agent graph waits for tool-level approval configured on endpoint', async (
   }
 });
 
-test('agent graph accepts structured wiki plan steps and selects MCP executors', async () => {
+test('agent graph accepts structured wiki plan steps without selecting MCP executors implicitly', async () => {
   let calls = 0;
   const session = sessionBase({
     mcp: {
@@ -337,8 +337,20 @@ test('agent graph accepts structured wiki plan steps and selects MCP executors',
                 name: 'wiki__plan_set',
                 arguments: JSON.stringify({
                   steps: [
-                    { id: 'cme-export', description: 'Export CME pages', outputRefs: ['raw/untracked'] },
-                    { id: 'build', description: 'Run production build', dependsOn: ['cme-export'] },
+                    {
+                      id: 'cme-export',
+                      description: 'Export CME pages',
+                      requiredCapability: 'external-source.export',
+                      executor: 'cme.cme_export_run',
+                      executorQuery: { capability: 'legacy export' },
+                      outputRefs: ['raw/untracked'],
+                    },
+                    {
+                      id: 'build',
+                      description: 'Run production build',
+                      requiredCapability: 'knowledge.pipeline',
+                      dependsOn: ['cme-export'],
+                    },
                   ],
                 }),
               },
@@ -359,8 +371,66 @@ test('agent graph accepts structured wiki plan steps and selects MCP executors',
 
   assert.equal(result.response, 'Plan ready.');
   assert.deepEqual(session.headlessPlan.map((step) => step.id), ['cme-export', 'build']);
-  assert.equal(session.headlessPlan[0].executor, 'cme.cme_export_run');
-  assert.equal(session.headlessPlan[1].executor, 'production.production_start_job');
+  assert.deepEqual(session.headlessPlan.map((step) => step.requiredCapability), ['external-source.export', 'knowledge.pipeline']);
+  assert.equal(session.headlessPlan[0].executor, null);
+  assert.equal(session.headlessPlan[0].executorQuery, null);
+  assert.equal(session.headlessPlan[1].executor, null);
   assert.deepEqual(session.headlessPlan[1].dependsOn, ['cme-export']);
   assert.deepEqual(session.headlessPlan[0].outputRefs, ['raw/untracked']);
 });
+
+test('buildAgentSystemPrompt forbids inventing slash commands or arguments', () => {
+  const prompt = buildAgentSystemPrompt({ session: sessionBase({ commands: ['status', 'services'] }) });
+  assert.match(prompt, /Available primitives: \/status, \/services\./);
+  assert.match(prompt, /Do not invent command names, subcommands, or arguments/);
+  assert.doesNotMatch(prompt, /\/restart serve/);
+  assert.doesNotMatch(prompt, /executorQuery/);
+  assert.doesNotMatch(prompt, /executor:"/);
+});
+
+// Guard: the system prompt must never show a connected tool's bare name
+// outside its qualified server__tool form. Bare mentions are what teach the
+// model to emit unqualified tool calls (the cme_status incident). The bare
+// name list comes from the session's declared servers, never from a manual
+// list (amendment A6). New prompt text or injected skill descriptions that
+// reintroduce a bare name must fail here.
+test('buildAgentSystemPrompt contains no unqualified tool names for connected servers', () => {
+  const session = sessionBase({
+    mcp: {
+      production: {
+        status: 'connected',
+        tools: [
+          { name: 'production_start_job' }, { name: 'production_job_status' },
+          { name: 'production_job_logs' }, { name: 'production_cancel_job' },
+          { name: 'production_list_jobs' }, { name: 'production_list_templates' },
+          { name: 'production_status' }, { name: 'agent_describe' },
+          { name: 'agent_plan' }, { name: 'agent_execute' },
+          { name: 'agent_status' }, { name: 'agent_cancel' },
+        ],
+      },
+      cme: {
+        status: 'connected',
+        tools: [
+          { name: 'cme_status' }, { name: 'cme_setup' },
+          { name: 'cme_sources_list' }, { name: 'cme_source_add' },
+          { name: 'cme_source_remove' }, { name: 'cme_export_run' },
+          { name: 'cme_export_status' }, { name: 'cme_export_cancel' },
+          { name: 'agent_describe' }, { name: 'agent_execute' },
+          { name: 'agent_status' }, { name: 'agent_cancel' },
+        ],
+      },
+    },
+  });
+  const prompt = buildAgentSystemPrompt({ session });
+  const offenders = [];
+  for (const [serverName, value] of Object.entries(session.mcp)) {
+    for (const tool of value.tools) {
+      // A bare occurrence is the tool name not embedded in a wider
+      // identifier: `production__production_start_job` does not match
+      // because the inner occurrence is preceded by `_`.
+      const bare = new RegExp(`(?<![\\w])${tool.name}(?![\\w])`);
+      if (bare.test(prompt)) offenders.push(`${serverName}:${tool.name}`);
+    }
+  }
+  assert.deepEqual(offenders, [], `Unqualified tool names found in system prompt: ${offenders.join(', ')}`);
+});

package/src/cli/wiki-manager.js

@@ -294,6 +294,7 @@ async function runRuntime(argv, agent) {
   }
   const { defaultRuntimeStateDir, openRuntimeStore, RECOVERABLE_QUEUE_STATUSES } = await import('../runtime/store.js');
   const { startRuntimeServer } = await import('../runtime/server.js');
+  const { recoverActiveRuns } = await import('../runtime/recoveryManager.js');
   const { emitRuntimeLog, startActivitySupervisor } = await import('../runtime/supervisor.js');
   const { resolveRuntimeAuthToken } = await import('../runtime/auth.js');
   const { createSqliteQueueStore } = await import('../runtime/queueStore.js');
@@ -484,6 +485,27 @@ async function runRuntime(argv, agent) {
           reason: `MCP unavailable: ${gaps.join(', ')}`,
         };
       }
+      const taskRecovery = await recoverActiveRuns({
+        store,
+        session: context.session,
+        workspace: context.workspace,
+        callTool: callMcpTool,
+      });
+      if (!taskRecovery.ok) {
+        const interrupted = store.interruptRuns({ workspace: context.workspace });
+        return {
+          workspace: context.workspace ?? workspace ?? null,
+          resumed: false,
+          interrupted,
+          reason: `Task recovery failed: ${taskRecovery.errors.map((item) => `${item.taskId}: ${item.error}`).join('; ')}`,
+        };
+      }
+      if (taskRecovery.recovered.length > 0 || taskRecovery.rescheduled.length > 0) {
+        emitRuntimeLog(
+          context.session,
+          `runtime: recovery attached ${taskRecovery.recovered.length} job(s), requeued ${taskRecovery.rescheduled.length} task(s)`,
+        );
+      }
       const recoverableRuns = store.listRecoverableRuns({ workspace: context.workspace });
       const runningRun = recoverableRuns.find((run) => run.status === 'running');
       const activeActivities = activeNonTerminalActivities(context.session);