@dotdrelle/wiki-manager 0.15.62 → 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.62",
+  "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.62",
-  "commit": "399432f"
+  "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.62';
+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/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/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) => {
@@ -385,7 +387,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

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',