@dotdrelle/wiki-manager 0.12.10 → 0.12.12

package/.env.example

@@ -29,8 +29,10 @@ WORKSPACES_ROOT=/path/to/workspaces
 CME_MCP_AUTH_TOKEN=
 DOCUMENTS_MCP_AUTH_TOKEN=
 
-# ── Mailer (MailerSend) ────────────────────────────────────────────────────────
+# ── Agent ports (optional, change only if defaults conflict) ───────────────────
 
+# CME_MCP_PORT=3336
+# DOCUMENTS_MCP_PORT=3337
 
 # ── Documents LLM OCR / Mermaid (optional) ─────────────────────────────────────
 
@@ -46,6 +48,12 @@ DOCUMENTS_MCP_AUTH_TOKEN=
 # lives HERE and is referenced from mcp.endpoints.json as ${VAR_NAME}.
 # Add your own entries when you declare additional endpoints.
 
+# ── Orchestration (optional) ───────────────────────────────────────────────────
+# Parallel tasks dispatched at once for capability runs. Defaults to what the
+# agent itself declares (agent_describe limits); set only to constrain it.
+# Example constraint (never raises an agent's declared capacity):
+# WIKI_MANAGER_CAPABILITY_CONCURRENCY=3
+
 # ── MCP retry policy (optional) ────────────────────────────────────────────────
 
 # Tool calls are retried on transient HTTP/MCP errors before the run fails.
@@ -65,8 +73,3 @@ DOCUMENTS_MCP_AUTH_TOKEN=
 # Runtime approvals can pause runs or protected tools until /approve is called.
 # WIKI_MANAGER_APPROVAL_TIMEOUT_MS=600000
 # WIKI_MANAGER_REQUIRE_APPROVAL_TOOLS=production.production_start_job
-
-# ── Agent ports (optional, change only if defaults conflict) ───────────────────
-
-# CME_MCP_PORT=3336
-# DOCUMENTS_MCP_PORT=3337

package/README.md

@@ -48,7 +48,7 @@ Use a local installation when the manager should be pinned in a project's
 
 ```bash
 npm install @dotdrelle/wiki-manager
-npm approve-scripts bun  # only when npm reports that Bun's postinstall is pending
+npm approve-scripts bun@1.3.14  # only when npm reports that Bun's postinstall is pending
 npx wiki-manager
 npx wiki-workspace --help
 ```
@@ -57,8 +57,8 @@ npx wiki-workspace --help
 global `PATH`. Run local executables with `npx` (or `npm exec wiki-manager` and
 `npm exec wiki-workspace`). Bun is installed automatically as a package runtime;
 you do not need to add `~/.bun/bin` to `PATH`. Recent npm versions may require
-the explicit `npm approve-scripts bun` security approval shown above before the
-first launch.
+the explicit `npm approve-scripts bun@1.3.14` security approval shown above
+before the first launch.
 
 ### Global installation
 

package/package.json

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

package/src/agent/graph.js

@@ -27,7 +27,7 @@ const MAX_PROFILE_CHARS = 4000;
 const INTERNAL_TOOL_SERVERS = {
   wiki: ['plan_set', 'plan_done'],
   shell: ['run_command', 'read_command', 'profile_update'],
-  runtime: ['kill', 'cancel', 'status', 'approve', 'enqueue'],
+  runtime: ['kill', 'cancel', 'status', 'approve', 'enqueue', 'start_capability_run'],
 };
 
 const AGENT_SLASH_COMMANDS = new Set([
@@ -165,6 +165,24 @@ const RUNTIME_ENQUEUE_TOOL = {
   },
 };
 
+const RUNTIME_CAPABILITY_RUN_TOOL = {
+  type: 'function',
+  function: {
+    name: 'runtime__start_capability_run',
+    description: 'Start a DETERMINISTIC orchestrated run for a discovered capability: the runtime asks the capable agent for its task graph (agent_plan), validates and integrates it, creates the approval requests, and dispatches the tasks in parallel. Use this whenever the user asks for multi-document or multi-step work covered by a known capability (e.g. ingest everything pending → capability "knowledge.update", operation "ingest"). Do NOT call production tools directly for such requests.',
+    parameters: {
+      type: 'object',
+      additionalProperties: false,
+      properties: {
+        capability: { type: 'string', description: 'Capability id from the known list (e.g. knowledge.update).' },
+        operation: { type: 'string', description: 'Operation supported by the capability (e.g. ingest, build).' },
+        inputs: { type: 'array', items: { type: 'string' }, description: 'Optional file subset; omit to cover everything pending.' },
+      },
+      required: ['capability'],
+    },
+  },
+};
+
 const WIKI_PLAN_SET_TOOL = {
   type: 'function',
   function: {
@@ -250,6 +268,7 @@ const AgentState = Annotation.Root({
   readyToStream: Annotation(),
   streamContext: Annotation(),
   streamedInline: Annotation(),
+  retryWithoutTool: Annotation({ default: () => false }),
 });
 
 function commandList(session) {
@@ -521,6 +540,33 @@ export function knownCapabilityIds(session) {
   }))].sort();
 }
 
+// Deterministic fragment→plan mapping, shared by the agent_plan tool bridge
+// and the /ingest-style direct capability runs: the parallel path must not
+// depend on an LLM copying fields correctly.
+export function planStepsFromFragment(payload) {
+  const tasks = Array.isArray(payload?.tasks) ? payload.tasks : [];
+  return tasks.map((task, index) => normalizeDeclaredPlanStep({
+    id: task.id,
+    description: task.label ?? task.id ?? `Task ${index + 1}`,
+    requiredCapability: task.requiredCapability ?? payload.capability ?? null,
+    operation: task.operation ?? null,
+    arguments: task.arguments ?? {},
+    dependsOn: task.dependsOn ?? [],
+    outputRefs: (task.expectedOutputRefs ?? []).map((ref) => (ref && typeof ref === 'object' ? String(ref.ref ?? '') : String(ref))).filter(Boolean),
+    groupId: task.groupId ?? null,
+    dependsOnGroup: task.dependsOnGroup ?? null,
+    parallelizable: task.parallelizable,
+    barrier: task.barrier,
+    locks: task.locks,
+    requiresApproval: task.requiresApproval,
+    approvalClass: task.approvalClass,
+    approvalSummary: task.approvalSummary,
+    idempotencyKey: task.idempotencyKey,
+    progressWeight: task.progressWeight,
+    recommendedConcurrency: task.recommendedConcurrency,
+  }, index));
+}
+
 async function handleRuntimeControlTool(session, tool, args = {}) {
   const url = session.runtime?.url ?? null;
   if (!url) return 'Runtime not connected: no runtime URL available in this session.';
@@ -538,6 +584,23 @@ async function handleRuntimeControlTool(session, tool, args = {}) {
       const result = await postRuntimeControl('message', { url, workspace, input: 'approve', intent: 'approve' });
       return String(result?.explanation ?? (result?.accepted ? 'Approval granted.' : 'No pending approval found.'));
     }
+    if (tool === 'start_capability_run') {
+      const { postRuntimeRun } = await import('../runtime/client.js');
+      const result = await postRuntimeRun(`Run de capability ${args.capability}${args.operation ? ` (${args.operation})` : ''} demandé par Donna.`, {
+        url,
+        workspace,
+        capabilityPlan: {
+          capability: String(args.capability ?? ''),
+          ...(args.operation ? { operation: String(args.operation) } : {}),
+          ...(Array.isArray(args.inputs) && args.inputs.length > 0 ? { inputs: args.inputs.map(String) } : {}),
+          // No concurrency dictated here: the runtime reads the provider's
+          // own declared capacity (agent_describe limits).
+        },
+      });
+      return result?.runId
+        ? `Run de capability accepté (${String(result.runId).slice(0, 8)}) : le plan sera intégré et dispatché en parallèle ; une approbation sera demandée avant les mutations (l'utilisateur peut dire « valide tout » ou taper /approve). Suis la progression dans Activity.`
+        : `Run non démarré : ${result?.explanation ?? result?.error ?? JSON.stringify(result)}`;
+    }
     if (tool === 'enqueue') {
       const result = await postRuntimeControl('message', { url, workspace, input: String(args.input ?? ''), intent: 'enqueue' });
       return String(result?.explanation ?? 'Request queued for after the current run.');
@@ -688,8 +751,12 @@ export function buildAgentSystemPrompt(state) {
     skills,
     'You can call MCP tools directly using the provided tool functions.',
     'When the user asks for an action that can be performed with connected MCP tools or safe primitives, do not answer with future intent such as "I will call...", "I am going to run...", or "launching..." unless you also call the tool in the same turn. Either call the tool now, ask for the exact missing required arguments, or explain the concrete blocker.',
+    'Execution truthfulness: never invent a job id, status, percentage, duration, generated file, file content, URL, command, or tool result. An action is executed only when you call an available tool and receive its result. Examples and placeholders are forbidden in execution reports.',
+    'After any completed action, give a short factual summary based only on the tool result: outcome and concrete outputs or references actually returned. Mention a viewing primitive only when it exists in Available primitives and is relevant. Do not interpret generated content, propose verification checklists, invent next steps, or suggest commands unless the user explicitly asks.',
+    'When calling a tool, emit no preliminary narration. Call it directly; the PLAN and Activity panels show progress. After completion, keep the final response concise and proportional to the result.',
     'For connector configuration/setup/update requests, if a matching setup/configuration tool is connected and the required arguments are known, call it immediately. If the connector or tool is not connected, say which concrete capability is missing and recommend the exact service/status primitive to inspect it. Do not invent a pending connector action in plain text.',
     'For workspace-scoped external MCP tools, the orchestrator enforces workspace injection. Use the active workspace for configuration, source, import, export, conversion, and generation tools unless a tool is explicitly job-scoped and only requires a job id.',
+    'Dynamic capability inputs are owned by the agent that provides the capability. To answer which inputs are pending or available, call the qualified `<provider>__agent_status` tool with {capability, operation} and report only its pendingInputs. Never infer this state from /uploads or a hardcoded workspace directory. If no capable agent/status tool is connected, say that the pending inputs cannot be determined.',
     'You can call shell__run_command for safe manager slash commands such as /workspace list, /workspace init <name> [path], /use <workspace>, /config, /status, /services, /skills, /skills show <name>, and /skills run <name>.',
     'Skills are workflow instructions, not executable code. When a user asks to run a skill, inspect it, propose the concrete primitive/tool plan, and ask for confirmation before costly or mutating actions.',
     [
@@ -733,7 +800,7 @@ export function buildAgentSystemPrompt(state) {
     '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.',
-    'MULTI-DOCUMENT ingest (more than 2 files, or "ingest everything pending"): call production__agent_plan first, e.g. {capability:"knowledge.update", operation:"ingest", constraints:{maxConcurrency:3, requireApprovalForMutations:true}}. The shell integrates the returned task graph as the plan automatically and the orchestrator dispatches the per-document tasks IN PARALLEL with an approval gate. Do not call production__production_start_job for multi-document ingest — that creates one monolithic sequential job.',
+    'MULTI-DOCUMENT ingest (more than 2 files, or "ingest everything pending") and any multi-step capability work: when runtime__start_capability_run is available, call it (e.g. {capability:"knowledge.update", operation:"ingest"}) — the runtime integrates the agent task graph deterministically and dispatches IN PARALLEL with an approval gate. Inside a runtime run (no runtime tools), call production__agent_plan instead; the shell integrates the fragment automatically. Never call production__production_start_job for multi-document ingest — that creates one monolithic sequential job.',
     'Single-document ingest or one-off jobs (doctor, one build, one export): production__production_start_job is fine. To chain sequential steps (e.g. build then polish) use ONE call with type="pipeline" and steps=["build","polish"] — never separate jobs (the first is asynchronous). For existing deliverables where content stability matters, pass stabilize:true. Do not ask the user to confirm between steps.',
     '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__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.',
@@ -820,6 +887,9 @@ function toolsForClassification(classification, writeTools, session = null) {
   const controlTools = session?.runtime?.url
     ? [RUNTIME_STATUS_TOOL, RUNTIME_CANCEL_TOOL, RUNTIME_KILL_TOOL, RUNTIME_APPROVE_TOOL, RUNTIME_ENQUEUE_TOOL]
     : [];
+  const capabilityRunTools = session?.runtime?.url && !classification.activeRun
+    ? [RUNTIME_CAPABILITY_RUN_TOOL]
+    : [];
   if (classification.activeRun && ['converse', 'observe', 'ambiguous', 'approve', 'cancel', 'enqueue_run'].includes(classification.kind)) {
     // During an active run Donna gets read + profile + the runtime control
     // suite: she can answer, approve, enqueue for later, soft-cancel or
@@ -827,7 +897,7 @@ function toolsForClassification(classification, writeTools, session = null) {
     // what runtime__enqueue is for). No canned regex answers anywhere.
     return [SHELL_READ_COMMAND_TOOL, SHELL_PROFILE_UPDATE_TOOL, ...controlTools];
   }
-  return [SHELL_READ_COMMAND_TOOL, ...controlTools, ...writeTools];
+  return [SHELL_READ_COMMAND_TOOL, ...controlTools, ...capabilityRunTools, ...writeTools];
 }
 
 export function createAgentGraph(options = {}) {
@@ -892,12 +962,14 @@ export function createAgentGraph(options = {}) {
 
     try {
       const useStreamWithTools = typeof llm.streamWithTools === 'function';
+      const suppressExecutionNarration = runtimeExecution && (iterations === 0 || state.retryWithoutTool);
       const result = useStreamWithTools
         ? await llm.streamWithTools({
             system,
             tools,
             messages: conversationMessages,
             onTextDelta: (delta) => {
+              if (suppressExecutionNarration) return;
               emitAgentEvent(state.session, 'assistant_delta', 'llm', { delta });
               state.session._onStream?.(delta);
             },
@@ -930,6 +1002,39 @@ export function createAgentGraph(options = {}) {
           toolIterations: iterations + 1,
           readyToStream: false,
           inputClassification: classification,
+          retryWithoutTool: false,
+        };
+      }
+
+      if (runtimeExecution && iterations === 0 && !state.retryWithoutTool) {
+        state.session._onStreamReset?.();
+        state.session._onStep?.('Agent: action response rejected — no tool was called; retrying…');
+        return {
+          pendingToolCalls: null,
+          messages: [
+            { role: 'user', content: state.input },
+            result.message ?? { role: 'assistant', content: result.content ?? '' },
+            {
+              role: 'user',
+              content: 'Your previous response did not execute the requested action because it called no tool. Do not narrate or simulate execution. Call the appropriate available tool now. Never invent results.',
+            },
+          ],
+          toolIterations: 1,
+          readyToStream: false,
+          inputClassification: classification,
+          retryWithoutTool: true,
+        };
+      }
+
+      if (runtimeExecution && state.retryWithoutTool) {
+        state.session._onStreamReset?.();
+        const failure = 'Action non exécutée : Donna n’a appelé aucun outil disponible. Aucun job ni résultat n’a été créé.';
+        emitAgentEvent(state.session, 'assistant_message', 'agent_guard', { content: failure });
+        return {
+          response: failure,
+          pendingToolCalls: null,
+          readyToStream: false,
+          retryWithoutTool: false,
         };
       }
 
@@ -1068,26 +1173,7 @@ export function createAgentGraph(options = {}) {
           // wiki__plan_set would lose fields (a small local model dropped
           // arguments/operations in testing) — the shell does the mapping.
           if (/(^|__)agent_plan$/.test(tool) && Array.isArray(payload?.tasks) && payload.tasks.length > 0) {
-            const steps = payload.tasks.map((task, index) => normalizeDeclaredPlanStep({
-              id: task.id,
-              description: task.label ?? task.id ?? `Task ${index + 1}`,
-              requiredCapability: task.requiredCapability ?? payload.capability ?? null,
-              operation: task.operation ?? null,
-              arguments: task.arguments ?? {},
-              dependsOn: task.dependsOn ?? [],
-              outputRefs: (task.expectedOutputRefs ?? []).map((ref) => (ref && typeof ref === 'object' ? String(ref.ref ?? '') : String(ref))).filter(Boolean),
-              groupId: task.groupId ?? null,
-              dependsOnGroup: task.dependsOnGroup ?? null,
-              parallelizable: task.parallelizable,
-              barrier: task.barrier,
-              locks: task.locks,
-              requiresApproval: task.requiresApproval,
-              approvalClass: task.approvalClass,
-              approvalSummary: task.approvalSummary,
-              idempotencyKey: task.idempotencyKey,
-              progressWeight: task.progressWeight,
-              recommendedConcurrency: task.recommendedConcurrency,
-            }, index, state.session));
+            const steps = planStepsFromFragment(payload);
             emitAgentEvent(state.session, 'plan_set', 'tool', { steps });
             state.session._onStep?.(`Plan: ${steps.length} task(s) declared from ${server} fragment`);
             resultText = `Task-graph fragment integrated as the current plan (${steps.length} task(s), groups: ${[...new Set(payload.tasks.map((task) => task.groupId).filter(Boolean))].join(', ') || 'none'}). The orchestrator will dispatch these tasks — do NOT call production tools for them yourself. Reply with a short summary and wait.`;
@@ -1163,6 +1249,7 @@ export function createAgentGraph(options = {}) {
 
   function routeOrchestrator(state) {
     if (state.pendingToolCalls?.length > 0) return 'tool_executor';
+    if (state.retryWithoutTool) return 'orchestrator';
     return END;
   }
 

package/src/agent/graph.test.js

@@ -686,6 +686,61 @@ test('agent graph survives more than 12 tool iterations (recursion limit)', asyn
   }
 });
 
+test('runtime action retries a text-only hallucination and requires a real tool call', async () => {
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = async () => ({
+    ok: true,
+    status: 200,
+    headers: { get: () => null },
+    text: async () => JSON.stringify({ result: { content: [{ type: 'text', text: '{"ok":true,"outputs":["deliverables/result.md"]}' }] } }),
+  });
+  let calls = 0;
+  let retryMessages = [];
+  const session = sessionBase({
+    _currentRunIdentity: { runId: 'run-build', turnId: 'run-build:turn-1', workspace: 'docs' },
+    llm: {
+      async completeWithTools({ messages }) {
+        calls += 1;
+        if (calls === 1) {
+          return {
+            content: 'Build terminé, faux-job-123, rapport.pdf.',
+            message: { role: 'assistant', content: 'Build terminé, faux-job-123, rapport.pdf.' },
+            tool_calls: null,
+          };
+        }
+        if (calls === 2) {
+          retryMessages = messages;
+          return {
+            content: null,
+            message: { role: 'assistant', content: null },
+            tool_calls: [{
+              id: 'build-call',
+              type: 'function',
+              function: { name: 'production__production_start_job', arguments: '{"type":"build"}' },
+            }],
+          };
+        }
+        return {
+          content: 'Build terminé. Résultat : deliverables/result.md. Disponible dans /openui.',
+          message: { role: 'assistant', content: 'Build terminé. Résultat : deliverables/result.md. Disponible dans /openui.' },
+          tool_calls: null,
+        };
+      },
+    },
+  });
+
+  try {
+    const result = await createAgentGraph().invoke({ input: 'lance le build', session });
+    assert.equal(calls, 3);
+    assert.match(retryMessages.at(-1).content, /called no tool/);
+    assert.doesNotMatch(result.response, /faux-job-123|rapport\.pdf/);
+    assert.match(result.response, /deliverables\/result\.md/);
+    assert.equal(session.headlessPlan?.[0]?.status, 'done');
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
 test('agent graph auto-declares the plan from an agent_plan task-graph fragment', async () => {
   // The bridge that makes parallel ingestion real: when the LLM calls
   // production__agent_plan, the shell integrates the fragment as the plan
@@ -790,3 +845,83 @@ test('Donna interprets a cleanup request and calls runtime__kill herself', async
     globalThis.fetch = originalFetch;
   }
 });
+
+test('buildAgentSystemPrompt delegates pending inputs to the capability provider without filesystem fallback', () => {
+  const workspacePath = mkdtempSync(join(tmpdir(), 'facts-'));
+  try {
+    mkdirSync(join(workspacePath, 'raw', 'untracked'), { recursive: true });
+    writeFileSync(join(workspacePath, 'raw', 'untracked', 'note-a.md'), '# a\n');
+    const prompt = buildAgentSystemPrompt({ session: sessionBase({ workspacePath }) });
+    assert.match(prompt, /call the qualified `<provider>__agent_status` tool with \{capability, operation\}/);
+    assert.match(prompt, /report only its pendingInputs/);
+    assert.doesNotMatch(prompt, /note-a\.md/);
+    assert.doesNotMatch(prompt, /Workspace facts:/);
+  } finally {
+    rmSync(workspacePath, { recursive: true, force: true });
+  }
+});
+
+test('Donna reads pending inputs from the qualified capability provider status tool', async () => {
+  const originalFetch = globalThis.fetch;
+  let requestedArguments = null;
+  globalThis.fetch = async (_url, options) => {
+    const request = JSON.parse(options.body);
+    requestedArguments = request.params.arguments;
+    return {
+      ok: true,
+      status: 200,
+      headers: { get: () => null },
+      text: async () => JSON.stringify({ result: { content: [{
+        type: 'text',
+        text: JSON.stringify({
+          contractVersion: '1',
+          agentInstanceId: 'production-main',
+          capability: 'knowledge.update',
+          operation: 'ingest',
+          available: true,
+          pendingInputs: [{ type: 'file', ref: 'provider/source-a', label: 'source-a.md', mediaType: 'text/markdown' }],
+        }),
+      }] } }),
+    };
+  };
+  let calls = 0;
+  const session = sessionBase({
+    mcp: {
+      production: {
+        status: 'connected',
+        url: 'http://127.0.0.1:3000/mcp/',
+        tools: [{
+          name: 'agent_status',
+          description: 'Read a job or discover capability inputs.',
+          inputSchema: { type: 'object', properties: { capability: { type: 'string' }, operation: { type: 'string' } } },
+        }],
+      },
+    },
+    llm: {
+      async completeWithTools({ messages }) {
+        calls += 1;
+        if (calls === 1) {
+          return {
+            content: null,
+            message: { role: 'assistant', content: null },
+            tool_calls: [{
+              id: 'status-call',
+              type: 'function',
+              function: { name: 'production__agent_status', arguments: JSON.stringify({ capability: 'knowledge.update', operation: 'ingest' }) },
+            }],
+          };
+        }
+        assert.match(JSON.stringify(messages), /provider\/source-a/);
+        return { content: 'Un fichier est en attente : source-a.md.', message: { role: 'assistant', content: 'Un fichier est en attente : source-a.md.' }, tool_calls: null };
+      },
+    },
+  });
+
+  try {
+    const result = await createAgentGraph().invoke({ input: 'Quels fichiers sont en attente d’ingestion ?', session });
+    assert.equal(result.response, 'Un fichier est en attente : source-a.md.');
+    assert.deepEqual(requestedArguments, { capability: 'knowledge.update', operation: 'ingest' });
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});

package/src/cli/wiki-manager.js

@@ -15,6 +15,7 @@ import { extractActivity, parseJsonText, sessionActivities, terminalFailures } f
 import { syncActivitiesToPlan, formatPlanStatus } from '../core/plan.js';
 import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
 import { runAgentTurn, runAgenticLoop } from '../core/agentLoop.js';
+import { resolveCapabilityConcurrency } from '../orchestrator/scheduler.js';
 // Runtime modules use node:sqlite (Node.js built-in unavailable in Bun).
 // They are imported dynamically so the shell / TUI path never loads them.
 
@@ -628,6 +629,71 @@ async function runRuntime(argv, agent) {
         : undefined;
       supervisor?.setRunSignal(signal);
       session._onStep = (message) => emitRuntimeLog(session, message);
+      // Deterministic capability run (/ingest): ask the capable agent for its
+      // task-graph fragment and integrate it as the plan BEFORE any LLM turn.
+      // The parallel path must not depend on a small model deciding to call
+      // agent_plan by itself.
+      if (body.capabilityPlan?.capability) {
+        const { validateFragment } = await import('../orchestrator/planValidator.js');
+        const { integrate } = await import('../orchestrator/planIntegrator.js');
+        const registry = session.capabilityRegistry ?? null;
+        const agents = session.agentRegistry?.snapshot?.() ?? session.agentRegistrySnapshot ?? [];
+        const provider = agents.find((item) => (item.description?.capabilities ?? [])
+          .some((capability) => capability.id === body.capabilityPlan.capability));
+        if (!provider?.serverName) {
+          throw new Error(`No agent provides capability ${body.capabilityPlan.capability}.`);
+        }
+        const fragment = parseJsonText(formatMcpToolResult(await callMcpTool(session.mcp, provider.serverName, 'agent_plan', {
+          capability: body.capabilityPlan.capability,
+          operation: body.capabilityPlan.operation ?? undefined,
+          workspace: { revision: String(Date.now()) },
+          constraints: {
+            // The agent declares its capacity. Request/env values are only
+            // constraints: they may lower that capacity, never raise it.
+            maxConcurrency: resolveCapabilityConcurrency(
+              provider,
+              body.capabilityPlan.maxConcurrency,
+              process.env.WIKI_MANAGER_CAPABILITY_CONCURRENCY,
+            ),
+            requireApprovalForMutations: body.capabilityPlan.requireApproval !== false,
+          },
+          ...(Array.isArray(body.capabilityPlan.inputs) && body.capabilityPlan.inputs.length > 0
+            ? { arguments: { inputs: body.capabilityPlan.inputs } }
+            : {}),
+        })));
+        if (!Array.isArray(fragment?.tasks) || fragment.tasks.length === 0) {
+          dispatchAgentEvent(session, createAgentEvent('assistant_message', {
+            origin: 'runtime',
+            runId,
+            payload: { content: `Aucune tâche à planifier pour ${body.capabilityPlan.capability} (${fragment?.summary?.initialSynthesis?.[0] ?? 'fragment vide'}).` },
+          }));
+          dispatchAgentEvent(session, createAgentEvent('run_done', { origin: 'runtime', runId, payload: { runId } }));
+          return;
+        }
+        // Full official integration path — NOT a bare plan_set: integrate()
+        // validates the fragment, persists the tasks, and CREATES the
+        // approval requests the scheduler's approvalCovered() filter waits
+        // for. A bare plan_set left requiresApproval tasks unreachable
+        // forever (stalled as no_ready_plan_task with nothing to approve).
+        const validation = validateFragment(fragment, {
+          registry,
+          run: { plannerAgentInstanceId: provider.agentInstanceId ?? provider.serverName },
+        });
+        if (!validation.ok) {
+          throw new Error(`Capability plan rejected: ${validation.errors.map((error) => error.message ?? error.code ?? String(error)).join('; ')}`);
+        }
+        const integrated = integrate(runId, validation.normalizedFragment, {
+          registry,
+          session,
+          store,
+          workspace: session.workspace ?? null,
+          enforceApprovalCoverage: true,
+        });
+        if (!integrated.ok) {
+          throw new Error(`Capability plan integration failed: ${(integrated.errors ?? []).map((error) => error.message ?? error.code ?? String(error)).join('; ')}`);
+        }
+        emitRuntimeLog(session, `capability-plan: ${fragment.tasks.length} task(s) integrated from ${provider.serverName}.agent_plan (${body.capabilityPlan.capability}); approvals: ${(session.agentProjection?.approvals ?? []).filter((approval) => approval.status === 'pending_approval').length} pending`);
+      }
       await runRuntimeAgenticWorkflow(agent, session, input, {
         signal,
         timeoutMs,
@@ -811,11 +877,11 @@ export async function runCli(argv) {
       runtime = unavailableRuntime(err);
       console.error(`Runtime unavailable: ${runtime.error}`);
     }
+    // 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.
     await runOpenTuiShell({ agent, packageJson, runtime });
-    if (runtime?.url) {
-      const { shutdownOwnedRuntime } = await import('../runtime/lifecycle.js');
-      await shutdownOwnedRuntime(runtime, { log: (message) => console.log(`[wiki-manager] ${message}`) });
-    }
     return;
   }
 

package/src/commands/slash.js

@@ -43,7 +43,7 @@ import {
   listDocumentUploads,
   storeAndMaybeConvertDocument,
 } from '../core/documentIntake.js';
-import { fetchRuntimeState, postRuntimeCancel, postRuntimeKill } from '../runtime/client.js';
+import { fetchRuntimeState, postRuntimeCancel, postRuntimeControl, postRuntimeKill, postRuntimeRun } from '../runtime/client.js';
 import { versionWithBuild } from '../core/buildInfo.js';
 
 export function printVersion(packageJson) {
@@ -513,9 +513,6 @@ export async function refreshMcpRuntimeStatus(session) {
 
 async function statusText(session) {
   const states = await refreshMcpRuntimeStatus(session);
-  const services = session.workspacePath
-    ? await composeServices(session).catch(() => [])
-    : [];
   const workspaceStats = collectWorkspaceStats(session);
   const workspaceColumn = sectionBlock('Workspace', [
     `workspace: ${session.workspace ?? '-'}`,
@@ -530,9 +527,6 @@ async function statusText(session) {
     `model: ${session.wikircConfig?.llm?.model ?? '-'}`,
     `baseUrl: ${session.wikircConfig?.llm?.baseUrl ?? '-'}`,
   ]);
-  const servicesColumn = sectionBlock('Services', services.length > 0
-    ? services.map((service) => `- ${service}`)
-    : ['No workspace loaded.']);
   const runtimeColumn = sectionBlock('Runtime', (states ? serviceStatesText(states) : 'Docker runtime not available or no workspace loaded.').split('\n'));
   const mcpColumn = sectionBlock('MCP', formatMcpStatus(session.mcp).split('\n'));
   const mcpToolsColumn = sectionBlock('MCP tool summary', formatMcpToolSummary(session.mcp).split('\n'));
@@ -542,7 +536,7 @@ async function statusText(session) {
     '',
     workspaceStatsText(workspaceStats),
     '',
-    twoColumns(servicesColumn, runtimeColumn),
+    runtimeColumn,
     '',
     twoColumns(mcpColumn, mcpToolsColumn),
   ].join('\n');
@@ -635,6 +629,8 @@ ${helpPair('/wiki', 'Run wiki index', '/wiki run <args>', 'Raw wiki CLI')}
 ${helpPair('/chat', 'Chat mode', '/agent', 'Agent mode')}
 ${helpPair('/openui', 'Open web UI in browser', '', '')}
 ${helpPair('/run status', 'Runtime status', '/run kill', 'Kill runtime run(s)')}
+${helpPair('/run capability <id>', 'Deterministic capability run', '/approve', 'Grant pending approval')}
+${helpPair('/cancel', 'Cancel active run', '', '')}
 ${helpPair('/run cancel', 'Cancel active run', '', '')}
 ${helpPair('/queue', 'MCP job queue', '/queue clear', 'Clear finished')}
 ${helpPair('/queue cancel <id>', 'Cancel queued/running', '', '')}
@@ -972,6 +968,27 @@ export async function handleSlashCommand(line, context) {
       }
       return { output: 'Usage: /mcp <status|endpoints|tools|call> [mcp]' };
     }
+    case 'cancel': {
+      // Alias of /run cancel — people type /cancel when they want out.
+      const runtime = context.runtime ?? {};
+      if (!runtime.url) return { output: 'Runtime unavailable. Start/connect the runtime before using /cancel.' };
+      const result = await postRuntimeCancel({ url: runtime.url, workspace: context.session.workspace ?? null });
+      return { output: result.cancelled ? 'Runtime cancel requested.' : `Nothing to cancel${result.reason ? ` (${result.reason})` : ''} — use /run kill to purge everything.` };
+    }
+    case 'approve': {
+      // /approve was only wired in the legacy REPL — in the opentui TUI it
+      // returned "Unknown command", which made every approval time out and
+      // every requiresApproval plan stall forever.
+      const runtime = context.runtime ?? {};
+      if (!runtime.url) return { output: 'Runtime unavailable. Start/connect the runtime before using /approve.' };
+      const result = await postRuntimeControl('message', {
+        url: runtime.url,
+        workspace: context.session.workspace ?? null,
+        input: args.slice(1).join(' ') || 'approve',
+        intent: 'approve',
+      });
+      return { output: String(result?.explanation ?? (result?.accepted ? 'Approval granted.' : 'No pending approval found.')) };
+    }
     case 'run': {
       const subcommand = args[1] ?? 'status';
       const runtime = context.runtime ?? {};
@@ -985,11 +1002,34 @@ export async function handleSlashCommand(line, context) {
         const result = await postRuntimeCancel({ url, workspace: context.session.workspace ?? null });
         return { output: result.cancelled ? 'Runtime cancel requested.' : `Runtime cancel skipped: ${result.reason ?? 'no active run'}` };
       }
+      if (subcommand === 'capability') {
+        // Business-agnostic deterministic run: mirrors the capability
+        // registry instead of hardcoding an application verb. The agent's
+        // task graph is validated/integrated server-side before any LLM turn.
+        const capability = args[2];
+        if (!capability) return { output: 'Usage: /run capability <capability-id> [operation] [files…]' };
+        if (!context.session.workspace) return { output: 'No workspace loaded. Use /use <workspace> first.' };
+        const operation = args[3] && !args[3].includes('.') && !args[3].includes('/') ? args[3] : undefined;
+        const inputs = args.slice(operation ? 4 : 3);
+        const result = await postRuntimeRun(`Run de capability ${capability}${operation ? ` (${operation})` : ''} demandé via /run capability.`, {
+          url,
+          workspace: context.session.workspace,
+          capabilityPlan: {
+            capability,
+            ...(operation ? { operation } : {}),
+            ...(inputs.length > 0 ? { inputs } : {}),
+          },
+        });
+        if (result?.runId) {
+          return { output: `▶ Run de capability accepté (${String(result.runId).slice(0, 8)}) — le plan de l'agent sera intégré et dispatché en parallèle ; approbation demandée avant les mutations (« valide tout » ou /approve).` };
+        }
+        return { output: `Run non démarré: ${result?.explanation ?? result?.error ?? JSON.stringify(result)}` };
+      }
       if (subcommand === 'kill') {
         const result = await postRuntimeKill({ url, workspace: context.session.workspace ?? null, runId: args[2] ?? null });
         return { output: `Runtime kill requested: ${result.runs ?? 0} run${result.runs === 1 ? '' : 's'}, ${result.tasks ?? 0} task${result.tasks === 1 ? '' : 's'} cancelled.` };
       }
-      return { output: 'Usage: /run [status|cancel|kill [runId]]' };
+      return { output: 'Usage: /run [status|cancel|kill [runId]|capability <id> [operation] [files…]]' };
     }
     case 'queue': {
       const subcommand = args[1] ?? 'list';