@dotdrelle/wiki-manager 0.12.10 → 0.12.11

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) ─────────────────────────────────────
 
@@ -65,8 +67,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.11",
   "description": "Agentic shell and orchestration cockpit for llm-wiki workspaces.",
   "license": "PolyForm-Noncommercial-1.0.0",
   "author": "dotrelle",

package/src/agent/graph.js

@@ -250,6 +250,7 @@ const AgentState = Annotation.Root({
   readyToStream: Annotation(),
   streamContext: Annotation(),
   streamedInline: Annotation(),
+  retryWithoutTool: Annotation({ default: () => false }),
 });
 
 function commandList(session) {
@@ -688,6 +689,9 @@ 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.',
     '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>.',
@@ -892,12 +896,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 +936,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,
         };
       }
 
@@ -1163,6 +1202,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

package/src/commands/slash.js

@@ -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');

package/src/core/agentLoop.js

@@ -66,6 +66,7 @@ export async function runAgenticLoop(agent, session, initialInput, {
   onPendingSteps = null,
   onActivitiesStarted = null,
   onActivitiesCompleted = null,
+  deterministicTerminalSummary = false,
   onMaxTurns = null,
   abortMessage = 'Agent run cancelled.',
   parallelHandoff = false,
@@ -149,6 +150,11 @@ export async function runAgenticLoop(agent, session, initialInput, {
     const completed = waitResult.completed ?? [];
     const summary = formatCompletedActivities(completed);
     onActivitiesCompleted?.({ completed, summary });
+    const unfinished = (session.headlessPlan ?? []).some((step) =>
+      ['pending', 'pending_approval', 'running', 'starting', 'queued'].includes(String(step.status ?? '').toLowerCase()));
+    if (deterministicTerminalSummary && !unfinished) {
+      return { ok: true, completed, summary, deterministicSummary: true };
+    }
     if (parallelHandoff && readyPlanTasks(session.headlessPlan).length > 1) {
       return { ok: true, handoff: true };
     }

package/src/core/agentLoop.test.js

@@ -77,8 +77,56 @@ test('runAgenticLoop waits for new activities and continues with a completion su
   assert.equal(result.ok, true);
   assert.equal(inputs.length, 2);
   assert.match(inputs[1], /Completed activities:/);
-  assert.match(inputs[1], /production job-1: done/);
-  assert.deepEqual(callbacks, ['started:1', '- production job-1: done']);
+  assert.match(inputs[1], /- job: done/);
+  assert.deepEqual(callbacks, ['started:1', '- job: done']);
+});
+
+test('runAgenticLoop can finish from terminal activity facts without another LLM turn', async () => {
+  const session = { activities: {}, headlessPlan: null };
+  let turns = 0;
+  const result = await runAgenticLoop({
+    async invoke({ session: turnSession }) {
+      turns += 1;
+      dispatchAgentEvent(turnSession, createAgentEvent('activity_upserted', {
+        payload: {
+          activity: {
+            id: 'job-build',
+            source: 'production',
+            kind: 'build',
+            label: 'Build workspace',
+            status: 'running',
+            terminal: false,
+          },
+        },
+      }));
+      return { response: 'Job started.' };
+    },
+  }, session, 'Build workspace', {
+    maxTurns: 3,
+    timeoutMs: 1000,
+    deterministicTerminalSummary: true,
+    waitForActivities: async (turnSession) => {
+      dispatchAgentEvent(turnSession, createAgentEvent('activity_upserted', {
+        payload: {
+          activity: {
+            id: 'job-build',
+            source: 'production',
+            kind: 'build',
+            label: 'Build workspace',
+            status: 'done',
+            terminal: true,
+            outputRefs: ['deliverables/result.md'],
+          },
+        },
+      }));
+      return { ok: true, completed: Object.values(turnSession.activities) };
+    },
+  });
+
+  assert.equal(turns, 1);
+  assert.equal(result.deterministicSummary, true);
+  assert.match(result.summary, /build: done/);
+  assert.match(result.summary, /output: deliverables\/result\.md/);
 });
 
 test('runAgenticLoop extracts a fallback numbered plan from first response', async () => {

package/src/core/buildInfo.json

@@ -1,4 +1,4 @@
 {
-  "version": "0.12.10",
-  "commit": "e256e16"
+  "version": "0.12.11",
+  "commit": "d8eae0b"
 }

package/src/core/mcp.js

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { managerEnvFile, managerMcpEndpointsFile, readEnvFile } from './env.js';
 
-const WIKI_MANAGER_VERSION = '0.12.10';
+const WIKI_MANAGER_VERSION = '0.12.11';
 
 function envValue(key) {
   const filePath = managerEnvFile();

package/src/core/plan.js

@@ -141,10 +141,17 @@ export function formatConfigValue(value) {
 }
 
 export function formatCompletedActivities(activities) {
-  return activities
-    .filter((a) => a.terminal)
-    .map((a) => `- ${a.source} ${a.id ?? a.kind}: ${a.status}${a.error ? ` (${a.error})` : ''}`)
-    .join('\n');
+  const terminal = activities.filter((activity) => activity.terminal);
+  const lines = terminal.map((activity) => {
+    const label = activity.kind ?? activity.label ?? `${activity.source} ${activity.id ?? 'activity'}`;
+    return `- ${label}: ${activity.status}${activity.error ? ` (${activity.error})` : ''}`;
+  });
+  const outputs = [...new Set(terminal.flatMap((activity) => activity.outputRefs ?? []).map((ref) => {
+    if (ref && typeof ref === 'object') return String(ref.ref ?? ref.path ?? ref.url ?? '').trim();
+    return String(ref ?? '').trim();
+  }).filter(Boolean))];
+  if (outputs.length > 0) lines.push(...outputs.map((output) => `- output: ${output}`));
+  return lines.join('\n');
 }
 
 function findMatchingPlanStepByStructure(plan, activity) {

package/src/runtime/runner.js

@@ -50,6 +50,7 @@ export async function runRuntimeAgenticLoop(agent, session, initialInput, { sign
     maxTurns,
     runId,
     parallelHandoff,
+    deterministicTerminalSummary: true,
     abortMessage: 'Runtime run cancelled.',
     waitForActivities: (turnSession, startedActivities, waitOptions) =>
       waitForRuntimeActivities(turnSession, startedActivities, { ...waitOptions, pollBusy }),
@@ -78,6 +79,14 @@ export async function runRuntimeAgenticLoop(agent, session, initialInput, { sign
     onActivitiesStarted: ({ activities }) => {
       emitRuntimeLog(session, `agentic-loop: ${activities.length} new activity(s), waiting`);
     },
+    onActivitiesCompleted: ({ summary }) => {
+      emitRuntimeLog(session, `agentic-loop: completed activities:\n${summary}`);
+      dispatchAgentEvent(session, createAgentEvent('assistant_message', {
+        origin: 'runtime',
+        runId,
+        payload: { content: summary || 'Action terminée.' },
+      }));
+    },
     onMaxTurns: ({ maxTurns: totalTurns }) => {
       emitRuntimeLog(session, `agentic-loop: max turns (${totalTurns}) reached`);
     },

package/src/shell/LeftPane.tsx

@@ -375,7 +375,10 @@ function conversationLines(messages: Array<{ role: string; content: string }>, c
     let inFence = false;
     const lines: Array<{ text: string; isCode: boolean }> = [];
     for (const line of raw.split('\n')) {
-      if (/^(`{2,3}|~{2,3})/.test(line)) { inFence = !inFence; continue; }
+      // LLM responses often indent fenced blocks as part of a list. Accept
+      // leading whitespace so ```bash / ~~~ fences are rendered as code
+      // instead of leaking their Markdown markers into the conversation.
+      if (/^\s*(`{3,}|~{3,})/.test(line)) { inFence = !inFence; continue; }
       lines.push({ text: line, isCode: inFence });
     }
     return [