@dotdrelle/wiki-manager 0.15.94 → 0.15.97

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,6 +530,16 @@ export function startRuntimeServer({
           }
           return;
         }
+        // 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)) {
+          input = runtimeStatusSynthesisPrompt(input, controlStatus(context, store));
+          readOnlyChat = true;
+        }
         if (context.running && !readOnlyChat) {
           // Agent-mode message while a run is active. Classify once: control
           // verbs and new tasks go to the control lane, plain conversation is
@@ -538,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,
@@ -547,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.' });
@@ -566,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,
@@ -853,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)
@@ -1147,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}.`;
   }
@@ -1173,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.';
 }
 
@@ -1632,6 +1761,27 @@ function rejectPlanPatch(context, store, patchId, reason) {
   };
 }
 
+// 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 ?? '').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);
+}
+
 // Classifier for the control lane's free-text messages. The classification is
 // LLM-backed: the only deterministic matches left are the runtime's own
 // control verbs (cancel, an explicit "later/queue", status and plan-change
@@ -1668,6 +1818,14 @@ async function classifyControlMessage(input, status, { forcedIntent = null, llm
   if (/\b(o[uù] en es[t-]|status|statut|progress|progression|logs?|explique|explain|inspect|show|montre|quoi de neuf)\b/i.test(lower)) {
     return { kind: 'observe', confidence: 0.86, reason: 'status_or_explanation_request' };
   }
+  // A bare "yes" answers the runtime's own last prompt (the launch
+  // acknowledgement used to end on "check progress or cancel?"). While a run is
+  // 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)) {
+    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)) {
     return { kind: 'modify_run', confidence: 0.78, reason: 'active_run_change_request' };
   }

package/src/runtime/server.test.js

@@ -1733,6 +1733,212 @@ test('POST /turn keeps informational skill and build questions conversational',
   }
 });
 
+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 = {
+    status: 'running',
+    running: true,
+    plan: [{ step: 1, description: 'Build TechSections', status: 'running' }],
+    queue: [],
+    controlQueue: [],
+    approvals: [],
+    conversation: [],
+  };
+  let turns = 0;
+  let turnInput = '';
+  let turnMode = null;
+  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; 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 {
+    // 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, 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();
+  }
+});
+
+test('POST /turn treats a bare confirmation during a run as a status check', async (t) => {
+  const session = { workspace: 'acme', controlQueue: [] };
+  const context = { workspace: 'acme', session, running: true, currentAbortController: null };
+  const status = {
+    status: 'running',
+    running: true,
+    plan: [{ step: 1, description: 'Rebuild the wiki', status: 'running' }],
+    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 {
+    // "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, 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();
+  }
+});
+
 test('POST /run accepts named skill arguments and deduplicates an explicit retry key', async (t) => {
   const root = mkdtempSync(join(tmpdir(), 'runtime-named-skill-'));
   mkdirSync(join(root, '.wiki', 'skills'), { recursive: true });

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. 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

@@ -94,17 +94,22 @@ test('generateSkillAcknowledgment asks Donna in the session language and echoes
   assert.equal(calls.length, 1);
   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, 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 () => {

package/src/shell/repl.js

@@ -1583,13 +1583,17 @@ async function runChatToolLoop({ input, session, history, donnaMessage, onUpdate
     executeCall,
     maxIterations: Math.min(8, Number(session?.chatAccess?.maxToolIterations) || 4),
     signal: session._abortSignal,
-    onStep: (i, cap) => onStep?.(`Chat: consulting… [${i}/${cap}]`),
+    onStep: () => onStep?.('Chat: consulting…'),
     onTextDelta,
     onTextReset,
   });
-  donnaMessage.content = capped
+  // A capped turn now asks the model for a final answer without tools, so an
+  // answer may exist even when the loop hit its limit: show it. Only fall back
+  // to the honest limit notice when there is genuinely nothing to show.
+  const answer = stripDsmlArtifacts(content).trim();
+  donnaMessage.content = answer || (capped
     ? 'Could not finish within the chat mode iteration limit. Switch to /agent if needed.'
-    : (stripDsmlArtifacts(content).trimEnd() || formatLlmUnavailableMessage('empty response'));
+    : formatLlmUnavailableMessage('empty response'));
   onUpdate?.();
 }