@dotdrelle/wiki-manager 0.15.96 → 0.15.98

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

@@ -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,11 +503,17 @@ 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;
         }
+        // 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.
@@ -529,19 +536,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 +555,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 +570,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 +590,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,
@@ -596,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,
           });
@@ -867,12 +885,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 +1191,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 +1304,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 +1772,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);
@@ -1665,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;
@@ -1699,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

@@ -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,9 @@ test('POST /turn answers a run status question from the runtime instead of the m
     conversation: [],
   };
   let turns = 0;
+  let turnInput = '';
+  let turnDisplayInput = '';
+  let turnMode = null;
   let handle;
   try {
     handle = await startRuntimeServer({
@@ -1753,24 +1756,95 @@ 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;
+        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; }
     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);
+    // …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();
+  }
+});
+
+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 +1864,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 +1872,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();