@dotdrelle/wiki-manager 0.15.50 → 0.15.53

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,9 +1,17 @@
 {
   "name": "@dotdrelle/wiki-manager",
-  "version": "0.15.50",
+  "version": "0.15.53",
   "description": "Agentic shell and orchestration cockpit for llm-wiki workspaces.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dotdrelle/llm-wiki-manager.git"
+  },
+  "homepage": "https://github.com/dotdrelle/llm-wiki-manager#readme",
+  "bugs": {
+    "url": "https://github.com/dotdrelle/llm-wiki-manager/issues"
+  },
   "license": "PolyForm-Noncommercial-1.0.0",
-  "author": "dotrelle",
+  "author": "dotdrelle",
   "type": "module",
   "bin": {
     "wiki-manager": "bin/wiki-manager",

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.50",
-  "commit": "844cf7e"
+  "version": "0.15.53",
+  "commit": "43997b0"
 }

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.50';
+const WIKI_MANAGER_VERSION = '0.15.53';
 
 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…');
+});