@dotdrelle/wiki-manager 0.12.0 → 0.12.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dotdrelle/wiki-manager",
-  "version": "0.12.0",
+  "version": "0.12.1",
   "description": "Agentic shell and orchestration cockpit for llm-wiki workspaces.",
   "license": "PolyForm-Noncommercial-1.0.0",
   "author": "dotrelle",
@@ -11,7 +11,7 @@
   },
   "scripts": {
     "start": "bun ./bin/wiki-manager.js",
-    "test": "node --test src/agent/graph.test.js src/contracts/schemas.test.js src/core/activity.test.js src/core/agentEvents.test.js src/core/runtimeLog.test.js src/activity/activityAggregator.test.js src/graph/runGraphProjector.test.js src/core/workflow.test.js src/core/planPatch.test.js src/core/agentLoop.test.js src/core/plan.test.js src/core/mcp.test.js src/core/documentIntake.test.js src/core/dockerCompose.test.js src/core/wikiWorkspace.test.js src/core/wikirc.test.js src/core/modelFetch.test.js src/core/startupCheck.test.js src/core/queueStore.test.js src/orchestrator/agentRegistry.test.js src/orchestrator/capabilityRegistry.test.js src/orchestrator/capabilityResolver.test.js src/orchestrator/planValidator.test.js src/orchestrator/planIntegrator.test.js src/orchestrator/scheduler.test.js src/orchestrator/attemptManager.test.js src/orchestrator/resultAggregator.test.js src/orchestrator/approvalPolicy.test.js src/commands/slash.test.js src/shell/repl.test.js src/runtime/store.test.js src/runtime/recoveryManager.test.js src/runtime/server.test.js src/runtime/supervisor.test.js src/runtime/runner.test.js src/runtime/runner.e2e.test.js src/runtime/donna-contract.test.js src/runtime/auth.test.js",
+    "test": "node --test src/agent/graph.test.js src/contracts/schemas.test.js src/core/activity.test.js src/core/agentEvents.test.js src/core/runtimeLog.test.js src/activity/activityAggregator.test.js src/graph/runGraphProjector.test.js src/core/workflow.test.js src/core/planPatch.test.js src/core/agentLoop.test.js src/core/plan.test.js src/core/mcp.test.js src/core/documentIntake.test.js src/core/dockerCompose.test.js src/core/wikiWorkspace.test.js src/core/wikirc.test.js src/core/modelFetch.test.js src/core/startupCheck.test.js src/core/queueStore.test.js src/orchestrator/agentRegistry.test.js src/orchestrator/capabilityRegistry.test.js src/orchestrator/capabilityResolver.test.js src/orchestrator/planValidator.test.js src/orchestrator/planIntegrator.test.js src/orchestrator/scheduler.test.js src/orchestrator/attemptManager.test.js src/orchestrator/resultAggregator.test.js src/orchestrator/approvalPolicy.test.js src/commands/slash.test.js src/shell/repl.test.js src/runtime/store.test.js src/runtime/controlMessages.test.js src/runtime/recoveryManager.test.js src/runtime/server.test.js src/runtime/supervisor.test.js src/runtime/runner.test.js src/runtime/runner.e2e.test.js src/runtime/donna-contract.test.js src/runtime/auth.test.js",
     "check-versions": "node scripts/check-versions.js",
     "prepack": "node scripts/check-versions.js",
     "prepublishOnly": "node scripts/check-versions.js",

package/src/agent/graph.js

@@ -5,7 +5,7 @@ import {
   callMcpTool,
   formatMcpToolResult,
   formatMcpToolsForAgent,
-  parseToolCallName,
+  resolveToolCallName,
 } from '../core/mcp.js';
 import { formatSkillsForAgent, readOptionalText } from '../core/skills.js';
 import { handleSlashCommand } from '../commands/slash.js';
@@ -18,6 +18,14 @@ const MAX_TOOL_ITERATIONS = 80;
 const MAX_SPINNER_ARG_LENGTH = 96;
 const MAX_PROFILE_CHARS = 4000;
 
+// Pseudo-servers handled directly by the tool executor (not present in
+// session.mcp). Listed so unqualified names like "plan_set" resolve the same
+// way as MCP tools in resolveToolCallName.
+const INTERNAL_TOOL_SERVERS = {
+  wiki: ['plan_set', 'plan_done'],
+  shell: ['run_command', 'read_command', 'profile_update'],
+};
+
 const AGENT_SLASH_COMMANDS = new Set([
   'help',
   'version',
@@ -562,11 +570,11 @@ export function buildAgentSystemPrompt(state) {
     ].filter(Boolean).join('\n'),
     'For service actions, recommend only available service primitives from Available primitives, with the exact service name when the primitive supports one.',
     'Disambiguate export requests carefully.',
-    'Confluence/CME/source export means exporting external Confluence sources into raw/untracked: use cme MCP tools (`cme_export_run`, then `cme_export_status`). Never use production `type=export` for Confluence source export.',
-    'Wiki/deliverable/publication export means exporting generated deliverables from the wiki: use production MCP tools (`production_start_job` with `type:"export"` or pipeline steps). Require the deliverable path when exporting deliverables.',
-    'For ingest/build/export/polish/pipeline workflows, use production MCP tools. Do not route these through direct /wiki shortcuts. To chain multiple sequential steps (e.g. build then polish), always use a single production_start_job call with type="pipeline" and steps=["build","polish"] — never start them as separate jobs: the first job is asynchronous and the second would run before it completes. For existing deliverables where content stability matters, pass stabilize:true so the build step preserves unchanged sections; keep polish in the pipeline when publication output is requested. Do not ask the user to confirm between steps; start the pipeline call directly.',
+    'Confluence/CME/source export means exporting external Confluence sources into raw/untracked: use cme MCP tools (`cme__cme_export_run`, then `cme__cme_export_status`). Never use production `type=export` for Confluence source export.',
+    'Wiki/deliverable/publication export means exporting generated deliverables from the wiki: use production MCP tools (`production__production_start_job` with `type:"export"` or pipeline steps). Require the deliverable path when exporting deliverables.',
+    'For ingest/build/export/polish/pipeline workflows, use production MCP tools. Do not route these through direct /wiki shortcuts. To chain multiple sequential steps (e.g. build then polish), always use a single production__production_start_job call with type="pipeline" and steps=["build","polish"] — never start them as separate jobs: the first job is asynchronous and the second would run before it completes. For existing deliverables where content stability matters, pass stabilize:true so the build step preserves unchanged sections; keep polish in the pipeline when publication output is requested. Do not ask the user to confirm between steps; start the pipeline call directly.',
     'Long-running MCP jobs: do not call the same status tool more than once consecutively. When chaining jobs sequentially: (1) start the job, report job/activity id and status; (2) check status once — if done, proceed to the next step immediately; (3) if still running, report status, list the remaining steps, and return control; (4) when re-invoked, check status first, then proceed. Do not spin-poll (status → status → status with no new action between). The shell activity panel monitors non-terminal jobs automatically.',
-    'If production_start_job is returned as queued/waiting by the manager, report that it is waiting in the local queue and return control. Do not continue as if the production job has started.',
+    'If production__production_start_job is returned as queued/waiting by the manager, report that it is waiting in the local queue and return control. Do not continue as if the production job has started.',
     'For diagnostics, use /wiki run doctor when the user asks for doctor. Use /workspace init <name> [path] for low-level non-interactive workspace creation. In the interactive TUI, /new <name> opens the setup wizard. Use /wiki for index, or /wiki run index through the explicit backup hatch. Use /wiki run init only for explicit current-workspace llm-wiki init.',
     'If an action requires tools or skills not available yet, explain the limitation and name the expected primitive.',
     workspaceProfile
@@ -771,11 +779,19 @@ export function createAgentGraph(options = {}) {
     const toolResultMessages = [];
 
     for (const call of toolCalls) {
-      const { server, tool } = parseToolCallName(call.function.name);
+      const resolved = resolveToolCallName(state.session.mcp, call.function.name, INTERNAL_TOOL_SERVERS);
+      const { server, tool } = resolved;
       const argsSummary = summarizeToolArguments(call.function.arguments);
       const isInternalWikiTool = server === 'wiki' && (tool === 'plan_set' || tool === 'plan_done');
       const serverLabel = server === 'shell' ? 'Shell' : isInternalWikiTool ? 'Plan' : 'MCP';
-      const toolName = `${server}.${tool}`;
+      const toolName = server ? `${server}.${tool}` : call.function.name;
+      if (resolved.normalized) {
+        // Keep normalizations visible: the defensive routing must not hide
+        // prompt/skill regressions that reintroduce unqualified names.
+        state.session._onStep?.(
+          `tool name normalized: ${call.function.name} -> ${server}__${tool}`,
+        );
+      }
       state.session._onStep?.(
         `[${state.toolIterations}/${MAX_TOOL_ITERATIONS}] ${serverLabel} ${toolName}${argsSummary ? ` (${argsSummary})` : ''}`,
       );
@@ -796,6 +812,18 @@ export function createAgentGraph(options = {}) {
       let resultText;
       let ok = true;
       try {
+        if (!server) {
+          if (resolved.candidates.length > 1) {
+            throw new Error(
+              `Ambiguous unqualified tool name "${call.function.name}": several connected servers expose it. `
+              + `Use the <server>__<tool> form: ${resolved.candidates.map((s) => `${s}__${tool}`).join(', ')}.`,
+            );
+          }
+          throw new Error(
+            `Unqualified tool call name "${call.function.name}". Tool calls must use the <server>__<tool> `
+            + `naming convention (e.g. production__production_start_job); no connected server exposes a tool named "${tool}".`,
+          );
+        }
         let args = JSON.parse(call.function.arguments ?? '{}');
         if (server === 'production' && tool === 'production_start_job' && state.session.workspace && !args.callerLabel) {
           args = { ...args, callerLabel: `${state.session.workspace}/wiki-manager` };
@@ -869,7 +897,7 @@ export function createAgentGraph(options = {}) {
           err.name === 'ApprovalError'
         ) throw err;
         ok = false;
-        resultText = `Error [${server}.${tool}]: ${err instanceof Error ? err.message : String(err)}`;
+        resultText = `Error [${toolName}]: ${err instanceof Error ? err.message : String(err)}`;
         if (minimalPlanActive && state.session.headlessPlan?.[0]?._activityKey === null) {
           emitAgentEvent(state.session, 'plan_step_updated', 'tool', { step: 1, status: 'failed' });
         }

package/src/agent/graph.test.js

@@ -387,3 +387,50 @@ test('buildAgentSystemPrompt forbids inventing slash commands or arguments', ()
   assert.doesNotMatch(prompt, /executorQuery/);
   assert.doesNotMatch(prompt, /executor:"/);
 });
+
+// Guard: the system prompt must never show a connected tool's bare name
+// outside its qualified server__tool form. Bare mentions are what teach the
+// model to emit unqualified tool calls (the cme_status incident). The bare
+// name list comes from the session's declared servers, never from a manual
+// list (amendment A6). New prompt text or injected skill descriptions that
+// reintroduce a bare name must fail here.
+test('buildAgentSystemPrompt contains no unqualified tool names for connected servers', () => {
+  const session = sessionBase({
+    mcp: {
+      production: {
+        status: 'connected',
+        tools: [
+          { name: 'production_start_job' }, { name: 'production_job_status' },
+          { name: 'production_job_logs' }, { name: 'production_cancel_job' },
+          { name: 'production_list_jobs' }, { name: 'production_list_templates' },
+          { name: 'production_status' }, { name: 'agent_describe' },
+          { name: 'agent_plan' }, { name: 'agent_execute' },
+          { name: 'agent_status' }, { name: 'agent_cancel' },
+        ],
+      },
+      cme: {
+        status: 'connected',
+        tools: [
+          { name: 'cme_status' }, { name: 'cme_setup' },
+          { name: 'cme_sources_list' }, { name: 'cme_source_add' },
+          { name: 'cme_source_remove' }, { name: 'cme_export_run' },
+          { name: 'cme_export_status' }, { name: 'cme_export_cancel' },
+          { name: 'agent_describe' }, { name: 'agent_execute' },
+          { name: 'agent_status' }, { name: 'agent_cancel' },
+        ],
+      },
+    },
+  });
+  const prompt = buildAgentSystemPrompt({ session });
+  const offenders = [];
+  for (const [serverName, value] of Object.entries(session.mcp)) {
+    for (const tool of value.tools) {
+      // A bare occurrence is the tool name not embedded in a wider
+      // identifier: `production__production_start_job` does not match
+      // because the inner occurrence is preceded by `_`.
+      const bare = new RegExp(`(?<![\\w])${tool.name}(?![\\w])`);
+      if (bare.test(prompt)) offenders.push(`${serverName}:${tool.name}`);
+    }
+  }
+  assert.deepEqual(offenders, [], `Unqualified tool names found in system prompt: ${offenders.join(', ')}`);
+});

package/src/contracts/schemas.test.js

@@ -50,7 +50,7 @@ test('agent event contract carries the unified audit identity fields', () => {
     runId: 'run-1',
     turnId: 'turn-1',
     taskId: 'task-1',
-    workspace: 'juno',
+    workspace: 'acme',
     payload: { toolCallId: 'call-1', ok: true },
   };
 
@@ -58,7 +58,7 @@ test('agent event contract carries the unified audit identity fields', () => {
 });
 
 test('run and control request contracts reject empty run input but accept explicit controls', () => {
-  assert.equal(validateContract('runRequest', { input: 'Build docs', workspace: 'juno' }).ok, true);
+  assert.equal(validateContract('runRequest', { input: 'Build docs', workspace: 'acme' }).ok, true);
   assert.equal(validateContract('runRequest', { input: '' }).ok, false);
   assert.equal(validateContract('controlMessage', { action: 'message', input: 'Ou en est le build ?', intent: 'observe' }).ok, true);
 });

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.12.0';
+const WIKI_MANAGER_VERSION = '0.12.1';
 
 function envValue(key) {
   const filePath = managerEnvFile();
@@ -174,7 +174,7 @@ function clarifyToolDescription(serverName, toolName, description) {
   if (serverName === 'production' && toolName === 'production_start_job') {
     return compactDescription([
       base,
-      'Production export means wiki deliverable/publication export only. Do not use type=export for Confluence/CME/source export; use cme_export_run instead.',
+      'Production export means wiki deliverable/publication export only. Do not use type=export for Confluence/CME/source export; use cme__cme_export_run instead.',
     ].filter(Boolean).join(' '));
   }
   return base;
@@ -469,7 +469,9 @@ export function formatMcpToolsForAgent(mcpStatus) {
       sections.push(`${name}: connected, tools not discovered yet`);
       continue;
     }
-    sections.push(`${name}: ${tools.map((tool) => tool.name).join(', ')}`);
+    // Always advertise the qualified call name (server__tool): showing bare
+    // tool names here is what teaches the model to emit unqualified calls.
+    sections.push(`${name}: ${tools.map((tool) => `${name}__${tool.name}`).join(', ')}`);
   }
   return sections.length > 0 ? sections.join('\n') : 'No connected MCP tools discovered yet.';
 }
@@ -498,6 +500,31 @@ export function parseToolCallName(name) {
   return { server: name.slice(0, sep), tool: name.slice(sep + 2) };
 }
 
+// Deterministic recovery for unqualified tool-call names emitted by the LLM
+// (e.g. "cme_status" instead of "cme__cme_status"). Exact-name match only:
+// if exactly one connected server (or extra pseudo-server) exposes the bare
+// tool name, route to it and report `normalized: true`; otherwise return
+// `server: null` with the list of candidate servers so the caller can raise
+// an explicit error. This is name normalization, never fuzzy matching — do
+// not extend it to description/similarity-based selection (plan directeur
+// §20 forbids that).
+export function resolveToolCallName(mcpStatus, name, extraServers = {}) {
+  const parsed = parseToolCallName(name);
+  if (parsed.server) return { ...parsed, normalized: false, candidates: [] };
+  const candidates = [];
+  for (const [serverName, toolNames] of Object.entries(extraServers)) {
+    if (toolNames.includes(parsed.tool)) candidates.push(serverName);
+  }
+  for (const [serverName, value] of Object.entries(mcpStatus ?? {})) {
+    if (value.status !== 'connected') continue;
+    if ((value.tools ?? []).some((tool) => tool.name === parsed.tool)) candidates.push(serverName);
+  }
+  if (candidates.length === 1) {
+    return { server: candidates[0], tool: parsed.tool, normalized: true, candidates };
+  }
+  return { server: null, tool: parsed.tool, normalized: false, candidates };
+}
+
 export function mcpStatusMarker(status) {
   if (status === 'connected') return '●';
   if (status === 'configured') return '◐';

package/src/core/mcp.test.js

@@ -3,7 +3,75 @@ import assert from 'node:assert/strict';
 import { mkdtemp, writeFile } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
-import { buildMcpStatus, callMcpTool, discoverMcpTools, resolveRetryPolicy } from './mcp.js';
+import {
+  buildMcpStatus,
+  callMcpTool,
+  discoverMcpTools,
+  formatMcpToolsForAgent,
+  resolveRetryPolicy,
+  resolveToolCallName,
+} from './mcp.js';
+
+const resolveFixtureStatus = {
+  production: {
+    status: 'connected',
+    tools: [{ name: 'production_start_job' }, { name: 'agent_status' }],
+  },
+  cme: {
+    status: 'connected',
+    tools: [{ name: 'cme_status' }, { name: 'agent_status' }],
+  },
+  documents: {
+    status: 'configured', // not connected: must never be a candidate
+    tools: [{ name: 'cme_status' }],
+  },
+};
+
+test('resolveToolCallName passes qualified names through untouched', () => {
+  const resolved = resolveToolCallName(resolveFixtureStatus, 'cme__cme_status');
+  assert.deepEqual(
+    { server: resolved.server, tool: resolved.tool, normalized: resolved.normalized },
+    { server: 'cme', tool: 'cme_status', normalized: false },
+  );
+});
+
+test('resolveToolCallName normalizes a bare name with exactly one connected match', () => {
+  const resolved = resolveToolCallName(resolveFixtureStatus, 'cme_status');
+  assert.deepEqual(
+    { server: resolved.server, tool: resolved.tool, normalized: resolved.normalized },
+    { server: 'cme', tool: 'cme_status', normalized: true },
+  );
+});
+
+test('resolveToolCallName refuses ambiguous bare names and reports candidates', () => {
+  const resolved = resolveToolCallName(resolveFixtureStatus, 'agent_status');
+  assert.equal(resolved.server, null);
+  assert.equal(resolved.normalized, false);
+  assert.deepEqual([...resolved.candidates].sort(), ['cme', 'production']);
+});
+
+test('resolveToolCallName returns no server for unknown bare names', () => {
+  const resolved = resolveToolCallName(resolveFixtureStatus, 'does_not_exist');
+  assert.equal(resolved.server, null);
+  assert.deepEqual(resolved.candidates, []);
+});
+
+test('resolveToolCallName resolves internal pseudo-server tools via extraServers', () => {
+  const resolved = resolveToolCallName(resolveFixtureStatus, 'plan_set', { wiki: ['plan_set', 'plan_done'] });
+  assert.deepEqual(
+    { server: resolved.server, tool: resolved.tool, normalized: resolved.normalized },
+    { server: 'wiki', tool: 'plan_set', normalized: true },
+  );
+});
+
+test('formatMcpToolsForAgent advertises qualified server__tool names only', () => {
+  const listing = formatMcpToolsForAgent(resolveFixtureStatus);
+  assert.match(listing, /cme__cme_status/);
+  assert.match(listing, /production__production_start_job/);
+  // No bare tool name outside a qualified form.
+  assert.doesNotMatch(listing, /(?<![\w])cme_status(?![\w])/);
+  assert.doesNotMatch(listing, /(?<![\w])production_start_job(?![\w])/);
+});
 
 test('buildMcpStatus reads external MCP endpoints from mcp.endpoints.json', async () => {
   const originalCwd = process.cwd();

package/src/runtime/controlMessages.js

@@ -0,0 +1,43 @@
+// Deterministic, localized 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.
+
+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: 'The runtime cannot safely classify this message.',
+    fr: 'Le runtime ne peut pas classer ce message de façon sûre.',
+  },
+  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.',
+  },
+};
+
+export function controlLanguage(session) {
+  const raw = String(session?.language ?? 'en').toLowerCase();
+  return raw.startsWith('fr') ? 'fr' : 'en';
+}
+
+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;
+}

package/src/runtime/controlMessages.test.js

@@ -0,0 +1,21 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { controlLanguage, 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 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/);
+  assert.throws(() => controlMessage({ language: 'fr-FR' }, 'nope'), /Unknown control message key/);
+});

package/src/runtime/donna-contract.test.js

@@ -531,7 +531,7 @@ function toolResult(payload) {
 }
 
 test('Recipe #7 — "où en es-tu ?" during an active run: status in conversation, run continues, no new run', async (t) => {
-  const session = { workspace: 'juno', controlQueue: [] };
+  const session = { workspace: 'acme', controlQueue: [] };
   let runCount = 0;
   let handle;
   try {
@@ -550,7 +550,7 @@ test('Recipe #7 — "où en es-tu ?" during an active run: status in conversatio
         listEvents: () => [],
       },
       getContext: async () => ({
-        workspace: 'juno',
+        workspace: 'acme',
         session,
         running: true,
         currentAbortController: new AbortController(),
@@ -566,7 +566,7 @@ test('Recipe #7 — "où en es-tu ?" during an active run: status in conversatio
   }
 
   try {
-    const response = await fetch(`http://127.0.0.1:${handle.port}/control?workspace=juno`, {
+    const response = await fetch(`http://127.0.0.1:${handle.port}/control?workspace=acme`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({ action: 'message', input: 'où en es-tu ?' }),

package/src/runtime/server.js

@@ -5,6 +5,7 @@ import { activeCacertPath } from '../core/cacert.js';
 import { normalizePlanPatch, rebasePlanPatch } from '../core/planPatch.js';
 import { validateContractInDev } from '../contracts/schemas.js';
 import { runtimeTokenFromEnv } from './auth.js';
+import { controlMessage } from './controlMessages.js';
 
 export function startRuntimeServer({
   host = '127.0.0.1',
@@ -248,7 +249,7 @@ export function startRuntimeServer({
               kind: 'enqueue_run',
               item,
               ...controlStatus(context, store),
-              explanation: 'Request queued for a future run.',
+              explanation: controlMessage(context?.session, 'queued_for_future_run'),
             });
             return;
           }
@@ -522,7 +523,7 @@ async function handleControlMessage(context, store, input, { intent = null, star
         classification,
         proposal,
         ...controlStatus(context, store),
-        explanation: 'Plan patch proposed. Approve it explicitly to apply it to the active plan.',
+        explanation: controlMessage(context?.session, 'plan_patch_proposed'),
       },
     };
   }
@@ -540,12 +541,12 @@ async function handleControlMessage(context, store, input, { intent = null, star
         classification,
         item,
         ...controlStatus(context, store),
-        explanation: 'Request queued for a future run.',
+        explanation: controlMessage(context?.session, 'queued_for_future_run'),
       },
     };
   }
   if (classification.kind === 'ambiguous') {
-    return readOnlyControlResponse('ambiguous', classification, status, 'The runtime cannot safely classify this message.', {
+    return readOnlyControlResponse('ambiguous', classification, status, controlMessage(context?.session, 'ambiguous_control'), {
       accepted: false,
       extra: {
         choices: [
@@ -557,8 +558,8 @@ async function handleControlMessage(context, store, input, { intent = null, star
     });
   }
   return readOnlyControlResponse('converse', classification, status, status.running
-    ? 'Runtime run is still active. This message was treated as conversation and did not create a queued run.'
-    : 'Runtime is idle. This message was treated as conversation and did not create a run.');
+    ? controlMessage(context?.session, 'converse_while_running')
+    : controlMessage(context?.session, 'converse_while_idle'));
 }
 
 function enqueueControlRequest(context, input) {

package/src/runtime/server.test.js

@@ -271,7 +271,7 @@ test('runtime server returns the accepted run id and passes it to the runner', a
     const response = await fetch(`http://127.0.0.1:${handle.port}/run`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ input: 'build', workspace: 'juno', evaluate: false, replans: 1 }),
+      body: JSON.stringify({ input: 'build', workspace: 'acme', evaluate: false, replans: 1 }),
     });
     assert.equal(response.status, 202);
     const body = await response.json();
@@ -279,7 +279,7 @@ test('runtime server returns the accepted run id and passes it to the runner', a
     assert.match(body.runId, /^[0-9a-f-]{36}$/);
     await new Promise((resolve) => setImmediate(resolve));
     assert.equal(receivedBody.runId, body.runId);
-    assert.equal(receivedBody.workspace, 'juno');
+    assert.equal(receivedBody.workspace, 'acme');
     assert.equal(receivedBody.evaluate, false);
     assert.equal(receivedBody.replans, 1);
   } finally {
@@ -290,8 +290,8 @@ test('runtime server returns the accepted run id and passes it to the runner', a
 test('runtime server state exposes active run identity while running', async (t) => {
   let releaseRun;
   const context = {
-    workspace: 'juno',
-    session: { workspace: 'juno' },
+    workspace: 'acme',
+    session: { workspace: 'acme' },
     running: false,
     currentAbortController: null,
     currentRunId: null,
@@ -321,18 +321,18 @@ test('runtime server state exposes active run identity while running', async (t)
   }
 
   try {
-    const runResponse = await fetch(`http://127.0.0.1:${handle.port}/run?workspace=juno`, {
+    const runResponse = await fetch(`http://127.0.0.1:${handle.port}/run?workspace=acme`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({ input: 'build' }),
     });
     acceptedRun = await runResponse.json();
-    const stateResponse = await fetch(`http://127.0.0.1:${handle.port}/state?workspace=juno`);
+    const stateResponse = await fetch(`http://127.0.0.1:${handle.port}/state?workspace=acme`);
     const state = await stateResponse.json();
     assert.equal(state.status, 'running');
     assert.equal(state.running, true);
     assert.equal(state.runId, acceptedRun.runId);
-    assert.equal(state.workspace, 'juno');
+    assert.equal(state.workspace, 'acme');
   } finally {
     releaseRun?.();
     await handle.close();
@@ -381,8 +381,8 @@ test('runtime server isolates active runs by workspace', async (t) => {
 
   try {
     const url = `http://127.0.0.1:${handle.port}/run`;
-    const [juno, docs] = await Promise.all([
-      fetch(`${url}?workspace=juno`, {
+    const [acme, docs] = await Promise.all([
+      fetch(`${url}?workspace=acme`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
         body: JSON.stringify({ input: 'first' }),
@@ -393,18 +393,18 @@ test('runtime server isolates active runs by workspace', async (t) => {
         body: JSON.stringify({ input: 'second' }),
       }),
     ]);
-    assert.deepEqual([juno.status, docs.status], [202, 202]);
+    assert.deepEqual([acme.status, docs.status], [202, 202]);
 
-    const queued = await fetch(`${url}?workspace=juno`, {
+    const queued = await fetch(`${url}?workspace=acme`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({ input: 'third' }),
     });
     assert.equal(queued.status, 202);
     assert.equal((await queued.json()).queued, true);
-    assert.deepEqual(runWorkspaces.sort(), ['docs', 'juno']);
+    assert.deepEqual(runWorkspaces.sort(), ['acme', 'docs']);
   } finally {
-    releases.get('juno')?.();
+    releases.get('acme')?.();
     releases.get('docs')?.();
     await handle.close();
   }
@@ -446,10 +446,10 @@ test('runtime server filters state and events by workspace', async (t) => {
   }
 
   try {
-    const state = await fetch(`http://127.0.0.1:${handle.port}/state?workspace=juno`);
+    const state = await fetch(`http://127.0.0.1:${handle.port}/state?workspace=acme`);
     assert.equal(state.status, 200);
-    assert.equal((await state.json()).workspace, 'juno');
-    assert.equal(stateWorkspace, 'juno');
+    assert.equal((await state.json()).workspace, 'acme');
+    assert.equal(stateWorkspace, 'acme');
 
     const events = await fetch(`http://127.0.0.1:${handle.port}/events?workspace=docs`);
     assert.equal(events.status, 200);
@@ -533,15 +533,15 @@ test('runtime server exposes manual resume endpoint', async (t) => {
   }
 
   try {
-    const response = await fetch(`http://127.0.0.1:${handle.port}/resume?workspace=juno`, {
+    const response = await fetch(`http://127.0.0.1:${handle.port}/resume?workspace=acme`, {
       method: 'POST',
     });
     assert.equal(response.status, 202);
-    assert.equal(resumedWorkspace, 'juno');
+    assert.equal(resumedWorkspace, 'acme');
     assert.deepEqual(await response.json(), {
       resumed: 1,
       interrupted: 0,
-      workspaces: [{ workspace: 'juno', resumed: true }],
+      workspaces: [{ workspace: 'acme', resumed: true }],
     });
   } finally {
     await handle.close();
@@ -575,13 +575,13 @@ test('runtime server exposes approval endpoint', async (t) => {
   }
 
   try {
-    const response = await fetch(`http://127.0.0.1:${handle.port}/approve?workspace=juno&runId=run-1&itemId=item-1`, {
+    const response = await fetch(`http://127.0.0.1:${handle.port}/approve?workspace=acme&runId=run-1&itemId=item-1`, {
       method: 'POST',
     });
     assert.equal(response.status, 202);
     assert.deepEqual(approved, {
-      workspace: 'juno',
-      workspaceId: 'juno',
+      workspace: 'acme',
+      workspaceId: 'acme',
       runId: 'run-1',
       itemId: 'item-1',
       approvalId: null,
@@ -599,8 +599,8 @@ test('runtime server exposes approval endpoint', async (t) => {
 
 test('runtime server exposes control status and explanation', async (t) => {
   const session = {
-    workspace: 'juno',
-    controlQueue: [{ id: 'control-1', workspace: 'juno', status: 'queued', input: 'later' }],
+    workspace: 'acme',
+    controlQueue: [{ id: 'control-1', workspace: 'acme', status: 'queued', input: 'later' }],
   };
   let handle;
   try {
@@ -620,7 +620,7 @@ test('runtime server exposes control status and explanation', async (t) => {
         listEvents: () => [],
       },
       getContext: async () => ({
-        workspace: 'juno',
+        workspace: 'acme',
         session,
         running: false,
         currentAbortController: null,
@@ -636,14 +636,14 @@ test('runtime server exposes control status and explanation', async (t) => {
   }
 
   try {
-    const status = await fetch(`http://127.0.0.1:${handle.port}/control?workspace=juno`);
+    const status = await fetch(`http://127.0.0.1:${handle.port}/control?workspace=acme`);
     assert.equal(status.status, 200);
     const statusBody = await status.json();
     assert.equal(statusBody.status, 'idle');
     assert.equal(statusBody.running, false);
     assert.equal(statusBody.controlQueue[0].id, 'control-1');
 
-    const explain = await fetch(`http://127.0.0.1:${handle.port}/control?workspace=juno`, {
+    const explain = await fetch(`http://127.0.0.1:${handle.port}/control?workspace=acme`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({ action: 'explain' }),
@@ -657,7 +657,7 @@ test('runtime server exposes control status and explanation', async (t) => {
 
 test('runtime server control enqueue emits events but does not patch an active plan or start a run', async (t) => {
   const session = {
-    workspace: 'juno',
+    workspace: 'acme',
     controlQueue: [],
   };
   const events = [];
@@ -681,7 +681,7 @@ test('runtime server control enqueue emits events but does not patch an active p
         listEvents: () => [],
       },
       getContext: async () => ({
-        workspace: 'juno',
+        workspace: 'acme',
         session,
         running: true,
         currentAbortController: new AbortController(),
@@ -697,7 +697,7 @@ test('runtime server control enqueue emits events but does not patch an active p
   }
 
   try {
-    const response = await fetch(`http://127.0.0.1:${handle.port}/control?workspace=juno`, {
+    const response = await fetch(`http://127.0.0.1:${handle.port}/control?workspace=acme`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({ action: 'enqueue', input: 'run this after current work' }),
@@ -718,7 +718,7 @@ test('runtime server control enqueue emits events but does not patch an active p
 
 test('runtime server control message observes an active run without enqueueing', async (t) => {
   const session = {
-    workspace: 'juno',
+    workspace: 'acme',
     controlQueue: [],
   };
   let runCount = 0;
@@ -739,7 +739,7 @@ test('runtime server control message observes an active run without enqueueing',
         listEvents: () => [],
       },
       getContext: async () => ({
-        workspace: 'juno',
+        workspace: 'acme',
         session,
         running: true,
         currentAbortController: new AbortController(),
@@ -755,7 +755,7 @@ test('runtime server control message observes an active run without enqueueing',
   }
 
   try {
-    const response = await fetch(`http://127.0.0.1:${handle.port}/control?workspace=juno`, {
+    const response = await fetch(`http://127.0.0.1:${handle.port}/control?workspace=acme`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({ action: 'message', input: 'Où en est le build ?' }),
@@ -773,7 +773,7 @@ test('runtime server control message observes an active run without enqueueing',
 
 test('runtime server control message handles approve and cancel intents during an active run', async (t) => {
   const session = {
-    workspace: 'juno',
+    workspace: 'acme',
     controlQueue: [],
   };
   const abortController = new AbortController();
@@ -795,7 +795,7 @@ test('runtime server control message handles approve and cancel intents during a
         listEvents: () => [],
       },
       getContext: async () => ({
-        workspace: 'juno',
+        workspace: 'acme',
         session,
         running: true,
         currentAbortController: abortController,
@@ -812,7 +812,7 @@ test('runtime server control message handles approve and cancel intents during a
   }
 
   try {
-    const approveResponse = await fetch(`http://127.0.0.1:${handle.port}/control?workspace=juno`, {
+    const approveResponse = await fetch(`http://127.0.0.1:${handle.port}/control?workspace=acme`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({ action: 'message', input: 'valide tout' }),
@@ -820,7 +820,7 @@ test('runtime server control message handles approve and cancel intents during a
     assert.equal(approveResponse.status, 200);
     assert.equal((await approveResponse.json()).kind, 'approve');
 
-    const cancelResponse = await fetch(`http://127.0.0.1:${handle.port}/control?workspace=juno`, {
+    const cancelResponse = await fetch(`http://127.0.0.1:${handle.port}/control?workspace=acme`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({ action: 'message', input: 'annule le run' }),
@@ -837,18 +837,18 @@ test('runtime server control message handles approve and cancel intents during a
 
 test('runtime server control message records active plan mutation as a proposal', async (t) => {
   const session = {
-    workspace: 'juno',
+    workspace: 'acme',
     controlQueue: [],
   };
   dispatchAgentEvent(session, createAgentEvent('run_started', {
     origin: 'runtime',
     runId: 'run-mutate',
-    workspace: 'juno',
+    workspace: 'acme',
   }));
   dispatchAgentEvent(session, createAgentEvent('plan_set', {
     origin: 'tool',
     runId: 'run-mutate',
-    workspace: 'juno',
+    workspace: 'acme',
     payload: {
       steps: [{ step: 1, id: 'generate', description: 'Generate', status: 'running' }],
     },
@@ -865,13 +865,13 @@ test('runtime server control message records active plan mutation as a proposal'
           ...session.agentProjection,
           status: session.agentProjection?.status ?? 'running',
           queue: [],
-          runs: [{ id: 'run-mutate', workspace: 'juno', status: 'running' }],
+          runs: [{ id: 'run-mutate', workspace: 'acme', status: 'running' }],
           runId: 'run-mutate',
         }),
         listEvents: () => [],
       },
       getContext: async () => ({
-        workspace: 'juno',
+        workspace: 'acme',
         session,
         running: true,
         currentAbortController: new AbortController(),
@@ -888,7 +888,7 @@ test('runtime server control message records active plan mutation as a proposal'
   }
 
   try {
-    const response = await fetch(`http://127.0.0.1:${handle.port}/control?workspace=juno`, {
+    const response = await fetch(`http://127.0.0.1:${handle.port}/control?workspace=acme`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({ action: 'message', input: 'Ajoute un envoi après chaque génération' }),
@@ -901,7 +901,7 @@ test('runtime server control message records active plan mutation as a proposal'
     assert.equal(session.agentProjection.planPatches[0].status, 'proposed');
     assert.ok(session.agentEvents.some((event) => event.type === 'control_message_received'));
     assert.ok(session.agentEvents.some((event) => event.type === 'plan_patch_proposed'));
-    const approveResponse = await fetch(`http://127.0.0.1:${handle.port}/control?workspace=juno`, {
+    const approveResponse = await fetch(`http://127.0.0.1:${handle.port}/control?workspace=acme`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({ action: 'approve_patch', patchId: body.proposal.id }),
@@ -924,7 +924,7 @@ 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) => {
   const session = {
-    workspace: 'juno',
+    workspace: 'acme',
     controlQueue: [],
   };
   let runCount = 0;
@@ -945,7 +945,7 @@ test('runtime server control message reports ambiguity without starting a run',
         listEvents: () => [],
       },
       getContext: async () => ({
-        workspace: 'juno',
+        workspace: 'acme',
         session,
         running: true,
         currentAbortController: new AbortController(),
@@ -961,7 +961,7 @@ test('runtime server control message reports ambiguity without starting a run',
   }
 
   try {
-    const response = await fetch(`http://127.0.0.1:${handle.port}/control?workspace=juno`, {
+    const response = await fetch(`http://127.0.0.1:${handle.port}/control?workspace=acme`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({ action: 'message', input: 'Lance aussi la publication' }),
@@ -979,7 +979,7 @@ test('runtime server control message reports ambiguity without starting a run',
 
 test('runtime server drains queued control requests when idle', async (t) => {
   const session = {
-    workspace: 'juno',
+    workspace: 'acme',
     controlQueue: [],
   };
   const events = [];
@@ -1003,7 +1003,7 @@ test('runtime server drains queued control requests when idle', async (t) => {
         listEvents: () => [],
       },
       getContext: async () => ({
-        workspace: 'juno',
+        workspace: 'acme',
         session,
         running: false,
         currentAbortController: null,
@@ -1021,7 +1021,7 @@ test('runtime server drains queued control requests when idle', async (t) => {
   }
 
   try {
-    const response = await fetch(`http://127.0.0.1:${handle.port}/control?workspace=juno`, {
+    const response = await fetch(`http://127.0.0.1:${handle.port}/control?workspace=acme`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({ action: 'enqueue', input: 'run from control queue' }),
@@ -1029,7 +1029,7 @@ test('runtime server drains queued control requests when idle', async (t) => {
     assert.equal(response.status, 202);
     await new Promise((resolve) => setImmediate(resolve));
     assert.equal(receivedBody.input, 'run from control queue');
-    assert.equal(receivedBody.workspace, 'juno');
+    assert.equal(receivedBody.workspace, 'acme');
     assert.match(receivedBody.runId, /^[0-9a-f-]{36}$/);
     assert.equal(session.controlQueue[0].status, 'running');
     assert.equal(session.controlQueue[0].runId, receivedBody.runId);
@@ -1041,13 +1041,13 @@ test('runtime server drains queued control requests when idle', async (t) => {
 
 test('runtime server handle drains a pre-existing hydrated control request', async (t) => {
   const session = {
-    workspace: 'juno',
-    controlQueue: [{ id: 'control-existing', workspace: 'juno', status: 'queued', input: 'resume queued control' }],
+    workspace: 'acme',
+    controlQueue: [{ id: 'control-existing', workspace: 'acme', status: 'queued', input: 'resume queued control' }],
   };
   const events = [];
   session._onAgentEvent = (event) => events.push(event);
   const context = {
-    workspace: 'juno',
+    workspace: 'acme',
     session,
     running: false,
     currentAbortController: null,
@@ -1089,8 +1089,8 @@ test('runtime server handle drains a pre-existing hydrated control request', asy
 
 test('runtime server exposes config profile list and switch endpoints', async (t) => {
   const context = {
-    workspace: 'juno',
-    session: { workspace: 'juno', wikirc: { profile: 'default' } },
+    workspace: 'acme',
+    session: { workspace: 'acme', wikirc: { profile: 'default' } },
     running: false,
     currentAbortController: null,
   };
@@ -1123,11 +1123,11 @@ test('runtime server exposes config profile list and switch endpoints', async (t
   }
 
   try {
-    const profiles = await fetch(`http://127.0.0.1:${handle.port}/config/profiles?workspace=juno`);
+    const profiles = await fetch(`http://127.0.0.1:${handle.port}/config/profiles?workspace=acme`);
     assert.equal(profiles.status, 200);
     assert.deepEqual(await profiles.json(), { profiles: ['default', 'vpn'], active: 'default' });
 
-    const use = await fetch(`http://127.0.0.1:${handle.port}/config/use?workspace=juno`, {
+    const use = await fetch(`http://127.0.0.1:${handle.port}/config/use?workspace=acme`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({ profile: 'vpn' }),
@@ -1152,8 +1152,8 @@ test('runtime server rejects config switching while a run is active', async (t)
         listEvents: () => [],
       },
       getContext: async () => ({
-        workspace: 'juno',
-        session: { workspace: 'juno' },
+        workspace: 'acme',
+        session: { workspace: 'acme' },
         running: true,
         currentAbortController: null,
       }),
@@ -1169,7 +1169,7 @@ test('runtime server rejects config switching while a run is active', async (t)
   }
 
   try {
-    const response = await fetch(`http://127.0.0.1:${handle.port}/config/use?workspace=juno`, {
+    const response = await fetch(`http://127.0.0.1:${handle.port}/config/use?workspace=acme`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({ profile: 'vpn' }),

package/src/runtime/store.test.js

@@ -281,8 +281,8 @@ test('runtime store persists duplicate events idempotently', () => {
     origin: 'test',
     runId: 'run-1',
     turnId: 'run-1:turn-0',
-    workspace: 'juno',
-    payload: { input: 'build wiki', workspace: 'juno' },
+    workspace: 'acme',
+    payload: { input: 'build wiki', workspace: 'acme' },
   });
 
   store.persistEvent(event);
@@ -292,7 +292,7 @@ test('runtime store persists duplicate events idempotently', () => {
   assert.equal(store.listEvents()[0].sequence, 1);
   assert.equal(store.getState().eventsCursor, 1);
   assert.equal(store.listRuns()[0].id, 'run-1');
-  assert.equal(store.listRuns()[0].workspace, 'juno');
+  assert.equal(store.listRuns()[0].workspace, 'acme');
   assert.equal(store.listRuns()[0].status, 'running');
   store.close();
 });
@@ -590,19 +590,19 @@ test('runtime store persists cancelled run status', () => {
     origin: 'test',
     runId: 'run-1',
     turnId: 'run-1:turn-0',
-    workspace: 'juno',
-    payload: { input: 'build wiki', workspace: 'juno' },
+    workspace: 'acme',
+    payload: { input: 'build wiki', workspace: 'acme' },
   }));
   store.persistEvent(createAgentEvent('run_cancelled', {
     origin: 'test',
     runId: 'run-1',
     turnId: 'run-1:turn-1',
-    workspace: 'juno',
-    payload: { runId: 'run-1', workspace: 'juno' },
+    workspace: 'acme',
+    payload: { runId: 'run-1', workspace: 'acme' },
   }));
 
   assert.equal(store.listRuns()[0].status, 'cancelled');
-  assert.equal(store.listRuns()[0].workspace, 'juno');
+  assert.equal(store.listRuns()[0].workspace, 'acme');
   store.close();
 });
 
@@ -724,10 +724,10 @@ test('runtime store filters events runs and queue by workspace', () => {
   const store = openRuntimeStore({ stateDir });
   store.persistEvent(createAgentEvent('run_started', {
     origin: 'test',
-    runId: 'run-juno',
-    turnId: 'run-juno:turn-0',
-    workspace: 'juno',
-    payload: { input: 'juno', workspace: 'juno' },
+    runId: 'run-acme',
+    turnId: 'run-acme:turn-0',
+    workspace: 'acme',
+    payload: { input: 'acme', workspace: 'acme' },
   }));
   store.persistEvent(createAgentEvent('run_started', {
     origin: 'test',
@@ -736,12 +736,12 @@ test('runtime store filters events runs and queue by workspace', () => {
     workspace: 'docs',
     payload: { input: 'docs', workspace: 'docs' },
   }));
-  store.saveQueue([{ id: 'q-juno', workspace: 'juno', status: 'waiting' }], { workspace: 'juno' });
+  store.saveQueue([{ id: 'q-acme', workspace: 'acme', status: 'waiting' }], { workspace: 'acme' });
   store.saveQueue([{ id: 'q-docs', workspace: 'docs', status: 'waiting' }], { workspace: 'docs' });
 
-  assert.deepEqual(store.listEvents({ workspace: 'juno' }).map((event) => event.runId), ['run-juno']);
+  assert.deepEqual(store.listEvents({ workspace: 'acme' }).map((event) => event.runId), ['run-acme']);
   assert.deepEqual(store.listRuns({ workspace: 'docs' }).map((run) => run.id), ['run-docs']);
-  assert.deepEqual(store.listQueue({ workspace: 'juno' }).map((item) => item.id), ['q-juno']);
+  assert.deepEqual(store.listQueue({ workspace: 'acme' }).map((item) => item.id), ['q-acme']);
 
   const session = { activities: {}, headlessPlan: null };
   store.hydrateSession(session, { workspace: 'docs' });
@@ -794,8 +794,8 @@ test('runtime store persists and replays control queue events without mixing MCP
   }));
   store.persistEvent(createAgentEvent('control_enqueued', {
     origin: 'runtime',
-    workspace: 'juno',
-    payload: { id: 'control-juno', workspace: 'juno', input: 'other' },
+    workspace: 'acme',
+    payload: { id: 'control-acme', workspace: 'acme', input: 'other' },
   }));
   store.close();
 
@@ -925,10 +925,10 @@ test('runtime store identifies recoverable workspaces and interrupts stale runs'
   const stateDir = mkdtempSync(join(tmpdir(), 'wiki-manager-runtime-'));
   const store = openRuntimeStore({ stateDir });
   store.persistRun({
-    id: 'run-juno',
-    workspace: 'juno',
+    id: 'run-acme',
+    workspace: 'acme',
     status: 'running',
-    input: 'build juno',
+    input: 'build acme',
   });
   store.persistRun({
     id: 'run-done',
@@ -938,9 +938,9 @@ test('runtime store identifies recoverable workspaces and interrupts stale runs'
   });
   store.saveQueue([{ id: 'q-docs', workspace: 'docs', status: 'waiting' }], { workspace: 'docs' });
 
-  assert.deepEqual(store.listRecoverableWorkspaces(), ['docs', 'juno']);
-  assert.deepEqual(store.listRecoverableRuns({ workspace: 'juno' }).map((run) => run.id), ['run-juno']);
-  assert.equal(store.interruptRuns({ workspace: 'juno' }), 1);
-  assert.equal(store.listRuns({ workspace: 'juno' })[0].status, 'interrupted');
+  assert.deepEqual(store.listRecoverableWorkspaces(), ['acme', 'docs']);
+  assert.deepEqual(store.listRecoverableRuns({ workspace: 'acme' }).map((run) => run.id), ['run-acme']);
+  assert.equal(store.interruptRuns({ workspace: 'acme' }), 1);
+  assert.equal(store.listRuns({ workspace: 'acme' })[0].status, 'interrupted');
   store.close();
 });

package/src/shell/repl.js

@@ -1580,14 +1580,15 @@ async function runTuiShell({ agent, packageJson, session, runtime = null }) {
             if (outcome.kind === 'accepted') {
               activityLines = [...activityLines, 'runtime: run accepted'].slice(-LOWER_DETAIL_ROWS);
             } else if (outcome.kind === 'queued') {
-              conversationMessages(session).push({ role: 'command', content: 'Runtime is busy — request added to the control queue, it will start automatically.' });
+              // Server-localized acknowledgement (src/runtime/controlMessages.js).
+              conversationMessages(session).push({ role: 'command', content: String(outcome.result?.explanation ?? 'Request added to the queue.') });
               activityLines = [...activityLines, 'runtime: control queued'].slice(-LOWER_DETAIL_ROWS);
             } else if (outcome.kind === 'observe' || outcome.kind === 'converse' || outcome.kind === 'mutate') {
               const explanation = outcome.result?.explanation ?? 'Runtime control message accepted.';
               conversationMessages(session).push({ role: 'command', content: explanation });
               activityLines = [...activityLines, `runtime: ${outcome.kind}`].slice(-LOWER_DETAIL_ROWS);
             } else if (outcome.kind === 'ambiguous') {
-              conversationMessages(session).push({ role: 'command', content: 'Runtime could not classify that message. Use /queue for a future run, or ask/status more explicitly.' });
+              conversationMessages(session).push({ role: 'command', content: String(outcome.result?.explanation ?? 'Runtime could not classify that message. Use /queue for a future run, or ask/status more explicitly.') });
               activityLines = [...activityLines, 'runtime: ambiguous control'].slice(-LOWER_DETAIL_ROWS);
             } else {
               conversationMessages(session).push({ role: 'command', content: `Runtime error: ${outcome.message}` });

package/src/shell/repl.test.js

@@ -183,7 +183,7 @@ test('agent mode without runtime records a visible error instead of falling back
 
 test('runtime status exposes the disconnected reason', () => {
   assert.equal(
-    runtimeStatusLine({ error: 'token mismatch' }, { workspace: 'juno' }),
+    runtimeStatusLine({ error: 'token mismatch' }, { workspace: 'acme' }),
     'runtime: disconnected: token mismatch',
   );
   assert.equal(

package/src/shell/useAgent.ts

@@ -31,7 +31,11 @@ export function useAgent(props: { agent: unknown; packageJson: Record<string, un
           props.onRuntimeAccepted?.();
           props.addLog('runtime: run accepted');
         } else if (outcome.kind === 'queued') {
-          conversationMessages(props.session).push({ role: 'command', content: 'Runtime is busy — request added to the control queue, it will start automatically.' });
+          // 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 {
           conversationMessages(props.session).push({ role: 'command', content: `Runtime error: ${outcome.message}` });

package/src/shell/useSession.ts

@@ -224,36 +224,64 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
       ? lastVisibleActivities.map((activity) => ({ ...activity }))
       : current;
   });
+  // Control-lane run requests (user messages queued while the runtime is
+  // busy) live in state.controlQueue, a separate lane from the MCP job
+  // queue. They must appear in the Queue panel too — otherwise a queued run
+  // request is invisible (Queue (0)) even though it is registered and will
+  // start automatically.
+  const controlQueueItems = createMemo(() => {
+    version();
+    const controlQueue = runtimeState()?.controlQueue;
+    if (!Array.isArray(controlQueue)) return [] as any[];
+    return controlQueue
+      .filter((item: any) => ['queued', 'running', 'starting'].includes(String(item.status ?? '').toLowerCase()))
+      .map((item: any) => ({
+        ...item,
+        id: item.id,
+        label: `run: ${String(item.input ?? '').slice(0, 64)}`,
+        status: item.status,
+        _runtime: true,
+        _control: true,
+      }));
+  });
   const queueItems = createMemo(() => {
     version();
+    const control = controlQueueItems();
     const workflowQueue = nonEmptyRuntimeArray(runtimeState()?.workflow?.nodes?.filter((node: any) => node.type === 'queue'));
     if (workflowQueue) {
-      return workflowQueue.map((node: any) => ({ ...(node.raw ?? {}), id: node.itemId ?? node.id, label: node.label, status: node.status, _runtime: true, _workflow: true }));
+      return [...control, ...workflowQueue.map((node: any) => ({ ...(node.raw ?? {}), id: node.itemId ?? node.id, label: node.label, status: node.status, _runtime: true, _workflow: true }))];
     }
     const runtimeQueue = nonEmptyRuntimeArray(runtimeState()?.queue);
-    if (runtimeQueue) return runtimeQueue.map((item: any) => ({ ...item, _runtime: true }));
-    return projectQueue((session as any).headlessPlan, (session as any).jobQueue ?? [], { workspace: (session as any).workspace ?? null })
-      .map((item: any) => ({ ...item }));
+    if (runtimeQueue) return [...control, ...runtimeQueue.map((item: any) => ({ ...item, _runtime: true }))];
+    return [
+      ...control,
+      ...projectQueue((session as any).headlessPlan, (session as any).jobQueue ?? [], { workspace: (session as any).workspace ?? null })
+        .map((item: any) => ({ ...item })),
+    ];
   });
   const queueInfo = createMemo(() => {
     version();
+    const control = controlQueueItems();
+    const controlActive = control.length;
+    const controlCurrent = control.filter((item: any) => ['starting', 'running'].includes(String(item.status ?? '').toLowerCase())).length;
     const workflowQueue = runtimeState()?.workflow?.nodes?.filter((node: any) => node.type === 'queue');
     if (Array.isArray(workflowQueue)) {
       return {
-        active: workflowQueue.filter((item: any) => ['waiting', 'starting', 'running', 'queued', 'pending', 'pending_approval'].includes(String(item.status ?? '').toLowerCase())).length,
-        current: workflowQueue.filter((item: any) => ['starting', 'running'].includes(String(item.status ?? '').toLowerCase())).length,
+        active: controlActive + workflowQueue.filter((item: any) => ['waiting', 'starting', 'running', 'queued', 'pending', 'pending_approval'].includes(String(item.status ?? '').toLowerCase())).length,
+        current: controlCurrent + workflowQueue.filter((item: any) => ['starting', 'running'].includes(String(item.status ?? '').toLowerCase())).length,
         frozen: 0,
       };
     }
     const runtimeQueue = runtimeState()?.queue;
     if (Array.isArray(runtimeQueue)) {
       return {
-        active: runtimeQueue.filter((item: any) => ['waiting', 'starting', 'running', 'queued', 'pending', 'pending_approval'].includes(String(item.status ?? '').toLowerCase())).length,
-        current: runtimeQueue.filter((item: any) => ['starting', 'running'].includes(String(item.status ?? '').toLowerCase())).length,
+        active: controlActive + runtimeQueue.filter((item: any) => ['waiting', 'starting', 'running', 'queued', 'pending', 'pending_approval'].includes(String(item.status ?? '').toLowerCase())).length,
+        current: controlCurrent + runtimeQueue.filter((item: any) => ['starting', 'running'].includes(String(item.status ?? '').toLowerCase())).length,
         frozen: 0,
       };
     }
-    return queueCounts(session);
+    const base = queueCounts(session);
+    return { ...base, active: (base.active ?? 0) + controlActive, current: (base.current ?? 0) + controlCurrent };
   });
   const plan = createMemo(() => {
     version();