@dotdrelle/wiki-manager 0.15.94 → 0.15.97

package/README.md

@@ -121,47 +121,60 @@ in isolated workspaces.
 
 ## How wikiLLM compares
 
-Several open projects now build a Markdown wiki with an LLM. They target
+Several open projects now build an LLM-maintained knowledge layer over your
+sources — some as a wiki, some as a retrieval and answer platform. They target
 **different problems** — the useful questions are *what goes in, what comes out,
-and who operates it*. Snapshot as of 2026; all of these move quickly.
+and who operates it*. Snapshot as of **September 2026**; all of these move quickly.
 
 ✅ first-class · 🟡 partial or indirect · ❌ not a goal
 
-Projects compared: [OpenWiki](https://github.com/langchain-ai/openwiki),
-[DeepWiki-Open](https://github.com/asyncfuncai/deepwiki-open),
+Projects compared: [OpenWiki](https://github.com/langchain-ai/openwiki) and
+[DeepWiki-Open](https://github.com/asyncfuncai/deepwiki-open) (code / knowledge
+wikis), [RAGFlow](https://github.com/infiniflow/ragflow) and
+[Onyx](https://github.com/onyx-dot-app/onyx) (RAG platforms), and
 [GraphRAG](https://github.com/microsoft/graphrag).
 
 <table>
 <thead>
-<tr><th><small>Need</small></th><th><small><strong>wikiLLM</strong></small></th><th><small><strong>OpenWiki</strong></small></th><th><small><strong>DeepWiki-Open</strong></small></th><th><small><strong>GraphRAG</strong></small></th></tr>
+<tr>
+<th><small>Need</small></th>
+<th><small><strong>wikiLLM</strong></small></th>
+<th><small><strong>Code / knowledge wikis</strong><br>OpenWiki · DeepWiki-Open</small></th>
+<th><small><strong>RAG platforms</strong><br>RAGFlow · Onyx</small></th>
+<th><small><strong>Graph pipeline</strong><br>GraphRAG</small></th>
+</tr>
 </thead>
 <tbody>
-<tr><td><small>Input</small></td><td><small>✅ Business docs — Confluence, PDF, Office, SaaS</small></td><td><small>✅ Codebase (code mode)</small></td><td><small>✅ Code repo → diagrams</small></td><td><small>🟡 Plain-text corpus only</small></td></tr>
-<tr><td><small>Output</small></td><td><small>✅ Maintained wiki <strong>+ deliverables</strong> from your templates</small></td><td><small>🟡 Wiki about the code, for agents</small></td><td><small>🟡 Interactive wiki + diagrams</small></td><td><small>❌ Entity graph + summaries — no wiki</small></td></tr>
-<tr><td><small>Keep current</small></td><td><small>✅ Re-ingest / scheduled</small></td><td><small>✅ <code>--update</code>, CI action</small></td><td><small>🟡 Regenerated per run</small></td><td><small>✅ <code>graphrag update</code> (delta)</small></td></tr>
-<tr><td><small>Evidence &amp; citations</small></td><td><small>🟡 Cites retrieved context</small></td><td><small>✅ Claims tied to versioned source</small></td><td><small>🟡 RAG-cited answers</small></td><td><small>✅ Citations to text units</small></td></tr>
-<tr><td><small>Corpus-wide Q&amp;A</small></td><td><small>🟡 BM25 + vector feeding generation</small></td><td><small>❌</small></td><td><small>🟡 Repo-scoped RAG chat</small></td><td><small>✅ Local/global community search</small></td></tr>
-<tr><td><small>Team UI</small></td><td><small>✅ Web console — wiki, graph, chat, runs (single-user today)</small></td><td><small>🟡 Local viewer + CLI chat</small></td><td><small>✅ Self-hosted web app + RAG</small></td><td><small>❌ Library / CLI</small></td></tr>
-<tr><td><small>Multi-project isolation</small></td><td><small>✅ Workspaces, own services, ports, secrets</small></td><td><small>❌ One wiki per run</small></td><td><small>❌ One wiki per repo</small></td><td><small>❌ One index per corpus</small></td></tr>
-<tr><td><small>Orchestration &amp; governance</small></td><td><small>✅ Approval-gated dispatcher, budgets, idempotent writes, crash recovery</small></td><td><small>❌ One agent loop</small></td><td><small>❌ One generation pipeline</small></td><td><small>❌ Indexing pipeline</small></td></tr>
-<tr><td><small>Connectors as services</small></td><td><small>✅ Independent MCP agents (Confluence, docs, e-mail…)</small></td><td><small>🟡 Built-in connector set</small></td><td><small>❌</small></td><td><small>❌</small></td></tr>
-<tr><td><small>Offline / local models</small></td><td><small>✅ Per-workspace OpenAI-compatible or gateway (Ollama, vLLM, MLX…)</small></td><td><small>✅ 13+ providers</small></td><td><small>✅ Ollama</small></td><td><small>✅ Any OpenAI-compatible</small></td></tr>
-<tr><td><small>License</small></td><td><small>❌ PolyForm <strong>Noncommercial</strong></small></td><td><small>✅ MIT</small></td><td><small>✅ MIT</small></td><td><small>✅ MIT</small></td></tr>
+<tr><td><small>Input</small></td><td><small>✅ Business docs — Confluence, PDF, Office, SaaS</small></td><td><small>✅ Code repo; OpenWiki also personal sources (Notion, Gmail, Slack…)</small></td><td><small>✅ PDF/Office/images, Confluence, S3, 50+ connectors</small></td><td><small>🟡 Plain text</small></td></tr>
+<tr><td><small>Output</small></td><td><small>✅ Maintained wiki <strong>+ deliverables</strong></small></td><td><small>✅ Linked Markdown wiki (+ graph / diagrams)</small></td><td><small>🟡 Grounded RAG answers, not a wiki</small></td><td><small>❌ Entity graph + summaries</small></td></tr>
+<tr><td><small>Agents &amp; actions</small></td><td><small>✅ Capability dispatcher, external agentic runtime, MCP tools</small></td><td><small>✅ Doc-generation agents, MCP connectors</small></td><td><small>✅ Agentic workflow, MCP actions, deep research</small></td><td><small>❌ Indexing pipeline</small></td></tr>
+<tr><td><small>Keep current</small></td><td><small>✅ Re-ingest / scheduled</small></td><td><small>✅ <code>--update</code> / regenerate, CI</small></td><td><small>✅ Scheduled connector sync</small></td><td><small>🟡 Maintenance mode</small></td></tr>
+<tr><td><small>Team UI</small></td><td><small>✅ Web console — wiki, graph, chat, runs</small></td><td><small>🟡 CLI + visualizer; DeepWiki-Open web app</small></td><td><small>✅ Self-hosted web app</small></td><td><small>❌ Library / CLI</small></td></tr>
+<tr><td><small>Multi-project isolation</small></td><td><small>✅ Workspaces, own services, ports, secrets</small></td><td><small>❌ One wiki per repo / directory</small></td><td><small>🟡 Datasets / teams, not isolated services</small></td><td><small>❌ One index per corpus</small></td></tr>
+<tr><td><small>Human approval &amp; governance</small></td><td><small>✅ Approval-gated dispatcher, budgets, crash recovery</small></td><td><small>❌ PR review only</small></td><td><small>🟡 RBAC / SSO (Onyx enterprise)</small></td><td><small>❌</small></td></tr>
+<tr><td><small>License</small></td><td><small>❌ PolyForm <strong>Noncommercial</strong></small></td><td><small>✅ MIT</small></td><td><small>✅ Apache-2.0 / MIT CE</small></td><td><small>✅ MIT</small></td></tr>
 </tbody>
 </table>
 
+<small>Per-project details: OpenWiki emits OKF v0.2 and maintains a versioned
+evidence graph of “grounded claims”; GraphRAG is a research project now in
+maintenance mode; Onyx’s SSO/RBAC live in its enterprise edition.</small>
+
 **The short version:**
 
-- **OpenWiki** and **DeepWiki-Open** document *source code*. Point wikiLLM at a
-  repository and there is nothing for it to ingest; point either of them at a
-  stack of Confluence pages and a Word document and that is not their job.
-- **GraphRAG** builds *retrieval structure*, not a wiki you read or deliverables
-  you ship — it is a strong back end for corpus-wide Q&A, and complementary
-  rather than competing.
-- **wikiLLM** is the only one of the four whose output is *both* a browsable wiki
-  *and* regenerated business documents, and the only one with the operational
-  layer — isolated projects, bounded approvals, automatic recovery, a web
-  console — that a shared internal tool needs.
+- **OpenWiki** and **DeepWiki-Open** build wikis from a **code repository**
+  (OpenWiki also ingests personal sources — Notion, Gmail, Slack…). Their input
+  is code or personal feeds, not a stack of business documents feeding your
+  deliverable templates.
+- **RAGFlow** and **Onyx** are RAG platforms: they index sources and answer
+  questions from them, with agents and connectors, but the output is an answer,
+  not a wiki you browse or a document you ship.
+- **GraphRAG** builds retrieval structure and is now in maintenance mode — a
+  complementary back end, not a wiki.
+- **wikiLLM** is the only one whose output is *both* a browsable wiki *and*
+  regenerated business documents, and the only one with the operational layer —
+  isolated projects, bounded approvals, automatic recovery, a web console —
+  that a shared internal tool needs.
 
 **What wikiLLM does *not* try to do (today):**
 
@@ -170,8 +183,6 @@ Projects compared: [OpenWiki](https://github.com/langchain-ai/openwiki),
 - Serve a true multi-user instance with per-user identity and an attributed
   audit trail. This is a single-user deployment baseline (see the scope note
   above).
-- Expose a graph-query API over the corpus the way GraphRAG does; retrieval is
-  BM25 plus a vector index feeding generation.
 - Ship or host the multi-provider AI gateway — routing to several providers is
   supported, the gateway itself is infrastructure you bring.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotdrelle/wiki-manager",
-  "version": "0.15.94",
+  "version": "0.15.97",
   "description": "Agentic shell and orchestration cockpit for llm-wiki workspaces.",
   "repository": {
     "type": "git",
@@ -19,7 +19,7 @@
   },
   "scripts": {
     "start": "bun ./bin/wiki-manager.js",
-    "test": "node --test src/core/skillInvocation.test.js src/core/skillCompiler.test.js src/runtime/skillRun.test.js src/runtime/controlDrain.test.js src/runtime/controlCancellation.test.js src/cli/runtimeStartup.test.js src/cli/wiki-manager.test.js src/agent/graph.test.js src/agent/skillRecursion.test.js src/contracts/schemas.test.js src/core/activity.test.js src/core/env.test.js src/core/agentsCompose.test.js src/core/profileServiceStatus.test.js src/core/workspaceProfile.test.js src/core/buildInfo.test.js src/core/agentEvents.test.js src/core/skillChainView.test.js src/core/runtimeLog.test.js src/core/runtimeEventAdapter.test.js src/activity/activityAggregator.test.js src/graph/runGraphProjector.test.js src/core/workflow.test.js src/core/planPatch.test.js src/core/agentLoop.test.js src/core/plan.test.js src/core/mcp.test.js src/core/toolLoop.test.js src/core/documentIntake.test.js src/core/dockerCompose.test.js src/core/otherWorkspacesRunning.test.js src/core/wikiSetup.test.js src/core/wikiWorkspace.test.js src/core/wikiWorkspaceStart.test.js src/core/wikirc.test.js src/core/workspaceInherit.test.js src/core/cacert.test.js src/core/composeOverrides.test.js src/core/setEnvValue.test.js src/core/commandFailure.test.js src/core/currentArtifact.test.js src/core/googleGrants.test.js src/core/modelFetch.test.js src/core/startupCheck.test.js src/core/queueStore.test.js src/orchestrator/agentRegistry.test.js src/orchestrator/capabilityRegistry.test.js src/orchestrator/capabilityResolver.test.js src/orchestrator/planValidator.test.js src/orchestrator/planIntegrator.test.js src/orchestrator/taskStatuses.test.js src/orchestrator/scheduler.test.js src/orchestrator/attemptManager.test.js src/orchestrator/resultAggregator.test.js src/orchestrator/approvalPolicy.test.js src/orchestrator/dispatcher.test.js src/orchestrator/objectiveResolver.test.js src/orchestrator/providers/fakeRuntimeProvider.test.js src/orchestrator/providers/runtimeProviders.test.js src/orchestrator/providers/dispatcherExternalRuntime.test.js src/orchestrator/providers/deepAgentsProvider.test.js src/commands/slash.test.js src/shell/repl.test.js src/shell/setupWizardModality.test.js src/shell/setupWizardPlaceholders.test.js src/shell/setupWizardSuggestions.test.js src/shell/setupWizardDiscovery.test.js src/shell/wrapText.test.js src/runtime/lifecycle.test.js src/runtime/store.test.js src/runtime/workspaceIsolation.test.js src/runtime/controlMessages.test.js src/runtime/recoveryManager.test.js src/runtime/server.test.js src/runtime/supervisor.test.js src/runtime/delegation.test.js src/runtime/runner.test.js src/runtime/runner.e2e.test.js src/runtime/skillChain.e2e.test.js src/runtime/donna-contract.test.js src/runtime/approvals.test.js src/runtime/auth.test.js src/runtime/totp.test.js src/runtime/loginSession.test.js src/runtime/loginRoutes.test.js",
+    "test": "node --test src/core/skillInvocation.test.js src/core/skillCompiler.test.js src/runtime/skillRun.test.js src/runtime/controlDrain.test.js src/runtime/controlCancellation.test.js src/cli/runtimeStartup.test.js src/cli/wiki-manager.test.js src/agent/graph.test.js src/agent/skillRecursion.test.js src/contracts/schemas.test.js src/core/activity.test.js src/core/env.test.js src/core/agentsCompose.test.js src/core/profileServiceStatus.test.js src/core/workspaceProfile.test.js src/core/buildInfo.test.js src/core/agentEvents.test.js src/core/skillChainView.test.js src/core/runtimeLog.test.js src/core/runtimeEventAdapter.test.js src/activity/activityAggregator.test.js src/graph/runGraphProjector.test.js src/core/workflow.test.js src/core/planPatch.test.js src/core/agentLoop.test.js src/core/plan.test.js src/core/mcp.test.js src/core/toolLoop.test.js src/core/documentIntake.test.js src/core/dockerCompose.test.js src/core/otherWorkspacesRunning.test.js src/core/wikiSetup.test.js src/core/wikiWorkspace.test.js src/core/wikiWorkspaceStart.test.js src/core/wikirc.test.js src/core/workspaceInherit.test.js src/core/cacert.test.js src/core/composeOverrides.test.js src/core/setEnvValue.test.js src/core/commandFailure.test.js src/core/currentArtifact.test.js src/core/googleGrants.test.js src/core/modelFetch.test.js src/core/startupCheck.test.js src/core/queueStore.test.js src/orchestrator/agentRegistry.test.js src/orchestrator/capabilityRegistry.test.js src/orchestrator/capabilityResolver.test.js src/orchestrator/planValidator.test.js src/orchestrator/planIntegrator.test.js src/orchestrator/taskStatuses.test.js src/orchestrator/scheduler.test.js src/orchestrator/attemptManager.test.js src/orchestrator/resultAggregator.test.js src/orchestrator/approvalPolicy.test.js src/orchestrator/dispatcher.test.js src/orchestrator/objectiveResolver.test.js src/orchestrator/providers/fakeRuntimeProvider.test.js src/orchestrator/providers/runtimeProviders.test.js src/orchestrator/providers/dispatcherExternalRuntime.test.js src/orchestrator/providers/deepAgentsProvider.test.js src/commands/slash.test.js src/shell/repl.test.js src/shell/setupWizardModality.test.js src/shell/setupWizardPlaceholders.test.js src/shell/setupWizardSuggestions.test.js src/shell/setupWizardDiscovery.test.js src/shell/wrapText.test.js src/runtime/lifecycle.test.js src/runtime/store.test.js src/runtime/workspaceIsolation.test.js src/runtime/controlMessages.test.js src/runtime/deltaCoalescer.test.js src/runtime/recoveryManager.test.js src/runtime/server.test.js src/runtime/supervisor.test.js src/runtime/delegation.test.js src/runtime/runner.test.js src/runtime/runner.e2e.test.js src/runtime/skillChain.e2e.test.js src/runtime/donna-contract.test.js src/runtime/approvals.test.js src/runtime/auth.test.js src/runtime/totp.test.js src/runtime/loginSession.test.js src/runtime/loginRoutes.test.js",
     "check-versions": "node scripts/check-versions.js",
     "prepack": "node scripts/check-versions.js",
     "prepublishOnly": "node scripts/check-versions.js",

package/src/agent/graph.js

@@ -31,6 +31,7 @@ import { artifactFromToolCall, currentArtifactFor, currentArtifactPromptLine, re
 import { capabilityRegistryForSession } from '../orchestrator/capabilityRegistry.js';
 import { objectiveForResolution } from '../orchestrator/objectiveResolver.js';
 import { fetchRuntimeState, postRuntimeCancel, postRuntimeControl, postRuntimeDelegate, postRuntimeKill, postRuntimeSkill } from '../runtime/client.js';
+import { formatPublicSkillInvocation, generateSkillAcknowledgment } from '../runtime/skillRun.js';
 
 const MAX_TOOL_ITERATIONS = 80;
 /**
@@ -435,6 +436,19 @@ export function bareToolCallJson(content, tools = []) {
   return hasArguments ? name : null;
 }
 
+/**
+ * A model that has NO tool to call sometimes writes the call as text:
+ * `runtime__delegate{"objective":"…"}`. Unlike `bareToolCallJson` it is not
+ * JSON and cannot be validated against the offered set (there is none), but the
+ * `<namespace>__<tool>{` shape is never legitimate prose. Observed after a
+ * terminal failure stripped the tools from the synthesis turn: the raw call
+ * reached the user and nothing ran.
+ */
+export function narratedToolCallText(content) {
+  const match = String(content ?? '').trim().match(/^([a-z][a-z0-9_-]*__[a-z][a-z0-9_-]*)\s*\{/i);
+  return match ? match[1] : null;
+}
+
 function parseActionJson(text) {
   const cleaned = String(text ?? '').trim().replace(/^```(?:json)?\s*/i, '').replace(/\s*```$/, '');
   if (!cleaned) return null;
@@ -978,7 +992,7 @@ export async function handleRuntimeControlTool(session, tool, args = {}) {
     }
     if (tool === 'run_skill') {
       const skillName = String(args.skillName ?? '').trim();
-      if (!skillName) return JSON.stringify({ ok: false, terminal: true, code: 'skill_not_found', availableSkills: [] });
+      if (!skillName) return JSON.stringify({ ok: false, terminal: false, code: 'skill_not_found', message: 'skillName is required: pass the exact skill name, or delegate the objective with runtime__delegate.', availableSkills: [] });
       const selectedSkill = findSkill(session, skillName);
       const suppliedArguments = args.arguments && typeof args.arguments === 'object' && !Array.isArray(args.arguments)
         ? args.arguments
@@ -1377,24 +1391,6 @@ export function buildAgentSystemPrompt(state) {
   return customPrompt ? `${customPrompt}\n\n${agentContext}` : agentContext;
 }
 
-export function buildLimitedAgentResponse(state, reason = 'no workspace loaded with .wikirc.yaml') {
-  const workspace = state.session.workspace ?? 'no workspace selected';
-  const wikirc = state.session.wikirc?.profile ?? 'no profile loaded';
-  return [
-    `Donna is active. Current workspace: ${workspace}.`,
-    `Current wikirc profile: ${wikirc}.`,
-    '',
-    'I am the shell agent mode: use `/agent` to route free text through this LangGraph graph, or `/chat` for direct chat.',
-    `LLM connection: limited mode (${reason}).`,
-    `Available primitives: ${commandList(state.session)}.`,
-    '',
-    'Connected MCP tools:',
-    formatMcpToolsForAgent(state.session.mcp),
-    '',
-    'Limited mode: workspace, Docker Compose tools, MCP calls, /wiki fallback, skill discovery, and headless mode are wired.',
-    'Use `/help` to see deterministic shell commands.',
-  ].join('\n');
-}
 
 export function formatLlmUnavailableMessage(reason) {
   const clean = String(reason ?? 'unknown reason').replace(/\s+/g, ' ').trim();
@@ -1713,10 +1709,14 @@ export function createAgentGraph(options = {}) {
       // text really is a call to one of them: a legitimate answer that happens
       // to contain JSON (a config excerpt, an API sample) must go through
       // untouched, which is why this is not a "content starts with {" test.
-      const bareCall = tools.length > 0 ? bareToolCallJson(result.content, tools) : null;
+      const bareCall = (tools.length > 0 ? bareToolCallJson(result.content, tools) : null)
+        ?? narratedToolCallText(result.content);
       if (bareCall) {
         const retries = Number(state.invalidToolCallRetries ?? 0);
-        if (retries < 2) {
+        // Retry only when a tool can still be called; when none are offered (the
+        // synthesis turn after a terminal failure) the call is unexecutable and
+        // the honest failure below is the whole answer.
+        if (tools.length > 0 && retries < 2) {
           state.session._onStreamReset?.();
           state.session._onStep?.('Agent: tool call written as JSON text rejected; retrying…');
           return {
@@ -1903,6 +1903,7 @@ export function createAgentGraph(options = {}) {
     const toolCalls = state.pendingToolCalls ?? [];
     const toolResultMessages = [];
     let terminalFailure = null;
+    let skillLaunch = null;
 
     for (const call of toolCalls) {
       const resolved = resolveToolCallName(state.session.mcp, call.function.name, INTERNAL_TOOL_SERVERS);
@@ -2017,6 +2018,24 @@ export function createAgentGraph(options = {}) {
             if (skillResult?.terminal === true) {
               terminalFailure = skillResult.code ?? 'skill_failed';
               ok = false;
+            } else if (skillResult?.accepted === true) {
+              // The skill owns execution from here. Without this the turn kept
+              // going and the model could re-delegate or refuse the very
+              // objective it had just launched — the "launched, then no agent
+              // capable" contradiction. End the turn with the launch
+              // acknowledgement instead of another tool round.
+              skillLaunch = {
+                publicInput: formatPublicSkillInvocation(
+                  skillResult.skill ?? args.skillName ?? '',
+                  args.arguments && typeof args.arguments === 'object' ? args.arguments : {},
+                ),
+                objectives: Number(skillResult.objectiveCount ?? skillResult.objectives ?? 1) || 1,
+              };
+            } else if (skillResult?.ok === false) {
+              // A recoverable refusal (guessed skill, missing input): keep the
+              // turn alive so the model can correct itself or delegate, but do
+              // not let the progress note call it a success.
+              ok = false;
             }
           }
           if (tool === 'delegate' && /^Runtime control error \(delegate\):/i.test(resultText)) {
@@ -2181,6 +2200,24 @@ export function createAgentGraph(options = {}) {
         invalidResponseRetries: 0,
       };
     }
+    if (skillLaunch) {
+      // Deterministic, localized acknowledgement, generated in the session
+      // language like the `/turn` skill path. No further model turn: the skill
+      // is launched and owns execution, so nothing can contradict it.
+      const response = await generateSkillAcknowledgment(state.session, skillLaunch).catch(
+        () => `Started ${skillLaunch.publicInput} — ${skillLaunch.objectives} step(s) in progress.`,
+      );
+      return {
+        messages: toolResultMessages,
+        pendingToolCalls: null,
+        response,
+        forceDelegation: false,
+        retryWithoutTool: false,
+        terminalToolFailure: false,
+        invalidToolCallRetries: 0,
+        invalidResponseRetries: 0,
+      };
+    }
     return {
       messages: toolResultMessages,
       pendingToolCalls: null,
@@ -2193,6 +2230,9 @@ export function createAgentGraph(options = {}) {
   }
 
   function routeToolExecutor(state) {
+    // A skill launch already produced its final acknowledgement: end the turn
+    // instead of routing back for another model call that could contradict it.
+    if (state.response != null) return END;
     return 'orchestrator';
   }
 

package/src/agent/graph.test.js

@@ -624,7 +624,10 @@ test('an explicitly selected skill runs through the intra-runtime path with name
     },
   });
   const result = await createAgentGraph().invoke({ input: 'lance le skill deliver avec le template Quarterly report', session });
-  assert.equal(result.response, 'Skill mis en file.');
+  // Launching a skill ends the turn: the acknowledgement is generated once and
+  // the model is not given a second chance to re-delegate or contradict it.
+  assert.equal(result.response, 'Started /deliver deliverable="Quarterly report" — 1 step(s) queued.');
+  assert.equal(mainCalls, 1);
   // `skillStack` accompagne désormais la demande : le run imbriqué démarre après
   // le nettoyage de celui-ci, et c'est le seul canal par lequel il peut savoir
   // quelles compétences sont déjà ouvertes au-dessus de lui.
@@ -706,6 +709,73 @@ test('a terminal skill refusal stops the whole turn before a delegate fallback',
   assert.equal(delegated, false);
 });
 
+test('a narrated tool call on the tool-less synthesis turn is never shown, and nothing runs', async () => {
+  // After a terminal failure the synthesis turn offers no tools; a model that
+  // still wants to act writes the call as text (`runtime__delegate{"…"}`) and
+  // the turn did nothing. That raw call must never reach the user.
+  let delegated = false;
+  const narrated = 'runtime__delegate{"objective":"nettoyer le wiki"}';
+  const session = sessionBase({
+    runtime: { url: 'http://runtime.test' },
+    _runSkillWithinRun: async () => ({ ok: false, terminal: true, code: 'skill_not_found', availableSkills: [] }),
+    _delegateWithinRun: async () => { delegated = true; return { runId: 'bad' }; },
+    llm: {
+      async completeWithTools({ tools }) {
+        if (tools.some((tool) => tool.function?.name === 'classify_action_request')) {
+          return { content: null, message: { role: 'assistant', content: null }, tool_calls: [{ id: 'classify', type: 'function', function: { name: 'classify_action_request', arguments: '{"action":true}' } }] };
+        }
+        if (tools.length > 0) {
+          return { content: null, message: { role: 'assistant', content: null }, tool_calls: [
+            { id: 'missing', type: 'function', function: { name: 'runtime__run_skill', arguments: '{"skillName":"missing","selectionKind":"explicit_name"}' } },
+          ] };
+        }
+        return { content: narrated, message: { role: 'assistant', content: narrated }, tool_calls: null };
+      },
+    },
+  });
+  const result = await createAgentGraph().invoke({ input: 'nettoie le wiki', session });
+  assert.equal(delegated, false);
+  assert.match(result.response, /printed an internal tool request/);
+  assert.doesNotMatch(result.response, /runtime__delegate/);
+});
+
+test('a recoverable skill refusal lets the delegate fallback run in the same turn', async () => {
+  // The observed defect: the model guessed `/diagnose`, the skill runner
+  // answered skill_not_found, and because that was terminal the tools were
+  // stripped from the next turn — the model then wrote
+  // `runtime__delegate{...}` as plain text and the turn did nothing. A guessed
+  // skill must be recoverable so the fallback can actually run.
+  let delegated = false;
+  const session = sessionBase({
+    runtime: { url: 'http://runtime.test' },
+    _runSkillWithinRun: async () => ({
+      ok: false,
+      terminal: false,
+      code: 'skill_not_found',
+      message: 'No skill named "/diagnose". Pass the exact name without a leading slash, or delegate the objective with runtime__delegate.',
+      availableSkills: ['diagnose'],
+    }),
+    _delegateWithinRun: async () => { delegated = true; return { runId: 'run-1', summary: { tasks: 1, agent: 'gateway' } }; },
+    llm: {
+      async completeWithTools({ tools }) {
+        if (tools.some((tool) => tool.function?.name === 'classify_action_request')) {
+          return { content: null, message: { role: 'assistant', content: null }, tool_calls: [{ id: 'classify', type: 'function', function: { name: 'classify_action_request', arguments: '{"action":true}' } }] };
+        }
+        return {
+          content: null, message: { role: 'assistant', content: null },
+          tool_calls: [
+            { id: 'guess', type: 'function', function: { name: 'runtime__run_skill', arguments: '{"skillName":"/diagnose","arguments":{}}' } },
+            { id: 'fallback', type: 'function', function: { name: 'runtime__delegate', arguments: '{"objective":"nettoyer le wiki, corriger les doublons et les affirmations non sourcées"}' } },
+          ],
+        };
+      },
+    },
+  });
+  const result = await createAgentGraph().invoke({ input: 'nettoie le wiki, corrige les doublons et les affirmations non sourcées', session });
+  assert.equal(delegated, true);
+  assert.notEqual(result.terminalToolFailure, true);
+});
+
 test('tool argument normalization repairs only an unambiguous schema-compatible field name', () => {
   const schema = {
     type: 'object',

package/src/cli/wiki-manager.js

@@ -29,6 +29,8 @@ import { extractActivity, mergePolledActivity, parseJsonText, sessionActivities,
 import { syncActivitiesToPlan, formatPlanStatus } from '../core/plan.js';
 import { createAgentEvent, dispatchAgentEvent, reduceAgentEvents } from '../core/agentEvents.js';
 import { runAgentTurn, runAgenticLoop } from '../core/agentLoop.js';
+import { createDeltaCoalescer } from '../runtime/deltaCoalescer.js';
+import { TERMINAL_STATUS_SET } from '../orchestrator/taskStatuses.js';
 import { resolveCapabilityConcurrency } from '../orchestrator/scheduler.js';
 import { capabilityRegistryForSession } from '../orchestrator/capabilityRegistry.js';
 import { CapabilityUnavailableError, resolve as resolveCapability } from '../orchestrator/capabilityResolver.js';
@@ -827,7 +829,7 @@ async function runHeadless(argv, agent) {
 // export finished, before the ingest had even started. The control queue is the
 // only place where the whole chain is observable, so the wait is scoped to
 // chainId and ends when every item of that chain is terminal.
-const CHAIN_TERMINAL_STATUSES = new Set(['done', 'failed', 'cancelled', 'skipped']);
+const CHAIN_TERMINAL_STATUSES = TERMINAL_STATUS_SET;
 
 export async function waitForRuntimeChain(session, log, {
   chainId,
@@ -1739,7 +1741,21 @@ async function runRuntime(argv, agent) {
       workspace: context.workspace ?? ephemeral.workspace ?? null,
     }));
     const messages = conversationSeed({ agentProjection: persistedProjection }, input);
+    // Streaming fragments are coalesced before they are persisted and pushed —
+    // one synchronous SQLite insert (plus one SSE write) per token stalled the
+    // event loop, freezing both chats (serve and ShellUI) while a long answer
+    // was still being produced. Flushed before any non-delta event so ordering
+    // and the final tail are preserved.
+    const deltaCoalescer = createDeltaCoalescer((delta) => dispatchAgentEvent(ephemeral, createAgentEvent('assistant_delta', {
+      origin: 'runtime_turn',
+      turnId,
+      workspace: context.workspace ?? null,
+      payload: { delta },
+    })), { intervalMs: 80 });
     ephemeral._onAgentEvent = (event) => {
+      // Never let a final message (or any other event) overtake the buffered
+      // fragments that precede it: flush them first, in order.
+      if (event.type !== 'assistant_delta' && event.type !== 'assistant_delta_reset') deltaCoalescer.flush();
       const interactiveEvent = {
         ...event,
         origin: 'runtime_turn',
@@ -1785,28 +1801,30 @@ async function runRuntime(argv, agent) {
       response = await runHeadlessChatTurn(ephemeral, input, {
         history,
         onStep: ephemeral._onStep,
-        // Fragments de réponse publiés au fil de l'eau. Le réducteur les
-        // agrège dans la dernière entrée de conversation (`assistant_delta`),
-        // que `assistant_message` vient ensuite figer : les deux interfaces
-        // voient la réponse s'écrire, au lieu d'attendre le tour complet.
-        onTextDelta: (delta) => dispatchAgentEvent(ephemeral, createAgentEvent('assistant_delta', {
-          origin: 'runtime_turn',
-          turnId,
-          workspace: context.workspace ?? null,
-          payload: { delta },
-        })),
-        onTextReset: () => dispatchAgentEvent(ephemeral, createAgentEvent('assistant_delta_reset', {
-          origin: 'runtime_turn',
-          turnId,
-          workspace: context.workspace ?? null,
-          payload: {},
-        })),
+        // Fragments de réponse publiés au fil de l'eau, coalescés (voir
+        // deltaCoalescer ci-dessus). Le réducteur les agrège dans la dernière
+        // entrée de conversation (`assistant_delta`), que `assistant_message`
+        // vient ensuite figer : les deux interfaces voient la réponse s'écrire
+        // sans qu'un insert SQLite par token ne bloque le flux.
+        onTextDelta: (delta) => deltaCoalescer.push(delta),
+        onTextReset: () => {
+          deltaCoalescer.reset();
+          dispatchAgentEvent(ephemeral, createAgentEvent('assistant_delta_reset', {
+            origin: 'runtime_turn',
+            turnId,
+            workspace: context.workspace ?? null,
+            payload: {},
+          }));
+        },
         openWikiPages,
       });
     } else {
       ephemeral.openWikiPages = openWikiPages;
       response = await runAgentTurn(agent, ephemeral, input, { messages, signal });
     }
+    // Flush the tail before the turn is finalized, then stop the timer.
+    deltaCoalescer.flush();
+    deltaCoalescer.dispose();
     // Persist the artifact the turn may have opened/edited (template_write,
     // template_read, …) back onto the long-lived session, so the next /turn —
     // chat or agent — sees it. The ephemeral session is otherwise discarded.

package/src/core/agentEvents.js

@@ -1,11 +1,12 @@
 import { normalizeActivity } from './activity.js';
+import { cloneJson } from './json.js';
 import { attachActivityToExistingPlan, syncActivitiesToPlan } from './plan.js';
 import { applyPlanPatch, normalizePlanPatch, normalizePlanRevision, rebasePlanPatch } from './planPatch.js';
 import { formatRuntimeLogPayload, isDispatchPlumbingLine, normalizeRuntimeLog, shortTaskLabel } from './runtimeLog.js';
 import { projectSkillChains, TERMINAL as CONTROL_TERMINAL_STATUSES } from './skillChainView.js';
 import { projectWorkflow } from './workflow.js';
 import { validateContractInDev } from '../contracts/schemas.js';
-import { isTerminal, isSuccessful, isUnknownStatus, normalizeTaskStatus } from '../orchestrator/taskStatuses.js';
+import { isActive, isTerminal, isSuccessful, isUnknownStatus, normalizeTaskStatus } from '../orchestrator/taskStatuses.js';
 
 const SESSION_PROJECTION_EVENTS = new Set([
   'run_started',
@@ -291,6 +292,11 @@ export function applyAgentProjectionToSession(session, projection) {
   } : session.productionActivity ?? null;
 }
 
+function hasRunningPlanStep(state) {
+  return (Array.isArray(state.plan) ? state.plan : [])
+    .some((step) => isActive(step?.status));
+}
+
 function applyEvent(state, event) {
   switch (event.type) {
     case 'run_started':
@@ -597,6 +603,13 @@ function applyEvent(state, event) {
         reason: event.payload?.reason ?? null,
         createdAt: event.ts,
       });
+      // A run waiting for a human is not "running": showing it as running is
+      // how the chat could claim a rebuild was executing before anyone
+      // approved it. Mirror `run_pending_approval` (AGENTS.md: the run status
+      // is pending_approval while the decision is outstanding), but only when
+      // no task is actually executing — a parallel run may have work in flight
+      // while one branch waits.
+      if (!hasRunningPlanStep(state)) state.status = 'pending_approval';
       return;
     case 'approval.granted': {
       const grant = {
@@ -616,6 +629,13 @@ function applyEvent(state, event) {
       };
       upsertApproval(state, grant);
       markCoveredApprovalsApproved(state.approvals, grant, event.ts);
+      // The decision is in: the run goes back to running unless another
+      // approval is still outstanding (a run-scoped grant clears its covered
+      // ones, markCoveredApprovalsApproved above).
+      if (state.status === 'pending_approval'
+        && !(state.approvals ?? []).some((approval) => approval.status === 'pending_approval')) {
+        state.status = 'running';
+      }
       return;
     }
     case 'approval.rejected':
@@ -1240,6 +1260,3 @@ function sortedActivities(activities) {
     .sort((a, b) => String(a.updatedAt ?? '').localeCompare(String(b.updatedAt ?? '')));
 }
 
-function cloneJson(value) {
-  return value == null ? value : JSON.parse(JSON.stringify(value));
-}

package/src/core/agentEvents.test.js

@@ -127,6 +127,40 @@ test('reduceAgentEvents: interactive (user) run_started clears state but is not
   assert.notEqual(projection.status, 'running');
 });
 
+test('reduceAgentEvents: a run blocked on approval is not shown as running', () => {
+  // The chat claimed a rebuild was executing while its only task was still
+  // waiting for a human: the run status stayed 'running' through the per-task
+  // approval request. It must mirror run_pending_approval.
+  const projection = reduceAgentEvents([
+    createAgentEvent('run_started', { origin: 'runtime' }),
+    createAgentEvent('plan_set', { origin: 'tool', payload: { steps: ['Rebuild the concepts'] } }),
+    createAgentEvent('plan_step_updated', { origin: 'runtime', payload: { step: 1, status: 'waiting_approval' } }),
+    createAgentEvent('approval.requested', { origin: 'runtime', payload: { id: 'a1', scope: 'task', taskId: 't1' } }),
+  ]);
+  assert.equal(projection.status, 'pending_approval');
+});
+
+test('reduceAgentEvents: granting the approval puts the run back to running', () => {
+  const projection = reduceAgentEvents([
+    createAgentEvent('run_started', { origin: 'runtime' }),
+    createAgentEvent('plan_set', { origin: 'tool', payload: { steps: ['Rebuild the concepts'] } }),
+    createAgentEvent('plan_step_updated', { origin: 'runtime', payload: { step: 1, status: 'waiting_approval' } }),
+    createAgentEvent('approval.requested', { origin: 'runtime', payload: { id: 'a1', scope: 'task', taskId: 't1' } }),
+    createAgentEvent('approval.granted', { origin: 'runtime', payload: { id: 'a1', scope: 'task', taskId: 't1' } }),
+  ]);
+  assert.equal(projection.status, 'running');
+});
+
+test('reduceAgentEvents: an approval request does not hide a genuinely running task', () => {
+  const projection = reduceAgentEvents([
+    createAgentEvent('run_started', { origin: 'runtime' }),
+    createAgentEvent('plan_set', { origin: 'tool', payload: { steps: ['Export', 'Build'] } }),
+    createAgentEvent('plan_step_updated', { origin: 'runtime', payload: { step: 1, status: 'running' } }),
+    createAgentEvent('approval.requested', { origin: 'runtime', payload: { id: 'a1', scope: 'task', taskId: 't2' } }),
+  ]);
+  assert.equal(projection.status, 'running');
+});
+
 test('reduceAgentEvents: tracks manual plan and step updates', () => {
   const projection = reduceAgentEvents([
     createAgentEvent('plan_set', {

package/src/core/buildInfo.json

@@ -1,4 +1,4 @@
 {
-  "version": "0.15.94",
-  "commit": "00c41b1"
+  "version": "0.15.97",
+  "commit": "b90e735"
 }

package/src/core/googleGrants.js

@@ -33,6 +33,3 @@ export function defaultGoogleGrants() {
   return [...GOOGLE_GRANTS];
 }
 
-export function describeGoogleGrant(grant) {
-  return GOOGLE_GRANT_LABELS[grant] ?? null;
-}

package/src/core/json.js

@@ -0,0 +1,9 @@
+/*
+ * Deep clone via a JSON round-trip; `null`/`undefined` pass through.
+ *
+ * Three modules had grown their own byte-identical copy (agentEvents,
+ * agentRegistry, planValidator). One implementation, imported.
+ */
+export function cloneJson(value) {
+  return value == null ? value : JSON.parse(JSON.stringify(value));
+}

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.15.94';
+const WIKI_MANAGER_VERSION = '0.15.97';
 
 function envValue(key) {
   const filePath = managerEnvFile();

package/src/core/plan.js

@@ -48,10 +48,6 @@ export function extractHeadlessPlan(text) {
   return steps;
 }
 
-export function matchCompletedToPlan(plan, completed) {
-  if (!plan) return;
-  syncActivitiesToPlan(plan, completed.filter((activity) => activity.terminal));
-}
 
 export function syncActivitiesToPlan(plan, activities) {
   if (!plan) return;

package/src/core/progressNotes.js

@@ -48,7 +48,3 @@ export function toolResultNote(name, ok, detail) {
   return reason ? `${tool} done: ${reason}` : `${tool} done.`;
 }
 
-export function turnDoneNote(steps) {
-  if (!steps) return 'Done.';
-  return `Done — ${steps} step${steps > 1 ? 's' : ''}.`;
-}