@dotdrelle/wiki-manager 0.15.60 → 0.15.64

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.60",
+  "version": "0.15.64",
   "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.',

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/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/buildInfo.json

@@ -1,4 +1,4 @@
 {
-  "version": "0.15.60",
-  "commit": "8c5c615"
+  "version": "0.15.64",
+  "commit": "d77449c"
 }

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.60';
+const WIKI_MANAGER_VERSION = '0.15.64';
 
 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/skillCompiler.test.js

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

package/src/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/controlMessages.js

@@ -13,6 +13,7 @@
 
 const CONTROL_MESSAGES = {
   queued_for_future_run: 'Request added to the queue — it will start automatically after the current run.',
+  control_run_started: 'A queued request is now starting.',
   plan_patch_proposed: 'Plan patch proposed. Approve it explicitly to apply it to the active plan.',
   ambiguous_control: 'A run is already active, and this looks like a new action. Say "queue it" to run it after the current run, "modify the run" to change the active plan, "cancel" to stop the current run first — or wait for it to finish.',
   converse_while_running: 'Runtime run is still active. This message was treated as conversation and did not create a queued run.',

package/src/runtime/server.js

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

package/src/runtime/server.test.js

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

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

@@ -202,7 +202,7 @@ test('E2E-003 cancel: the running step and its chain stop, unrelated queue survi
 // that silently fragments would show up as extra runs, not as extra objectives.
 const PERFORMANCE_TABLE = {
   pipeline: 1,
-  'wiki-ingest': 1,
+  'wiki-ingest': 2,
   'wiki-build': 1,
   deliver: 1,
   diagnose: 1,

package/src/runtime/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/LeftPane.tsx

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

package/src/shell/RightPane.tsx

@@ -20,7 +20,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);
-const PLAN_VIEWPORT_ROWS = 12;
+// 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);
@@ -194,12 +198,10 @@ export function PlanPanel(props: { plan: PlanStep[]; width: number; jobName?: st
   // Keep one column for the native vertical scrollbar when the plan is long.
   const lineWidth = () => Math.max(8, props.width - 3);
   const firstPending = () => props.plan.find((s) => s.status === 'pending')?.step ?? null;
-  // A running step carries a thick left border, which costs one column: the
-  // wrap width is therefore one less for it. The same function feeds both the
-  // row-count memo and the render, so the viewport height can never undercount
-  // a running step's wrapped lines and clip the last one.
-  const isRunningStep = (step: PlanStep) => String(step.status ?? '').toLowerCase() === 'running';
-  const stepTextWidth = (step: PlanStep) => lineWidth() - (isRunningStep(step) ? 1 : 0);
+  // Plus de liseré bleu à gauche : l'icône et la couleur du texte suffisent à
+  // distinguer une étape en cours, et le cadre se voyait aussi sur une étape en
+  // attente (jaune). Toutes les étapes utilisent donc la même largeur.
+  const stepTextWidth = (_step: PlanStep) => lineWidth();
   const icon = (rawStatus: string) => {
     const status = String(rawStatus ?? '').toLowerCase();
     if (DONE_STATUSES.includes(status)) return '[✓]';
@@ -214,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">
@@ -229,23 +230,24 @@ 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) => {
             // Wrap step descriptions over up to 2 lines instead of truncating —
             // "Ingest des 39 documents raw/untrac…" hid the actual target.
-            const running = () => isRunningStep(step());
             const textWidth = () => stepTextWidth(step());
             const lines = () => wrapLine(`${icon(step().status)} ${step().step}. ${step().description}`, textWidth()).slice(0, 2);
             return (
-              <box flexShrink={0} flexDirection="column" border={running() ? ['left'] : undefined} borderStyle="heavy" borderColor="#89B4FA">
+              <box flexShrink={0} flexDirection="column">
                 <text width={textWidth()} fg={planStepColor(step(), firstPending())} content={lines()[0]} />
                 <Show when={lines()[1]}>
                   <text width={textWidth()} fg={planStepColor(step(), firstPending())} content={`    ${fit(lines()[1], Math.max(8, textWidth() - 4))}`} />
@@ -265,7 +267,7 @@ export function ActivityPanel(props: { activities: any[]; width: number }) {
   const visibleSlots = () => visible().map((_activity, index) => index);
   const activityAt = (index: number) => visible()[index] ?? null;
   return (
-    <box flexShrink={0} flexDirection="column" paddingX={1}>
+    <box flexShrink={0} flexDirection="column" paddingX={1} backgroundColor="#111318">
       <text width={lineWidth()} fg="#D6DEE8" content="Activity" />
       <Show when={visible().length > 0} fallback={<text width={lineWidth()} fg="#7F8C8D" content="no active jobs" />}>
         <Index each={visibleSlots()}>
@@ -385,6 +387,10 @@ 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 (
+    // 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">

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';
@@ -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/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';
@@ -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',