@dotdrelle/wiki-manager 0.15.52 → 0.15.54

package/README.md

@@ -118,7 +118,7 @@ and a *replaceable* toolbox of *external* MCP servers — to produce the **core
 wiki** outputs, all driven by an agentic, multi-model orchestrator and grounded
 in isolated workspaces.
 
-![wikiLLM functional diagram — inputs, MCP calls and outputs around the agentic orchestrator and workspaces](docs/architecture.svg)
+![wikiLLM functional diagram — inputs, MCP calls and outputs around the agentic orchestrator and workspaces](https://raw.githubusercontent.com/dotdrelle/llm-wiki-manager/main/docs/architecture.png)
 
 ## Quick start — your first wiki in ~5 minutes
 

package/docker-compose.override.example.yml

@@ -78,5 +78,24 @@
 #           resources:
 #             limits:
 #               cpus: '2.0'
+#
+# ── Host timezone (opt-in) ────────────────────────────────────────────────────
+#
+# Containers default to UTC, so runtime/production logs can read an hour or two
+# off the host's wall clock. Mount the host's timezone to make them agree. This
+# is deliberately NOT in the packaged file: the mount assumes /etc/localtime
+# exists on the host (true on most Linux/macOS hosts, but not all), and a
+# timezone is a property of the machine, not of the workspace.
+#
+#     services:
+#       serve:
+#         volumes:
+#           - /etc/localtime:/etc/localtime:ro
+#       mcp-http:
+#         volumes:
+#           - /etc/localtime:/etc/localtime:ro
+#       production-mcp:
+#         volumes:
+#           - /etc/localtime:/etc/localtime:ro
 
 services: {}

package/package.json

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

package/src/agent/graph.js

@@ -70,7 +70,7 @@ const SHELL_RUN_COMMAND_TOOL = {
     description: [
       'Run a deterministic wiki-manager slash command inside the current shell session.',
       'Allowed commands: /workspace list, /workspace init <name> [path], /use <workspace>, /config, /status, /services, /skills, /skills show <name>, /skills run <name>, /upload <path>, /upload convert <id|pending>.',
-      'Do not use for arbitrary system shell commands, /workspace delete, /mcp call, /wiki run, /start, /stop, /logs, or /exit.',
+      'Do not use for arbitrary system shell commands, /workspace delete, /wiki run, /start, /stop, /logs, or /exit.',
     ].join(' '),
     parameters: {
       type: 'object',
@@ -522,6 +522,27 @@ function delegationBlockerForDonna(rawFailure) {
   });
 }
 
+function isUnresolvedTargetFailure(rawFailure) {
+  return /file does not exist|does not exist|no files match/i.test(rawFailure);
+}
+
+function unresolvedTargetForDonna(rawFailure) {
+  const cleaned = String(rawFailure ?? '')
+    .replace(/\b(?:provider|endpoint)=[^\s,]+/g, '')
+    .replace(/\[[^\]]*\.(?:agent_plan|agent_execute)\]/g, '')
+    .replace(/\s*Available capabilities:\s*[\s\S]*$/i, '')
+    .replace(/\s*<-\s*[\s\S]*$/s, '')
+    .replace(/\s{2,}/g, ' ')
+    .trim();
+  return JSON.stringify({
+    delegated: false,
+    blocker: 'unresolved_target',
+    reason: cleaned,
+    instruction:
+      'The target the user named does not match an existing file. Look up the available targets with the read-only list tools, then retry the delegation with the exact resolved path, or ask the user to confirm which target they meant. Never widen to an all-targets operation, and never expose exception names, tool names, or internal routing details.',
+  });
+}
+
 function summarizeToolArguments(rawArguments) {
   if (!rawArguments || rawArguments === '{}') return '';
   try {
@@ -869,17 +890,13 @@ export async function handleRuntimeControlTool(session, tool, args = {}) {
        409 garde tout son sens.
       */
       if (typeof session?._delegateWithinRun === 'function') {
-        try {
-          const inRun = await session._delegateWithinRun(objective);
-          return JSON.stringify({
-            delegated: true,
-            runId: inRun.runId,
-            summary: inRun.summary ?? null,
-            message: `Action lancée (${String(inRun.runId).slice(0, 8)}) après validation du plan réel : ${inRun.summary?.tasks ?? 0} tâche(s), ${inRun.summary?.agent ?? 'agent résolu'}. Exécution en cours.`,
-          });
-        } catch (err) {
-          return `Délégation refusée : ${err instanceof Error ? err.message : String(err)}`;
-        }
+        const inRun = await session._delegateWithinRun(objective);
+        return JSON.stringify({
+          delegated: true,
+          runId: inRun.runId,
+          summary: inRun.summary ?? null,
+          message: `Action lancée (${String(inRun.runId).slice(0, 8)}) après validation du plan réel : ${inRun.summary?.tasks ?? 0} tâche(s), ${inRun.summary?.agent ?? 'agent résolu'}. Exécution en cours.`,
+        });
       }
       const result = await postRuntimeDelegate(objective, { url, workspace });
       return result?.runId
@@ -1877,7 +1894,8 @@ export function createAgentGraph(options = {}) {
           if (tool === 'delegate' && /^Runtime control error \(delegate\):/i.test(resultText)) {
             const delegationFailure = resultText
               .replace(/^Runtime control error \(delegate\):\s*/i, '')
-              .replace(/^Delegation failed during objective_resolution:\s*/i, '');
+              .replace(/^Delegation failed during objective_resolution:\s*/i, '')
+              .replace(/^Delegation failed during agent_plan:\s*/i, '');
             const needsInput = delegationFailure.match(/^Delegation requires input:\s*(.+)$/i);
             if (needsInput) {
               // Missing provider-required fields are a conversational blocker,
@@ -1889,6 +1907,11 @@ export function createAgentGraph(options = {}) {
                 missingRequiredFields: needsInput[1].split(',').map((item) => item.trim()).filter(Boolean),
                 instruction: 'Ask the user for the missing required information. Do not expose internal validation details.',
               });
+            } else if (isUnresolvedTargetFailure(delegationFailure)) {
+              // A named target that resolves to nothing is not an unsupported
+              // action: Donna can look it up and retry (or ask), so the turn
+              // must not be marked terminal here.
+              resultText = unresolvedTargetForDonna(delegationFailure);
             } else {
               terminalFailure = delegationFailure;
               resultText = delegationBlockerForDonna(delegationFailure);

package/src/agent/graph.test.js

@@ -476,7 +476,7 @@ test('an explicitly selected skill runs through the intra-runtime path with name
         mainCalls += 1;
         if (mainCalls === 1) return {
           content: null, message: { role: 'assistant', content: null },
-          tool_calls: [{ id: 'skill', type: 'function', function: { name: 'runtime__run_skill', arguments: '{"skillName":"deliver","arguments":{"template":"Quarterly report"},"selectionKind":"explicit_name"}' } }],
+          tool_calls: [{ id: 'skill', type: 'function', function: { name: 'runtime__run_skill', arguments: '{"skillName":"deliver","arguments":{"deliverable":"Quarterly report"},"selectionKind":"explicit_name"}' } }],
         };
         return { content: 'Skill mis en file.', message: { role: 'assistant', content: 'Skill mis en file.' }, tool_calls: null };
       },
@@ -489,7 +489,7 @@ test('an explicitly selected skill runs through the intra-runtime path with name
   // quelles compétences sont déjà ouvertes au-dessus de lui.
   assert.deepEqual(calls, [[
     'deliver',
-    { template: 'Quarterly report' },
+    { deliverable: 'Quarterly report' },
     { selectionKind: 'explicit_name', turnId: 'turn-skill-1', skillStack: [] },
   ]]);
 });
@@ -1334,6 +1334,42 @@ test('a delegation missing required provider inputs returns to Donna for clarifi
   }
 });
 
+test('a delegation whose named target does not resolve returns to Donna to resolve, not as a terminal refusal', async () => {
+  let calls = 0;
+  const session = sessionBase({
+    runtime: { url: 'http://runtime.test' },
+    _delegateWithinRun: async () => {
+      throw new Error('Delegation failed during agent_plan: provider=production endpoint=http://127.0.0.1:3000/mcp/ templates file does not exist: basic note');
+    },
+    llm: {
+      async completeWithTools() {
+        calls += 1;
+        if (calls === 1) {
+          return {
+            content: null,
+            message: { role: 'assistant', content: null },
+            tool_calls: [{
+              id: 'delegate-target',
+              type: 'function',
+              function: { name: 'runtime__delegate', arguments: '{"objective":"build basic note"}' },
+            }],
+          };
+        }
+        return {
+          content: 'Je n’ai trouvé aucun template « basic note ».',
+          message: { role: 'assistant', content: 'Je n’ai trouvé aucun template « basic note ».' },
+          tool_calls: null,
+        };
+      },
+    },
+  });
+
+  const result = await createAgentGraph().invoke({ input: 'build basic note', session });
+  assert.equal(result.terminalToolFailure, false);
+  assert.equal(result.response, 'Je n’ai trouvé aucun template « basic note ».');
+  assert.doesNotMatch(result.response, /provider=|endpoint=|file does not exist|agent_plan/i);
+});
+
 // Guard: the system prompt must never show a connected tool's bare name
 // outside its qualified server__tool form. Bare mentions are what teach the
 // model to emit unqualified tool calls (the cme_status incident). The bare

package/src/cli/wiki-manager.js

@@ -109,12 +109,20 @@ export function buildExecutorOnlyFragment({ objective, workspace, selection }) {
 }
 
 /**
- * Fill a single-task executor's arguments from the natural-language objective,
+ * Fill a task's structured arguments from the natural-language objective,
  * generically — against the capability's own declared `inputSchema`, with no
  * per-agent or per-provider knowledge in the manager. This lets Donna honour
  * stated constraints ("les 10 derniers mails", "de LinkedIn") while keeping
  * `runtime__delegate` agnostic (it still only carries the objective).
  *
+ * Used on BOTH delegation branches:
+ * - executor-only (`singleTaskOnly`) agents: the extracted arguments become the
+ *   single task's `arguments`;
+ * - planner (`canPlan`) agents: the extracted arguments are forwarded to
+ *   `agent_plan` as its `arguments`, so a targeted selector (a template, a
+ *   deliverable, a source) reaches the plan instead of widening to "all"
+ *   (a `/wiki-build <template>` that built every template).
+ *
  * Degrades gracefully (cf. provider compatibility): forced tool_choice first,
  * then a JSON-text completion, then no arguments — the executor uses its own
  * defaults. It never throws and never invents identifiers.
@@ -1234,6 +1242,13 @@ async function runRuntime(argv, agent) {
     let fragment;
     if (canPlan) {
       try {
+        const extractedArguments = await resolveExecutorArguments({
+          llm: session.llm,
+          objective,
+          capability: provider.capability,
+          workspace: session.workspace ?? context.workspace ?? '',
+          signal: session._abortSignal,
+        });
         planResult = await callMcpTool(
           session.mcp,
           provider.serverName,
@@ -1242,6 +1257,9 @@ async function runRuntime(argv, agent) {
             capability: selection.capability,
             operation: selection.operation,
             objective,
+            ...(extractedArguments && Object.keys(extractedArguments).length > 0
+              ? { arguments: extractedArguments }
+              : {}),
             workspace: { revision: String(Date.now()) },
             constraints: {
               maxConcurrency: resolveCapabilityConcurrency(

package/src/cli/wiki-manager.test.js

@@ -126,6 +126,37 @@ test('argument extraction falls back to a JSON-text completion', async () => {
   assert.deepEqual(args, { query: 'from:linkedin.com' });
 });
 
+const BUILD_CAPABILITY = {
+  description: 'Build llm-wiki deliverables from templates in templates/.',
+  inputSchema: {
+    type: 'object',
+    additionalProperties: true,
+    properties: {
+      templates: { type: 'array', items: { type: 'string' } },
+      stabilize: { type: 'boolean' },
+    },
+  },
+};
+
+test('argument extraction maps a skill template selector to the templates array', async () => {
+  // Regression: a skill carries its `template` parameter as a natural-language
+  // "User parameters:" block. The delegation path must turn it back into the
+  // structured `templates` array, or a targeted build widens to every template.
+  const llm = {
+    completeWithTools: async () => ({
+      tool_calls: [{
+        function: { name: 'set_task_arguments', arguments: JSON.stringify({ templates: ['overview'] }) },
+      }],
+    }),
+  };
+  const args = await resolveExecutorArguments({
+    llm,
+    objective: 'Build deliverables from the current wiki within the exact scope requested by the template parameter.\n\nUser parameters:\ntemplate: overview',
+    capability: BUILD_CAPABILITY,
+  });
+  assert.deepEqual(args, { templates: ['overview'] });
+});
+
 test('argument extraction stays agnostic and safe when it cannot extract', async () => {
   // No inputSchema → no extraction attempted at all.
   assert.deepEqual(

package/src/commands/slash.js

@@ -32,9 +32,7 @@ import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
 import {
   cancelQueueItem,
   clearFinishedQueueItems,
-  enqueueProductionJob,
   formatQueue,
-  productionLockBusy,
 } from '../core/jobQueue.js';
 import {
   listWikircProfiles,
@@ -599,11 +597,6 @@ async function createWorkspaceCommand(context, workspaceName, targetPath) {
 }
 
 
-function formatMcpCallActivity(serverName, toolName, resultText) {
-  if (serverName === 'production') return null;
-  return formatActivitySummary(serverName, toolName, resultText);
-}
-
 function publishPayloadActivity(session, payload, context = {}) {
   const activity = extractActivity(payload, context);
   if (!activity) return null;
@@ -748,7 +741,7 @@ ${helpPair('/stop [all|everything|service|agents]', 'Stop service(s)', '/logs <s
 ${helpPair('/skills', 'List skills', '/skills show <n>', 'Show skill')}
 ${helpPair('/skills run <n>', 'Run skill guide', '/skills edit <n>', 'Edit skill')}
 ${helpPair('/mcp status', 'MCP status', '/mcp endpoints', 'MCP endpoints')}
-${helpPair('/mcp tools [mcp]', 'MCP tools', '/mcp call ...', 'Call MCP tool')}
+${helpPair('/mcp tools [mcp]', 'MCP tools', '', '')}
 ${helpPair('/connector list', 'Connector auth status', '/connector auth <n>', 'Authorize connector')}
 ${helpPair('/upload <path>', 'Upload document', '/uploads', 'Uploaded docs')}
 ${helpPair('/upload convert pending', 'Convert pending', '/uploads clean', 'Clean uploads')}
@@ -1218,40 +1211,7 @@ export async function handleSlashCommand(line, context) {
         }
         return { output: formatMcpTools(context.session.mcp, filterName) };
       }
-      if (subcommand === 'call') {
-        const serverName = args[2];
-        const toolName = args[3];
-        if (!serverName || !toolName) {
-          return { output: 'Usage: /mcp call <mcp> <tool> [json]' };
-        }
-        try {
-          const rawArgs = args.slice(4).join(' ');
-          let toolArgs = rawArgs ? JSON.parse(rawArgs) : {};
-          if (serverName === 'production' && toolName === 'production_start_job' && context.session.workspace && !toolArgs.callerLabel) {
-            toolArgs = { ...toolArgs, callerLabel: `${context.session.workspace}/wiki-manager` };
-          }
-          if (serverName === 'production' && toolName === 'production_start_job' && productionLockBusy(context.session)) {
-            const item = enqueueProductionJob(context.session, toolArgs, 'production lock busy');
-            return { output: `Queued ${item.id}: waiting ${item.workspace ?? 'no-workspace'} ${item.tool}` };
-          }
-          step(`MCP: calling ${serverName}.${toolName}…`);
-          const result = await callMcpTool(context.session.mcp, serverName, toolName, toolArgs);
-          const output = formatMcpToolResult(result);
-          const payload = parseJsonText(output);
-          if (serverName === 'production' && toolName === 'production_start_job' && payload?.ok === false && payload?.error === 'workspace_busy') {
-            const item = enqueueProductionJob(context.session, toolArgs, 'workspace_busy');
-            return { output: `Queued ${item.id}: waiting for production lock (${payload.activeJobId ?? 'active job'})` };
-          }
-          const activity = formatMcpCallActivity(serverName, toolName, output);
-          if (activity) step(activity);
-          return rawCommandResult(`/mcp call ${serverName} ${toolName}`, output);
-        } catch (err) {
-          const message = err instanceof Error ? err.message : String(err);
-          step(formatActivityError(serverName, toolName, err));
-          return { output: message };
-        }
-      }
-      return { output: 'Usage: /mcp <status|endpoints|tools|call> [mcp]' };
+      return { output: 'Usage: /mcp <status|endpoints|tools> [mcp]' };
     }
     case 'connector': {
       const subcommand = args[1] ?? 'list';

package/src/commands/slash.test.js

@@ -34,6 +34,15 @@ test('/status MCP overview contains only connector name, port and status', () =>
   assert.doesNotMatch(output, /tools|error|detail|http/i);
 });
 
+test('/mcp exposes diagnostics only and cannot directly execute arbitrary MCP tools', async () => {
+  const result = await handleSlashCommand('/mcp call production production_start_job {"step":"ingest"}', {
+    packageJson: { version: 'test' },
+    session: { mcp: {} },
+  });
+
+  assert.equal(result.output, 'Usage: /mcp <status|endpoints|tools> [mcp]');
+});
+
 test('/status base URL displays only its domain while retaining the full link', () => {
   assert.equal(
     compactBaseUrl('https://albert.api.etalab.gouv.fr/v1'),

package/src/core/agentEvents.js

@@ -2,7 +2,7 @@ import { normalizeActivity } from './activity.js';
 import { attachActivityToExistingPlan, syncActivitiesToPlan } from './plan.js';
 import { applyPlanPatch, normalizePlanPatch, normalizePlanRevision, rebasePlanPatch } from './planPatch.js';
 import { formatRuntimeLogPayload } from './runtimeLog.js';
-import { projectSkillChains } from './skillChainView.js';
+import { projectSkillChains, TERMINAL as CONTROL_TERMINAL_STATUSES } from './skillChainView.js';
 import { projectWorkflow } from './workflow.js';
 import { validateContractInDev } from '../contracts/schemas.js';
 import { isTerminal, isSuccessful, isUnknownStatus, normalizeTaskStatus } from '../orchestrator/taskStatuses.js';
@@ -269,6 +269,7 @@ function applyEvent(state, event) {
       state.planRevision = 0;
       state.planPatches = [];
       state.summary = null;
+      pruneTerminalControlItems(state.controlQueue);
       return;
     case 'user_message':
       state.conversation.push({ role: 'user', content: String(event.payload?.content ?? '') });
@@ -711,6 +712,44 @@ function finishControlByRun(queue, runId, status, finishedAt) {
   item.updatedAt = finishedAt;
 }
 
+/*
+ A new run makes the previous control items history.
+
+ `run_started` already resets plan, activities and logs, but the control queue
+ was left to accumulate: a cancelled or failed chain stayed in the CHAIN panel
+ across the next plan, and its terminal items kept counting in the queue ("Queue
+ (14)" over 4 live items). Prune here, not in the UI, so both projections agree.
+
+ A chain is dropped only once EVERY item is terminal — the active chain always
+ has a running/queued item and is therefore never pruned mid-flight. Standalone
+ control items (no chainId) are dropped as soon as they are terminal.
+*/
+function pruneTerminalControlItems(queue) {
+  const byChain = new Map();
+  const standalone = [];
+  for (const item of queue) {
+    if (item.chainId) {
+      if (!byChain.has(item.chainId)) byChain.set(item.chainId, []);
+      byChain.get(item.chainId).push(item);
+    } else {
+      standalone.push(item);
+    }
+  }
+  const drop = new Set();
+  for (const items of byChain.values()) {
+    if (items.every((item) => CONTROL_TERMINAL_STATUSES.has(String(item.status ?? '').toLowerCase()))) {
+      for (const item of items) drop.add(item.id);
+    }
+  }
+  for (const item of standalone) {
+    if (CONTROL_TERMINAL_STATUSES.has(String(item.status ?? '').toLowerCase())) drop.add(item.id);
+  }
+  if (!drop.size) return;
+  for (let i = queue.length - 1; i >= 0; i--) {
+    if (drop.has(queue[i].id)) queue.splice(i, 1);
+  }
+}
+
 function appendAssistantDelta(state, delta) {
   if (!delta) return;
   const last = state.conversation.at(-1);

package/src/core/agentEvents.test.js

@@ -401,6 +401,35 @@ test('reduceAgentEvents: control queue is event sourced and follows run status',
   assert.equal(projection.controlQueue[1].status, 'cancelled');
 });
 
+test('reduceAgentEvents: run_started prunes terminal control items and fully terminal chains', () => {
+  const ts = '2026-01-01T00:00:00.000Z';
+  const enqueue = (id, extra = {}) => createAgentEvent('control_enqueued', {
+    origin: 'runtime',
+    workspace: 'docs',
+    payload: { id, workspace: 'docs', input: 'objective', createdAt: ts, ...extra },
+  });
+  const projection = reduceAgentEvents([
+    // Fully terminal chain (done + skipped): becomes history, pruned.
+    enqueue('chain-old-1', { chainId: 'chain-old', chainSequence: 1 }),
+    enqueue('chain-old-2', { chainId: 'chain-old', chainSequence: 2 }),
+    createAgentEvent('control_started', { origin: 'runtime', runId: 'run-old-1', workspace: 'docs', payload: { id: 'chain-old-1', runId: 'run-old-1' } }),
+    createAgentEvent('run_done', { origin: 'runtime', runId: 'run-old-1', workspace: 'docs' }),
+    createAgentEvent('control_skipped', { origin: 'runtime', workspace: 'docs', payload: { id: 'chain-old-2', reason: 'required_predecessor_failed' } }),
+    // Standalone terminal item: pruned.
+    enqueue('standalone-old'),
+    createAgentEvent('control_cancelled', { origin: 'runtime', workspace: 'docs', payload: { id: 'standalone-old' } }),
+    // Active chain (done + queued): must survive the prune.
+    enqueue('chain-active-1', { chainId: 'chain-active', chainSequence: 1 }),
+    enqueue('chain-active-2', { chainId: 'chain-active', chainSequence: 2 }),
+    createAgentEvent('control_started', { origin: 'runtime', runId: 'run-active-1', workspace: 'docs', payload: { id: 'chain-active-1', runId: 'run-active-1' } }),
+    createAgentEvent('run_done', { origin: 'runtime', runId: 'run-active-1', workspace: 'docs' }),
+    // A new run starts: terminal relics are history, the active chain is not.
+    createAgentEvent('run_started', { origin: 'runtime', runId: 'run-new', workspace: 'docs' }),
+  ]);
+
+  assert.deepEqual(projection.controlQueue.map((item) => item.id), ['chain-active-1', 'chain-active-2']);
+});
+
 test('reduceAgentEvents: control_enqueued preserves a structured capabilityPlan across replay', () => {
   const capabilityPlan = {
     capability: 'workspace.restore',

package/src/core/buildInfo.json

@@ -1,4 +1,4 @@
 {
-  "version": "0.15.52",
-  "commit": "2b8e3e3"
+  "version": "0.15.54",
+  "commit": "7a84126"
 }

package/src/core/googleGrants.test.js

@@ -1,13 +1,23 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
-import { readFileSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { GOOGLE_GRANTS, GOOGLE_GRANT_LABELS, defaultGoogleGrants } from './googleGrants.js';
 
+// `agent-connectors` n'est pas cloné par le CI du manager, qui ne tire que
+// llm-wiki, agent-wiki-production, agent-cme et agent-wiki-documents (voir
+// check-versions.js). Les contrôles de cohérence croisée ci-dessous lisent la
+// source de l'agent connectors : sans elle, on les saute plutôt que d'échouer
+// sur un ENOENT. Le flux de release complet (build-and-push.sh) la fournit,
+// donc le contrôle y reste effectif.
+const connectorsPresent = existsSync(
+  fileURLToPath(new URL('../../../agent-external/agent-connectors', import.meta.url)),
+);
+
 const connectorsSrc = (file) =>
   readFileSync(fileURLToPath(new URL(`../../../agent-external/agent-connectors/src/${file}`, import.meta.url)), 'utf8');
 
-test('the grant names mirror the agent, spelling included', () => {
+test('the grant names mirror the agent, spelling included', { skip: !connectorsPresent }, () => {
   // `modify` est le nom de Google (scope gmail.modify) et celui de l'agent.
   // Un synonyme côté manager créerait une troisième orthographe à tenir à jour
   // — le travers qui avait déjà donné une seconde paire de variables OAuth.
@@ -26,7 +36,7 @@ test('every grant is described in plain words, never left as a bare token', () =
   }
 });
 
-test('the default asks for everything the agent can actually do', () => {
+test('the default asks for everything the agent can actually do', { skip: !connectorsPresent }, () => {
   // Un défaut plus étroit promet des actions que l'autorisation ne couvre pas :
   // `/connector auth google` ne demandait que `read`, et l'envoi comme le
   // marquage échouaient après coup, en ressemblant à des fonctions absentes.

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

package/src/core/runtimeLog.js

@@ -65,7 +65,7 @@ export function formatRuntimeLogPayload(payload = {}, ts = null) {
   // lines ended up visually glued at the bottom of Logs/Trace, out of
   // chronology with the shell's own timestamped lines.
   if (payload?.message != null && !payload.event) {
-    return [timeLabel(ts), String(payload.message)].filter(Boolean).join(' ');
+    return [timeLabel(ts), shortenUuids(String(payload.message))].filter(Boolean).join(' ');
   }
   const time = timeLabel(ts);
   const event = eventLabel(payload.event);
@@ -75,10 +75,26 @@ export function formatRuntimeLogPayload(payload = {}, ts = null) {
   if (payload.status != null) fields.push(formatField('status', payload.status));
   if (payload.percent != null) fields.push(formatField('percent', payload.percent));
   if (payload.outputs != null) fields.push(formatField('outputs', payload.outputs));
-  if (payload.detail != null && payload.detail !== '') fields.push(`detail=${quoteIfNeeded(payload.detail)}`);
+  if (payload.detail != null && payload.detail !== '') fields.push(`detail=${quoteIfNeeded(shortenUuids(payload.detail))}`);
   return [time, event, ...fields].filter(Boolean).join(' ');
 }
 
+// Runtime/agent ids are long UUIDs (run, task, attempt, agent instance). A full
+// UUID pushed the readable fields off the line and wrapped mid-id, which is what
+// made the Logs/Trace panel illegible. Collapse the UUID to its first 8 hex
+// characters — the same disambiguating prefix every UI already shows — and cap
+// over-long slugs so a single field never monopolises the line.
+const UUID_RE = /\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\b/gi;
+
+function shortenUuids(text) {
+  return String(text ?? '').replace(UUID_RE, (uuid) => `${uuid.slice(0, 8)}…`);
+}
+
+export function shortLogId(value, { maxLength = 40 } = {}) {
+  const shortened = shortenUuids(value);
+  return shortened.length > maxLength ? `${shortened.slice(0, maxLength - 1)}…` : shortened;
+}
+
 export function runtimeLogMatchesFilter(line, filter = '') {
   const query = String(filter ?? '').trim();
   if (!query) return true;
@@ -122,7 +138,7 @@ function eventLabel(event) {
 
 function formatField(key, value) {
   if (value == null || value === '') return null;
-  return `${key}=${quoteIfNeeded(value)}`;
+  return `${key}=${quoteIfNeeded(shortenUuids(value))}`;
 }
 
 function quoteIfNeeded(value) {

package/src/core/runtimeLog.test.js

@@ -2,7 +2,7 @@ import assert from 'node:assert/strict';
 import test from 'node:test';
 
 import { createAgentEvent, dispatchAgentEvent } from './agentEvents.js';
-import { compactRuntimeLogForDisplay, formatRuntimeLogPayload } from './runtimeLog.js';
+import { compactRuntimeLogForDisplay, formatRuntimeLogPayload, shortLogId } from './runtimeLog.js';
 import { emitRuntimeLog } from '../runtime/supervisor.js';
 
 const CYCLE_EVENTS = [
@@ -98,3 +98,29 @@ test('runtime display compaction leaves other log entries unchanged', () => {
   const line = '09:25:35 trace: ERROR retrieval failed message="broken"';
   assert.equal(compactRuntimeLogForDisplay(line), line);
 });
+
+test('long UUIDs collapse to a short prefix so log lines stay on one line', () => {
+  const uuid = '7fadad27-0be6-4d08-96e5-664fe7ee841e';
+  const line = formatRuntimeLogPayload({
+    event: 'task.ready',
+    runId: uuid,
+    taskId: `${uuid}:taxonomy-synthesis`,
+    attemptId: `attempt-${uuid}`,
+    agentInstanceId: `production-${uuid}`,
+    capability: 'document.build',
+    operation: 'build',
+  }, '2026-07-08T14:42:18.000Z');
+
+  assert.match(line, /run=7fadad27…/);
+  assert.match(line, /task=7fadad27…:taxonomy-synthesis/);
+  assert.match(line, /attempt=attempt-7fadad27…/);
+  assert.match(line, /agentInstance=production-7fadad27…/);
+  assert.doesNotMatch(line, /7fadad27-0be6-4d08-96e5-664fe7ee841e/);
+});
+
+test('shortLogId caps an over-long task slug while shortening embedded UUIDs', () => {
+  const long = `${'x'.repeat(48)}-deadbeef`;
+  assert.match(shortLogId(long), /…$/);
+  assert.ok(shortLogId(long).length <= 40);
+  assert.equal(shortLogId('7fadad27-0be6-4d08-96e5-664fe7ee841e'), '7fadad27…');
+});

package/src/core/skillChainView.js

@@ -16,7 +16,7 @@ const SYMBOLS = {
   skipped: '–',
 };
 
-const TERMINAL = new Set(['done', 'failed', 'cancelled', 'skipped']);
+export const TERMINAL = new Set(['done', 'failed', 'cancelled', 'skipped']);
 
 // Objectives are whole paragraphs; a chain view needs a line. Keep the first
 // sentence, drop the parameter block the compiler appends, and never cut a word
@@ -39,19 +39,24 @@ export function projectSkillChains(controlQueue = []) {
     byChain.get(item.chainId).push(item);
   }
   return [...byChain.entries()].map(([chainId, chainItems]) => {
-    const steps = chainItems
-      .slice()
-      .sort((a, b) => Number(a.chainSequence ?? 0) - Number(b.chainSequence ?? 0))
-      .map((item) => ({
-        id: item.id,
-        sequence: Number(item.chainSequence ?? 0),
-        label: chainStepLabel(item.input),
-        status: String(item.status ?? 'queued'),
-        symbol: SYMBOLS[String(item.status ?? 'queued')] ?? '○',
-        optional: item.optional === true,
-        ...(item.skipReason ? { skipReason: item.skipReason } : {}),
-        ...(item.runId ? { runId: item.runId } : {}),
-      }));
+    const sorted = chainItems.slice().sort((a, b) => Number(a.chainSequence ?? 0) - Number(b.chainSequence ?? 0));
+    const total = sorted.length;
+    // Compiled objectives are private execution material and never reach the
+    // projection, so a step cannot be labelled with its intent prose. When the
+    // chain has several steps, the public input is identical for all of them —
+    // labelling them all "/skill args" is what read as six tasks with the same
+    // name. Distinguish them by position instead; the skill name already sits
+    // in the chain head.
+    const steps = sorted.map((item, index) => ({
+      id: item.id,
+      sequence: Number(item.chainSequence ?? 0),
+      label: total > 1 ? `Step ${index + 1}/${total}` : chainStepLabel(item.input),
+      status: String(item.status ?? 'queued'),
+      symbol: SYMBOLS[String(item.status ?? 'queued')] ?? '○',
+      optional: item.optional === true,
+      ...(item.skipReason ? { skipReason: item.skipReason } : {}),
+      ...(item.runId ? { runId: item.runId } : {}),
+    }));
     return {
       chainId,
       skillName: chainItems.find((item) => item.skillName)?.skillName ?? null,

package/src/core/skillChainView.test.js

@@ -19,7 +19,7 @@ test('a chain reads as ordered steps with one short label each', () => {
   assert.equal(chain.selectionKind, 'description_match');
   assert.equal(chain.status, 'running');
   assert.deepEqual(chain.steps.map((step) => step.symbol), ['✓', '●']);
-  assert.equal(chain.steps[0].label, 'Export the requested Confluence source, or all…');
+  assert.equal(chain.steps[0].label, 'Step 1/2');
   assert.equal(chain.steps[1].runId, 'run-b');
 });
 
@@ -40,7 +40,7 @@ test('after a cancel the chain shows the cancelled step and the skipped remainde
   assert.equal(chain.status, 'cancelled');
   assert.equal(
     renderSkillChain(chain),
-    ['wiki-sync', '', '✓ Export source', '  done', '× Ingest files', '  cancelled', '– Publish results', '  skipped · chain_cancelled'].join('\n'),
+    ['wiki-sync', '', '✓ Step 1/3', '  done', '× Step 2/3', '  cancelled', '– Step 3/3', '  skipped · chain_cancelled'].join('\n'),
   );
 });
 

package/src/core/skillInvocation.test.js

@@ -9,7 +9,7 @@ import { formatSkillsForAgent, inspectSkills } from './skills.js';
 test('matchSkillInvocation resolves only a real workspace skill', () => {
   const root = mkdtempSync(join(tmpdir(), 'skill-invocation-'));
   mkdirSync(join(root, '.wiki', 'skills'), { recursive: true });
-  writeFileSync(join(root, '.wiki', 'skills', 'deliver.md'), '---\nname: deliver\nparams:\n  - template\n  - polish\n---\nDeliver.');
+  writeFileSync(join(root, '.wiki', 'skills', 'deliver.md'), '---\nname: deliver\nparams:\n  - deliverable\n  - polish\n---\nDeliver.');
   const match = matchSkillInvocation({ workspacePath: root }, '/deliver "architecture" "improve security"');
   assert.equal(match.skill.name, 'deliver');
   assert.equal(match.rawArgs, '"architecture" "improve security"');
@@ -18,7 +18,7 @@ test('matchSkillInvocation resolves only a real workspace skill', () => {
 
 test('parseSkillArguments preserves one free-form argument and parses quoted multi params', () => {
   assert.deepEqual(parseSkillArguments({ params: ['files'] }, 'document A.md document B.md'), { files: 'document A.md document B.md' });
-  assert.deepEqual(parseSkillArguments({ params: ['template', 'polish'] }, '"architecture-juno" "améliorer la sécurité réseau"'), { template: 'architecture-juno', polish: 'améliorer la sécurité réseau' });
+  assert.deepEqual(parseSkillArguments({ params: ['deliverable', 'polish'] }, '"architecture-juno" "améliorer la sécurité réseau"'), { deliverable: 'architecture-juno', polish: 'améliorer la sécurité réseau' });
 });
 
 test('legacy placeholders remain supported and are reported', () => {
@@ -66,8 +66,8 @@ test('catalog renders declared parameters and marks a missing description explic
   const root = mkdtempSync(join(tmpdir(), 'skill-catalog-'));
   const dir = join(root, '.wiki', 'skills');
   mkdirSync(dir, { recursive: true });
-  writeFileSync(join(dir, 'deliver.md'), '---\nname: deliver\nparams:\n  - template\n  - polish\n---\nDeliver.');
+  writeFileSync(join(dir, 'deliver.md'), '---\nname: deliver\nparams:\n  - deliverable\n  - polish\n---\nDeliver.');
   const inspection = inspectSkills({ workspacePath: root });
   assert.deepEqual(inspection.warnings.map((item) => item.reason), ['missing_description']);
-  assert.match(formatSkillsForAgent({ workspacePath: root }), /\/deliver \[<template> <polish>\]: workflow skill \[explicit name only\]/);
+  assert.match(formatSkillsForAgent({ workspacePath: root }), /\/deliver \[<deliverable> <polish>\]: workflow skill \[explicit name only\]/);
 });

package/src/runtime/runner.js

@@ -14,6 +14,7 @@ import { assertValidatedFragment } from '../orchestrator/planValidator.js';
 import { createResultAggregator } from '../orchestrator/resultAggregator.js';
 import { describePlanConcurrency, drainActive, startReadyTasks } from '../orchestrator/scheduler.js';
 import { emitRuntimeLog, pollActivitiesOnce } from './supervisor.js';
+import { shortLogId } from '../core/runtimeLog.js';
 
 // 0 by default: automatic replans turn evaluator/replanner TEXT into
 // executable pseudo-tasks (no capability, no operation) that stall at 0%
@@ -713,7 +714,7 @@ export function skipImpossibleTasks(session, runId, { maxPasses = 50 } = {}) {
         taskId: skippedId,
         payload: { taskId: skippedId, status: 'skipped', reason: `dependency_failed:${because}` },
       }));
-      emitRuntimeLog(session, `scheduler: skipping ${skippedId} (dependency failed: ${because})`);
+      emitRuntimeLog(session, `scheduler: skipping ${shortLogId(skippedId)} (dependency failed: ${because.split(', ').map((dep) => shortLogId(dep)).join(', ')})`);
     }
     total += changed;
     if (changed === 0) break;

package/src/runtime/server.test.js

@@ -1723,7 +1723,7 @@ test('POST /turn keeps informational skill and build questions conversational',
 test('POST /run accepts named skill arguments and deduplicates an explicit retry key', async (t) => {
   const root = mkdtempSync(join(tmpdir(), 'runtime-named-skill-'));
   mkdirSync(join(root, '.wiki', 'skills'), { recursive: true });
-  writeFileSync(join(root, '.wiki', 'skills', 'deliver.md'), '---\nname: deliver\nparams:\n  - template\n  - polish\n---\nDeliver the output.');
+  writeFileSync(join(root, '.wiki', 'skills', 'deliver.md'), '---\nname: deliver\nparams:\n  - deliverable\n  - polish\n---\nDeliver the output.');
   const session = { workspace: 'acme', workspacePath: root, controlQueue: [] };
   const context = { workspace: 'acme', session, running: false, currentAbortController: null };
   const persisted = new Map();
@@ -1746,7 +1746,7 @@ test('POST /run accepts named skill arguments and deduplicates an explicit retry
   try {
     const request = () => fetch(`http://127.0.0.1:${handle.port}/run?workspace=acme`, {
       method: 'POST', headers: { 'content-type': 'application/json' },
-      body: JSON.stringify({ input: '/deliver', skillName: 'deliver', skillArguments: { template: 'Quarterly report' }, idempotencyKey: 'retry-1' }),
+      body: JSON.stringify({ input: '/deliver', skillName: 'deliver', skillArguments: { deliverable: 'Quarterly report' }, idempotencyKey: 'retry-1' }),
     });
     const first = await (await request()).json();
     const second = await (await request()).json();
@@ -1756,7 +1756,7 @@ test('POST /run accepts named skill arguments and deduplicates an explicit retry
     assert.equal(session.controlQueue.length, 1);
     assert.equal('input' in first.items[0], false);
     assert.equal('objectives' in first, false);
-    assert.equal(session.controlQueue[0].input, '/deliver template="Quarterly report"');
+    assert.equal(session.controlQueue[0].input, '/deliver deliverable="Quarterly report"');
   } finally {
     context.currentAbortController?.abort();
     await handle.close();

package/src/runtime/skillRun.test.js

@@ -2,24 +2,24 @@ import assert from 'node:assert/strict';
 import test from 'node:test';
 import { formatPublicSkillInvocation, runSkillChain, validateNamedSkillArguments } from './skillRun.js';
 
-const skill = { name: 'deliver', params: ['template', 'polish'], body: 'Deliver the requested output.' };
+const skill = { name: 'deliver', params: ['deliverable', 'polish'], body: 'Deliver the requested output.' };
 
 test('named skill arguments preserve spaces and fill omitted declarations with empty strings', () => {
-  const args = validateNamedSkillArguments(skill, { template: 'Quarterly report' });
+  const args = validateNamedSkillArguments(skill, { deliverable: 'Quarterly report' });
   assert.equal(Object.getPrototypeOf(args), null);
-  assert.deepEqual({ ...args }, { template: 'Quarterly report', polish: '' });
+  assert.deepEqual({ ...args }, { deliverable: 'Quarterly report', polish: '' });
 });
 
 test('named skill arguments reject undeclared, non-string, and oversized values', () => {
   assert.throws(() => validateNamedSkillArguments(skill, { target: 'x' }), { code: 'skill_arguments_invalid' });
-  assert.throws(() => validateNamedSkillArguments(skill, { template: 42 }), { code: 'skill_arguments_invalid' });
-  assert.throws(() => validateNamedSkillArguments(skill, { template: 'x'.repeat(2_001) }), { code: 'skill_arguments_invalid' });
+  assert.throws(() => validateNamedSkillArguments(skill, { deliverable: 42 }), { code: 'skill_arguments_invalid' });
+  assert.throws(() => validateNamedSkillArguments(skill, { deliverable: 'x'.repeat(2_001) }), { code: 'skill_arguments_invalid' });
 });
 
 test('runSkillChain enqueues named arguments without exposing a skill body field', async () => {
   const queued = [];
   const result = await runSkillChain({ session: {} }, skill, {
-    args: { template: 'Quarterly report' },
+    args: { deliverable: 'Quarterly report' },
     enqueueControlRequest(_context, input, metadata) {
       const item = { id: `item-${queued.length}`, input, status: 'queued', ...metadata };
       queued.push(item);
@@ -28,15 +28,15 @@ test('runSkillChain enqueues named arguments without exposing a skill body field
     drainControlQueue() {},
   });
   assert.equal(result.objectives, 1);
-  assert.match(queued[0].input, /template: Quarterly report/);
-  assert.equal(queued[0].publicInput, '/deliver template="Quarterly report"');
+  assert.match(queued[0].input, /deliverable: Quarterly report/);
+  assert.equal(queued[0].publicInput, '/deliver deliverable="Quarterly report"');
   assert.equal(queued[0].skillExecution, 'orchestrated');
   assert.equal('body' in queued[0], false);
 });
 
 test('public skill invocation contains arguments but never compiled objective prose', () => {
-  const rendered = formatPublicSkillInvocation('deliver', { template: 'Quarterly report', polish: '' });
-  assert.equal(rendered, '/deliver template="Quarterly report"');
+  const rendered = formatPublicSkillInvocation('deliver', { deliverable: 'Quarterly report', polish: '' });
+  assert.equal(rendered, '/deliver deliverable="Quarterly report"');
   assert.doesNotMatch(rendered, /Deliver the requested output/);
 });
 

package/src/shell/LeftPane.tsx

@@ -5,6 +5,7 @@ import { useRenderer } from '@opentui/solid';
 import { colorForRenderedLine, helpCommandParts, keyValueParts, renderPlainMarkdown } from './renderer';
 import { httpLinkParts, wrapHttpLinks } from './externalLinks.js';
 import { normalizeExternalUrl } from './openExternal.js';
+import { ActivityPanel } from './RightPane';
 
 const LEGACY_DONNA_ROLE = 'do' + 't';
 
@@ -806,6 +807,7 @@ export function LeftPane(props: {
   busy: boolean;
   chatMode: boolean;
   chatFocused: boolean;
+  activities: any[];
   setInput: (value: string) => void;
   submit: (value?: string) => void;
   conversationRows: number;
@@ -851,6 +853,15 @@ export function LeftPane(props: {
           onOpenLink={props.onOpenLink}
         />
       )}
+      {/*
+        Activity strip. The run status used to live only in the right pane,
+        one glance away from where the reader types. A compact 4-line strip
+        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">
+        <ActivityPanel activities={props.activities} width={props.width - 2} />
+      </box>
       <ChatInput
         width={props.width}
         prompt={props.prompt}

package/src/shell/RightPane.tsx

@@ -9,6 +9,7 @@ type QueueItem = {
   workspace?: string | null;
   status: string;
   args?: Record<string, any>;
+  label?: string;
   jobId?: string;
   error?: string;
   reason?: string;
@@ -170,9 +171,10 @@ function activityJobName(activity: any) {
 }
 
 function queueSummary(item: QueueItem) {
+  const label = item.label ? String(item.label).trim() : '';
   const args = item.args ?? {};
   const parts = [
-    args.type ?? 'production',
+    label || args.type || 'production',
     Array.isArray(args.steps) && args.steps.length ? args.steps.join('+') : null,
     Array.isArray(args.templates) && args.templates.length ? `tpl:${args.templates.length}` : null,
     Array.isArray(args.deliverables) && args.deliverables.length ? `del:${args.deliverables.length}` : null,
@@ -180,10 +182,24 @@ function queueSummary(item: QueueItem) {
   return parts.join(' ');
 }
 
+// A queue id is a long UUID (optionally `control-`-prefixed). The panel shows a
+// short, recognisable prefix instead of the full string, which pushed the
+// status and summary off the line and made the queue unreadable.
+function shortQueueId(id: string) {
+  const value = String(id ?? '').replace(/^control-/, '');
+  return value.length > 12 ? `${value.slice(0, 12)}…` : value;
+}
+
 export function PlanPanel(props: { plan: PlanStep[]; width: number; jobName?: string; summary?: string | null; spinnerFrame?: string }) {
   // 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);
   const icon = (rawStatus: string) => {
     const status = String(rawStatus ?? '').toLowerCase();
     if (DONE_STATUSES.includes(status)) return '[✓]';
@@ -195,7 +211,7 @@ export function PlanPanel(props: { plan: PlanStep[]; width: number; jobName?: st
     return status === 'running' ? `[${props.spinnerFrame ?? '…'}]` : '[ ]';
   };
   const visualRows = createMemo(() => props.plan.reduce((total, step) =>
-    total + wrapLine(`${icon(step.status)} ${step.step}. ${step.description}`, lineWidth()).slice(0, 2).length, 0));
+    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;
@@ -225,12 +241,14 @@ export function PlanPanel(props: { plan: PlanStep[]; width: number; jobName?: st
           {(step) => {
             // Wrap step descriptions over up to 2 lines instead of truncating —
             // "Ingest des 39 documents raw/untrac…" hid the actual target.
-            const lines = () => wrapLine(`${icon(step().status)} ${step().step}. ${step().description}`, lineWidth()).slice(0, 2);
+            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">
-                <text width={lineWidth()} fg={planStepColor(step(), firstPending())} content={lines()[0]} />
+              <box flexShrink={0} flexDirection="column" border={running() ? ['left'] : undefined} borderStyle="heavy" borderColor="#89B4FA">
+                <text width={textWidth()} fg={planStepColor(step(), firstPending())} content={lines()[0]} />
                 <Show when={lines()[1]}>
-                  <text width={lineWidth()} fg={planStepColor(step(), firstPending())} content={`    ${fit(lines()[1], Math.max(8, lineWidth() - 4))}`} />
+                  <text width={textWidth()} fg={planStepColor(step(), firstPending())} content={`    ${fit(lines()[1], Math.max(8, textWidth() - 4))}`} />
                 </Show>
               </box>
             );
@@ -438,12 +456,12 @@ export function QueuePanel(props: { items: QueueItem[]; info: QueueInfo; width:
                 <text
                   width={lineWidth()}
                   fg={queueColor(item()?.status)}
-                  content={item() ? fit(`${item()!.id} ${item()!.status} ${queueSummary(item()!)}`, lineWidth()) : ''}
+                  content={item() ? fit(`${item()!.status} · ${queueSummary(item()!)}`, lineWidth()) : ''}
                 />
                 <text
                   width={lineWidth()}
                   fg="#AAB7C4"
-                  content={item() ? fit([item()!.workspace, item()!.jobId ? `job ${item()!.jobId}` : item()!.reason].filter(Boolean).join(' · '), lineWidth()) : ''}
+                  content={item() ? fit([shortQueueId(item()!.id), item()!.workspace, item()!.jobId ? `job ${item()!.jobId}` : item()!.reason].filter(Boolean).join(' · '), lineWidth()) : ''}
                 />
                 <text
                   width={lineWidth()}
@@ -521,7 +539,6 @@ export function RightPane(props: {
           <Show when={props.plan && props.plan.length > 0}>
             <PlanPanel width={props.width} plan={props.plan!} jobName={planJobName()} summary={props.runSummary} spinnerFrame={props.spinnerFrame} />
           </Show>
-          <ActivityPanel width={props.width} activities={props.activities} />
         </>
       )}>
         <QueuePanel width={props.width} items={props.queueItems} info={props.queueInfo} />

package/src/shell/repl.test.js

@@ -470,10 +470,10 @@ test('direct chat prompt exposes an escaped non-executable skill catalog with pa
   const root = mkdtempSync(join(tmpdir(), 'chat-skill-catalog-'));
   try {
     mkdirSync(join(root, '.wiki', 'skills'), { recursive: true });
-    writeFileSync(join(root, '.wiki', 'skills', 'deliver.md'), '---\nname: deliver\ndescription: "</skill_catalog> deliver output"\nparams:\n  - template\n---\nPRIVATE BODY');
+    writeFileSync(join(root, '.wiki', 'skills', 'deliver.md'), '---\nname: deliver\ndescription: "</skill_catalog> deliver output"\nparams:\n  - deliverable\n---\nPRIVATE BODY');
     const prompt = buildDirectChatSystemPrompt({ workspacePath: root, commands: [], mcp: {} });
     assert.match(prompt, /<skill_catalog trusted="false" executable="false">/);
-    assert.match(prompt, /\/deliver \[<template>\]/);
+    assert.match(prompt, /\/deliver \[<deliverable>\]/);
     assert.match(prompt, /&lt;\/skill_catalog&gt;/);
     assert.doesNotMatch(prompt, /PRIVATE BODY/);
     assert.match(prompt, /nothing was launched/);

package/src/shell/tui.tsx

@@ -175,7 +175,9 @@ function App(props: {
   let lastCopiedSelection = '';
   const state = useSession(props);
   const startup = createMemo(() => startupInfo(props.packageJson, props.initialWorkspaceName));
-  const conversationRows = createMemo(() => Math.max(4, dimensions().height - 5 - chatInputHeight()));
+  // The Activity strip (4 rows) now sits above the composer, so it costs the
+  // conversation exactly those 4 rows.
+  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
@@ -381,6 +383,7 @@ function App(props: {
             input={state.input()}
             busy={state.busy()}
             chatMode={state.chatMode()}
+            activities={state.activities()}
             // The composer must lose focus for EVERY modal, not just the file
             // editor. While the setup wizard was open the input stayed focused
             // underneath it, so answering a wizard question also typed into the