@dotdrelle/wiki-manager 0.15.62 → 0.15.66

package/README.md

@@ -401,6 +401,7 @@ answer "what is this and how do I start it", and stop there.
 | [`docs/usage.md`](docs/usage.md) | The four ways to run wikiLLM, and how to configure the external agents |
 | [`docs/configuration.md`](docs/configuration.md) | Every configuration key: root `.env`, Compose overrides, `mcp.endpoints.json`, workspace `.env`, `.wikirc.yaml`, parallelism |
 | [`docs/technical-reference.md`](docs/technical-reference.md) | Workspace model, services, the `donna` shell, agent tooling, orchestration and activity contracts, security model |
+| [`docs/authoring-skills.md`](docs/authoring-skills.md) | Writing a workspace skill: what splits a body into runs, chains, concurrency, parameters, and the interpretation rules |
 | [`docs/claude-desktop.md`](docs/claude-desktop.md) | Using a workspace from Claude Desktop |
 | [`CLAUDE.md`](CLAUDE.md) | Repository guidance: invariants to preserve when changing this code |
 

package/package.json

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

package/src/agent/graph.js

@@ -19,7 +19,7 @@ import {
   truncateToolResult,
 } from '../core/mcp.js';
 import { findSkill, formatSkillsForAgent } from '../core/skills.js';
-import { RESERVED_SLASH_COMMANDS, explicitSkillReference } from '../core/skillInvocation.js';
+import { RESERVED_SLASH_COMMANDS, explicitSkillReference, objectiveNamesSkill } from '../core/skillInvocation.js';
 import { handleSlashCommand } from '../commands/slash.js';
 import { extractActivity, formatActivitySummary, parseJsonText, sessionActivities } from '../core/activity.js';
 import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
@@ -947,6 +947,32 @@ export async function handleRuntimeControlTool(session, tool, args = {}) {
           message: `Skill "${skillName}" is already running in this chain: execute its objective directly instead of re-invoking it.`,
         });
       }
+      /*
+       Depuis une intention compilée, une compétence se lance par son NOM, pas
+       par ressemblance.
+
+       La garde de cycle ci-dessus ne voit que les répétitions. Elle laissait
+       donc passer la cascade réellement observée sur un `/wiki-ingest` :
+       l'intention n°2 du corps est mot pour mot celui de
+       `/wiki-rebuild-concepts`, dont l'intention décrit à son tour
+       `/wiki-reclassify`, puis `/wiki-taxonomy`. Trois compétences distinctes,
+       aucun cycle, et la grille de concepts comme la taxonomie reconstruites
+       plusieurs fois pour une seule demande.
+
+       Une intention compilée EST déjà le travail à faire : elle se délègue.
+       La composition explicite reste ouverte — un corps qui nomme sa cible dit
+       ce qu'il veut ; une intention qui se contente de la décrire ne le dit
+       pas.
+      */
+      if (skillStack.length > 0 && !objectiveNamesSkill(args._userInput, skillName)) {
+        return JSON.stringify({
+          ok: false,
+          terminal: true,
+          code: 'nested_skill_match_blocked',
+          skillStack,
+          message: `The current objective does not name skill "${skillName}"; it only describes what that skill does. Execute the objective yourself with runtime__delegate instead of re-routing it to another skill.`,
+        });
+      }
       if (skillStack.length >= MAX_SKILL_DEPTH) {
         return JSON.stringify({
           ok: false,
@@ -1184,7 +1210,7 @@ export function buildAgentSystemPrompt(state) {
     skills,
     '</skill_catalog>',
     runningSkillStack.length > 0
-      ? `You are already executing the compiled objective of workspace skill ${JSON.stringify(runningSkillStack.at(-1))}. The current user message IS that objective: execute it directly${runningSkillExecution === 'direct' ? ' and stop after its requested direct mutation; delegation and nested skills are forbidden for this workflow' : ' by delegating it with runtime__delegate (or a matching direct tool)'}. Do not select or call that skill again, with or without a leading slash — the runtime refuses the re-invocation with skill_recursion_blocked, and that refusal means act on the objective yourself, not report an error. A skill run is not successful until its requested mutation has an affirmative tool result; never infer success from the runtime merely becoming idle or done, and never end the run with an empty reply or a bare "{}".`
+      ? `You are already executing the compiled objective of workspace skill ${JSON.stringify(runningSkillStack.at(-1))}. The current user message IS that objective: execute it directly${runningSkillExecution === 'direct' ? ' and stop after its requested direct mutation; delegation and nested skills are forbidden for this workflow' : ' by delegating it with runtime__delegate (or a matching direct tool)'}. Do not select or call that skill again, with or without a leading slash — the runtime refuses the re-invocation with skill_recursion_blocked, and that refusal means act on the objective yourself, not report an error. Do not select ANY OTHER skill by description either: an objective necessarily reads like the description of the neighbouring skill that performs it, and re-routing it there re-runs work this objective already covers. From inside a compiled objective, runtime__run_skill is only for a skill the objective names explicitly; everything else is delegated with runtime__delegate. A skill run is not successful until its requested mutation has an affirmative tool result; never infer success from the runtime merely becoming idle or done, and never end the run with an empty reply or a bare "{}".`
       : null,
     'In interactive agent mode, call only tools actually provided to you. Any directly offered tool stays direct; never substitute an orchestration-contract tool yourself.',
     'When the user asks for an action that can be performed with connected MCP tools or safe primitives, do not answer with future intent such as "I will call...", "I am going to run...", or "launching..." unless you also call the tool in the same turn. Either call the tool now, ask for the exact missing required arguments, or explain the concrete blocker.',
@@ -1269,8 +1295,8 @@ export function buildLimitedAgentResponse(state, reason = 'no workspace loaded w
 }
 
 export function formatLlmUnavailableMessage(reason) {
-  const clean = String(reason ?? 'raison inconnue').replace(/\s+/g, ' ').trim();
-  return `⚠ LLM injoignable : ${clean || 'raison inconnue'}`;
+  const clean = String(reason ?? 'unknown reason').replace(/\s+/g, ' ').trim();
+  return `⚠ LLM unavailable: ${clean || 'unknown reason'}`;
 }
 
 function toolsForClassification(classification, writeTools, session = null) {
@@ -1429,7 +1455,7 @@ export function createAgentGraph(options = {}) {
     const llm = state.session.llm ?? options.llm ?? null;
 
     if (!llm) {
-      return { response: formatLlmUnavailableMessage('aucun client LLM configure'), pendingToolCalls: null, readyToStream: false };
+      return { response: formatLlmUnavailableMessage('no LLM client configured'), pendingToolCalls: null, readyToStream: false };
     }
 
     const iterations = state.toolIterations ?? 0;

package/src/agent/graph.test.js

@@ -292,7 +292,7 @@ test('agent graph reports LLM unavailable without Donna active boilerplate', asy
   const agent = createAgentGraph();
   const result = await agent.invoke({ input: 'salut', session: sessionBase({ llm: null }) });
 
-  assert.equal(result.response, '⚠ LLM injoignable : aucun client LLM configure');
+  assert.equal(result.response, '⚠ LLM unavailable: no LLM client configured');
   assert.doesNotMatch(result.response, /Donna is active/);
 });
 

package/src/agent/skillRecursion.test.js

@@ -96,3 +96,80 @@ test('borne la profondeur même sans cycle', async () => {
 
   assert.equal(result.code, 'skill_depth_exceeded');
 });
+
+/*
+ Cascade observée sur un `/wiki-ingest` : deux `/wiki-rebuild-concepts`, puis
+ `/wiki-reclassify`, puis `/wiki-taxonomy`. Aucun cycle — trois compétences
+ distinctes — mais la grille de concepts et la taxonomie reconstruites
+ plusieurs fois pour une seule demande. La deuxième intention compilée de
+ `/wiki-ingest` est mot pour mot le corps de `/wiki-rebuild-concepts` : le
+ sélecteur par description la reconnaissait légitimement.
+*/
+const callWithObjective = (state, skillName, objective) =>
+  handleRuntimeControlTool(state, 'run_skill', { skillName, _userInput: objective })
+    .then((raw) => JSON.parse(raw));
+
+test('refuse une compétence voisine que l’intention décrit sans la nommer', async () => {
+  const objective = 'Run the production pipeline steps concepts, reclassify-concepts and taxonomy, in that order.';
+  const ran = [];
+  const result = await callWithObjective(session(['wiki-ingest'], ran), 'wiki-rebuild-concepts', objective);
+
+  assert.equal(result.ok, false);
+  assert.equal(result.code, 'nested_skill_match_blocked');
+  assert.deepEqual(ran, [], 'un refus ne doit lancer aucun travail');
+  assert.match(result.message, /runtime__delegate/);
+});
+
+test('laisse passer la compétence que l’intention nomme explicitement', async () => {
+  const ran = [];
+  const result = await callWithObjective(session(['wiki-sync'], ran), 'deliver', 'Then run /deliver on the produced report.');
+
+  assert.equal(result.ok, true);
+  assert.deepEqual(ran, ['deliver']);
+});
+
+test('ne confond pas un nom de compétence avec son préfixe', async () => {
+  const result = await callWithObjective(session(['pipeline']), 'wiki-build', 'Hand the result to the wiki-builder service.');
+
+  assert.equal(result.code, 'nested_skill_match_blocked');
+});
+
+test('un chemin de fichier commençant par un nom de compétence ne vaut pas invocation', async () => {
+  const result = await callWithObjective(
+    session(['wiki-ingest']),
+    'wiki-build',
+    'Move the leaf file /wiki-build/unclassified/x.md into place then continue.',
+  );
+
+  assert.equal(result.code, 'nested_skill_match_blocked');
+});
+
+test('hors de toute chaîne, la sélection par description reste permise', async () => {
+  const result = await callWithObjective(session(undefined), 'wiki-taxonomy', 'republish the graph taxonomy');
+
+  assert.equal(result.ok, true);
+});
+
+/*
+ Le nom seul ne prouve rien. Plusieurs compétences du scaffold portent un nom
+ qui est aussi un mot courant : « Run the production pipeline steps concepts,
+ reclassify-concepts and taxonomy » nomme `pipeline`, dont le lancement rejoue
+ ingest + build + export + polish. Une intention doit citer sa cible EN TANT QUE
+ compétence, pas l'employer comme mot.
+*/
+test('un nom employé comme mot courant ne vaut pas invocation', async () => {
+  const objective = 'Run the production pipeline steps concepts, reclassify-concepts and taxonomy, in that order.';
+  const ran = [];
+  const result = await callWithObjective(session(['wiki-ingest'], ran), 'pipeline', objective);
+
+  assert.equal(result.code, 'nested_skill_match_blocked');
+  assert.deepEqual(ran, []);
+});
+
+test('la tournure « the deliver skill » vaut invocation explicite', async () => {
+  const ran = [];
+  const result = await callWithObjective(session(['wiki-sync'], ran), 'deliver', 'Hand the report to the deliver skill.');
+
+  assert.equal(result.ok, true);
+  assert.deepEqual(ran, ['deliver']);
+});

package/src/cli/wiki-manager.js

@@ -24,7 +24,7 @@ import { applySessionWikircProfile } from '../core/sessionConfig.js';
 import { listWikircProfiles } from '../core/wikirc.js';
 import { callMcpTool, formatMcpToolResult, readChatAccessConfig } from '../core/mcp.js';
 import { deleteManagedMcpEndpoint, listManagedMcpEndpoints, upsertManagedMcpEndpoint } from '../core/mcpEndpoints.js';
-import { extractActivity, parseJsonText, sessionActivities, terminalFailures } from '../core/activity.js';
+import { extractActivity, mergePolledActivity, parseJsonText, sessionActivities, terminalFailures } from '../core/activity.js';
 import { syncActivitiesToPlan, formatPlanStatus } from '../core/plan.js';
 import { createAgentEvent, dispatchAgentEvent, reduceAgentEvents } from '../core/agentEvents.js';
 import { runAgentTurn, runAgenticLoop } from '../core/agentLoop.js';
@@ -432,7 +432,7 @@ async function runHeadlessActivityLoop(session, log, { wait, timeoutMs }) {
       try {
         const result = await callMcpTool(session.mcp, activity.poll.server, activity.poll.tool, activity.poll.args ?? {});
         const payload = parseJsonText(formatMcpToolResult(result));
-        const polledActivity = extractActivity(payload, { server: activity.poll.server, tool: activity.poll.tool });
+        const polledActivity = mergePolledActivity(activity, extractActivity(payload, { server: activity.poll.server, tool: activity.poll.tool }));
         if (polledActivity) {
           dispatchAgentEvent(session, createAgentEvent('activity_upserted', {
             origin: 'poll',

package/src/commands/slash.js

@@ -1386,7 +1386,7 @@ export async function handleSlashCommand(line, context) {
         if (!context.session.workspace) return { output: 'No workspace loaded. Use /use <workspace> first.' };
         const operation = args[3] && !args[3].includes('.') && !args[3].includes('/') ? args[3] : undefined;
         const inputs = args.slice(operation ? 4 : 3);
-        const result = await postRuntimeRun(`Run de capability ${capability}${operation ? ` (${operation})` : ''} demandé via /run capability.`, {
+        const result = await postRuntimeRun(`Capability run ${capability}${operation ? ` (${operation})` : ''} requested via /run capability.`, {
           url,
           workspace: context.session.workspace,
           capabilityPlan: {
@@ -1396,9 +1396,9 @@ export async function handleSlashCommand(line, context) {
           },
         });
         if (result?.runId) {
-          return { output: `▶ Run de capability accepté (${String(result.runId).slice(0, 8)}) — le plan de l'agent sera intégré et dispatché en parallèle ; approbation demandée avant les mutations (/approve).` };
+          return { output: `▶ Capability run accepted (${String(result.runId).slice(0, 8)}) — the agent's plan will be integrated and dispatched in parallel; approval requested before mutations (/approve).` };
         }
-        return { output: `Run non démarré: ${result?.explanation ?? result?.error ?? JSON.stringify(result)}` };
+        return { output: `Run not started: ${result?.explanation ?? result?.error ?? JSON.stringify(result)}` };
       }
       if (subcommand === 'kill') {
         const result = await postRuntimeKill({ url, workspace: context.session.workspace ?? null, runId: args[2] ?? null });
@@ -1419,7 +1419,7 @@ export async function handleSlashCommand(line, context) {
         const runActive = String(context.session.agentProjection?.status ?? '').toLowerCase() === 'running';
         if (count === 0 && (activeRuntimeItems > 0 || runActive)) {
           return {
-            output: `Cleared 0 finished queue items — ${activeRuntimeItems || 'des'} item(s) actifs sont gérés par le runtime${runActive ? ' (run en cours)' : ''}. Utilisez /run cancel (arrêt doux) ou /run kill (abort + purge complète).`,
+            output: `Cleared 0 finished queue items — ${activeRuntimeItems || 'the'} active item(s) are managed by the runtime${runActive ? ' (run in progress)' : ''}. Use /run cancel (graceful stop) or /run kill (abort + full purge).`,
           };
         }
         return { output: `Cleared ${count} finished queue item${count === 1 ? '' : 's'}.` };
@@ -1433,7 +1433,7 @@ export async function handleSlashCommand(line, context) {
         // would silently revert the item to waiting (fake cancel).
         const localItem = (context.session.jobQueue ?? []).find((item) => String(item.id) === String(id));
         if (localItem?.origin === 'runtime' || (!localItem && runtimeManagedItemId(context, id))) {
-          if (!context.runtime?.url) return { output: 'Item géré par le runtime — reconnectez le runtime pour l’annuler, ou utilisez /run cancel ou /run kill.' };
+          if (!context.runtime?.url) return { output: 'Runtime-managed item — reconnect the runtime to cancel it, or use /run cancel or /run kill.' };
           try {
             const result = await postRuntimeControl('cancel_item', {
               url: context.runtime.url,
@@ -1659,13 +1659,13 @@ export async function handleSlashCommand(line, context) {
         try {
           const killed = await postRuntimeKill({ url: runtime.url, workspace, runId: null, purge: true });
           const purged = killed.purged ?? { runs: 0, events: 0, queue: 0 };
-          parts.push(`runtime : ${killed.runs ?? 0} run(s) interrompu(s), ${killed.tasks ?? 0} tâche(s), ${killed.queued ?? 0} requête(s)`);
-          parts.push(`store purgé : ${purged.runs ?? 0} run(s), ${purged.events ?? 0} événement(s), ${purged.queue ?? 0} item(s) de file`);
+          parts.push(`runtime: ${killed.runs ?? 0} run(s) stopped, ${killed.tasks ?? 0} task(s), ${killed.queued ?? 0} request(s)`);
+          parts.push(`store purged: ${purged.runs ?? 0} run(s), ${purged.events ?? 0} event(s), ${purged.queue ?? 0} queue item(s)`);
         } catch (err) {
-          parts.push(`runtime kill échoué : ${err instanceof Error ? err.message : String(err)}`);
+          parts.push(`runtime kill failed: ${err instanceof Error ? err.message : String(err)}`);
         }
       } else {
-        parts.push('runtime non connecté (rien à purger côté serveur)');
+        parts.push('runtime not connected (nothing to purge server-side)');
       }
 
       const clearedQueue = clearFinishedQueueItems(context.session);
@@ -1686,9 +1686,9 @@ export async function handleSlashCommand(line, context) {
       context.session.workflow = null;
       context.session.jobQueue = [];
       context.session.productionActivity = null;
-      parts.push(`file locale : ${clearedQueue} item(s) terminés nettoyés`);
+      parts.push(`local queue: ${clearedQueue} finished item(s) cleared`);
 
-      return { output: `Interface réinitialisée (--all) — ${parts.join(' · ')}.` };
+      return { output: `Interface reset (--all) — ${parts.join(' · ')}.` };
     }
     case 'exit':
     case 'quit':

package/src/core/activity.js

@@ -104,7 +104,19 @@ export function normalizeActivity(activity, fallback = {}) {
   return normalized;
 }
 
-function productionActivityFromPayload(payload, context = {}) {
+// A status payload can only be polled with the tool that produced it. Any
+// `*_status` tool qualifies; anything else (a `*_start_job` call whose result
+// carried the first snapshot) falls back to the production status tool, and
+// for a non-production agent to null — the caller then keeps the poll
+// descriptor the tracked activity already had.
+function statusPollTool(context, source) {
+  const tool = String(context?.tool ?? '');
+  if (/status$/i.test(tool)) return tool;
+  return source === 'production' ? 'production_job_status' : null;
+}
+
+function activityFromStatusPayload(payload, context = {}) {
+  const source = String(context?.server ?? 'production');
   const progress = payload?.progress;
   const job = payload?.job;
   const jobId = payload?.jobId ?? job?.jobId;
@@ -141,11 +153,12 @@ function productionActivityFromPayload(payload, context = {}) {
     progressDetail,
     progress?.lastEvent ? `last ${progress.lastEvent}` : null,
   ].filter(Boolean).join(' · ');
+  const prefix = source === 'production' ? 'Production' : source;
   return normalizeActivity({
     id: jobId,
-    source: 'production',
+    source,
     kind: job?.type ?? payload?.operation ?? payload?.type ?? progress?.phase ?? progress?.currentStep ?? 'job',
-    label: detail ? `Production: ${detail}` : `Production: ${status}`,
+    label: detail ? `${prefix}: ${detail}` : `${prefix}: ${status}`,
     status,
     progress: {
       ...(progress ?? {}),
@@ -154,9 +167,9 @@ function productionActivityFromPayload(payload, context = {}) {
       ...(payload?.taskId ? { stepId: String(payload.taskId) } : {}),
     },
     plan: Array.isArray(progress?.steps) ? { steps: progress.steps } : null,
-    poll: jobId ? {
-      server: 'production',
-      tool: context.tool === 'agent_status' ? 'agent_status' : 'production_job_status',
+    poll: jobId && statusPollTool(context, source) ? {
+      server: source,
+      tool: statusPollTool(context, source),
       args: { jobId },
       intervalMs: 2500,
     } : null,
@@ -170,10 +183,47 @@ export function extractActivity(payload, context = {}) {
   if (payload._activity) {
     return normalizeActivity(payload._activity, { source: context.server });
   }
-  if (context.server === 'production') {
-    return productionActivityFromPayload(payload, context);
-  }
-  return null;
+  // Without an explicit `_activity` opt-in, a status payload is inferred into an
+  // activity only where we already know how it would be polled: the production
+  // server (whose `*_start_job` result carries the first snapshot), or any agent
+  // answering through a `*_status` tool. This is what lets a job run by another
+  // executor (knowledge.update on agent-cme, polled via `agent_status`) update
+  // its percentage instead of the panel showing the dispatcher's initial 0 %
+  // for the whole run. An arbitrary agent-mode tool call that merely happens to
+  // return a `jobId`/`progress`-shaped object must NOT create or replace the run
+  // plan — monitoring stays opt-in (`_activity`) for it.
+  const source = String(context?.server ?? 'production');
+  if (source !== 'production' && !statusPollTool(context, source)) return null;
+  return activityFromStatusPayload(payload, context);
+}
+
+// A poll answers with the AGENT's view of the job: it knows the job id, the
+// status and the progress, but nothing about the plan task the orchestrator
+// dispatched it for. Re-normalizing that answer on its own therefore dropped
+// `progress.stepId` and could re-key the activity under a different source,
+// breaking the task<->activity link the Activity/Plan panels use to attach a
+// live percentage to a plan step. Merge onto the tracked activity instead:
+// identity and linkage come from what we already know, live values from the
+// poll.
+export function mergePolledActivity(tracked, polled) {
+  if (!polled) return null;
+  if (!tracked) return polled;
+  const stepId = polled.progress?.stepId ?? tracked.progress?.stepId ?? null;
+  return normalizeActivity({
+    ...polled,
+    // Identity: keep the tracked source/id so activityKey() stays stable.
+    id: tracked.id ?? polled.id,
+    source: tracked.source ?? polled.source,
+    // Keep polling with the descriptor that worked when the agent's answer
+    // does not carry one of its own.
+    poll: polled.poll ?? tracked.poll,
+    plan: polled.plan ?? tracked.plan ?? null,
+    startedAt: tracked.startedAt ?? polled.startedAt ?? null,
+    progress: {
+      ...(polled.progress ?? {}),
+      ...(stepId !== null ? { stepId } : {}),
+    },
+  });
 }
 
 export function rememberActivity(session, activity) {

package/src/core/activity.test.js

@@ -1,6 +1,6 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
-import { normalizeActivity, extractActivity, isCancelledStatus, rememberActivity, rememberActivityFromPayload } from './activity.js';
+import { normalizeActivity, extractActivity, mergePolledActivity, isCancelledStatus, rememberActivity, rememberActivityFromPayload } from './activity.js';
 
 test('normalizeActivity: plan.steps preserved with id and label', () => {
   const a = normalizeActivity({
@@ -171,3 +171,61 @@ test('rememberActivityFromPayload: returns null for irrelevant payload', () => {
   const session = {};
   assert.equal(rememberActivityFromPayload(session, { message: 'ok' }), null);
 });
+
+test('extractActivity: a non-production agent status payload yields an activity', () => {
+  const activity = extractActivity({
+    jobId: 'job-know-1',
+    status: 'running',
+    progress: { percent: 42, phase: 'knowledge.update', detail: 'chunk 3/7' },
+  }, { server: 'cme', tool: 'agent_status' });
+  assert.ok(activity, 'a knowledge.update job run outside the production server must still produce an activity');
+  assert.equal(activity.source, 'cme');
+  assert.equal(activity.progress.percent, 42);
+  assert.equal(activity.poll.server, 'cme');
+  assert.equal(activity.poll.tool, 'agent_status');
+});
+
+test('extractActivity: a non-status tool result on another server is not inferred into an activity', () => {
+  // Agent mode: the LLM calls an arbitrary connector tool whose result happens
+  // to carry a jobId/progress-shaped object. Without an `_activity` opt-in and
+  // without a `*_status` poll tool, this must not create or replace the plan.
+  const activity = extractActivity({
+    jobId: 'export-42',
+    progress: { steps: [{ id: 'a', label: 'A' }, { id: 'b', label: 'B' }] },
+  }, { server: 'connectors', tool: 'gmail_export_run' });
+  assert.equal(activity, null);
+});
+
+test('extractActivity: production start-job result is still inferred without a status tool', () => {
+  const activity = extractActivity({
+    jobId: 'job-1',
+    status: 'running',
+    progress: { percent: 5, phase: 'ingest' },
+  }, { server: 'production', tool: 'production_start_job' });
+  assert.ok(activity);
+  assert.equal(activity.source, 'production');
+  assert.equal(activity.poll.tool, 'production_job_status');
+});
+
+test('mergePolledActivity: keeps the tracked key, poll and stepId across polls', () => {
+  const tracked = normalizeActivity({
+    id: 'job-know-1',
+    source: 'cme',
+    kind: 'knowledge.update',
+    label: 'Mise a jour des connaissances',
+    status: 'queued',
+    progress: { percent: 0, stepId: 'task-3' },
+    poll: { server: 'cme', tool: 'agent_status', args: { jobId: 'job-know-1' }, intervalMs: 1000 },
+  });
+  const polled = extractActivity({
+    jobId: 'job-know-1',
+    status: 'running',
+    progress: { percent: 63, detail: 'chunk 5/7' },
+  }, { server: 'cme', tool: 'agent_status' });
+  const merged = mergePolledActivity(tracked, polled);
+  assert.equal(merged.key, tracked.key, 'the activity must not be re-keyed by a poll');
+  assert.equal(merged.progress.stepId, 'task-3', 'the plan task link must survive a poll');
+  assert.equal(merged.progress.percent, 63);
+  assert.equal(merged.poll.tool, 'agent_status');
+  assert.equal(merged.terminal, false);
+});

package/src/core/agentLoop.js

@@ -36,7 +36,7 @@ export async function runAgentTurn(agent, session, input, {
     if (session._abortSignal === signal) delete session._abortSignal;
   }
   if (result.streamedInline) {
-    return streamedContent.trim() || formatLlmUnavailableMessage('flux vide');
+    return streamedContent.trim() || formatLlmUnavailableMessage('empty stream');
   }
   if (result.response != null) return result.response;
   if (result.readyToStream && session.llm?.stream) {
@@ -49,9 +49,9 @@ export async function runAgentTurn(agent, session, input, {
     })) {
       content += delta;
     }
-    return content.trim() || formatLlmUnavailableMessage('flux vide');
+    return content.trim() || formatLlmUnavailableMessage('empty stream');
   }
-  return formatLlmUnavailableMessage('reponse vide');
+  return formatLlmUnavailableMessage('empty response');
 }
 
 export async function runAgenticLoop(agent, session, initialInput, {

package/src/core/agentLoop.test.js

@@ -18,7 +18,7 @@ test('runAgentTurn returns a one-line LLM error on empty stream', async () => {
 
   const response = await runAgentTurn(agent, session, 'salut');
 
-  assert.equal(response, '⚠ LLM injoignable : flux vide');
+  assert.equal(response, '⚠ LLM unavailable: empty stream');
 });
 
 test('runAgenticLoop waits for new activities and continues with a completion summary', async () => {

package/src/core/buildInfo.json

@@ -1,4 +1,4 @@
 {
-  "version": "0.15.62",
-  "commit": "399432f"
+  "version": "0.15.66",
+  "commit": "d9639a4"
 }

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.62';
+const WIKI_MANAGER_VERSION = '0.15.66';
 
 function envValue(key) {
   const filePath = managerEnvFile();

package/src/core/skillChainView.js

@@ -16,6 +16,18 @@ const SYMBOLS = {
   skipped: '–',
 };
 
+// The selection reason is an audit enum (`explicit_name` / `description_match`);
+// leaking it verbatim into a queue label read as a broken token (`[explicit_name]`).
+// Humanize it for display; keep the raw value on `selectionKind` for audit.
+const SELECTION_KIND_LABELS = {
+  explicit_name: 'explicit name',
+  description_match: 'description match',
+};
+
+export function selectionKindLabel(selectionKind) {
+  return SELECTION_KIND_LABELS[selectionKind] ?? selectionKind ?? null;
+}
+
 export const TERMINAL = new Set(['done', 'failed', 'cancelled', 'skipped']);
 
 // Objectives are whole paragraphs; a chain view needs a line. Keep the first
@@ -61,6 +73,7 @@ export function projectSkillChains(controlQueue = []) {
       chainId,
       skillName: chainItems.find((item) => item.skillName)?.skillName ?? null,
       selectionKind: chainItems.find((item) => item.selectionKind)?.selectionKind ?? null,
+      selectionLabel: selectionKindLabel(chainItems.find((item) => item.selectionKind)?.selectionKind ?? null),
       steps,
       status: chainStatus(steps),
     };
@@ -79,7 +92,7 @@ function chainStatus(steps) {
 // The text form used by the Shell; serve renders the same projection as DOM.
 export function renderSkillChain(chain) {
   if (!chain?.steps?.length) return '';
-  const selection = chain.selectionKind ? ` · ${chain.selectionKind}` : '';
+  const selection = chain.selectionLabel ? ` · ${chain.selectionLabel}` : '';
   const lines = [`${chain.skillName ?? 'skill'}${selection}`, ''];
   for (const step of chain.steps) {
     lines.push(`${step.symbol} ${step.label}`);

package/src/core/skillChainView.test.js

@@ -1,6 +1,6 @@
 import test from 'node:test';
 import assert from 'node:assert/strict';
-import { chainStepLabel, projectSkillChains, renderSkillChain } from './skillChainView.js';
+import { chainStepLabel, projectSkillChains, renderSkillChain, selectionKindLabel } from './skillChainView.js';
 
 const WIKI_SYNC = [
   {
@@ -48,3 +48,15 @@ test('standalone control items are not chains', () => {
   assert.deepEqual(projectSkillChains([{ id: 'x', status: 'queued', input: 'do something' }]), []);
   assert.deepEqual(projectSkillChains(), []);
 });
+
+test('the selection reason is humanized, not leaked as an audit enum', () => {
+  assert.equal(selectionKindLabel('explicit_name'), 'explicit name');
+  assert.equal(selectionKindLabel('description_match'), 'description match');
+  assert.equal(selectionKindLabel(null), null);
+  const [chain] = projectSkillChains([
+    { id: 'c0', chainId: 'k', chainSequence: 0, skillName: 'wiki-taxonomy', selectionKind: 'explicit_name', status: 'running', input: '/wiki-taxonomy' },
+  ]);
+  assert.equal(chain.selectionKind, 'explicit_name');
+  assert.equal(chain.selectionLabel, 'explicit name');
+  assert.equal(renderSkillChain(chain).split('\n')[0], 'wiki-taxonomy · explicit name');
+});

package/src/core/skillInvocation.js

@@ -19,6 +19,54 @@ export function explicitSkillReference(input, skillName, language = null) {
   return text.some((sentence) => patterns.some((pattern) => pattern.test(sentence)));
 }
 
+/*
+ Une intention compilée NOMME-t-elle la compétence qu'on veut lancer depuis
+ elle ?
+
+ Le corps d'une compétence est compilé en intentions métier, et une intention
+ décrit forcément ce que fait une compétence voisine : la deuxième intention de
+ `/wiki-ingest` est mot pour mot le corps de `/wiki-rebuild-concepts`. Le
+ sélecteur par description la reconnaissait donc et relançait la compétence
+ voisine, qui relançait la suivante — concepts et taxonomie produits plusieurs
+ fois pour un seul `/wiki-ingest`.
+
+ La composition volontaire reste possible : un corps qui écrit `/deliver` ou
+ « the deliver skill » nomme sa cible, et se distingue ainsi d'une intention
+ qui se contente de la décrire. C'est le seul signal qui ne dépende pas de ce
+ que le modèle déclare de sa propre sélection.
+*/
+export function objectiveNamesSkill(input, skillName) {
+  const raw = String(skillName ?? '').trim();
+  const name = escapeRegExp(raw);
+  if (!name) return false;
+  const text = String(input ?? '').trim();
+  // Une invocation directe : la demande EST le nom, rien d'autre.
+  if (text.toLowerCase() === raw.toLowerCase()) return true;
+  /*
+   Le nom seul ne suffit pas : plusieurs compétences du scaffold portent un nom
+   qui est aussi un mot courant. « Run the production pipeline steps concepts,
+   reclassify-concepts and taxonomy » nomme ainsi la compétence `pipeline`, qui
+   relance ingest + build + export + polish — bien pire que la cascade qu'on
+   corrige. Le nom doit donc être cité EN TANT QUE compétence : forme slash, ou
+   tournure explicite. La borne droite est écrite à la main, `\b` ne bornant pas
+   après un `-` final (`wiki-build` ne doit pas matcher dans `wiki-builder`).
+  */
+  const end = '(?![A-Za-z0-9_-])';
+  // The slash form is a command, not a path: `/wiki-build` followed by `/` is
+  // `wiki/concepts/...`-style text referencing a file, not an invocation of the
+  // `wiki-build` skill. A trailing `/` must not satisfy the right boundary here,
+  // or a compiled objective that merely names a path re-opens the nested-skill
+  // cascade this guard exists to close.
+  const slashEnd = '(?![A-Za-z0-9_/-])';
+  const keyword = '(?:skill|workflow|compétence)';
+  return [
+    new RegExp(`(?:^|[^A-Za-z0-9_-])/${name}${slashEnd}`, 'i'),
+    new RegExp(`\\b${keyword}\\s+/?${name}${end}`, 'i'),
+    new RegExp(`(?:^|[^A-Za-z0-9_-])/?${name}${end}\\s+${keyword}\\b`, 'i'),
+    new RegExp(`/skills\\s+run\\s+${name}${end}`, 'i'),
+  ].some((pattern) => pattern.test(text));
+}
+
 export function matchSkillInvocation(session, input, { allowReserved = false } = {}) {
   const match = INVOCATION_RE.exec(String(input ?? '').trim());
   if (!match) return null;

package/src/runtime/runner.js

@@ -116,7 +116,7 @@ export async function runRuntimeAgenticLoop(agent, session, initialInput, { sign
       dispatchAgentEvent(session, createAgentEvent('assistant_message', {
         origin: 'runtime',
         runId,
-        payload: { content: summary || 'Action terminée.' },
+        payload: { content: summary || 'Action completed.' },
       }));
     },
     onMaxTurns: ({ maxTurns: totalTurns }) => {
@@ -261,7 +261,7 @@ export async function runRuntimeAgenticWorkflow(agent, session, input, {
           origin: 'runtime',
           runId,
           payload: {
-            content: `Le run est terminé mais l'évaluation le juge incomplet : ${evaluation.reason}`,
+            content: `The run finished but the evaluation judged it incomplete: ${evaluation.reason}`,
           },
         }));
         dispatchAgentEvent(session, createAgentEvent('run_error', {
@@ -570,10 +570,10 @@ export async function runRuntimeParallelPlan(agent, session, input, {
               runId,
               payload: {
                 content: [
-                  `⏸ Approbation requise avant exécution : ${newlyRequested.length} tâche(s) mutante(s) en attente.`,
+                  `⏸ Approval required before execution: ${newlyRequested.length} mutating task(s) pending.`,
                   ...newlyRequested.slice(0, 5).map((step) => `  - ${step.description ?? step.id}`),
-                  newlyRequested.length > 5 ? `  … et ${newlyRequested.length - 5} autre(s).` : null,
-                  'Tape /approve (ou clique sur « Approuver ») pour lancer, « annule » pour abandonner.',
+                  newlyRequested.length > 5 ? `  … and ${newlyRequested.length - 5} more.` : null,
+                  'Type /approve (or click "Approve") to start, "cancel" to abandon.',
                 ].filter(Boolean).join('\n'),
               },
             }));
@@ -591,7 +591,7 @@ export async function runRuntimeParallelPlan(agent, session, input, {
             origin: 'runtime',
             runId,
             payload: {
-              content: `⏱ Approbation non reçue dans le délai imparti — run arrêté, ${needingApproval.length} tâche(s) annulée(s). Relance la demande quand tu veux.`,
+              content: `⏱ Approval not received in time — run stopped, ${needingApproval.length} task(s) cancelled. Ask again whenever you're ready.`,
             },
           }));
           return { ok: false, stalled: true, reason: 'awaiting_approval', completed: sessionActivities(session), failures };

package/src/runtime/runner.test.js

@@ -865,7 +865,7 @@ test('runRuntimeParallelPlan skips work stuck behind a failed dependency instead
   // tâche disparaître sans savoir pourquoi.
   assert.match(session.headlessPlan[1].error.message, /\ba\b/);
   assert.equal(session.agentEvents.some((event) => event.type === 'assistant_message'
-    && /Approbation requise/.test(event.payload?.content ?? '')), false);
+    && /Approval required/.test(event.payload?.content ?? '')), false);
   assert.equal(session.agentEvents.some((event) => event.type === 'plan_step_updated'
     && event.payload?.status === 'skipped'), true);
 });

package/src/runtime/supervisor.js

@@ -1,7 +1,7 @@
 import { openSync, readSync, closeSync, fstatSync } from 'node:fs';
 import { isAbsolute, join, normalize, resolve } from 'node:path';
 import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
-import { extractActivity, parseJsonText, sessionActivities } from '../core/activity.js';
+import { extractActivity, mergePolledActivity, parseJsonText, sessionActivities } from '../core/activity.js';
 import { callMcpTool, formatMcpToolResult } from '../core/mcp.js';
 import { normalizeRuntimeLog } from '../core/runtimeLog.js';
 import { startNextQueuedJob, syncQueueWithActivity } from '../core/jobQueue.js';
@@ -107,10 +107,10 @@ export async function pollActivitiesOnce(session, {
     try {
       const result = await callTool(session.mcp, activity.poll.server, activity.poll.tool, activity.poll.args ?? {}, signal);
       const payload = parseJsonText(formatMcpToolResult(result));
-      const polledActivity = extractActivity(payload, {
+      const polledActivity = mergePolledActivity(activity, extractActivity(payload, {
         server: activity.poll.server,
         tool: activity.poll.tool,
-      });
+      }));
       if (polledActivity) {
         dispatchAgentEvent(session, createAgentEvent('activity_upserted', {
           origin: 'runtime_poll',

package/src/shell/RightPane.tsx

@@ -20,10 +20,11 @@ type LogLineParts = { time: string | null; message: string };
 // 4 slots (was 6): items can now span up to 5 lines each (wrapped label +
 // wrapped status/error), so fewer, readable entries beat more, truncated ones.
 const ACTIVITY_SLOTS = Array.from({ length: 4 }, (_, index) => index);
-// Hauteur du panneau Plan : 6 lignes visibles au maximum. Les etapes suivantes
-// restent atteignables en faisant defiler la scrollbox (barre de defilement
-// affichee des que le plan depasse la fenetre).
-const PLAN_VIEWPORT_ROWS = 6;
+// Hauteur MINIMALE du panneau Plan : 6 lignes visibles. Le panneau occupe
+// desormais tout l'espace libre jusqu'au panneau Runtime/Agent status (il ne
+// reste plus de trou de 6 lignes entre les deux) ; la scrollbox reste
+// defilable des que le plan depasse cette fenetre.
+const PLAN_MIN_VIEWPORT_ROWS = 6;
 
 function wrapLine(value: string, width: number) {
   const max = Math.max(8, width);
@@ -215,12 +216,11 @@ export function PlanPanel(props: { plan: PlanStep[]; width: number; jobName?: st
     total + wrapLine(`${icon(step.status)} ${step.step}. ${step.description}`, stepTextWidth(step)).slice(0, 2).length, 0));
   const title = () => {
     const label = props.jobName ? `Plan : ${props.jobName}` : 'Plan';
-    return visualRows() > PLAN_VIEWPORT_ROWS ? `${label} (${props.plan.length}) · scroll` : label;
+    return visualRows() > PLAN_MIN_VIEWPORT_ROWS ? `${label} (${props.plan.length}) · scroll` : label;
   };
-  const viewportRows = () => Math.min(PLAN_VIEWPORT_ROWS, Math.max(1, visualRows()));
   const summaryLines = () => props.summary ? wrapLine(props.summary, lineWidth()).slice(0, 2) : [];
   return (
-    <box flexShrink={0} flexDirection="column" padding={1}>
+    <box flexGrow={1} flexShrink={1} minHeight={PLAN_MIN_VIEWPORT_ROWS + 2} flexDirection="column" padding={1}>
       <text width={lineWidth()} fg="#D6DEE8" content={fit(title(), lineWidth())} />
       <Show when={summaryLines().length > 0}>
         <box flexShrink={0} flexDirection="column">
@@ -230,13 +230,15 @@ export function PlanPanel(props: { plan: PlanStep[]; width: number; jobName?: st
         </box>
       </Show>
       <scrollbox
-        height={viewportRows()}
+        flexGrow={1}
+        flexShrink={1}
+        minHeight={Math.min(PLAN_MIN_VIEWPORT_ROWS, Math.max(1, visualRows()))}
         focusable={false}
         scrollY={true}
         scrollX={false}
         stickyStart="top"
         viewportCulling={true}
-        verticalScrollbarOptions={{ visible: visualRows() > PLAN_VIEWPORT_ROWS }}
+        verticalScrollbarOptions={{ visible: visualRows() > PLAN_MIN_VIEWPORT_ROWS }}
       >
         <Index each={props.plan}>
           {(step) => {
@@ -261,16 +263,23 @@ export function PlanPanel(props: { plan: PlanStep[]; width: number; jobName?: st
 
 export function ActivityPanel(props: { activities: any[]; width: number }) {
   const lineWidth = () => Math.max(8, props.width - 2);
-  const visible = () => props.activities.slice(-ACTIVITY_SLOTS.length).reverse();
-  const visibleSlots = () => visible().map((_activity, index) => index);
-  const activityAt = (index: number) => visible()[index] ?? null;
+  const visible = () => props.activities.slice().reverse();
   return (
-    <box flexShrink={0} flexDirection="column" paddingX={1} backgroundColor="#111318">
+    <box flexGrow={1} flexDirection="column" paddingX={1} backgroundColor="#111318">
       <text width={lineWidth()} fg="#D6DEE8" content="Activity" />
       <Show when={visible().length > 0} fallback={<text width={lineWidth()} fg="#7F8C8D" content="no active jobs" />}>
-        <Index each={visibleSlots()}>
-          {(slot) => {
-            const activity = () => activityAt(slot());
+        <scrollbox
+          flexGrow={1}
+          flexShrink={1}
+          focusable={false}
+          scrollY={true}
+          scrollX={false}
+          stickyStart="top"
+          viewportCulling={true}
+          verticalScrollbarOptions={{ visible: visible().length > 3 }}
+        >
+        <Index each={visible()}>
+          {(activity) => {
             // Wrap instead of hard-truncating: a 40-column pane cut labels to
             // "Appliquer la config recommandée (doct…" and hid the one thing
             // that mattered. Labels get up to 2 lines, the status/error line
@@ -318,6 +327,7 @@ export function ActivityPanel(props: { activities: any[]; width: number }) {
             );
           }}
         </Index>
+        </scrollbox>
       </Show>
     </box>
   );
@@ -385,7 +395,11 @@ export function LogPanel(props: { logs: string[]; width: number; filter?: string
     .filter((line) => activeLogTab() === 'agent-status' ? isAgentStatus(line) : !isAgentStatus(line));
   const allLines = createMemo(() => logRenderLines(filteredLogs(), lineWidth()));
   return (
-    <box flexGrow={2} flexDirection="column" paddingX={1} marginTop={6} focusable={false}>
+    // No hardcoded marginTop here any more: the 6 blank lines it reserved
+    // above the Runtime/Agent status tabs left a dead gap under a short Plan
+    // and made the two panels look detached. The Plan/Queue panel now grows
+    // into that space instead, so its bottom edge meets this panel's header.
+    <box flexGrow={2} flexDirection="column" paddingX={1} focusable={false}>
       <text width={lineWidth()} fg="#4B5563" content={'─'.repeat(lineWidth())} />
       <box height={1} flexDirection="row">
         <text
@@ -530,8 +544,8 @@ export function RightPane(props: {
       <TabHeader active={props.activeTab} queueCount={props.queueInfo.active} onTabClick={props.onTabClick} />
       <Show when={props.pendingApprovals.length > 0}>
         <box height={2} flexDirection="column" border={['left']} borderStyle="heavy" borderColor="#FBBF24" paddingX={1}>
-          <text fg="#FBBF24" content={`${props.pendingApprovals.length} approbation(s) requise(s)`} />
-          <text fg="#0B1020" bg="#FBBF24" content=" Approuver le run " onMouseUp={props.onApprove} />
+          <text fg="#FBBF24" content={`${props.pendingApprovals.length} approval(s) required`} />
+          <text fg="#0B1020" bg="#FBBF24" content=" Approve run " onMouseUp={props.onApprove} />
         </box>
       </Show>
       <Show when={props.activeTab === 'queue'} fallback={(

package/src/shell/repl.js

@@ -11,7 +11,7 @@ import { markedTerminal } from 'marked-terminal';
 import { buildAgentSystemPrompt, formatLlmUnavailableMessage, isOrchestrationBypassTool } from '../agent/graph.js';
 import { handleSlashCommand, rawCommandAgentPrompt } from '../commands/slash.js';
 import { serviceChoices as composeServiceChoices, serviceDescription } from '../core/compose.js';
-import { extractActivity, parseJsonText, sessionActivities } from '../core/activity.js';
+import { extractActivity, mergePolledActivity, parseJsonText, sessionActivities } from '../core/activity.js';
 import { syncActivitiesToPlan } from '../core/plan.js';
 import { buildLlmTools, callMcpTool, formatMcpToolResult, parseToolCallName, resolveToolCallName } from '../core/mcp.js';
 import { runBoundedToolLoop } from '../core/toolLoop.js';
@@ -127,12 +127,12 @@ const SUBCOMMAND_COMPLETION_DESCRIPTIONS = {
 export function runtimeUnavailableReason(runtime) {
   if (runtime?.url) return null;
   const reason = runtime?.error ?? runtime?.unavailableReason ?? runtime?.reason ?? null;
-  return reason ? String(reason) : 'runtime introuvable';
+  return reason ? String(reason) : 'runtime unavailable';
 }
 
 export function runtimeUnavailableAgentMessage(runtime) {
   const reason = runtimeUnavailableReason(runtime);
-  return reason ? `⚠ Runtime indisponible : ${reason} — /agent désactivé, /chat reste possible` : null;
+  return reason ? `⚠ Runtime unavailable: ${reason} — /agent disabled, /chat still available` : null;
 }
 
 export function runtimeStatusLine(runtime, session) {
@@ -145,7 +145,7 @@ export function runtimeStatusLine(runtime, session) {
 export function recordRuntimeUnavailableAgentInput(session, line, runtime) {
   const message = runtimeUnavailableAgentMessage(runtime);
   conversationMessages(session).push({ role: 'user', content: line });
-  conversationMessages(session).push({ role: 'command', content: message ?? 'Runtime indisponible.' });
+  conversationMessages(session).push({ role: 'command', content: message ?? 'Runtime unavailable.' });
   return message;
 }
 
@@ -1422,10 +1422,10 @@ async function runAgentTurn(input, {
     if (donnaMessage) {
       donnaMessage.content = stripDsmlArtifacts(donnaMessage.content).trimEnd();
       if (!donnaMessage.content.trim()) {
-        donnaMessage.content = formatLlmUnavailableMessage('flux vide');
+        donnaMessage.content = formatLlmUnavailableMessage('empty stream');
       }
     } else {
-      messages.push({ role: 'donna', content: formatLlmUnavailableMessage('flux vide') });
+      messages.push({ role: 'donna', content: formatLlmUnavailableMessage('empty stream') });
     }
     onUpdate?.();
     return {};
@@ -1464,7 +1464,7 @@ async function runAgentTurn(input, {
       }
       donnaMessage.content = stripDsmlArtifacts(donnaMessage.content).trimEnd();
       if (!donnaMessage.content.trim()) {
-        donnaMessage.content = formatLlmUnavailableMessage('flux vide');
+        donnaMessage.content = formatLlmUnavailableMessage('empty stream');
         onUpdate?.();
       }
     } catch (err) {
@@ -1481,9 +1481,9 @@ async function runAgentTurn(input, {
   }
 
   if (donnaMessage) {
-    donnaMessage.content = formatLlmUnavailableMessage('reponse vide');
+    donnaMessage.content = formatLlmUnavailableMessage('empty response');
   } else {
-    messages.push({ role: 'donna', content: formatLlmUnavailableMessage('reponse vide') });
+    messages.push({ role: 'donna', content: formatLlmUnavailableMessage('empty response') });
   }
   onUpdate?.();
   return {};
@@ -1533,8 +1533,8 @@ async function runChatToolLoop({ input, session, history, donnaMessage, onUpdate
     onTextReset,
   });
   donnaMessage.content = capped
-    ? 'Je n’ai pas pu conclure dans la limite d’itérations du mode chat. Passe en /agent si besoin.'
-    : (stripDsmlArtifacts(content).trimEnd() || formatLlmUnavailableMessage('reponse vide'));
+    ? 'Could not finish within the chat mode iteration limit. Switch to /agent if needed.'
+    : (stripDsmlArtifacts(content).trimEnd() || formatLlmUnavailableMessage('empty response'));
   onUpdate?.();
 }
 
@@ -1580,7 +1580,7 @@ async function runDirectChatTurn(input, { session, onUpdate, onStep }) {
       }
       donnaMessage.content = stripDsmlArtifacts(donnaMessage.content).trimEnd();
       if (!donnaMessage.content.trim()) {
-        donnaMessage.content = formatLlmUnavailableMessage('flux vide');
+        donnaMessage.content = formatLlmUnavailableMessage('empty stream');
         onUpdate?.();
       }
     }
@@ -1639,7 +1639,7 @@ export async function runHeadlessChatTurn(session, input, { history = [], onStep
       const clean = stripDsmlArtifacts(delta);
       if (clean) { content += clean; onTextDelta?.(clean); }
     }
-    return stripDsmlArtifacts(content).trimEnd() || formatLlmUnavailableMessage('flux vide');
+    return stripDsmlArtifacts(content).trimEnd() || formatLlmUnavailableMessage('empty stream');
   }
   return directChatUnavailableText(session);
 }
@@ -1948,7 +1948,7 @@ async function runTuiShell({ agent, packageJson, session, runtime = null }) {
       void callMcpTool(session.mcp, activity.poll.server, activity.poll.tool, activity.poll.args ?? {})
         .then((result) => {
           const payload = parseJsonText(formatMcpToolResult(result));
-          const polledActivity = extractActivity(payload, { server: activity.poll.server, tool: activity.poll.tool });
+          const polledActivity = mergePolledActivity(activity, extractActivity(payload, { server: activity.poll.server, tool: activity.poll.tool }));
           if (polledActivity) {
             dispatchAgentEvent(session, createAgentEvent('activity_upserted', {
               origin: 'poll',

package/src/shell/repl.test.js

@@ -114,7 +114,7 @@ test('Activity uses only visible jobs and leaves remaining height to Flow/Trace'
     source.indexOf('export function ActivityPanel'),
     source.indexOf('type LogSegment'),
   );
-  assert.match(activityPanel, /<Index each=\{visibleSlots\(\)\}>/);
+  assert.match(activityPanel, /<Index each=\{visible\(\)\}>/);
   assert.doesNotMatch(activityPanel, /<Index each=\{ACTIVITY_SLOTS\}>/);
   assert.match(activityPanel, /paddingX=\{1\}/);
   assert.doesNotMatch(activityPanel, /updatedLine\(activity\(\)\)/);
@@ -144,7 +144,7 @@ test('ShellUI launcher never starts agents or workspace services implicitly', as
 test('ShellUI lets the right pane extend to the terminal edge', async () => {
   const tui = await readFile(new URL('./tui.tsx', import.meta.url), 'utf8');
   const pane = await readFile(new URL('./RightPane.tsx', import.meta.url), 'utf8');
-  assert.match(tui, /Math\.min\(58, Math\.floor\(width \* 0\.38\) \+ 2\)/);
+  assert.match(tui, /Math\.max\(32, Math\.floor\(width \* 0\.38\) \+ 2\)/);
   assert.match(pane, /paddingLeft=\{1\}/);
   assert.doesNotMatch(pane, /height="100%" flexDirection="column" padding=\{1\}/);
 });
@@ -742,7 +742,7 @@ test('agent mode without runtime records a visible error instead of falling back
 
   const message = recordRuntimeUnavailableAgentInput(session, 'salut', { error: 'port 7788 already in use' });
 
-  assert.equal(message, '⚠ Runtime indisponible : port 7788 already in use — /agent désactivé, /chat reste possible');
+  assert.equal(message, '⚠ Runtime unavailable: port 7788 already in use — /agent disabled, /chat still available');
   // `at` est posé à l'insertion : on compare le reste.
   assert.deepEqual(
     conversationMessages(session).map(({ at, ...rest }) => rest),
@@ -760,7 +760,7 @@ test('runtime status exposes the disconnected reason', () => {
   );
   assert.equal(
     runtimeUnavailableAgentMessage({ error: 'token mismatch' }),
-    '⚠ Runtime indisponible : token mismatch — /agent désactivé, /chat reste possible',
+    '⚠ Runtime unavailable: token mismatch — /agent disabled, /chat still available',
   );
 });
 
@@ -806,7 +806,7 @@ test('/queue cancel on a runtime workflow id points to run cancellation commands
   });
 
   assert.equal(result.exit, false);
-  assert.match(conversationMessages(session).at(-1).content, /Item géré par le runtime/);
+  assert.match(conversationMessages(session).at(-1).content, /Runtime-managed item/);
   assert.match(conversationMessages(session).at(-1).content, /\/run kill/);
 });
 

package/src/shell/tui.tsx

@@ -156,7 +156,7 @@ function App(props: {
   const exitShell = () => {
     if (exiting) return;
     exiting = true;
-    setExitStatus('Fermeture enclenchée…');
+    setExitStatus('Shutting down…');
     const task = Promise.resolve().then(async () => {
       renderer.destroy();
       console.log('[wiki-manager] shell closed; shared runtime left running.');
@@ -180,11 +180,11 @@ function App(props: {
   const conversationRows = createMemo(() => Math.max(4, dimensions().height - 5 - chatInputHeight() - 4));
   const rightColumns = createMemo(() => {
     const width = dimensions().width;
-    // 38% + 2 columns / cap 58: the Plan/Activity/Logs panes carry job
-    // labels, file names and error messages — 40 columns truncated everything
-    // into unreadable stubs. The small addition uses the terminal's right-side
-    // slack without making the conversation pane noticeably narrower.
-    return Math.max(32, Math.min(58, Math.floor(width * 0.38) + 2));
+    // 38% + 2 columns: the Plan/Activity/Logs panes carry job labels, file
+    // names and error messages. The pane scales with the terminal instead of
+    // being capped, so a wide screen widens the detail pane rather than leaving
+    // it narrow while the conversation column absorbs all the extra slack.
+    return Math.max(32, Math.floor(width * 0.38) + 2);
   });
   const leftColumns = createMemo(() => Math.max(32, dimensions().width - rightColumns() - 1));
   const conversationColumns = createMemo(() => {

package/src/shell/useAgent.ts

@@ -52,7 +52,7 @@ export function useAgent(props: { agent: unknown; packageJson: Record<string, un
       }
       if (!props.chatMode() && !trimmed.startsWith('/') && !freeTextRouting?.local) {
         const message = recordRuntimeUnavailableAgentInput(props.session, trimmed, {
-          error: props.runtimeUnavailableReason ?? 'runtime introuvable',
+          error: props.runtimeUnavailableReason ?? 'runtime unavailable',
         });
         props.addLog(message ?? 'runtime: disconnected');
         props.refresh();

package/src/shell/useSession.ts

@@ -3,7 +3,7 @@ import { isAbsolute, relative, resolve, sep } from 'node:path';
 import { createEffect, createMemo, createSignal, onCleanup } from 'solid-js';
 import { formatMcpToolResult, callMcpTool } from '../core/mcp.js';
 import { versionWithBuild } from '../core/buildInfo.js';
-import { extractActivity, parseJsonText, sessionActivities } from '../core/activity.js';
+import { extractActivity, mergePolledActivity, parseJsonText, sessionActivities } from '../core/activity.js';
 import { formatPlanStatus, formatCompletedActivities, formatPlanStep } from '../core/plan.js';
 import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
 import { projectQueue, queueCounts, startNextQueuedJob, syncQueueWithActivity } from '../core/jobQueue.js';
@@ -158,7 +158,7 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
   const runtimeHint = createMemo(() => {
     version();
     if (props.runtime?.url) return null;
-    return runtimeUnavailableAgentMessage({ error: runtimeUnavailableReason() ?? 'runtime introuvable' });
+    return runtimeUnavailableAgentMessage({ error: runtimeUnavailableReason() ?? 'runtime unavailable' });
   });
   const matchContext = createMemo(() => {
     if (input() === dismissedSlashInput()) return null;
@@ -277,7 +277,7 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
         return {
           ...item,
           id: item.id,
-          label: `${chain.skillName ?? 'skill'}${chain.selectionKind ? ` [${chain.selectionKind}]` : ''} ${position} · ${step.label}${reason}`,
+          label: `${chain.skillName ?? 'skill'}${chain.selectionLabel ? ` [${chain.selectionLabel}]` : ''} ${position} · ${step.label}${reason}`,
           status: item.status,
           _runtime: true,
           _control: true,
@@ -602,10 +602,10 @@ export function useSession(props: { agent: unknown; packageJson: Record<string,
       void callMcpTool(session.mcp, activity.poll.server, activity.poll.tool, activity.poll.args ?? {})
         .then((result) => {
           const payload = parseJsonText(formatMcpToolResult(result));
-          const polledActivity = extractActivity(payload, {
+          const polledActivity = mergePolledActivity(activity, extractActivity(payload, {
             server: activity.poll.server,
             tool: activity.poll.tool,
-          });
+          }));
           if (polledActivity) {
             dispatchAgentEvent(session, createAgentEvent('activity_upserted', {
               origin: 'poll',