@dotdrelle/wiki-manager 0.15.59 → 0.15.62

package/docker-compose.yml

@@ -130,7 +130,7 @@ services:
       # error. Every compose-deployed ingest then ran without the Lot 4 barrier
       # and left the published map stale — the very defect that work fixed.
       # `copy` stays out on purpose: it is the legacy step, opt-in only.
-      - PRODUCTION_ALLOWED_STEPS=${PRODUCTION_ALLOWED_STEPS:-doctor,ingest,ingest_plan,ingest_apply,taxonomy,build,export,polish,restore,pipeline}
+      - PRODUCTION_ALLOWED_STEPS=${PRODUCTION_ALLOWED_STEPS:-doctor,ingest,ingest_plan,ingest_apply,concepts,reclassify-concepts,taxonomy,build,export,polish,restore,pipeline}
       - PRODUCTION_REQUIRE_CONFIRMATION=${PRODUCTION_REQUIRE_CONFIRMATION:-false}
       # Parallelism levers — effective concurrency ≈ recommendedConcurrency.
       # Intermediate defaults (4/8). Low profile 2/4, high profile 8/16.

package/package.json

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

package/src/agent/graph.js

@@ -28,7 +28,6 @@ import { loadWorkspaceProfile, updateWorkspaceProfilePreference } from '../core/
 import { artifactFromToolCall, currentArtifactFor, currentArtifactPromptLine, rememberArtifact } from '../core/currentArtifact.js';
 import { capabilityRegistryForSession } from '../orchestrator/capabilityRegistry.js';
 import { fetchRuntimeState, postRuntimeCancel, postRuntimeControl, postRuntimeDelegate, postRuntimeKill, postRuntimeSkill } from '../runtime/client.js';
-import { controlLanguage } from '../runtime/controlMessages.js';
 
 const MAX_TOOL_ITERATIONS = 80;
 /**
@@ -433,10 +432,6 @@ export function bareToolCallJson(content, tools = []) {
   return hasArguments ? name : null;
 }
 
-function localizedFailure(session, english, french) {
-  return controlLanguage(session) === 'fr' ? french : english;
-}
-
 function parseActionJson(text) {
   const cleaned = String(text ?? '').trim().replace(/^```(?:json)?\s*/i, '').replace(/\s*```$/, '');
   if (!cleaned) return null;
@@ -1548,11 +1543,7 @@ export function createAgentGraph(options = {}) {
               invalidToolCallRetries: retries + 1,
             };
           }
-          const failure = localizedFailure(
-            state.session,
-            'Action not executed: the model generated an incomplete tool call.',
-            'Action non exécutée : l’appel d’outil généré par le modèle était incomplet.',
-          );
+          const failure = 'Action not executed: the model generated an incomplete tool call.';
           emitAgentEvent(state.session, 'assistant_message', 'agent_guard', { content: failure });
           return { response: failure, pendingToolCalls: null, readyToStream: false };
         }
@@ -1616,11 +1607,7 @@ export function createAgentGraph(options = {}) {
           };
         }
         state.session._onStreamReset?.();
-        const failure = localizedFailure(
-          state.session,
-          'Action not executed: Donna repeatedly printed an internal tool request instead of calling it. No result was created.',
-          'Action non exécutée : Donna a affiché à plusieurs reprises une requête interne au lieu d’appeler l’outil. Aucun résultat n’a été créé.',
-        );
+        const failure = 'Action not executed: Donna repeatedly printed an internal tool request instead of calling it. No result was created.';
         emitAgentEvent(state.session, 'assistant_message', 'agent_guard', { content: failure });
         return { response: failure, pendingToolCalls: null, readyToStream: false };
       }
@@ -1689,11 +1676,7 @@ export function createAgentGraph(options = {}) {
 
       if (runtimeExecution && state.retryWithoutTool) {
         state.session._onStreamReset?.();
-        const failure = localizedFailure(
-          state.session,
-          'Action not executed: Donna did not call any available tool. No job or result was created.',
-          'Action non exécutée : Donna n’a appelé aucun outil disponible. Aucun job ni résultat n’a été créé.',
-        );
+        const failure = 'Action not executed: Donna did not call any available tool. No job or result was created.';
         emitAgentEvent(state.session, 'assistant_message', 'agent_guard', { content: failure });
         return {
           response: failure,

package/src/agent/graph.test.js

@@ -2281,8 +2281,8 @@ test('LOT F: repeated bare tool-call JSON never reaches the user', async () => {
   assert.ok(offered.includes('production__production_start_job'), 'the turn must really offer the tool');
   assert.equal(calls, 3, 'two retries, then the guard');
   assert.doesNotMatch(result.response, /production__production_start_job/);
-  assert.match(result.response, /a affiché à plusieurs reprises une requête interne/);
-  assert.match(result.response, /Aucun .*résultat n’a été créé/);
+  assert.match(result.response, /repeatedly printed an internal tool request/);
+  assert.match(result.response, /No .*result was created/);
 });
 
 /*
@@ -2326,7 +2326,7 @@ test('LOT F: a skill re-invoking itself as bare JSON is neither executed nor sho
   assert.deepEqual(ran, [], 'a call written as text must never reach the skill runner');
   assert.doesNotMatch(result.response, /runtime__run_skill/);
   assert.doesNotMatch(result.response, /[{}]/, 'no JSON fragment may survive in the user-facing answer');
-  assert.match(result.response, /a affiché à plusieurs reprises une requête interne/);
+  assert.match(result.response, /repeatedly printed an internal tool request/);
   assert.ok(streamResets >= 1, 'the partially streamed payload must be wiped before the guard message');
   assert.ok(calls >= 2, 'the first occurrence is retried, not surfaced');
 
@@ -2338,7 +2338,7 @@ test('LOT F: a skill re-invoking itself as bare JSON is neither executed nor sho
   assert.equal(guard[0].payload.content, result.response);
 });
 
-test('LOT F: the guard message follows the session language', async () => {
+test('LOT F: the guard message stays English-only for every session language', async () => {
   const raw = '{"name":"production__production_start_job","arguments":{"type":"build"}}';
   const answer = async (language) => {
     const session = sessionBase({
@@ -2353,10 +2353,10 @@ test('LOT F: the guard message follows the session language', async () => {
     return result.response;
   };
 
-  // Le message de garde est produit par le code, pas par le modèle : il doit
-  // suivre la langue configurée au lieu d'imposer l'anglais comme le faisait
-  // l'ancien texte injecté par l'UI.
+  // The guard message is produced by deterministic code, not by the model, and
+  // this lane deliberately does not run an LLM turn — so it is English-only
+  // rather than a hardcoded catalog that would leave most languages unanswered.
   assert.match(await answer('en-US'), /repeatedly printed an internal tool request/);
   assert.match(await answer(undefined), /repeatedly printed an internal tool request/);
-  assert.match(await answer('fr'), /a affiché à plusieurs reprises une requête interne/);
+  assert.match(await answer('fr'), /repeatedly printed an internal tool request/);
 });

package/src/agent/llm.js

@@ -26,9 +26,10 @@ export function createLlmClientFromWikiConfig(config) {
   }
 
   return {
-    async complete({ system, input }) {
+    async complete({ system, input, signal }) {
       const response = await fetch(`${baseUrl}/chat/completions`, {
         method: 'POST',
+        signal,
         headers: {
           Authorization: `Bearer ${apiKey}`,
           'Content-Type': 'application/json',

package/src/core/buildInfo.json

@@ -1,4 +1,4 @@
 {
-  "version": "0.15.59",
-  "commit": "2899ec5"
+  "version": "0.15.62",
+  "commit": "399432f"
 }

package/src/core/dockerCompose.test.js

@@ -45,6 +45,36 @@ test('every shipped default allows the taxonomy step', async () => {
   assert.match(String(allowed), /(?:^|,)taxonomy(?:,|})/);
 });
 
+test('every shipped default allows the concepts step', async () => {
+  /*
+   Same silent-omission risk as `taxonomy` above, one lot earlier: without
+   `concepts`, `wiki concepts --apply` (which writes wiki/concepts-grid.md) is
+   never reachable through /wiki-sync, /pipeline, or any orchestrated flow.
+   Every ingest then files every concept page under the reserved
+   `unclassified` class forever, with nothing surfacing why.
+  */
+  const raw = await readFile(new URL('../../docker-compose.yml', import.meta.url), 'utf8');
+  const compose = YAML.parse(raw);
+  const allowed = compose.services['production-mcp'].environment
+    .find((entry) => String(entry).startsWith('PRODUCTION_ALLOWED_STEPS='));
+  assert.match(String(allowed), /(?:^|,)concepts(?:,|})/);
+});
+
+test('every shipped default allows the reclassify-concepts step', async () => {
+  /*
+   One step further than `concepts`: without `reclassify-concepts`, a page
+   already stuck under wiki/concepts/unclassified stays there even after a
+   grid exists — re-ingesting its source is not a reliable fix, since the
+   ingest prompt updates an existing leaf at its existing path instead of
+   moving it.
+  */
+  const raw = await readFile(new URL('../../docker-compose.yml', import.meta.url), 'utf8');
+  const compose = YAML.parse(raw);
+  const allowed = compose.services['production-mcp'].environment
+    .find((entry) => String(entry).startsWith('PRODUCTION_ALLOWED_STEPS='));
+  assert.match(String(allowed), /(?:^|,)reclassify-concepts(?:,|})/);
+});
+
 test('shipped compose files never carry a build context', async () => {
   // Ces deux fichiers partent dans le paquet npm, où les dépôts frères
   // (`../agent-external/…`) n'existent pas : un `build:` y rend toute commande

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.59';
+const WIKI_MANAGER_VERSION = '0.15.62';
 
 function envValue(key) {
   const filePath = managerEnvFile();
@@ -76,6 +76,17 @@ function normalizeExternalUrlForRuntime(url) {
 // server's entry shaped differently from every other. It is folded into
 // `allow` on read so existing installs keep working without regenerating
 // their endpoints file, but nothing writes it any more.
+// The packaged example and every scaffolded mcp.endpoints.json declare the
+// two built-in workspace servers' chatAccess under their public/documented
+// names ("llm-wiki", "wiki-production" — see PROTECTED_SERVERS in
+// mcpEndpoints.js and the root CLAUDE.md). Those servers are actually
+// discovered into session.mcp under different internal keys ("wiki",
+// "production" — MCP_SERVICE_MAP below). Without this alias, chatAllowedTools'
+// intersection of session.mcp against chatAccess.servers never matches the
+// built-in servers, so /chat silently gets zero wiki/production tools no
+// matter what is configured — alias both spellings onto the internal key.
+const BUILTIN_CHAT_ACCESS_ALIASES = { 'llm-wiki': 'wiki', 'wiki-production': 'production' };
+
 export function readChatAccessConfig() {
   const filePath = managerMcpEndpointsFile();
   if (!existsSync(filePath)) return null;
@@ -84,19 +95,21 @@ export function readChatAccessConfig() {
   const chatAccess = raw?.chatAccess;
   if (!chatAccess || typeof chatAccess !== 'object' || Array.isArray(chatAccess)) return null;
   const servers = {};
-  for (const [name, entry] of Object.entries(chatAccess.servers ?? {})) {
+  for (const [rawName, entry] of Object.entries(chatAccess.servers ?? {})) {
+    const name = BUILTIN_CHAT_ACCESS_ALIASES[rawName] ?? rawName;
     // "*" is also commonly written as a one-element array (["*"]) since every
     // other "allow" example in this config is an array of tool names — treat
     // both forms as the same wildcard rather than silently allowing nothing.
     const legacyActions = Array.isArray(entry?.allowActions)
       ? entry.allowActions.map(String).filter(Boolean)
       : [];
-    if (entry?.allow === '*' || (Array.isArray(entry?.allow) && entry.allow.length === 1 && entry.allow[0] === '*')) {
+    const isWildcard = entry?.allow === '*' || (Array.isArray(entry?.allow) && entry.allow.length === 1 && entry.allow[0] === '*');
+    const priorAllow = servers[name]?.allow;
+    if (isWildcard || priorAllow === '*') {
       servers[name] = { allow: '*' };
-    } else if (Array.isArray(entry?.allow)) {
-      servers[name] = { allow: [...new Set([...entry.allow.map(String).filter(Boolean), ...legacyActions])] };
-    } else if (legacyActions.length > 0) {
-      servers[name] = { allow: legacyActions };
+    } else if (Array.isArray(entry?.allow) || legacyActions.length > 0) {
+      const merged = [...(Array.isArray(priorAllow) ? priorAllow : []), ...(Array.isArray(entry?.allow) ? entry.allow.map(String).filter(Boolean) : []), ...legacyActions];
+      servers[name] = { allow: [...new Set(merged)] };
     }
   }
   const maxToolIterations = Number.isFinite(Number(chatAccess.maxToolIterations)) && Number(chatAccess.maxToolIterations) > 0

package/src/core/mcp.test.js

@@ -9,6 +9,7 @@ import {
   callMcpTool,
   discoverMcpTools,
   formatMcpToolsForAgent,
+  readChatAccessConfig,
   resetMcpSessionsForTests,
   resetMcpThrottleForTests,
   resolveRetryPolicy,
@@ -159,6 +160,71 @@ test('buildMcpStatus interpolates external endpoints from manager .env', async (
   }
 });
 
+test('readChatAccessConfig aliases the built-in servers\' public names onto their internal session.mcp keys', async () => {
+  // Every shipped example and scaffolded mcp.endpoints.json declares
+  // chatAccess for the built-in workspace servers under their public names
+  // ("llm-wiki", "wiki-production"), but session.mcp discovers them under
+  // different internal keys ("wiki", "production" — MCP_SERVICE_MAP).
+  // Without aliasing, chatAllowedTools' intersection against session.mcp
+  // never matches these entries and /chat silently gets zero wiki/production
+  // tools no matter what is configured.
+  const originalCwd = process.cwd();
+  const root = await mkdtemp(path.join(os.tmpdir(), 'wiki-manager-chat-access-'));
+  await writeFile(
+    path.join(root, 'mcp.endpoints.json'),
+    JSON.stringify({
+      mcpServers: {},
+      chatAccess: {
+        maxToolIterations: 8,
+        servers: {
+          'llm-wiki': { allow: ['wiki_search_context', 'wiki_read_page'] },
+          'wiki-production': { allow: ['production_job_status'] },
+          cme: { allow: ['cme_status'] },
+        },
+      },
+    }),
+    'utf8',
+  );
+
+  try {
+    process.chdir(root);
+    const config = readChatAccessConfig();
+    assert.deepEqual(config.servers.wiki, { allow: ['wiki_search_context', 'wiki_read_page'] });
+    assert.deepEqual(config.servers.production, { allow: ['production_job_status'] });
+    assert.deepEqual(config.servers.cme, { allow: ['cme_status'] });
+    assert.equal(config.servers['llm-wiki'], undefined);
+    assert.equal(config.servers['wiki-production'], undefined);
+  } finally {
+    process.chdir(originalCwd);
+  }
+});
+
+test('readChatAccessConfig merges a wildcard from either the public or internal built-in name', async () => {
+  const originalCwd = process.cwd();
+  const root = await mkdtemp(path.join(os.tmpdir(), 'wiki-manager-chat-access-wildcard-'));
+  await writeFile(
+    path.join(root, 'mcp.endpoints.json'),
+    JSON.stringify({
+      mcpServers: {},
+      chatAccess: {
+        servers: {
+          wiki: { allow: ['wiki_read_page'] },
+          'llm-wiki': { allow: '*' },
+        },
+      },
+    }),
+    'utf8',
+  );
+
+  try {
+    process.chdir(root);
+    const config = readChatAccessConfig();
+    assert.deepEqual(config.servers.wiki, { allow: '*' });
+  } finally {
+    process.chdir(originalCwd);
+  }
+});
+
 test('buildMcpStatus reloads external endpoint keys changed in manager .env', async () => {
   const originalCwd = process.cwd();
   const originalToken = process.env.TEST_EXTERNAL_TOKEN;

package/src/core/skillCompiler.test.js

@@ -31,7 +31,7 @@ test('validation rejects technical routing details', () => {
 });
 
 test('scaffold skills preserve existing capabilities and split only wiki-sync', async () => {
-  const expected = { pipeline: 1, 'wiki-ingest': 1, 'wiki-build': 1, deliver: 1, diagnose: 1, status: 1, 'new-template': 1, 'wiki-sync': 2 };
+  const expected = { pipeline: 1, 'wiki-ingest': 2, 'wiki-build': 1, deliver: 1, diagnose: 1, status: 1, 'new-template': 1, 'wiki-sync': 2 };
   for (const [name, count] of Object.entries(expected)) {
     const raw = readFileSync(resolve('../llm-wiki/scaffold/workspace/.wiki/skills', `${name}.md`), 'utf8');
     const { meta, body } = parseFrontmatter(raw);

package/src/orchestrator/objectiveResolver.js

@@ -106,9 +106,22 @@ function resolveMentionedRegistryOperation(objective, candidates) {
   const text = normalizeText(objective);
 
   const aliasHits = candidates
-    .filter((candidate) => (candidate.aliases ?? []).some((alias) =>
-      phraseIn(normalizePhrase(alias), words, text)))
-    .map((candidate) => ({ capability: candidate.id, operation: candidate.operations[0] }));
+    .map((candidate) => {
+      const matchedAlias = (candidate.aliases ?? []).find((alias) =>
+        phraseIn(normalizePhrase(alias), words, text));
+      if (matchedAlias === undefined) return null;
+      // A capability with more than one operation may declare
+      // aliasOperations, mapping the specific alias phrase that matched to
+      // the operation it actually names. Without it, operations[0]
+      // (alphabetical) is a silent guess: for knowledge.concepts this always
+      // picked the destructive grid-rebuild "concepts" operation, even when
+      // the matched alias ("reclassify concepts", "file unclassified
+      // concepts") named the safe, mechanical "reclassify-concepts" one —
+      // making that operation structurally unreachable from natural language.
+      const operation = candidate.aliasOperations?.[matchedAlias] ?? candidate.operations[0];
+      return { capability: candidate.id, operation };
+    })
+    .filter(Boolean);
   if (aliasHits.length === 1) return aliasHits[0];
   if (aliasHits.length > 1) return null;
 
@@ -142,8 +155,12 @@ export function capabilityCandidates(session) {
     const id = versionedId.includes('@') ? versionedId.slice(0, versionedId.lastIndexOf('@')) : versionedId;
     const operations = [...new Set((providers ?? []).flatMap((provider) => provider?.capability?.supportedOperations ?? []))].sort();
     const aliases = [...new Set((providers ?? []).flatMap((provider) => provider?.capability?.aliases ?? []))].sort();
+    const aliasOperations = Object.assign(
+      {},
+      ...(providers ?? []).map((provider) => provider?.capability?.aliasOperations ?? {}),
+    );
     const description = (providers ?? []).map((provider) => provider?.capability?.description).find(Boolean) ?? '';
-    byId.set(id, { id, description, operations, aliases });
+    byId.set(id, { id, description, operations, aliases, aliasOperations });
   }
   return [...byId.values()].filter((item) => item.operations.length > 0).sort((a, b) => a.id.localeCompare(b.id));
 }

package/src/orchestrator/objectiveResolver.test.js

@@ -7,8 +7,8 @@ import {
   ObjectiveNotOrchestrableError,
 } from './objectiveResolver.js';
 
-function makeCapability(id, { operations = [], aliases = [], description = '' } = {}) {
-  return { id, version: '1', description, supportedOperations: operations, aliases };
+function makeCapability(id, { operations = [], aliases = [], aliasOperations = {}, description = '' } = {}) {
+  return { id, version: '1', description, supportedOperations: operations, aliases, aliasOperations };
 }
 
 function provider(agentInstanceId, capability) {
@@ -63,6 +63,7 @@ test('capabilityCandidates exposes aliases from the closed live registry', () =>
     description: 'Update knowledge from pending sources.',
     operations: ['ingest', 'ingest_apply', 'ingest_plan'],
     aliases: ['ingest', 'ingestion'],
+    aliasOperations: {},
   }]);
 });
 
@@ -121,6 +122,67 @@ test('resolveObjective resolves diagnose via alias despite the notification "sen
   assert.equal(result.operation, 'doctor');
 });
 
+const concepts = makeCapability('knowledge.concepts', {
+  operations: ['concepts', 'reclassify-concepts'],
+  aliases: ['concept grid', 'reclassify concepts', 'file unclassified concepts'],
+  aliasOperations: {
+    'concept grid': 'concepts',
+    'reclassify concepts': 'reclassify-concepts',
+    'file unclassified concepts': 'reclassify-concepts',
+  },
+  description: 'Synthesize the concept grid or file unclassified pages into it.',
+});
+
+/*
+ Regression: with two operations, [...new Set(supportedOperations)].sort()
+ alphabetizes to ["concepts", "reclassify-concepts"], so a naive alias hit
+ defaulting to operations[0] would ALWAYS resolve to "concepts" — the
+ destructive grid rebuild — even for aliases explicitly authored to reach the
+ safe "reclassify-concepts" operation. aliasOperations must be consulted
+ first.
+*/
+test('resolveObjective routes "reclassify concepts" to reclassify-concepts, not operations[0]', async () => {
+  const session = sessionWith([provider('production-1', concepts)]);
+  session.llm.completeWithTools = async () => {
+    throw new Error('the aliased operation must not depend on LLM selection');
+  };
+  const result = await resolveObjective('Please reclassify concepts in the workspace', session);
+  assert.equal(result.capability, 'knowledge.concepts');
+  assert.equal(result.operation, 'reclassify-concepts');
+});
+
+test('resolveObjective routes "file unclassified concepts" to reclassify-concepts', async () => {
+  const session = sessionWith([provider('production-1', concepts)]);
+  session.llm.completeWithTools = async () => {
+    throw new Error('the aliased operation must not depend on LLM selection');
+  };
+  const result = await resolveObjective('File unclassified concepts into the grid', session);
+  assert.equal(result.capability, 'knowledge.concepts');
+  assert.equal(result.operation, 'reclassify-concepts');
+});
+
+test('resolveObjective routes "concept grid" to the concepts operation', async () => {
+  const session = sessionWith([provider('production-1', concepts)]);
+  session.llm.completeWithTools = async () => {
+    throw new Error('the aliased operation must not depend on LLM selection');
+  };
+  const result = await resolveObjective('Rebuild the concept grid', session);
+  assert.equal(result.capability, 'knowledge.concepts');
+  assert.equal(result.operation, 'concepts');
+});
+
+test('resolveObjective falls back to operations[0] when a matched alias has no aliasOperations entry', async () => {
+  // A capability that never declares aliasOperations (every existing
+  // single-operation capability) must keep working exactly as before.
+  const session = sessionWith(
+    [provider('production-1', diagnose)],
+    { capability: 'workspace.diagnose', operation: 'doctor' },
+  );
+  const result = await resolveObjective('diagnose the workspace', session);
+  assert.equal(result.capability, 'workspace.diagnose');
+  assert.equal(result.operation, 'doctor');
+});
+
 test('objectiveForResolution strips notification and negative guardrails', () => {
   const clean = objectiveForResolution(
     'Ingest files. Do not build or publish deliverables. If a messaging connector is available, send a summary; otherwise skip notification silently.',

package/src/runtime/controlMessages.js

@@ -1,43 +1,27 @@
-// Deterministic, localized messages for the runtime control lane.
+// Deterministic, English-only messages for the runtime control lane.
 //
 // Control-lane acknowledgements (run queued, ambiguous input, conversation
 // fallback…) are intentionally NOT generated by Donna: spending an LLM turn
 // to say "your request is queued" would reintroduce exactly the per-message
-// cost the orchestration refactor removed. But they are user-facing, so they
-// must follow the session's configured reply language. This catalog is the
-// single source for those strings — never hardcode a control-lane message in
-// the shell or the server directly.
+// cost the orchestration refactor removed. They are therefore English-only —
+// the one language this deterministic lane can guarantee — and are never
+// localized by a hardcoded fr/en catalog (a French-only fallback would still
+// leave every other language unanswered). Localized, personalised replies are
+// Donna's job on the conversational paths (see generateSkillAcknowledgment).
+// This catalog is the single source for these strings — never hardcode a
+// control-lane message in the shell or the server directly.
 
 const CONTROL_MESSAGES = {
-  queued_for_future_run: {
-    en: 'Request added to the queue — it will start automatically after the current run.',
-    fr: 'Demande ajoutée à la file — elle démarrera automatiquement à la fin du run en cours.',
-  },
-  plan_patch_proposed: {
-    en: 'Plan patch proposed. Approve it explicitly to apply it to the active plan.',
-    fr: 'Modification de plan proposée. Approuvez-la explicitement pour l’appliquer au plan actif.',
-  },
-  ambiguous_control: {
-    en: 'A run is already active, and this looks like a new action. Say "queue it" to run it after the current run, "modify the run" to change the active plan, "cancel" to stop the current run first — or wait for it to finish.',
-    fr: 'Un run est déjà actif et ta demande ressemble à une nouvelle action. Dis « mets en file » pour l\'exécuter après le run en cours, « modifie le run » pour changer le plan actif, « annule » pour arrêter le run actuel — ou attends la fin.',
-  },
-  converse_while_running: {
-    en: 'Runtime run is still active. This message was treated as conversation and did not create a queued run.',
-    fr: 'Un run est toujours actif. Ce message a été traité comme conversation et n’a pas créé de run en file.',
-  },
-  converse_while_idle: {
-    en: 'Runtime is idle. This message was treated as conversation and did not create a run.',
-    fr: 'Le runtime est inactif. Ce message a été traité comme conversation et n’a pas créé de run.',
-  },
+  queued_for_future_run: 'Request added to the queue — it will start automatically after the current run.',
+  control_run_started: 'A queued request is now starting.',
+  plan_patch_proposed: 'Plan patch proposed. Approve it explicitly to apply it to the active plan.',
+  ambiguous_control: 'A run is already active, and this looks like a new action. Say "queue it" to run it after the current run, "modify the run" to change the active plan, "cancel" to stop the current run first — or wait for it to finish.',
+  converse_while_running: 'Runtime run is still active. This message was treated as conversation and did not create a queued run.',
+  converse_while_idle: 'Runtime is idle. This message was treated as conversation and did not create a run.',
 };
 
-export function controlLanguage(session) {
-  const raw = String(session?.language ?? 'en').toLowerCase();
-  return raw.startsWith('fr') ? 'fr' : 'en';
-}
-
-export function controlMessage(session, key) {
+export function controlMessage(_session, key) {
   const entry = CONTROL_MESSAGES[key];
   if (!entry) throw new Error(`Unknown control message key: ${key}`);
-  return entry[controlLanguage(session)] ?? entry.en;
+  return entry;
 }

package/src/runtime/controlMessages.test.js

@@ -1,21 +1,15 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
-import { controlLanguage, controlMessage } from './controlMessages.js';
+import { controlMessage } from './controlMessages.js';
 
-test('controlLanguage maps fr locales to fr and everything else to en', () => {
-  assert.equal(controlLanguage({ language: 'fr-FR' }), 'fr');
-  assert.equal(controlLanguage({ language: 'fr' }), 'fr');
-  assert.equal(controlLanguage({ language: 'en-US' }), 'en');
-  assert.equal(controlLanguage({ language: null }), 'en');
-  assert.equal(controlLanguage(null), 'en');
+test('controlMessage returns the deterministic English acknowledgement regardless of locale', () => {
+  assert.match(controlMessage({ language: 'fr-FR' }, 'queued_for_future_run'), /added to the queue/);
+  assert.match(controlMessage({ language: 'es' }, 'queued_for_future_run'), /added to the queue/);
+  assert.match(controlMessage(null, 'queued_for_future_run'), /added to the queue/);
 });
 
-test('controlMessage returns the localized queued acknowledgement', () => {
-  assert.match(controlMessage({ language: 'fr-FR' }, 'queued_for_future_run'), /ajoutée à la file/);
-  assert.match(controlMessage({ language: 'en-US' }, 'queued_for_future_run'), /added to the queue/);
-});
-
-test('controlMessage falls back to en for unknown locales and throws on unknown keys', () => {
-  assert.match(controlMessage({ language: 'de-DE' }, 'queued_for_future_run'), /added to the queue/);
+test('controlMessage keeps every key in English and throws on unknown keys', () => {
+  assert.match(controlMessage({ language: 'fr' }, 'ambiguous_control'), /queue it/);
+  assert.match(controlMessage({ language: 'fr' }, 'converse_while_idle'), /treated as conversation/);
   assert.throws(() => controlMessage({ language: 'fr-FR' }, 'nope'), /Unknown control message key/);
 });

package/src/runtime/server.js

@@ -11,7 +11,8 @@ import { approvalClassForTask } from '../orchestrator/approvalPolicy.js';
 import { matchSkillInvocation } from '../core/skillInvocation.js';
 import { reconcileControlQueue } from './controlDrain.js';
 import { cancelControlChain, cancelQueuedControlItem } from './controlCancellation.js';
-import { runSkillChain } from './skillRun.js';
+import { generateSkillAcknowledgment, runSkillChain } from './skillRun.js';
+import { emitRuntimeLog } from './supervisor.js';
 import { findSkill, listSkills } from '../core/skills.js';
 
 const PRIVATE_CONTROL_INPUTS = new WeakMap();
@@ -347,7 +348,8 @@ export function startRuntimeServer({
           if (skillMatch) {
             try {
               const result = await enqueueSkillInvocation(context, skillMatch);
-              sendJson(response, 202, { accepted: true, kind: 'skill_chain', ...result, ...controlStatus(context, store) });
+              const explanation = await generateSkillAcknowledgment(context.session, result);
+              sendJson(response, 202, { accepted: true, kind: 'skill_chain', explanation, ...result, ...controlStatus(context, store) });
             } catch (err) {
               const error = skillInvocationErrorMessage(err);
               publishSkillInvocationFailure(context, input, error);
@@ -421,7 +423,8 @@ export function startRuntimeServer({
         if (skillMatch) {
           try {
             const result = await enqueueSkillInvocation(context, skillMatch);
-            sendJson(response, 202, { accepted: true, kind: 'skill_chain', ...result, ...controlStatus(context, store) });
+            const explanation = await generateSkillAcknowledgment(context.session, result);
+            sendJson(response, 202, { accepted: true, kind: 'skill_chain', explanation, ...result, ...controlStatus(context, store) });
           } catch (err) {
             const error = skillInvocationErrorMessage(err);
             publishSkillInvocationFailure(context, input, error);
@@ -778,7 +781,7 @@ export function startRuntimeServer({
     return { killed: true, workspace: targetWorkspace, runId: targetRunId, runs, tasks, queued, ...(purged !== null ? { purged } : {}) };
   }
 
-  function startRuntimeRun(context, body, { controlItemId = null, waitForPlan = false } = {}) {
+  function startRuntimeRun(context, body, { controlItemId = null, waitForPlan = false, announceLaunch = false } = {}) {
     const runId = randomUUID();
     const runWorkspace = context.workspace ?? body.workspace ?? null;
     context.running = true;
@@ -801,6 +804,14 @@ export function startRuntimeServer({
         workspace: runWorkspace,
         payload: { id: controlItemId, runId },
       }));
+      // A control item is now a live run: announce it in the conversation so the
+      // "queued" acknowledgement is closed out by a "starting" one. A task is a
+      // task whether it waited or not — it is about to go through approval — so
+      // this is not gated on having waited. Skill-chain steps are skipped: they
+      // already announced the whole skill at invocation.
+      if (announceLaunch) {
+        announceControlLaunch(context.session, body.publicInput ?? body.input, runWorkspace);
+      }
     }
     const runPromise = run(context, runBody, { signal: context.currentAbortController.signal, runId });
     runPromise
@@ -858,7 +869,7 @@ export function startRuntimeServer({
             },
           }
           : {}),
-      }, { controlItemId: item.id }),
+      }, { controlItemId: item.id, announceLaunch: !item.chainId }),
       skipItem: (item, reason) => {
         privateControlInputsFor(context.session).delete(item.id);
         emitControlSkipped(context, item, reason);
@@ -1089,7 +1100,11 @@ export function approvalRequestFromStatus(status) {
 
 async function handleControlMessage(context, store, input, { intent = null, startNextControlRequest = () => false, cancel = null, approve = null } = {}) {
   const status = controlStatus(context, store);
-  const classification = classifyControlMessage(input, status, intent);
+  const classification = await classifyControlMessage(input, status, {
+    forcedIntent: intent,
+    llm: context?.session?.llm,
+    session: context?.session,
+  });
   if (classification.kind === 'observe') {
     return readOnlyControlResponse('observe', classification, status, explainControlState(status));
   }
@@ -1127,6 +1142,7 @@ async function handleControlMessage(context, store, input, { intent = null, star
     // startNextControlRequest), which can change running/plan/status — a full
     // controlStatus() recompute is required here, not just controlQueue.
     void startNextControlRequest(context);
+    const explanation = await generateControlAcknowledgment(context?.session, { kind: 'queued', input });
     return {
       statusCode: 202,
       body: {
@@ -1135,7 +1151,7 @@ async function handleControlMessage(context, store, input, { intent = null, star
         classification,
         item,
         ...controlStatus(context, store),
-        explanation: controlMessage(context?.session, 'queued_for_future_run'),
+        explanation,
       },
     };
   }
@@ -1156,6 +1172,61 @@ async function handleControlMessage(context, store, input, { intent = null, star
     : controlMessage(context?.session, 'converse_while_idle'));
 }
 
+/*
+ Control-lane acknowledgements are Donna's to localize.
+
+ The control lane stays deterministic in its CLASSIFICATION and its actions,
+ but the acknowledgement the user reads ("queued, will run after this one" /
+ "the queued task is starting") is a conversational reply: it goes through a
+ single bounded LLM completion, like the skill-launch acknowledgement, and
+ falls back to the deterministic English catalog when no LLM is configured or
+ the call fails. The fallback is what keeps the lane deterministic-under-failure.
+ */
+async function generateControlAcknowledgment(session, { kind, input }) {
+  const language = String(session?.language ?? '').trim().toLowerCase() || 'en';
+  const llm = session?.llm;
+  const fallback = kind === 'queued'
+    ? controlMessage(session, 'queued_for_future_run')
+    : controlMessage(session, 'control_run_started');
+  if (llm && typeof llm.complete === 'function') {
+    try {
+      const scenario = kind === 'queued'
+        ? 'The user requested a new task while a run is active. It was queued and will start automatically after the current run finishes.'
+        : 'A task the user queued earlier is now starting.';
+      const instruction = kind === 'queued'
+        ? 'their request is queued and will run after the current run finishes'
+        : 'the queued task is now starting';
+      const reply = await llm.complete({
+        system: 'You are Donna, the workspace assistant. You acknowledge a runtime queue event in the user\'s language. Be concise: exactly one short sentence.',
+        input: `${scenario}\n\nThe task is: ${input}\n\nWrite ONE short sentence in ${language} that tells the user ${instruction}. Return only that sentence, nothing else.`,
+        signal: AbortSignal.timeout(8_000),
+      });
+      const text = String(reply ?? '').trim();
+      if (text) return text;
+      emitRuntimeLog(session, 'control-acknowledgment: LLM returned an empty reply, using the deterministic fallback');
+    } catch (err) {
+      // A degradation must announce itself: silently falling through here
+      // hides the difference between "no LLM configured" (expected) and "the
+      // configured LLM is failing every call" (a real problem) — both would
+      // otherwise look identical from the Shell or serve UI.
+      emitRuntimeLog(session, `control-acknowledgment: LLM call failed, using the deterministic fallback — ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  return fallback;
+}
+
+function announceControlLaunch(session, input, workspace) {
+  void generateControlAcknowledgment(session, { kind: 'started', input })
+    .then((content) => {
+      dispatchAgentEvent(session, createAgentEvent('assistant_message', {
+        origin: 'runtime',
+        workspace,
+        payload: { content, independent: true },
+      }));
+    })
+    .catch(() => {});
+}
+
 /*
  `skillStack` accompagne l'élément, il ne vit pas sur la session.
 
@@ -1351,13 +1422,15 @@ function rejectPlanPatch(context, store, patchId, reason) {
   };
 }
 
-// Interim classifier for control §4.2 of the plan directeur: the plan expects
-// an LLM-backed classification eventually ("la classification LLM se
-// trompera" — the plan's own fallback-UX rule presupposes an LLM). This is a
-// synchronous keyword/regex stand-in with the same {kind, confidence, reason}
-// contract, so swapping in an LLM call later shouldn't require touching
-// handleControlMessage.
-function classifyControlMessage(input, status, forcedIntent = null) {
+// Classifier for control §4.2 of the plan directeur. The plan expects an
+// LLM-backed classification — "the classification LLM se trompera" — and this
+// is that, now: the only deterministic matches left are the runtime's own
+// control verbs (cancel, an explicit "later/queue", status and plan-change
+// wording). Deciding "is this a NEW task to queue vs plain conversation" is a
+// 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 } = {}) {
   // Caller (the /control message route) already trims and rejects empty input.
   const lower = String(input ?? '').toLowerCase();
   const intent = forcedIntent ? String(forcedIntent).toLowerCase() : null;
@@ -1375,22 +1448,53 @@ function classifyControlMessage(input, status, forcedIntent = null) {
   if (explicit) {
     return { kind: explicit, confidence: 1, reason: 'explicit_intent' };
   }
+  // Cancel stays a keyword: it is a runtime control verb, and an abort must not
+  // wait on a model round-trip.
   if (/\b(cancel|annule|stop|arr[eê]te|interromps|abort)\b/i.test(lower)) {
     return { kind: 'cancel', confidence: 0.86, reason: 'cancel_request' };
   }
   if (/\b(plus tard|later|ensuite|apr[eè]s ce run|enqueue|mets en file|met en file|futur|next run|future run)\b/i.test(lower)) {
     return { kind: 'enqueue_run', confidence: 0.8, reason: 'future_run_request' };
   }
-  if (/\b(o[uù] en es[t-]|status|statut|progress|progression|build|run|job|queue|file|logs?|explique|explain|inspect|show|montre|quoi de neuf)\b/i.test(lower)) {
+  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' };
   }
   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' };
   }
-  if (status.running && /\b(lance|run|g[eé]n[eè]re|build|export|cr[eé]e|create|send|envoie|ingest|convert|importe|import)\b/i.test(lower)) {
-    return { kind: 'ambiguous', confidence: 0.45, reason: 'active_run_action_is_ambiguous' };
+  if (!status.running) return { kind: 'converse', confidence: 0.62, reason: 'plain_conversation' };
+  // A run is active and none of the runtime control verbs matched. The message
+  // is either a request to perform a NEW mutating task (→ queue it to run
+  // after the current one) or ordinary conversation — that is a judgement about
+  // the workspace's domain, so the model decides it, never a keyword list.
+  if (llm && typeof llm.complete === 'function') {
+    try {
+      const reply = await llm.complete({
+        system: 'You classify one user message typed while a run is already active. Return exactly one word, nothing else.',
+        input: [
+          `The user typed this while a run is active: "${input}"`,
+          '',
+          'Choose ONE of:',
+          '- "action" — a request to perform a NEW task (generate, create, ingest, build, export, convert, send, publish, produce…), which must run after the current run.',
+          '- "conversation" — ordinary conversation, a question, or an unrelated remark.',
+          '',
+          'Return only that one word.',
+        ].join('\n'),
+        signal: AbortSignal.timeout(8_000),
+      });
+      const kind = String(reply ?? '').trim().toLowerCase();
+      if (kind.startsWith('action')) return { kind: 'enqueue_run', confidence: 0.85, reason: 'llm_classified_action' };
+      if (kind.startsWith('conversation')) return { kind: 'converse', confidence: 0.85, reason: 'llm_classified_conversation' };
+      emitRuntimeLog(session, `control-classify: LLM returned an unrecognized reply, falling back to the choice menu — ${JSON.stringify(kind).slice(0, 200)}`);
+    } catch (err) {
+      // A degradation must announce itself: silently falling through here
+      // hides the difference between "no LLM configured" (expected) and "the
+      // configured LLM is failing every call" (a real problem) — both would
+      // otherwise look identical from the Shell or serve UI.
+      emitRuntimeLog(session, `control-classify: LLM call failed, falling back to the choice menu — ${err instanceof Error ? err.message : String(err)}`);
+    }
   }
-  return { kind: 'converse', confidence: 0.62, reason: 'plain_conversation' };
+  return { kind: 'ambiguous', confidence: 0.45, reason: 'action_vs_conversation_unclear' };
 }
 
 function isAuthorized(request, token) {

package/src/runtime/server.test.js

@@ -1434,10 +1434,14 @@ test('runtime server control message records active plan mutation as a proposal'
   }
 });
 
-test('runtime server control message reports ambiguity without starting a run', async (t) => {
+test('runtime server auto-queues a clear new action while a run is active', async (t) => {
   const session = {
     workspace: 'acme',
     controlQueue: [],
+    _onAgentEvent: () => {},
+    // The classifier asks the model whether the message is a new action; a
+    // keyword list is deliberately not part of the code path.
+    llm: { complete: async () => 'action' },
   };
   let runCount = 0;
   let handle;
@@ -1451,6 +1455,7 @@ test('runtime server control message reports ambiguity without starting a run',
           status: 'running',
           plan: [{ step: 1, description: 'Generate', status: 'running' }],
           queue: [],
+          controlQueue: session.controlQueue,
           approvals: [],
           summary: null,
         }),
@@ -1478,12 +1483,11 @@ test('runtime server control message reports ambiguity without starting a run',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({ action: 'message', input: 'Lance aussi la publication' }),
     });
-    assert.equal(response.status, 200);
+    assert.equal(response.status, 202);
     const body = await response.json();
-    assert.equal(body.kind, 'ambiguous');
-    assert.equal(body.choices.length, 3);
-    assert.equal(session.controlQueue.length, 0);
-    assert.equal(runCount, 0);
+    assert.equal(body.kind, 'enqueue_run');
+    assert.equal(body.item.status, 'queued');
+    assert.equal(runCount, 0, 'the queued task must not start while the current run is active');
   } finally {
     await handle.close();
   }
@@ -1545,7 +1549,7 @@ test('runtime server drains queued control requests when idle', async (t) => {
     assert.match(receivedBody.runId, /^[0-9a-f-]{36}$/);
     assert.equal(session.controlQueue[0].status, 'running');
     assert.equal(session.controlQueue[0].runId, receivedBody.runId);
-    assert.deepEqual(events.map((event) => event.type), ['control_enqueued', 'control_started']);
+    assert.deepEqual(events.map((event) => event.type), ['control_enqueued', 'control_started', 'assistant_message']);
   } finally {
     await handle.close();
   }

package/src/runtime/skillChain.e2e.test.js

@@ -142,7 +142,7 @@ test('E2E-002 wiki-sync: two objectives, two ordered runs, one chainId', async (
   assert.equal(body.objectives, 2);
   assert.equal(env.runs.length, 2, 'the second objective must run after the first');
   assert.match(env.runs[0].input, /^Export the requested Confluence source/);
-  assert.match(env.runs[1].input, /^Ingest the newly exported Markdown/);
+  assert.match(env.runs[1].input, /^Run the production pipeline over the newly exported Markdown/);
   // CME first, Production second — and the parameter reaches the step that
   // consumes it, not only the last objective.
   for (const run of env.runs) assert.match(run.input, /User parameters:\nsource: docs/);
@@ -202,7 +202,7 @@ test('E2E-003 cancel: the running step and its chain stop, unrelated queue survi
 // that silently fragments would show up as extra runs, not as extra objectives.
 const PERFORMANCE_TABLE = {
   pipeline: 1,
-  'wiki-ingest': 1,
+  'wiki-ingest': 2,
   'wiki-build': 1,
   deliver: 1,
   diagnose: 1,

package/src/runtime/skillRun.js

@@ -1,6 +1,7 @@
 import { randomUUID } from 'node:crypto';
 import { applyLegacySkillPlaceholders, parseSkillArguments } from '../core/skillInvocation.js';
 import { compileSkillObjectives, createSkillCompilerFallback } from '../core/skillCompiler.js';
+import { emitRuntimeLog } from './supervisor.js';
 
 const SKILL_PARAM_RE = /^[a-zA-Z][a-zA-Z0-9_-]{0,63}$/;
 const DANGEROUS_KEYS = new Set(['__proto__', 'prototype', 'constructor']);
@@ -86,6 +87,7 @@ export async function runSkillChain(context, skill, {
     skill: skill.name,
     objectives: objectives.length,
     items,
+    publicInput,
     deprecatedPlaceholders: legacy.deprecatedPlaceholders,
   };
 }
@@ -97,6 +99,48 @@ export function formatPublicSkillInvocation(name, args = {}) {
   return `/${String(name ?? '').trim()}${values.length ? ` ${values.join(' ')}` : ''}`;
 }
 
+/**
+ * Donna's launch acknowledgement for an executable skill.
+ *
+ * The reply is user-facing and echoes the caller's own arguments (a source, a
+ * file, a deliverable), so it must be generated by Donna in the session's
+ * configured language — a hardcoded fr/en catalog cannot cover every language
+ * and would drop the very parameters the user asked for. This is the single
+ * place that turns a compiled skill chain into a conversational reply; the
+ * browser and the shell both read the resulting `explanation`, never a
+ * language-specific string of their own.
+ *
+ * Degrades honestly: without an LLM client (no `.wikirc` LLM configured) there
+ * is nothing to localize with, so it falls back to a neutral, language-free
+ * acknowledgement instead of guessing a language.
+ */
+export async function generateSkillAcknowledgment(session, { publicInput, objectives }) {
+  const count = Number(objectives) || 1;
+  const language = String(session?.language ?? '').trim().toLowerCase() || 'en';
+  const llm = session?.llm;
+  if (llm && typeof llm.complete === 'function') {
+    try {
+      // Same bound as compileSkillObjectives' llmFallback above: a hung or
+      // 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.`,
+        signal: AbortSignal.timeout(8_000),
+      });
+      const text = String(reply ?? '').trim();
+      if (text) return text;
+      emitRuntimeLog(session, 'skill-acknowledgment: LLM returned an empty reply, using the neutral fallback');
+    } catch (err) {
+      // A degradation must announce itself: silently falling through here
+      // hides the difference between "no LLM configured" (expected) and "the
+      // configured LLM is failing every call" (a real problem) — both would
+      // otherwise look identical from the Shell or serve UI.
+      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.`;
+}
+
 function argumentError(message) {
   const error = new Error(message);
   error.code = 'skill_arguments_invalid';

package/src/runtime/skillRun.test.js

@@ -1,6 +1,6 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
-import { formatPublicSkillInvocation, runSkillChain, validateNamedSkillArguments } from './skillRun.js';
+import { formatPublicSkillInvocation, generateSkillAcknowledgment, runSkillChain, validateNamedSkillArguments } from './skillRun.js';
 
 const skill = { name: 'deliver', params: ['deliverable', 'polish'], body: 'Deliver the requested output.' };
 
@@ -82,3 +82,38 @@ test('runSkillChain starts a fresh stack for a top-level invocation', async () =
 
   assert.deepEqual(queued[0].skillStack, ['deliver']);
 });
+
+test('generateSkillAcknowledgment asks Donna in the session language and echoes the invocation', async () => {
+  const calls = [];
+  const session = {
+    language: 'es',
+    llm: { complete: async (request) => { calls.push(request); return 'Lanzado /deliver deliverable="Informe" — 1 paso en cola.'; } },
+  };
+  const reply = await generateSkillAcknowledgment(session, { publicInput: '/deliver deliverable="Informe"', objectives: 1 });
+  assert.equal(reply, 'Lanzado /deliver deliverable="Informe" — 1 paso en cola.');
+  assert.equal(calls.length, 1);
+  assert.match(calls[0].input, /es/);
+  assert.match(calls[0].input, /\/deliver deliverable="Informe"/);
+});
+
+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.');
+});
+
+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.');
+});
+
+test('generateSkillAcknowledgment announces an LLM failure instead of degrading silently', async () => {
+  // A degradation must announce itself: falling back to the neutral message
+  // with no trace anywhere makes "LLM unconfigured" (expected) and "LLM
+  // failing every call" (a real problem) look identical in the UI.
+  const session = { language: 'en', llm: { complete: async () => { throw new Error('provider timeout'); } } };
+  await generateSkillAcknowledgment(session, { publicInput: '/deliver', objectives: 1 });
+  const runtimeLogs = (session.agentEvents ?? []).filter((event) => event.type === 'runtime_log');
+  assert.equal(runtimeLogs.length, 1);
+  assert.match(runtimeLogs[0].payload.detail ?? runtimeLogs[0].payload.message, /provider timeout/);
+});

package/src/shell/LeftPane.tsx

@@ -859,7 +859,7 @@ export function LeftPane(props: {
         above the composer keeps the current job in view while composing; the
         right pane keeps the full Plan/Queue/Logs detail.
       */}
-      <box flexShrink={0} height={4} flexDirection="column" overflow="hidden">
+      <box flexShrink={0} height={4} flexDirection="column" overflow="hidden" backgroundColor="#111318">
         <ActivityPanel activities={props.activities} width={props.width - 2} />
       </box>
       <ChatInput

package/src/shell/RightPane.tsx

@@ -20,7 +20,10 @@ type LogLineParts = { time: string | null; message: string };
 // 4 slots (was 6): items can now span up to 5 lines each (wrapped label +
 // wrapped status/error), so fewer, readable entries beat more, truncated ones.
 const ACTIVITY_SLOTS = Array.from({ length: 4 }, (_, index) => index);
-const PLAN_VIEWPORT_ROWS = 12;
+// Hauteur du panneau Plan : 6 lignes visibles au maximum. Les etapes suivantes
+// restent atteignables en faisant defiler la scrollbox (barre de defilement
+// affichee des que le plan depasse la fenetre).
+const PLAN_VIEWPORT_ROWS = 6;
 
 function wrapLine(value: string, width: number) {
   const max = Math.max(8, width);
@@ -194,12 +197,10 @@ export function PlanPanel(props: { plan: PlanStep[]; width: number; jobName?: st
   // Keep one column for the native vertical scrollbar when the plan is long.
   const lineWidth = () => Math.max(8, props.width - 3);
   const firstPending = () => props.plan.find((s) => s.status === 'pending')?.step ?? null;
-  // A running step carries a thick left border, which costs one column: the
-  // wrap width is therefore one less for it. The same function feeds both the
-  // row-count memo and the render, so the viewport height can never undercount
-  // a running step's wrapped lines and clip the last one.
-  const isRunningStep = (step: PlanStep) => String(step.status ?? '').toLowerCase() === 'running';
-  const stepTextWidth = (step: PlanStep) => lineWidth() - (isRunningStep(step) ? 1 : 0);
+  // Plus de liseré bleu à gauche : l'icône et la couleur du texte suffisent à
+  // distinguer une étape en cours, et le cadre se voyait aussi sur une étape en
+  // attente (jaune). Toutes les étapes utilisent donc la même largeur.
+  const stepTextWidth = (_step: PlanStep) => lineWidth();
   const icon = (rawStatus: string) => {
     const status = String(rawStatus ?? '').toLowerCase();
     if (DONE_STATUSES.includes(status)) return '[✓]';
@@ -241,11 +242,10 @@ export function PlanPanel(props: { plan: PlanStep[]; width: number; jobName?: st
           {(step) => {
             // Wrap step descriptions over up to 2 lines instead of truncating —
             // "Ingest des 39 documents raw/untrac…" hid the actual target.
-            const running = () => isRunningStep(step());
             const textWidth = () => stepTextWidth(step());
             const lines = () => wrapLine(`${icon(step().status)} ${step().step}. ${step().description}`, textWidth()).slice(0, 2);
             return (
-              <box flexShrink={0} flexDirection="column" border={running() ? ['left'] : undefined} borderStyle="heavy" borderColor="#89B4FA">
+              <box flexShrink={0} flexDirection="column">
                 <text width={textWidth()} fg={planStepColor(step(), firstPending())} content={lines()[0]} />
                 <Show when={lines()[1]}>
                   <text width={textWidth()} fg={planStepColor(step(), firstPending())} content={`    ${fit(lines()[1], Math.max(8, textWidth() - 4))}`} />
@@ -265,7 +265,7 @@ export function ActivityPanel(props: { activities: any[]; width: number }) {
   const visibleSlots = () => visible().map((_activity, index) => index);
   const activityAt = (index: number) => visible()[index] ?? null;
   return (
-    <box flexShrink={0} flexDirection="column" paddingX={1}>
+    <box flexShrink={0} flexDirection="column" paddingX={1} backgroundColor="#111318">
       <text width={lineWidth()} fg="#D6DEE8" content="Activity" />
       <Show when={visible().length > 0} fallback={<text width={lineWidth()} fg="#7F8C8D" content="no active jobs" />}>
         <Index each={visibleSlots()}>
@@ -385,7 +385,7 @@ export function LogPanel(props: { logs: string[]; width: number; filter?: string
     .filter((line) => activeLogTab() === 'agent-status' ? isAgentStatus(line) : !isAgentStatus(line));
   const allLines = createMemo(() => logRenderLines(filteredLogs(), lineWidth()));
   return (
-    <box flexGrow={2} flexDirection="column" paddingX={1} focusable={false}>
+    <box flexGrow={2} flexDirection="column" paddingX={1} marginTop={6} focusable={false}>
       <text width={lineWidth()} fg="#4B5563" content={'─'.repeat(lineWidth())} />
       <box height={1} flexDirection="row">
         <text

package/src/shell/repl.js

@@ -1110,19 +1110,23 @@ export function shouldHandleFreeTextLocally(_line, session, { llmAvailable = Boo
   return { local: true, classification };
 }
 
-// Shared by both the one-shot `/agent <question>` path in runLine and the
-// interactive free-text-to-runtime path below: maps a submitRuntimeRun()
-// outcome to the conversation message(s) it produces and a short log line,
+// Shared by every caller that turns a submitRuntimeRun()/submitRuntimeTurn()
+// outcome into the conversation message(s) it produces and a short log line —
+// the legacy TTY shell (runLine, the interactive free-text path, /approve's
+// ambiguous-choice resubmission below) and the OpenTUI shell (useAgent.ts) —
 // so the classification → message mapping isn't duplicated per call site.
-function applyRuntimeOutcome(session, outcome, onLog, {
+// 'turn' (submitRuntimeTurn's default kind for a plain accepted turn) is
+// treated the same as submitRuntimeRun's 'accepted': the actual reply arrives
+// separately over the event stream, this call only logs.
+export function applyRuntimeOutcome(session, outcome, onLog, {
   ambiguousFallback = 'Runtime could not classify that message.',
 } = {}) {
-  if (outcome.kind === 'accepted') {
+  if (outcome.kind === 'accepted' || outcome.kind === 'turn') {
     onLog('runtime: run accepted');
-  } else if (outcome.kind === 'queued') {
+  } else if (outcome.kind === 'queued' || outcome.kind === 'enqueue_run') {
     conversationMessages(session).push({ role: 'command', content: String(outcome.result?.explanation ?? 'Request added to the queue.') });
     onLog('runtime: control queued');
-  } else if (outcome.kind === 'observe' || outcome.kind === 'converse' || outcome.kind === 'mutate') {
+  } else if (outcome.kind === 'observe' || outcome.kind === 'converse' || outcome.kind === 'modify_run') {
     conversationMessages(session).push({ role: 'command', content: String(outcome.result?.explanation ?? 'Runtime control message accepted.') });
     onLog(`runtime: ${outcome.kind}`);
   } else if (outcome.kind === 'ambiguous') {

package/src/shell/useAgent.ts

@@ -1,6 +1,6 @@
 import { createSignal } from 'solid-js';
 import { postRuntimeCancel } from '../runtime/client.js';
-import { conversationMessages, recordRuntimeUnavailableAgentInput, runLine, shouldHandleFreeTextLocally, submitRuntimeTurn } from './repl.js';
+import { applyRuntimeOutcome, conversationMessages, recordRuntimeUnavailableAgentInput, runLine, shouldHandleFreeTextLocally, submitRuntimeTurn } from './repl.js';
 
 export function useAgent(props: { agent: unknown; packageJson: Record<string, unknown>; session: Record<string, any>; chatMode: () => boolean; runtimeUrl?: string | null; runtimeUnavailableReason?: string | null; refresh: () => void; addLog: (line: string) => void; onRuntimeAccepted?: () => void }) {
   const [busy, setBusy] = createSignal(false);
@@ -41,24 +41,12 @@ export function useAgent(props: { agent: unknown; packageJson: Record<string, un
           runtime: { url: props.runtimeUrl },
           session: props.session,
         });
-        if (outcome.kind === 'turn' || (outcome as any).result?.accepted === true) {
-          props.addLog('runtime: agent turn accepted');
-        } else if (outcome.kind === 'queued') {
-          // The server localizes control-lane acknowledgements from the
-          // session language (src/runtime/controlMessages.js) — always prefer
-          // its explanation over a local hardcoded string.
-          const explanation = (outcome as any).result?.explanation ?? 'Request added to the queue.';
-          conversationMessages(props.session).push({ role: 'command', content: String(explanation) });
-          props.addLog('runtime: control queued');
-        } else if ((outcome as any).result?.explanation) {
-          // Control-lane kinds (cancel / approve / observe / modify_run…):
-          // surface the server's localized explanation instead of an error.
-          conversationMessages(props.session).push({ role: 'command', content: String((outcome as any).result.explanation) });
-          props.addLog(`runtime: ${outcome.kind}`);
-        } else {
-          conversationMessages(props.session).push({ role: 'command', content: `Runtime error: ${outcome.message}` });
-          props.addLog(`runtime error: ${outcome.message}`);
-        }
+        // Same classification → message mapping as the legacy TTY shell —
+        // see applyRuntimeOutcome in repl.js. Control-lane acknowledgements
+        // (src/runtime/controlMessages.js) are deterministic and English-only
+        // by design, never localized; this only supplies the last-resort
+        // fallback text for a response that carries neither.
+        applyRuntimeOutcome(props.session, outcome, props.addLog);
         props.refresh();
         return { exit: false, runtime: true };
       }