@dotdrelle/wiki-manager 0.15.97 → 0.15.98

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotdrelle/wiki-manager",
-  "version": "0.15.97",
+  "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

@@ -2031,10 +2031,17 @@ export function createAgentGraph(options = {}) {
                 ),
                 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.
+            } 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;
             }
           }
@@ -2186,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) {
@@ -2205,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

@@ -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 });
   }
@@ -776,6 +784,43 @@ test('a recoverable skill refusal lets the delegate fallback run in the same tur
   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

@@ -654,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

@@ -151,6 +151,31 @@ test('reduceAgentEvents: granting the approval puts the run back to running', ()
   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' }),

package/src/core/buildInfo.json

@@ -1,4 +1,4 @@
 {
-  "version": "0.15.97",
-  "commit": "b90e735"
+  "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.97';
+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 '';
   }
 }

package/src/runtime/controlClassify.test.js

@@ -0,0 +1,31 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { classifyControlMessage } from './server.js';
+
+const running = { running: true };
+
+// A bare "yes" answers the runtime's own last prompt. Anything MORE than a
+// bare yes is a request, and the rule used to be prefix-anchored only: every
+// message merely STARTING on a yes was classified `observe` and answered with
+// a status report, shadowing the modify_run and enqueue_run branches below it.
+test('a bare confirmation during a run is a status check', async () => {
+  for (const input of ['oui', 'OK', 'vas-y', "d'accord", 'yes.', 'entendu !']) {
+    const result = await classifyControlMessage(input, running);
+    assert.equal(result.kind, 'observe', `expected observe for ${JSON.stringify(input)}`);
+  }
+});
+
+test('a plan change that merely opens on a yes is still a plan change', async () => {
+  const result = await classifyControlMessage(
+    'oui, ajoute une étape de polish après le build',
+    running,
+  );
+  assert.equal(result.kind, 'modify_run');
+});
+
+test('a new task that opens on a yes reaches the model classifier, not the status branch', async () => {
+  const result = await classifyControlMessage("vas-y lance l'export", running, {
+    llm: { complete: async () => 'action' },
+  });
+  assert.equal(result.kind, 'enqueue_run');
+});

package/src/runtime/runner.js

@@ -9,7 +9,7 @@ import { createBudgetManager, BudgetExceededError } from '../orchestrator/budget
 import { createDispatcher } from '../orchestrator/dispatcher.js';
 import { approvalCovered, approvalRequestForTask } from '../orchestrator/approvalPolicy.js';
 import { blockedByFailedDependency, tasksAwaitingApproval } from '../orchestrator/dependencyResolver.js';
-import { isFailed, isPending, isSkipped, isSuccessful, isTerminal, isUnknownStatus } from '../orchestrator/taskStatuses.js';
+import { isCancelled, isFailed, isPending, isSkipped, isSuccessful, isTerminal, isUnknownStatus } from '../orchestrator/taskStatuses.js';
 import { assertValidatedFragment } from '../orchestrator/planValidator.js';
 import { createResultAggregator } from '../orchestrator/resultAggregator.js';
 import { describePlanConcurrency, drainActive, startReadyTasks } from '../orchestrator/scheduler.js';
@@ -308,6 +308,7 @@ export async function announceRunOutcome(session, { runId, ok, signal = null } =
   if (plan.length === 0) return;
   let failed = 0;
   let cancelled = 0;
+  let skipped = 0;
   let completed = 0;
   let pending = 0;
   let firstError = null;
@@ -319,8 +320,14 @@ export async function announceRunOutcome(session, { runId, ok, signal = null } =
         step?.error?.message ?? step?.error?.code ?? step?.error
         ?? step?.result?.error?.message ?? step?.result?.error?.code ?? '',
       ).trim() || null;
-    } else if (['cancelled', 'canceled'].includes(status)) {
+    } else if (isCancelled(status)) {
       cancelled += 1;
+    } else if (isSkipped(status)) {
+      // A chain step abandoned because an earlier required one failed. It fell
+      // through every bucket, so a 3-step chain that failed at step 1
+      // announced "0/3 réussie(s), 1 en erreur" and never mentioned the two
+      // steps nobody ran — precisely the silence the announce rule forbids.
+      skipped += 1;
     } else if (isSuccessful(status)) {
       completed += 1;
     } else if (isPending(status) || !isTerminal(status)) {
@@ -333,13 +340,15 @@ export async function announceRunOutcome(session, { runId, ok, signal = null } =
     }
   }
   const total = plan.length;
-  const finished = ok && failed === 0 && cancelled === 0 && pending === 0 && completed === total;
+  const finished = ok && failed === 0 && cancelled === 0 && skipped === 0
+    && pending === 0 && completed === total;
   const factLine = finished
     ? `Plan terminé avec succès — ${completed}/${total} tâche(s) réussie(s).`
     : `Plan non terminé — ${completed}/${total} tâche(s) réussie(s)` +
       `${pending ? `, ${pending} en attente (approbation ou exécution)` : ''}` +
       `${failed ? `, ${failed} en erreur` : ''}` +
-      `${cancelled ? `, ${cancelled} annulée(s)` : ''}.` +
+      `${cancelled ? `, ${cancelled} annulée(s)` : ''}` +
+      `${skipped ? `, ${skipped} abandonnée(s) faute d'une étape précédente` : ''}.` +
       `${firstError ? ` Première erreur : ${firstError}.` : ''}`;
   let content = factLine;
   const llm = session.llm;

package/src/runtime/runner.test.js

@@ -1306,6 +1306,26 @@ test('announceRunOutcome never calls a plan with pending tasks a success', async
   assert.doesNotMatch(message.payload.content, /succès/i);
 });
 
+test('announceRunOutcome names the steps a failed chain abandoned', async () => {
+  // `skipped` fell through every bucket: a 3-step chain failing at step 1
+  // announced "0/3 réussie(s), 1 en erreur" and never mentioned the two steps
+  // nobody ran. "When something is skipped, say so where the panels read."
+  const session = {
+    agentEvents: [],
+    agentProjection: null,
+    headlessPlan: [
+      { id: 'a', description: 'Sync', status: 'failed' },
+      { id: 'b', description: 'Ingest', status: 'skipped' },
+      { id: 'c', description: 'Build', status: 'skipped' },
+    ],
+  };
+  await announceRunOutcome(session, { runId: 'run-3', ok: false });
+  const message = session.agentEvents.find((event) => event.type === 'assistant_message');
+  assert.match(message.payload.content, /non terminé/i);
+  assert.match(message.payload.content, /1 en erreur/);
+  assert.match(message.payload.content, /2 abandonnée\(s\)/);
+});
+
 test('announceRunOutcome reports success only when every task finished', async () => {
   const session = {
     agentEvents: [],

package/src/runtime/server.js

@@ -508,6 +508,12 @@ export function startRuntimeServer({
           sendJson(response, 400, { error: 'Missing input.' });
           return;
         }
+        // What the reader actually typed. `input` below may be replaced by a
+        // system fact block for the model; the THREAD must still show the
+        // reader's own words — the replacement was persisted as the
+        // `user_message` and replayed as history on every later turn, which is
+        // exactly the "raw facts never enter the thread" rule it broke.
+        const displayInput = input;
         // Read-only chat turns intentionally remain available while an agent
         // run is active. Other interactive turns still become control
         // messages so they cannot start a competing agent decision.
@@ -603,7 +609,12 @@ export function startRuntimeServer({
               return result.body;
             }
           }
-          return turn(context, { ...body, input, mode: readOnlyChat ? 'chat' : body.mode }, {
+          return turn(context, {
+            ...body,
+            input,
+            displayInput,
+            mode: readOnlyChat ? 'chat' : body.mode,
+          }, {
             signal: controller.signal,
             turnId,
           });
@@ -1789,7 +1800,7 @@ function asksForRunStatus(input) {
 // semantic judgement about the workspace's domain, so it is never a keyword
 // list here — it goes to the model, bounded, and falls back to the choice menu
 // (`ambiguous`) rather than guessing when no model is available.
-async function classifyControlMessage(input, status, { forcedIntent = null, llm = null, session = null } = {}) {
+export async function classifyControlMessage(input, status, { forcedIntent = null, llm = null, session = null } = {}) {
   // Caller (the /control message route) already trims and rejects empty input.
   const lower = String(input ?? '').toLowerCase();
   const intent = forcedIntent ? String(forcedIntent).toLowerCase() : null;
@@ -1823,7 +1834,10 @@ async function classifyControlMessage(input, status, { forcedIntent = null, llm
   // active, the only thing the runtime can act on is a status check: treating
   // the word as ordinary conversation made the read-only chat fallback lecture
   // the user about switching modes instead of answering.
-  if (status.running && /^\s*(oui|yes|yep|ok|okay|vas[- ]?y|d'accord|daccord|entendu)\b/i.test(lower)) {
+  // Anchored at BOTH ends: "oui" is a confirmation, "oui, ajoute une étape de
+  // polish" is a plan change. Without the end anchor this branch shadowed
+  // modify_run and enqueue_run for every message merely STARTING on a yes.
+  if (status.running && /^\s*(oui|yes|yep|ok|okay|vas[- ]?y|d'accord|daccord|entendu)\s*[.!…]*\s*$/i.test(lower)) {
     return { kind: 'observe', confidence: 0.7, reason: 'confirmation_of_runtime_prompt' };
   }
   if (status.running && /\b(ajoute|add|change|modifie|modify|remplace|replace|retire|remove|skip|ignore|apr[eè]s|before|after|chaque|each|plan|step|t[aâ]che)\b/i.test(lower)) {

package/src/runtime/server.test.js

@@ -1747,6 +1747,7 @@ test('POST /turn hands a run status question to Donna with the runtime facts', a
   };
   let turns = 0;
   let turnInput = '';
+  let turnDisplayInput = '';
   let turnMode = null;
   let handle;
   try {
@@ -1755,7 +1756,13 @@ test('POST /turn hands a run status question to Donna with the runtime facts', a
       store: { dbPath: ':memory:', getState: () => status, listEvents: () => [] },
       getContext: async () => context,
       run: async () => new Promise(() => {}),
-      turn: async (_context, options) => { turns += 1; turnInput = options.input; turnMode = options.mode; return { ok: true }; },
+      turn: async (_context, options) => {
+        turns += 1;
+        turnInput = options.input;
+        turnDisplayInput = options.displayInput;
+        turnMode = options.mode;
+        return { ok: true };
+      },
     });
   } catch (err) {
     if (err?.code === 'EPERM') { t.skip('network listen is not permitted in this sandbox'); return; }
@@ -1778,6 +1785,11 @@ test('POST /turn hands a run status question to Donna with the runtime facts', a
     assert.equal(turnMode, 'chat');
     assert.match(turnInput, /Build TechSections/);
     assert.match(turnInput, /runtime run, not a production job/i);
+    // …and the THREAD still shows what the reader typed. `executeInteractiveTurn`
+    // persists `displayInput` as the user_message; feeding it the fact block
+    // put a raw English dump in the reader's own bubble and replayed it as
+    // history on every later turn.
+    assert.equal(turnDisplayInput, 'donne le status du job en cours');
   } finally {
     context.currentAbortController?.abort();
     await handle.close();

package/src/shell/openExternal.js

@@ -51,3 +51,46 @@ export function openExternalUrl(value, { run = execFileSync } = {}) {
   }
   return null;
 }
+
+// A Chromium `--app=<url>` window is chromeless from the start — no tab
+// strip, no address bar — and, when the origin serves a manifest (llm-wiki's
+// `/manifest.webmanifest`), it picks up the site's name/icon/theme-color and
+// window-controls-overlay exactly like a formally "installed" PWA, with no
+// prior install step required. `/openui`'s whole point is a desktop-feeling
+// window, so it tries this before falling back to `openExternalUrl`'s plain
+// tab. Same candidate/fallback shape as `openerCandidates` above, and the same
+// contract: returns the opened URL, or null when no Chromium browser answered.
+function appModeCandidates() {
+  if (process.platform === 'darwin') {
+    return [
+      ['open', ['-na', 'Google Chrome', '--args']],
+      ['open', ['-na', 'Microsoft Edge', '--args']],
+    ];
+  }
+  if (process.platform === 'win32') {
+    return [
+      ['cmd', ['/c', 'start', '', 'chrome']],
+      ['cmd', ['/c', 'start', '', 'msedge']],
+    ];
+  }
+  return [
+    ['google-chrome', []],
+    ['chromium', []],
+    ['chromium-browser', []],
+    ['microsoft-edge', []],
+  ];
+}
+
+export function openAppWindowUrl(value, { run = execFileSync } = {}) {
+  const url = normalizeExternalUrl(value);
+  if (!url) return null;
+  for (const [command, args] of appModeCandidates()) {
+    try {
+      run(command, [...args, `--app=${url}`], { stdio: 'ignore', timeout: 5_000 });
+      return url;
+    } catch {
+      // Missing binary or non-zero exit: try the next candidate.
+    }
+  }
+  return null;
+}

package/src/shell/repl.js

@@ -94,7 +94,7 @@ const COMMAND_COMPLETION_DESCRIPTIONS = {
   '/clear': 'Clear the conversation screen.',
   '/chat': 'Switch free text to direct LLM chat without tools.',
   '/agent': 'Switch to agent mode, or run one agent request with /agent <question>.',
-  '/openui': 'Open the workspace web UI in the browser.',
+  '/openui': 'Open the workspace web UI as a chromeless desktop window (Chrome/Edge), or a browser tab as fallback.',
   '/run': 'Inspect, cancel, kill runtime runs, or start a capability run.',
   '/approve': 'Approve a pending runtime run or tool.',
 };