@dotdrelle/wiki-manager 0.15.96 → 0.15.98

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotdrelle/wiki-manager",
-  "version": "0.15.96",
+  "version": "0.15.98",
   "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/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",
+    "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/testGate.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/mcpEndpoints.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/controlClassify.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

@@ -436,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;
@@ -979,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
@@ -1696,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 {
@@ -2014,6 +2031,18 @@ export function createAgentGraph(options = {}) {
                 ),
                 objectives: Number(skillResult.objectiveCount ?? skillResult.objectives ?? 1) || 1,
               };
+            } else if (skillResult?.ok === false && skillResult?.needsInput !== true) {
+              // A recoverable refusal (a guessed skill that does not exist):
+              // keep the turn alive so the model can correct itself or
+              // delegate, but do not let the progress note call it a success.
+              //
+              // `needsInput` is excluded on purpose: "ask the user for the
+              // missing scope" is a conversational blocker, and marking it
+              // failed published `runtime__run_skill failed: {…}` into the
+              // progress surfaces while the turn was working exactly as
+              // intended. The `delegate` branch below already treats the
+              // identical case that way; the two must not disagree.
+              ok = false;
             }
           }
           if (tool === 'delegate' && /^Runtime control error \(delegate\):/i.test(resultText)) {
@@ -2164,7 +2193,35 @@ export function createAgentGraph(options = {}) {
         tool_call_id: call.id,
         content: boundedResult,
       });
-      if (terminalFailure) break;
+      if (terminalFailure || skillLaunch) break;
+    }
+
+    // A skill launch owns execution and ends the turn, so the rest of the
+    // batch is NOT executed — a companion runtime__delegate in the same batch
+    // used to start a second, independent run with nothing in the thread
+    // naming it. Every unexecuted call still gets its tool result: a provider
+    // that sees tool_calls without matching results on a replayed history
+    // rejects the conversation.
+    if (skillLaunch) {
+      const executed = new Set(toolResultMessages.map((message) => message.tool_call_id));
+      const dropped = toolCalls.filter((call) => !executed.has(call.id));
+      const notRun = `Not executed: ${skillLaunch.publicInput} was launched earlier in this `
+        + 'turn and owns execution from here. Do not start a second run for the same objective.';
+      for (const call of dropped) {
+        emitAgentEvent(state.session, 'tool_call_result', 'tool', {
+          callId: call.id,
+          name: call.function?.name ?? 'tool',
+          ok: false,
+          result: notRun,
+          summary: 'skipped',
+        });
+        toolResultMessages.push({ role: 'tool', tool_call_id: call.id, content: notRun });
+      }
+      if (dropped.length > 0) {
+        state.session._onStep?.(
+          `${dropped.length} tool call(s) skipped: ${skillLaunch.publicInput} owns execution`,
+        );
+      }
     }
 
     if (terminalFailure) {
@@ -2183,7 +2240,7 @@ export function createAgentGraph(options = {}) {
       // 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.`,
+        () => `Started ${skillLaunch.publicInput} — ${skillLaunch.objectives} step(s) queued.`,
       );
       return {
         messages: toolResultMessages,

package/src/agent/graph.test.js

@@ -626,7 +626,7 @@ 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 });
   // 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) in progress.');
+  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
@@ -678,6 +678,14 @@ test('a natural-language skill match cannot drop declared scope and fall back to
     const toolResult = session.agentEvents.find((event) => event.type === 'tool_call_result');
     assert.match(toolResult?.payload?.result ?? '', /missingParameters/);
     assert.match(toolResult?.payload?.result ?? '', /never replace a missing parameter with an unscoped/);
+    // "Ask the user for the missing scope" is a conversational blocker, not an
+    // execution failure — the turn is working exactly as intended. Marking it
+    // failed published `runtime__run_skill failed: {…}` into the progress and
+    // activity surfaces; the `delegate` branch handles the identical case as a
+    // non-failure, and the two must not disagree.
+    assert.equal(toolResult?.payload?.ok, true);
+    const progress = session.agentEvents.find((event) => event.type === 'assistant_progress');
+    assert.doesNotMatch(progress?.payload?.message ?? '', /failed/i);
   } finally {
     rmSync(root, { recursive: true, force: true });
   }
@@ -709,6 +717,110 @@ 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('an ACCEPTED skill launch stops the rest of the batch, and says what it dropped', async () => {
+  // The mirror of the test above: a refusal must let the fallback run, an
+  // acceptance must not. The skill owns execution from there, but the loop
+  // kept going — a companion runtime__delegate in the same batch started a
+  // second, independent run while only the skill was acknowledged, with
+  // nothing in the thread naming the delegated one.
+  let delegated = false;
+  const session = sessionBase({
+    runtime: { url: 'http://runtime.test' },
+    _runSkillWithinRun: async () => ({ accepted: true, skill: 'pipeline', objectiveCount: 1 }),
+    _delegateWithinRun: async () => { delegated = true; return { runId: 'run-2', summary: { tasks: 1 } }; },
+    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: 'skill', type: 'function', function: { name: 'runtime__run_skill', arguments: '{"skillName":"pipeline","selectionKind":"explicit_name"}' } },
+            { id: 'also', type: 'function', function: { name: 'runtime__delegate', arguments: '{"objective":"construire le livrable"}' } },
+          ],
+        };
+      },
+    },
+  });
+  await createAgentGraph().invoke({ input: '/pipeline', session });
+  assert.equal(delegated, false, 'the delegate must not start a second run behind the skill');
+  // …and the skipped call is announced rather than silently dropped, with a
+  // tool result so a replayed history is not missing one.
+  const skipped = session.agentEvents.find(
+    (event) => event.type === 'tool_call_result' && event.payload?.callId === 'also',
+  );
+  assert.equal(skipped?.payload?.summary, 'skipped');
+  assert.match(skipped?.payload?.result ?? '', /owns execution/);
+});
+
 test('tool argument normalization repairs only an unambiguous schema-compatible field name', () => {
   const schema = {
     type: 'object',

package/src/cli/wiki-manager.js

@@ -1725,6 +1725,13 @@ async function runRuntime(argv, agent) {
   async function executeInteractiveTurn(context, body, { signal, turnId } = {}) {
     const input = String(body.input ?? body.prompt ?? '').trim();
     if (!input) throw new Error('Missing input.');
+    // The reader's own words, when the caller augmented `input` with system
+    // facts (a status question gets the runtime's fact block appended for the
+    // model). The thread, the SSE stream and the replayed history must all
+    // show what was typed — publishing the fact block as the user's message
+    // put a raw English dump in their bubble and seeded every later turn with
+    // it.
+    const displayInput = String(body.displayInput ?? '').trim() || input;
     // The runtime may start while optional agents are still stopped. `/start
     // agents` happens in the shell process, so its refreshed MCP snapshot does
     // not mutate this long-lived runtime context. Re-probe only while at least
@@ -1776,7 +1783,7 @@ async function runRuntime(argv, agent) {
       origin: 'runtime_turn',
       turnId,
       workspace: context.workspace ?? null,
-      payload: { content: input },
+      payload: { content: displayInput },
     }));
     // Read-only chat turn: same chatAccess policy as the Shell UI's /chat, now
     // reachable over HTTP so `wiki serve` chat mode gets read tools without
@@ -1792,39 +1799,46 @@ async function runRuntime(argv, agent) {
       body.context?.openWikiPages ?? body.context?.openWikiPage,
     );
     let response;
-    if (chatMode) {
-      ephemeral.chatMode = true;
-      ephemeral.chatAccess = readChatAccessConfig();
-      const history = messages.length && messages[messages.length - 1]?.role === 'user'
-        ? messages.slice(0, -1)
-        : messages;
-      response = await runHeadlessChatTurn(ephemeral, input, {
-        history,
-        onStep: ephemeral._onStep,
-        // 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 });
+    try {
+      if (chatMode) {
+        ephemeral.chatMode = true;
+        ephemeral.chatAccess = readChatAccessConfig();
+        const history = messages.length && messages[messages.length - 1]?.role === 'user'
+          ? messages.slice(0, -1)
+          : messages;
+        response = await runHeadlessChatTurn(ephemeral, input, {
+          history,
+          onStep: ephemeral._onStep,
+          // 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 });
+      }
+    } finally {
+      // In a `finally`, not after the await: a throwing or aborted turn left
+      // the 80 ms timer armed, so a stray assistant_delta fired AFTER the
+      // "Runtime turn failed" message and appended orphan fragments to the
+      // wrong conversation entry — and the handle kept the session closure
+      // alive. Flush the tail first so ordering survives either way.
+      deltaCoalescer.flush();
+      deltaCoalescer.dispose();
     }
-    // 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/commands/slash.js

@@ -9,7 +9,7 @@
  */
 import { isTerminal } from '../orchestrator/taskStatuses.js';
 import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
-import { openExternalUrl } from '../shell/openExternal.js';
+import { openAppWindowUrl, openExternalUrl } from '../shell/openExternal.js';
 import { classifyCommandFailure, failureHint, rawFailureText } from '../core/commandFailure.js';
 import { basename, join, relative } from 'node:path';
 import { composeServices, listServices, otherWorkspacesRunning, runWikiCli, serviceLogs, serviceNames, serviceStates, startService, stopService } from '../core/compose.js';
@@ -845,7 +845,7 @@ ${helpPair('/upload <path>', 'Upload document', '/uploads', 'Uploaded docs')}
 ${helpPair('/upload convert pending', 'Convert pending', '/uploads clean', 'Clean uploads')}
 ${helpPair('/wiki', 'Run wiki index', '/wiki run <args>', 'Raw wiki CLI')}
 ${helpPair('/chat', 'Chat mode', '/agent [question]', 'Agent mode / one-shot')}
-${helpPair('/openui', 'Open web UI in browser', '', '')}
+${helpPair('/openui', 'Open web UI as a desktop window', '', '')}
 ${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', '', '')}
@@ -1770,6 +1770,11 @@ export async function handleSlashCommand(line, context) {
         // No readable session (gate off, or a custom state dir): plain URL.
       }
       const note = context.session.workspaceEnv ? '' : ' (no workspace loaded — using default port)';
+      // App-mode first: a chromeless Chrome/Edge window picks up serve's own
+      // manifest (name, icon, window-controls-overlay) with no prior "Install"
+      // step. Falls back to the plain default-browser tab when neither is
+      // found (Safari/Firefox-only machines).
+      if (openAppWindowUrl(openUrl)) return { output: `Opening web UI: ${url}${note}` };
       if (openExternalUrl(openUrl)) return { output: `Opening web UI: ${url}${note}` };
       return { output: `Web UI: ${url}${note}` };
     }

package/src/core/agentEvents.js

@@ -6,7 +6,7 @@ import { formatRuntimeLogPayload, isDispatchPlumbingLine, normalizeRuntimeLog, s
 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',
@@ -292,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':
@@ -598,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 = {
@@ -617,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':
@@ -635,6 +654,17 @@ function applyEvent(state, event) {
         reason: event.payload?.reason ?? null,
         rejectedAt: event.ts,
       });
+      // Same latch release as `approval.granted`: a refusal IS a decision. Only
+      // `granted` cleared the status, so a rejected approval left the
+      // projection reporting `pending_approval` for the rest of the run —
+      // both UIs kept asking for a decision the user had already made, while
+      // `explainControlState` found no pending approval and answered "run is
+      // active". The two surfaces disagreed until some later run_done
+      // overwrote it.
+      if (state.status === 'pending_approval'
+        && !(state.approvals ?? []).some((approval) => approval.status === 'pending_approval')) {
+        state.status = 'running';
+      }
       return;
     case 'run_done':
       state.status = 'done';

package/src/core/agentEvents.test.js

@@ -127,6 +127,65 @@ 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: REJECTING the approval also puts the run back to running', () => {
+  // A refusal is a decision. Only `granted` cleared the latch, so a rejected
+  // approval left both UIs asking for a decision already made, for the rest of
+  // the run.
+  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.rejected', { origin: 'runtime', payload: { id: 'a1', scope: 'task', taskId: 't1' } }),
+  ]);
+  assert.equal(projection.status, 'running');
+});
+
+test('reduceAgentEvents: rejecting one of two approvals keeps the run blocked', () => {
+  const projection = reduceAgentEvents([
+    createAgentEvent('run_started', { origin: 'runtime' }),
+    createAgentEvent('plan_set', { origin: 'tool', payload: { steps: ['Export', 'Build'] } }),
+    createAgentEvent('approval.requested', { origin: 'runtime', payload: { id: 'a1', scope: 'task', taskId: 't1' } }),
+    createAgentEvent('approval.requested', { origin: 'runtime', payload: { id: 'a2', scope: 'task', taskId: 't2' } }),
+    createAgentEvent('approval.rejected', { origin: 'runtime', payload: { id: 'a1', scope: 'task', taskId: 't1' } }),
+  ]);
+  assert.equal(projection.status, 'pending_approval');
+});
+
+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.96",
-  "commit": "fbeddf2"
+  "version": "0.15.98",
+  "commit": "acf1986"
 }

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

package/src/core/testGate.test.js

@@ -0,0 +1,33 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { execFileSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../..');
+
+// The `npm test` argument list is hand-maintained, and it has drifted twice:
+// four files were once found outside the gate, and mcpEndpoints.test.js was
+// green on disk while nothing ran it. A test nobody runs is worse than no
+// test — it reads as coverage. This is the check that says so.
+test('every test file on disk is in the npm test gate', () => {
+  const pkg = JSON.parse(readFileSync(path.join(repoRoot, 'package.json'), 'utf8'));
+  const listed = new Set(
+    pkg.scripts.test.split(/\s+/).filter((argument) => argument.endsWith('.test.js')),
+  );
+  const onDisk = execFileSync('find', ['src', '-name', '*.test.js'], {
+    cwd: repoRoot,
+    encoding: 'utf8',
+  })
+    .trim()
+    .split('\n')
+    .filter(Boolean)
+    .sort();
+
+  const missing = onDisk.filter((file) => !listed.has(file));
+  assert.deepEqual(missing, [], `test files not run by \`npm test\`:\n${missing.join('\n')}`);
+
+  const stale = [...listed].filter((file) => !onDisk.includes(file));
+  assert.deepEqual(stale, [], `\`npm test\` names files that no longer exist:\n${stale.join('\n')}`);
+});

package/src/core/toolLoop.js

@@ -129,7 +129,13 @@ async function finalAnswerWithoutTools({
     });
     if (result?.tool_calls?.length) return '';
     return String(result?.content ?? result?.message?.content ?? '').trim();
-  } catch {
+  } catch (err) {
+    // An abort is the user cancelling, not an empty answer. Swallowing it here
+    // made `runBoundedToolLoop` return `{ content: '', capped: true }`, and the
+    // caller printed the iteration-limit notice for a turn that was cancelled
+    // — the loop's contract is that an abort escapes, and this was the one
+    // call that broke it.
+    if (err?.name === 'AbortError' || signal?.aborted) throw err;
     return '';
   }
 }