@dotdrelle/wiki-manager 0.15.57 → 0.15.60

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.57",
+  "version": "0.15.60",
   "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.57",
-  "commit": "8c83b75"
+  "version": "0.15.60",
+  "commit": "8c5c615"
 }

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.57';
+const WIKI_MANAGER_VERSION = '0.15.60';
 
 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/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,26 @@
-// 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.',
+  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,7 @@ 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 { findSkill, listSkills } from '../core/skills.js';
 
 const PRIVATE_CONTROL_INPUTS = new WeakMap();
@@ -347,7 +347,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 +422,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);

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/);

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/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 };
       }