@dotdrelle/wiki-manager 0.15.96 → 0.15.97

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotdrelle/wiki-manager",
-  "version": "0.15.96",
+  "version": "0.15.97",
   "description": "Agentic shell and orchestration cockpit for llm-wiki workspaces.",
   "repository": {
     "type": "git",

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,11 @@ 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.
+              ok = false;
             }
           }
           if (tool === 'delegate' && /^Runtime control error \(delegate\):/i.test(resultText)) {

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
@@ -709,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/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':

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.96",
-  "commit": "fbeddf2"
+  "version": "0.15.97",
+  "commit": "b90e735"
 }

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

package/src/runtime/server.js

@@ -7,6 +7,7 @@ import { validateContractInDev } from '../contracts/schemas.js';
 import { runtimeTokenFromEnv } from './auth.js';
 import { controlMessage } from './controlMessages.js';
 import { tasksAwaitingApproval } from '../orchestrator/dependencyResolver.js';
+import { isActive, isCancelled, isFailed, isSuccessful } from '../orchestrator/taskStatuses.js';
 import { approvalClassForTask } from '../orchestrator/approvalPolicy.js';
 import { RUNTIME_SHUTDOWN_ABORT_REASON } from '../orchestrator/dispatcher.js';
 import { matchSkillInvocation } from '../core/skillInvocation.js';
@@ -502,7 +503,7 @@ export function startRuntimeServer({
       }
       if (request.method === 'POST' && url.pathname === '/turn') {
         const { body, context } = await resolveBodyContext(request, url);
-        const input = String(body.input ?? body.prompt ?? '').trim();
+        let input = String(body.input ?? body.prompt ?? '').trim();
         if (!input) {
           sendJson(response, 400, { error: 'Missing input.' });
           return;
@@ -529,19 +530,15 @@ export function startRuntimeServer({
           }
           return;
         }
-        // A run/job status question is answered by the runtime itself, whatever
-        // the mode and whether or not a run is active. Left to the model it
-        // confused the runtime runId with a production job id ("job not
-        // found"); in chat mode it had no runtime status tool at all.
+        // A run/job status question must NEVER surface the raw system text in
+        // the thread: the runtime collects the facts and hands them to Donna,
+        // who synthesizes them in the session language. `readOnlyChat` so the
+        // turn is a conversation, not a control decision — and the facts are
+        // supplied here so the model cannot mistake the runtime run id for a
+        // production job id ("job not found").
         if (asksForRunStatus(input)) {
-          const status = controlStatus(context, store);
-          sendJson(response, 200, {
-            accepted: true,
-            kind: 'observe',
-            ...status,
-            explanation: explainControlState(status),
-          });
-          return;
+          input = runtimeStatusSynthesisPrompt(input, controlStatus(context, store));
+          readOnlyChat = true;
         }
         if (context.running && !readOnlyChat) {
           // Agent-mode message while a run is active. Classify once: control
@@ -552,7 +549,13 @@ export function startRuntimeServer({
             llm: context?.session?.llm,
             session: context?.session,
           });
-          if (classification.kind !== 'converse') {
+          if (classification.kind === 'observe') {
+            // An observation is system facts, not a control action: Donna gets
+            // them and answers in the session language, never a raw English
+            // line pushed into the thread.
+            input = runtimeStatusSynthesisPrompt(input, controlStatus(context, store));
+            readOnlyChat = true;
+          } else if (classification.kind !== 'converse') {
             const result = await handleControlMessage(context, store, input, {
               intent: body.intent,
               startNextControlRequest,
@@ -561,8 +564,9 @@ export function startRuntimeServer({
             });
             sendJson(response, result.statusCode, result.body);
             return;
+          } else {
+            readOnlyChat = true;
           }
-          readOnlyChat = true;
         }
         if (typeof turn !== 'function') {
           sendJson(response, 501, { error: 'Runtime interactive turns are unavailable.' });
@@ -580,7 +584,10 @@ export function startRuntimeServer({
               llm: context?.session?.llm,
               session: context?.session,
             });
-            if (classification.kind !== 'converse') {
+            if (classification.kind === 'observe') {
+              input = runtimeStatusSynthesisPrompt(input, controlStatus(context, store));
+              readOnlyChat = true;
+            } else if (classification.kind !== 'converse') {
               const result = await handleControlMessage(context, store, input, {
                 intent: body.intent,
                 startNextControlRequest,
@@ -867,12 +874,24 @@ export function startRuntimeServer({
     if (context?.session) {
       context.session._runSkillWithinRun = async (skillName, args = {}, metadata = {}) => {
         const skill = findSkill(context.session, skillName);
-        if (!skill) return {
-          ok: false,
-          terminal: true,
-          code: 'skill_not_found',
-          availableSkills: listSkills(context.session).map((item) => item.name),
-        };
+        if (!skill) {
+          const available = listSkills(context.session).map((item) => item.name);
+          /*
+           A skill the model GUESSED is recoverable, not terminal: the observed
+           failure was `/diagnose` (leading slash copied from the catalogue) →
+           skill_not_found → the terminal path stripped the tools from the
+           synthesis turn → the model wrote `runtime__delegate{...}` as plain
+           text and the turn did nothing. An explicitly user-named missing skill
+           stays terminal: there is nothing to fall back to.
+          */
+          return {
+            ok: false,
+            terminal: metadata.selectionKind === 'explicit_name',
+            code: 'skill_not_found',
+            message: `No skill named "${skillName}". Pass the exact name without a leading slash (${available.join(', ') || 'none'}), or delegate the objective with runtime__delegate.`,
+            availableSkills: available,
+          };
+        }
         try {
           const idempotencyKey = metadata.idempotencyKey
             ? String(metadata.idempotencyKey)
@@ -1161,22 +1180,109 @@ export function runtimeState(context, store, { workspace = null, session = null
     // own history) so those replies surface. The log is a superset of the
     // canonical run conversation, so run rendering is unaffected.
     conversation: reduceAgentEvents(store.listEvents({ workspace })).conversation,
-    status: context?.running ? 'running' : state.status ?? 'idle',
+    // `context.running` keeps the process alive while the scheduler waits for an
+    // approval, but the run is then NOT running — the reducer already says
+    // `pending_approval`. Prefer it over the blanket override.
+    status: context?.running
+      ? (state.status === 'pending_approval' ? 'pending_approval' : 'running')
+      : state.status ?? 'idle',
     running: Boolean(context?.running),
     runId: context?.currentRunId ?? state.runId ?? null,
     workspace: context?.currentRunWorkspace ?? context?.workspace ?? state.workspace ?? workspace ?? null,
   };
 }
 
+// The live figures of the activity the run is on, in one line: percent, plan
+// step, build batch, instruction count and the stabilize counters. A status
+// that only named the current step could not tell 5% from 95%, nor what the
+// running batch had actually done.
+function describeActivityProgress(activity) {
+  const progress = activity?.progress ?? {};
+  const bits = [];
+  if (Number.isFinite(Number(progress.percent))) bits.push(`${Number(progress.percent)}%`);
+  if (progress.stepIndex != null && progress.stepTotal != null) bits.push(`step ${progress.stepIndex}/${progress.stepTotal}`);
+  if (progress.batchIndex != null && progress.batchCount != null) bits.push(`batch ${Number(progress.batchIndex) + 1}/${progress.batchCount}`);
+  if (progress.instructionCount != null) bits.push(`${progress.instructionCount} instruction${Number(progress.instructionCount) > 1 ? 's' : ''}`);
+  const stabilize = [progress.stabilizeKept, progress.stabilizeMerged, progress.stabilizeInserted, progress.stabilizeRemoved];
+  if (stabilize.some((value) => value != null)) {
+    bits.push(`kept ${progress.stabilizeKept ?? 0}, merged ${progress.stabilizeMerged ?? 0}, inserted ${progress.stabilizeInserted ?? 0}, removed ${progress.stabilizeRemoved ?? 0}`);
+  }
+  const detail = progress.detail && !bits.includes(String(progress.detail)) ? String(progress.detail) : null;
+  return { bits: bits.join(' · '), detail, label: activity?.label ?? null };
+}
+
+// The facts a status answer is built from, rendered server-side ONCE. A status
+// question is answered by Donna, never by pushing this text into the thread:
+// the runtime supplies the figures, she phrases them in the session language.
+function runtimeStatusFacts(status) {
+  const plan = Array.isArray(status.plan) ? status.plan : [];
+  const approvals = Array.isArray(status.approvals) ? status.approvals : [];
+  const queue = Array.isArray(status.controlQueue) ? status.controlQueue : [];
+  const activities = Array.isArray(status.activities)
+    ? status.activities
+    : Object.values(status.activities ?? {});
+  const lines = [
+    `Runtime status: ${status.status ?? 'idle'}`,
+    `Workspace: ${status.workspace ?? '-'}`,
+  ];
+  if (status.runId) lines.push(`Run id: ${status.runId}`);
+  for (const activity of activities.filter((entry) => !entry?.terminal).slice(0, 8)) {
+    const info = describeActivityProgress(activity);
+    const detail = [info.bits, info.detail].filter(Boolean).join(' · ');
+    lines.push(
+      `Activity: ${info.label ?? activity.label ?? activity.id ?? '-'} — ${activity.status ?? '-'}${detail ? ` (${detail})` : ''}`,
+    );
+  }
+  for (const [index, step] of plan.slice(0, 60).entries()) {
+    lines.push(`Task ${step.step ?? index + 1}: ${step.status ?? 'pending'} - ${step.description ?? step.label ?? step.id ?? 'step'}`);
+  }
+  for (const approval of approvals.filter((entry) => entry.status === 'pending_approval')) {
+    lines.push(`Pending approval: ${approval.reason ?? approval.taskId ?? approval.id ?? '-'}`);
+  }
+  for (const item of queue.filter((entry) => entry.status === 'queued')) {
+    lines.push(`Queued: ${item.label ?? item.input ?? item.id ?? '-'}`);
+  }
+  return lines.join('\n');
+}
+
+function runtimeStatusSynthesisPrompt(asked, status) {
+  return [
+    'The runtime facts below are the authoritative status the system just collected (this is a runtime run, not a production job — do not look up a job id).',
+    `User question: ${asked}`,
+    'Answer in the session language with a concise, natural status: name the requested target first, then progress, blockers (pending approvals), queued items and the next step.',
+    'Keep every figure (percent, step, batch, instruction and stabilize counts) and every task status accurate; never invent, drop or round away a figure. Do not paste the fact block verbatim; summarize it into prose.',
+    '',
+    'Runtime facts:',
+    runtimeStatusFacts(status),
+  ].join('\n');
+}
+
 function explainControlState(status) {
   const plan = Array.isArray(status.plan) ? status.plan : [];
+  const activities = Array.isArray(status.activities)
+    ? status.activities
+    : Object.values(status.activities ?? {});
+  // A run whose only outstanding work is a human decision is not "running":
+  // `status.running` mirrors the process, which stays alive while the scheduler
+  // waits. Mirrors the reducer's rule — pending_approval, or a pending approval
+  // with no step actually executing.
+  const approvals = Array.isArray(status.approvals) ? status.approvals : [];
+  const pendingApproval = approvals.find((approval) => approval.status === 'pending_approval');
+  const awaitingApproval = pendingApproval
+    && (status.status === 'pending_approval' || !plan.some((step) => isActive(step?.status)));
+  if (awaitingApproval) {
+    return `Runtime is waiting for approval: ${pendingApproval.reason ?? pendingApproval.id}.`;
+  }
   if (status.running) {
     const runningStep = plan.find((step) => step.status === 'running');
+    const activity = activities.find((entry) => !entry?.terminal) ?? activities[0] ?? null;
+    const info = activity ? describeActivityProgress(activity) : { bits: '', detail: null, label: null };
+    const detailText = [info.bits, info.detail].filter(Boolean).join(' · ');
+    const suffix = detailText ? ` (${detailText})` : '';
     return runningStep
-      ? `Runtime run is active. Current step: ${runningStep.description ?? runningStep.label ?? runningStep.step}.`
-      : 'Runtime run is active. No current plan step is available yet.';
+      ? `Runtime run is active. Current step: ${runningStep.description ?? runningStep.label ?? runningStep.step}.${suffix}`
+      : `Runtime run is active. No current plan step is available yet.${suffix}`;
   }
-  const pendingApproval = status.approvals.find((approval) => approval.status === 'pending_approval');
   if (pendingApproval) {
     return `Runtime is waiting for approval: ${pendingApproval.reason ?? pendingApproval.id}.`;
   }
@@ -1187,6 +1293,15 @@ function explainControlState(status) {
   if (plan.some((step) => step.status === 'pending')) {
     return 'Runtime is idle with pending plan steps visible from the last run.';
   }
+  // Idle at the end of a run: say what the last run did, not just "idle" — that
+  // is the question the operator actually asks when the thread goes quiet.
+  const failed = plan.filter((step) => isFailed(step.status) || isCancelled(step.status)).length;
+  const done = plan.filter((step) => isSuccessful(step.status)).length;
+  if (plan.length > 0) {
+    return failed > 0
+      ? `Runtime is idle. Last run: ${done}/${plan.length} task(s) succeeded, ${failed} failed or cancelled.`
+      : `Runtime is idle. Last run: ${done}/${plan.length} task(s) succeeded.`;
+  }
   return 'Runtime is idle.';
 }
 
@@ -1646,13 +1761,22 @@ function rejectPlanPatch(context, store, patchId, reason) {
   };
 }
 
-// A question about the run/job currently executing. Deliberately narrow — a
-// status word AND a run/job noun — so it never hijacks an ordinary "explain how
-// X works" question. Such a question must be answered by the runtime itself:
-// left to the model, a runtime runId was mistaken for a production job id and
-// reported as "not found", and a read-only chat turn had no runtime status tool.
+// A question about the run/job currently executing. The free-text form is
+// deliberately narrow — a status word AND a run/job noun — so it never hijacks
+// an ordinary "explain how X works" question. Such a question must be answered
+// by the runtime itself: left to the model, a runtime runId was mistaken for a
+// production job id and reported as "not found", and a read-only chat turn had
+// no runtime status tool.
+//
+// The reserved built-in `/status` is ALWAYS a runtime status, in every surface:
+// `RESERVED_SLASH_COMMANDS` keeps the homonymous workspace skill out of
+// `matchSkillInvocation`, but without this branch `/turn` still handed the
+// literal command to the model, which ran the skill (English "status" output) or
+// an unrelated review instead of reporting anything. Serve types `/status` into
+// this endpoint; the ShellUI answers it locally.
 function asksForRunStatus(input) {
-  const text = String(input ?? '');
+  const text = String(input ?? '').trim();
+  if (/^\/status(?:\s|$)/i.test(text)) return true;
   const statusWord = /\b(status|statut|progression|progress|avancement|o[uù] en est|o[uù] en sont)\b/i;
   const runNoun = /\b(job|run|t[aâ]che|task|build|ingest|pipeline|export|polish|traitement)\b/i;
   return statusWord.test(text) && runNoun.test(text);

package/src/runtime/server.test.js

@@ -1733,7 +1733,7 @@ test('POST /turn keeps informational skill and build questions conversational',
   }
 });
 
-test('POST /turn answers a run status question from the runtime instead of the model', async (t) => {
+test('POST /turn hands a run status question to Donna with the runtime facts', async (t) => {
   const session = { workspace: 'acme', controlQueue: [] };
   const context = { workspace: 'acme', session, running: true, currentAbortController: null };
   const status = {
@@ -1746,6 +1746,8 @@ test('POST /turn answers a run status question from the runtime instead of the m
     conversation: [],
   };
   let turns = 0;
+  let turnInput = '';
+  let turnMode = null;
   let handle;
   try {
     handle = await startRuntimeServer({
@@ -1753,24 +1755,84 @@ test('POST /turn answers a run status question from the runtime instead of the m
       store: { dbPath: ':memory:', getState: () => status, listEvents: () => [] },
       getContext: async () => context,
       run: async () => new Promise(() => {}),
-      turn: async () => { turns += 1; return { ok: true }; },
+      turn: async (_context, options) => { turns += 1; turnInput = options.input; turnMode = options.mode; return { ok: true }; },
     });
   } catch (err) {
     if (err?.code === 'EPERM') { t.skip('network listen is not permitted in this sandbox'); return; }
     throw err;
   }
   try {
-    // The model once mistook the runtime runId for a production job id and
-    // answered "job not found". The runtime answers its own status.
+    // System facts never reach the thread as raw text: the runtime supplies
+    // them to Donna, who synthesizes the answer. The facts also prevent the
+    // model mistaking the runtime runId for a production job id.
     const response = await fetch(`http://127.0.0.1:${handle.port}/turn?workspace=acme`, {
       method: 'POST', headers: { 'content-type': 'application/json' },
       body: JSON.stringify({ input: 'donne le status du job en cours', mode: 'agent' }),
     });
     const body = await response.json();
-    assert.equal(response.status, 200);
-    assert.equal(body.kind, 'observe');
-    assert.match(body.explanation, /Build TechSections/);
-    assert.equal(turns, 0);
+    assert.equal(response.status, 202);
+    assert.equal(body.kind, 'turn');
+    // The turn is dispatched asynchronously after the 202.
+    await new Promise((resolve) => setTimeout(resolve, 25));
+    assert.equal(turns, 1);
+    assert.equal(turnMode, 'chat');
+    assert.match(turnInput, /Build TechSections/);
+    assert.match(turnInput, /runtime run, not a production job/i);
+  } finally {
+    context.currentAbortController?.abort();
+    await handle.close();
+  }
+});
+
+test('a run blocked on approval is described as waiting, not as running', async (t) => {
+  const session = { workspace: 'acme', controlQueue: [] };
+  const context = { workspace: 'acme', session, running: true, currentAbortController: null };
+  const status = {
+    status: 'pending_approval',
+    running: true,
+    plan: [{ step: 1, description: 'Rebuild the concepts', status: 'pending_approval' }],
+    queue: [],
+    controlQueue: [],
+    approvals: [{ id: 'a1', status: 'pending_approval', reason: 'a mutating task needs approval' }],
+    conversation: [],
+  };
+  let turns = 0;
+  let turnInput = '';
+  let handle;
+  try {
+    handle = await startRuntimeServer({
+      host: '127.0.0.1', port: 0,
+      store: { dbPath: ':memory:', getState: () => status, listEvents: () => [] },
+      getContext: async () => context,
+      run: async () => new Promise(() => {}),
+      turn: async (_context, options) => { turns += 1; turnInput = options.input; return { ok: true }; },
+    });
+  } catch (err) {
+    if (err?.code === 'EPERM') { t.skip('network listen is not permitted in this sandbox'); return; }
+    throw err;
+  }
+  try {
+    // The controller (`explainControlState`) must not call a pending approval
+    // "running": the scheduler keeps `context.running` true while it waits.
+    const control = await fetch(`http://127.0.0.1:${handle.port}/control?workspace=acme`, {
+      method: 'POST', headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ action: 'explain' }),
+    });
+    const controlBody = await control.json();
+    assert.match(controlBody.explanation, /waiting for approval/i);
+    assert.doesNotMatch(controlBody.explanation, /is active/i);
+
+    // And the turn hands the same facts to Donna rather than dumping them.
+    const response = await fetch(`http://127.0.0.1:${handle.port}/turn?workspace=acme`, {
+      method: 'POST', headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ input: 'donne le status du run en cours', mode: 'agent' }),
+    });
+    const body = await response.json();
+    assert.equal(response.status, 202);
+    assert.equal(body.kind, 'turn');
+    await new Promise((resolve) => setTimeout(resolve, 25));
+    assert.equal(turns, 1);
+    assert.match(turnInput, /Pending approval: a mutating task needs approval/);
   } finally {
     context.currentAbortController?.abort();
     await handle.close();
@@ -1790,6 +1852,7 @@ test('POST /turn treats a bare confirmation during a run as a status check', asy
     conversation: [],
   };
   let turns = 0;
+  let turnInput = '';
   let handle;
   try {
     handle = await startRuntimeServer({
@@ -1797,23 +1860,79 @@ test('POST /turn treats a bare confirmation during a run as a status check', asy
       store: { dbPath: ':memory:', getState: () => status, listEvents: () => [] },
       getContext: async () => context,
       run: async () => new Promise(() => {}),
-      turn: async () => { turns += 1; return { ok: true }; },
+      turn: async (_context, options) => { turns += 1; turnInput = options.input; return { ok: true }; },
     });
   } catch (err) {
     if (err?.code === 'EPERM') { t.skip('network listen is not permitted in this sandbox'); return; }
     throw err;
   }
   try {
-    // "oui" answers the launch acknowledgement. It must reach the runtime's
-    // status, not a read-only chat turn that lectures about switching modes.
+    // "oui" answers the launch acknowledgement. It is an observation, so it
+    // reaches Donna with the runtime facts — not a deterministic English line
+    // and not a read-only chat turn that lectures about switching modes.
     const response = await fetch(`http://127.0.0.1:${handle.port}/turn?workspace=acme`, {
       method: 'POST', headers: { 'content-type': 'application/json' },
       body: JSON.stringify({ input: 'oui', mode: 'agent' }),
     });
     const body = await response.json();
-    assert.equal(response.status, 200);
-    assert.equal(body.kind, 'observe');
-    assert.equal(turns, 0);
+    assert.equal(response.status, 202);
+    assert.equal(body.kind, 'turn');
+    await new Promise((resolve) => setTimeout(resolve, 25));
+    assert.equal(turns, 1);
+    assert.match(turnInput, /Runtime facts:/);
+    assert.match(turnInput, /Rebuild the wiki/);
+  } finally {
+    context.currentAbortController?.abort();
+    await handle.close();
+  }
+});
+
+test('POST /turn answers the reserved /status command itself, never the homonymous skill', async (t) => {
+  // A workspace skill named `status` exists precisely to prove the built-in
+  // wins: `/status` was handed to the model, which ran that skill (English
+  // output) or an unrelated review instead of reporting anything. Serve types
+  // `/status` into /turn; only `/skills run status` may reach the skill.
+  const root = mkdtempSync(join(tmpdir(), 'runtime-status-builtin-'));
+  mkdirSync(join(root, '.wiki', 'skills'), { recursive: true });
+  writeFileSync(join(root, '.wiki', 'skills', 'status.md'), '---\nname: status\n---\nInspect services.');
+  const session = { workspace: 'acme', workspacePath: root, controlQueue: [] };
+  const context = { workspace: 'acme', session, running: false, currentAbortController: null };
+  const status = {
+    status: 'idle',
+    running: false,
+    plan: [{ step: 1, description: 'Rebuild the wiki', status: 'done' }],
+    queue: [],
+    controlQueue: [],
+    approvals: [],
+    conversation: [],
+  };
+  let turns = 0;
+  let turnInput = '';
+  let handle;
+  try {
+    handle = await startRuntimeServer({
+      host: '127.0.0.1', port: 0,
+      store: { dbPath: ':memory:', getState: () => status, listEvents: () => [] },
+      getContext: async () => context,
+      run: async () => new Promise(() => {}),
+      turn: async (_context, options) => { turns += 1; turnInput = options.input; return { ok: true }; },
+    });
+  } catch (err) {
+    if (err?.code === 'EPERM') { t.skip('network listen is not permitted in this sandbox'); return; }
+    throw err;
+  }
+  try {
+    const response = await fetch(`http://127.0.0.1:${handle.port}/turn?workspace=acme`, {
+      method: 'POST', headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ input: '/status', mode: 'agent' }),
+    });
+    const body = await response.json();
+    assert.equal(response.status, 202);
+    assert.equal(body.kind, 'turn');
+    await new Promise((resolve) => setTimeout(resolve, 25));
+    assert.equal(turns, 1, 'the built-in status reaches Donna, never the homonymous skill');
+    assert.match(turnInput, /Runtime facts:/);
+    assert.doesNotMatch(turnInput, /Inspect services/);
   } finally {
     context.currentAbortController?.abort();
     await handle.close();

package/src/runtime/skillRun.js

@@ -165,7 +165,7 @@ export async function generateSkillAcknowledgment(session, { publicInput, object
       // slow provider must not block the skill-launch HTTP response forever.
       const reply = await llm.complete({
         system: 'You are Donna, the workspace assistant. You acknowledge a launched workflow in the user\'s language. Be concise: exactly one short sentence.',
-        input: `The user just launched the workspace skill ${publicInput}. It was compiled into ${count} step(s) and is now running.\n\nWrite ONE short sentence in ${language} that confirms the launch, echoes the skill and its arguments, and says progress will be reported. Do not ask a question, do not propose options, and do not offer to check, monitor or cancel anything: the runtime reports progress on its own and this acknowledgement is not a decision point. Return only that sentence, nothing else.`,
+        input: `The user just launched the workspace skill ${publicInput}. It was compiled into ${count} step(s) and has been queued.\n\nWrite ONE short sentence in ${language} that confirms the launch, echoes the skill and its arguments, and says progress will be reported. Do not claim the work is running, executing or done: a mutating step waits for the user's approval before it runs. Do not ask a question, do not propose options, and do not offer to check, monitor or cancel anything: the runtime reports progress on its own and this acknowledgement is not a decision point. Return only that sentence, nothing else.`,
         signal: AbortSignal.timeout(8_000),
       });
       const text = String(reply ?? '').trim();
@@ -179,7 +179,7 @@ export async function generateSkillAcknowledgment(session, { publicInput, object
       emitRuntimeLog(session, `skill-acknowledgment: LLM call failed, using the neutral fallback — ${err instanceof Error ? err.message : String(err)}`);
     }
   }
-  return `Started ${publicInput} — ${count} step(s) in progress.`;
+  return `Started ${publicInput} — ${count} step(s) queued.`;
 }
 
 function argumentError(message) {

package/src/runtime/skillRun.test.js

@@ -95,19 +95,21 @@ test('generateSkillAcknowledgment asks Donna in the session language and echoes
   assert.match(calls[0].input, /es/);
   assert.match(calls[0].input, /\/deliver deliverable="Informe"/);
   // The acknowledgement is not a decision point: it must not invite the user
-  // into a dialog the runtime cannot act on.
+  // into a dialog the runtime cannot act on, and it must not claim the work is
+  // already executing — a mutating step waits for approval.
   assert.match(calls[0].input, /Do not ask a question/);
+  assert.match(calls[0].input, /Do not claim the work is running/);
 });
 
 test('generateSkillAcknowledgment degrades to a neutral message without an LLM client', async () => {
   const reply = await generateSkillAcknowledgment({ language: 'fr' }, { publicInput: '/wiki-ingest docs', objectives: 2 });
-  assert.equal(reply, 'Started /wiki-ingest docs — 2 step(s) in progress.');
+  assert.equal(reply, 'Started /wiki-ingest docs — 2 step(s) queued.');
 });
 
 test('generateSkillAcknowledgment falls back when the LLM call fails', async () => {
   const session = { language: 'en', llm: { complete: async () => { throw new Error('down'); } } };
   const reply = await generateSkillAcknowledgment(session, { publicInput: '/deliver', objectives: 1 });
-  assert.equal(reply, 'Started /deliver — 1 step(s) in progress.');
+  assert.equal(reply, 'Started /deliver — 1 step(s) queued.');
 });
 
 test('generateSkillAcknowledgment announces an LLM failure instead of degrading silently', async () => {