@dotdrelle/wiki-manager 0.15.42 → 0.15.48

package/src/core/agentEvents.js

@@ -2,6 +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 { projectWorkflow } from './workflow.js';
 import { validateContractInDev } from '../contracts/schemas.js';
 import { isTerminal, isSuccessful, isUnknownStatus, normalizeTaskStatus } from '../orchestrator/taskStatuses.js';
@@ -41,6 +42,7 @@ const SESSION_PROJECTION_EVENTS = new Set([
   'control_enqueued',
   'control_started',
   'control_cancelled',
+  'control_skipped',
   'agent.registered',
   'agent.health_changed',
   'run_done',
@@ -130,6 +132,9 @@ function withSessionRunIdentity(event, session) {
   // assistant messages — used to leave with workspace=null and never reached
   // the UI, which then displayed a stale plan from the previous action.
   const workspace = event.workspace ?? identity?.workspace ?? session?.workspace ?? null;
+  if (event.payload?.independent === true) {
+    return { ...event, runId: null, turnId: event.turnId ?? null, taskId: event.taskId ?? null, workspace };
+  }
   if (!identity) {
     return workspace === (event.workspace ?? null) ? event : { ...event, workspace };
   }
@@ -208,6 +213,8 @@ function publicProjection(state) {
       patch: patch.patch ? { ...patch.patch, operations: (patch.patch.operations ?? []).map((operation) => ({ ...operation })) } : null,
     })),
     controlQueue: state.controlQueue.map((item) => ({ ...item })),
+    // LOT G: the chain is a projection, never stored state.
+    skillChains: projectSkillChains(state.controlQueue),
     agents: Object.values(state.agents)
       .map((agent) => ({ ...agent, description: cloneJson(agent.description) }))
       .sort((a, b) => a.agentInstanceId.localeCompare(b.agentInstanceId)),
@@ -224,6 +231,10 @@ export function applyAgentProjectionToSession(session, projection) {
   session.headlessPlan = projection.plan ? projection.plan.map((step) => ({ ...step })) : null;
   session.activities = Object.fromEntries((projection.activities ?? []).map((activity) => [activity.key, { ...activity }]));
   session.controlQueue = (projection.controlQueue ?? []).map((item) => ({ ...item }));
+  session.skillChains = (projection.skillChains ?? []).map((chain) => ({
+    ...chain,
+    steps: chain.steps.map((step) => ({ ...step })),
+  }));
   session.agents = (projection.agents ?? []).map((agent) => ({ ...agent, description: cloneJson(agent.description) }));
   session.planRevision = projection.planRevision ?? 0;
   session.planPatches = (projection.planPatches ?? []).map((patch) => ({ ...patch }));
@@ -545,6 +556,7 @@ function applyEvent(state, event) {
       // cancelled so the display reflects reality immediately.
       cancelPendingPlanSteps(state.plan);
       cancelActiveActivities(state.activities, event.ts);
+      cancelPendingApprovals(state.approvals, event.runId ?? event.payload?.runId ?? null, event.ts);
       finishControlByRun(state.controlQueue, event.runId ?? event.payload?.runId ?? null, 'cancelled', event.ts);
       return;
     case 'run_error':
@@ -556,6 +568,7 @@ function applyEvent(state, event) {
       // /kill honestly reported 0 because nothing was actually running.
       cancelPendingPlanSteps(state.plan);
       cancelActiveActivities(state.activities, event.ts);
+      cancelPendingApprovals(state.approvals, event.runId ?? event.payload?.runId ?? null, event.ts);
       finishControlByRun(state.controlQueue, event.runId ?? event.payload?.runId ?? null, 'failed', event.ts);
       return;
     case 'control_enqueued':
@@ -567,6 +580,25 @@ function applyEvent(state, event) {
         createdAt: event.payload?.createdAt ?? event.ts,
         updatedAt: event.ts,
         ...(event.payload?.capabilityPlan !== undefined ? { capabilityPlan: event.payload.capabilityPlan } : {}),
+        ...(event.payload?.chainId ? { chainId: event.payload.chainId } : {}),
+        ...(event.payload?.skillName ? { skillName: event.payload.skillName } : {}),
+        ...(event.payload?.skillExecution ? { skillExecution: event.payload.skillExecution } : {}),
+        /*
+         La pile des compétences ouvertes au-dessus de cet élément.
+
+         Elle DOIT survivre à la projection : c'est le seul état qui relie un
+         run imbriqué à ses ancêtres. Le run n'est pas exécuté en ligne — il est
+         mis en file et démarre après que son parent s'est nettoyé — donc rien
+         d'autre que l'élément lui-même ne peut la lui transmettre. La perdre
+         ici, c'est rouvrir A→B→A en silence.
+        */
+        ...(Array.isArray(event.payload?.skillStack) && event.payload.skillStack.length
+          ? { skillStack: [...event.payload.skillStack] }
+          : {}),
+        ...(event.payload?.selectionKind ? { selectionKind: event.payload.selectionKind } : {}),
+        ...(Number.isInteger(event.payload?.chainSequence) ? { chainSequence: event.payload.chainSequence } : {}),
+        optional: event.payload?.optional === true,
+        continueOnFailure: event.payload?.continueOnFailure === true,
       });
       return;
     case 'control_started':
@@ -586,6 +618,15 @@ function applyEvent(state, event) {
         updatedAt: event.ts,
       });
       return;
+    case 'control_skipped':
+      upsertControlItem(state.controlQueue, {
+        id: event.payload?.id ?? null,
+        status: 'skipped',
+        skipReason: event.payload?.reason ?? null,
+        finishedAt: event.payload?.finishedAt ?? event.ts,
+        updatedAt: event.ts,
+      });
+      return;
     case 'agent.registered':
       upsertAgent(state, event.payload?.agent, event.ts);
       return;
@@ -759,6 +800,15 @@ function cancelPendingPlanSteps(plan) {
   }
 }
 
+function cancelPendingApprovals(approvals, runId, ts) {
+  for (const approval of approvals ?? []) {
+    if (approval.status !== 'pending_approval') continue;
+    if (runId != null && approval.runId != null && String(approval.runId) !== String(runId)) continue;
+    approval.status = 'cancelled';
+    approval.cancelledAt = ts;
+  }
+}
+
 function cancelActiveActivities(activities, ts) {
   for (const activity of Object.values(activities ?? {})) {
     if (activity && activity.terminal !== true) {

package/src/core/agentEvents.test.js

@@ -39,6 +39,20 @@ test('a streamed reply keeps the sequence of the delta that created it', () => {
   assert.deepEqual(conversationEventSequences(events), [1, 2]);
 });
 
+test('an independent queued skill invocation never inherits the active run identity', () => {
+  const session = {
+    workspace: 'docs',
+    _currentRunIdentity: { runId: 'unrelated-run', turnId: 'unrelated-turn', workspace: 'docs' },
+  };
+  const event = dispatchAgentEvent(session, createAgentEvent('user_message', {
+    origin: 'user',
+    payload: { content: '/wiki-build overview', independent: true },
+  }));
+  assert.equal(event.runId, null);
+  assert.equal(event.turnId, null);
+  assert.equal(event.workspace, 'docs');
+});
+
 test('reduceAgentEvents: run_started clears stale plan', () => {
   const projection = reduceAgentEvents([
     createAgentEvent('activity_upserted', {
@@ -263,6 +277,29 @@ test('reduceAgentEvents: approvals move from pending to approved', () => {
   assert.deepEqual(projection.approvals[0].plan, ['Build']);
 });
 
+test('reduceAgentEvents: cancelling a run clears its pending approval projection', () => {
+  const projection = reduceAgentEvents([
+    createAgentEvent('approval.requested', {
+      origin: 'runtime',
+      runId: 'run-cancelled',
+      payload: { approvalId: 'approval-cancelled', scope: 'run', runId: 'run-cancelled' },
+    }),
+    createAgentEvent('approval.requested', {
+      origin: 'runtime',
+      runId: 'run-other',
+      payload: { approvalId: 'approval-other', scope: 'run', runId: 'run-other' },
+    }),
+    createAgentEvent('run_cancelled', {
+      origin: 'runtime',
+      runId: 'run-cancelled',
+      payload: { runId: 'run-cancelled' },
+    }),
+  ]);
+
+  assert.equal(projection.approvals.find((item) => item.runId === 'run-cancelled')?.status, 'cancelled');
+  assert.equal(projection.approvals.find((item) => item.runId === 'run-other')?.status, 'pending_approval');
+});
+
 test('reduceAgentEvents: bounded approval grant covers matching pending requests only', () => {
   const projection = reduceAgentEvents([
     createAgentEvent('approval.requested', {
@@ -396,6 +433,21 @@ test('reduceAgentEvents: control_enqueued preserves a structured capabilityPlan
   assert.equal(item.status, 'running');
 });
 
+test('reduceAgentEvents: chain metadata survives replay and control_skipped is terminal', () => {
+  const projection = reduceAgentEvents([
+    createAgentEvent('control_enqueued', { payload: {
+      id: 'chain-step-2', input: 'ingest', chainId: 'chain-1', chainSequence: 1,
+      skillName: 'wiki-sync', optional: false, continueOnFailure: false,
+    } }),
+    createAgentEvent('control_skipped', { payload: { id: 'chain-step-2', reason: 'chain_cancelled' } }),
+  ]);
+  assert.equal(projection.controlQueue[0].chainId, 'chain-1');
+  assert.equal(projection.controlQueue[0].chainSequence, 1);
+  assert.equal(projection.controlQueue[0].skillName, 'wiki-sync');
+  assert.equal(projection.controlQueue[0].status, 'skipped');
+  assert.equal(projection.controlQueue[0].skipReason, 'chain_cancelled');
+});
+
 test('reduceAgentEvents: activity-owned plan is used when no orchestrator plan exists', () => {
   const projection = reduceAgentEvents([
     createAgentEvent('activity_upserted', {

package/src/core/buildInfo.json

@@ -1,4 +1,4 @@
 {
-  "version": "0.15.42",
-  "commit": "d0180aa"
+  "version": "0.15.48",
+  "commit": "7290b94"
 }

package/src/core/env.js

@@ -2,6 +2,15 @@ import { copyFileSync, existsSync, mkdirSync, readFileSync, renameSync, writeFil
 import { dirname, isAbsolute, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
+const LEGACY_DEFAULT_WIKI_CHAT_TOOLS = [
+  'help_list', 'help_read', 'help_search', 'wiki_workspace_status',
+  'wiki_list_pages', 'wiki_read_page', 'wiki_read_pages', 'wiki_search_context',
+  'wiki_collect_context', 'wiki_read_ingested_source',
+];
+const TEMPLATE_AUTHORING_CHAT_TOOLS = [
+  'wiki_outline', 'template_read', 'template_write', 'build_context_write',
+];
+
 export function userManagerDir() {
   return process.cwd();
 }
@@ -126,15 +135,25 @@ export function ensureManagerScaffold({ log = () => {} } = {}) {
             && exampleServers && typeof exampleServers === 'object' && !Array.isArray(exampleServers)
             ? Object.keys(exampleServers).filter((key) => !(key in currentServers) && !disabledServers.has(key))
             : [];
+          // Upgrade only the recognizable packaged wiki allow-list. A custom
+          // allow-list remains operator-owned and untouched.
+          const wikiAllow = current.chatAccess?.servers?.['llm-wiki']?.allow;
+          const migrateWikiChatTools = Array.isArray(wikiAllow)
+            && LEGACY_DEFAULT_WIKI_CHAT_TOOLS.every((tool) => wikiAllow.includes(tool));
+          const missingWikiChatTools = migrateWikiChatTools
+            ? TEMPLATE_AUTHORING_CHAT_TOOLS.filter((tool) => !wikiAllow.includes(tool))
+            : [];
           if (missing.length > 0) {
             for (const key of missing) current[key] = example[key];
           }
           for (const key of missingServers) currentServers[key] = exampleServers[key];
-          if (missing.length > 0 || missingServers.length > 0) {
+          wikiAllow?.push(...missingWikiChatTools);
+          if (missing.length > 0 || missingServers.length > 0 || missingWikiChatTools.length > 0) {
             writeFileSync(endpointsFile, `${JSON.stringify(current, null, 2)}\n`);
             const changes = [
               missing.length > 0 ? `keys: ${missing.join(', ')}` : '',
               missingServers.length > 0 ? `servers: ${missingServers.join(', ')}` : '',
+              missingWikiChatTools.length > 0 ? `chat tools: ${missingWikiChatTools.join(', ')}` : '',
             ].filter(Boolean).join('; ');
             created.push(`mcp.endpoints.json ${changes}`);
           }

package/src/core/env.test.js

@@ -85,6 +85,7 @@ test('scaffold merges missing top-level keys into an existing endpoints file', (
     // Server keys must match the connected MCP endpoint keys (the tool-call
     // prefix): the wiki server is "llm-wiki", not "wiki".
     assert.ok(merged.chatAccess?.servers?.['llm-wiki']);
+    assert.ok(merged.chatAccess.servers['llm-wiki'].allow.includes('template_write'));
   });
 });
 
@@ -102,6 +103,39 @@ test('scaffold never overwrites an existing chatAccess, including explicit null'
   });
 });
 
+test('scaffold upgrades the packaged wiki chat allow-list with template authoring tools', () => {
+  withTempManagerDir((dir) => {
+    const endpointsFile = join(dir, 'mcp.endpoints.json');
+    const example = JSON.parse(readFileSync('mcp.endpoints.example.json', 'utf8'));
+    example.chatAccess.servers['llm-wiki'].allow = example.chatAccess.servers['llm-wiki'].allow
+      .filter((tool) => !['wiki_outline', 'template_read', 'template_write', 'build_context_write'].includes(tool));
+    writeFileSync(endpointsFile, JSON.stringify(example, null, 2));
+
+    const changes = ensureManagerScaffold();
+    const after = JSON.parse(readFileSync(endpointsFile, 'utf8'));
+
+    assert.ok(changes.some((item) => item.includes('template_write')));
+    assert.ok(after.chatAccess.servers['llm-wiki'].allow.includes('wiki_outline'));
+    assert.ok(after.chatAccess.servers['llm-wiki'].allow.includes('template_read'));
+    assert.ok(after.chatAccess.servers['llm-wiki'].allow.includes('template_write'));
+    assert.ok(after.chatAccess.servers['llm-wiki'].allow.includes('build_context_write'));
+  });
+});
+
+test('scaffold leaves a custom wiki chat allow-list untouched', () => {
+  withTempManagerDir((dir) => {
+    const endpointsFile = join(dir, 'mcp.endpoints.json');
+    writeFileSync(endpointsFile, JSON.stringify({
+      mcpServers: {},
+      chatAccess: { servers: { 'llm-wiki': { allow: ['wiki_read_page'] } } },
+    }, null, 2));
+
+    ensureManagerScaffold();
+    const after = JSON.parse(readFileSync(endpointsFile, 'utf8'));
+    assert.deepEqual(after.chatAccess.servers['llm-wiki'].allow, ['wiki_read_page']);
+  });
+});
+
 test('scaffold does not restore a packaged MCP explicitly removed in the UI', () => {
   withTempManagerDir((dir) => {
     const endpointsFile = join(dir, 'mcp.endpoints.json');

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

package/src/core/profile.js

@@ -1,5 +1,8 @@
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
+import { readOptionalText } from './skills.js';
+
+export const MAX_PROFILE_CHARS = 4000;
 
 const DEFAULT_PROFILE = `# Workspace Profile
 
@@ -22,6 +25,22 @@ function profilePathForWorkspace(workspacePath) {
   return join(workspacePath, '.wiki', 'profile.md');
 }
 
+// Durable per-workspace user preferences, injected into the system prompt of
+// BOTH shell modes. Agent mode used to own this loader; chat mode had nothing,
+// so the same workspace answered with a different tone depending on the mode,
+// and a skill running in chat could not know who it was talking to. `serve`
+// already injects the profile the same way (llm-wiki chatRoutes), so this keeps
+// the three surfaces aligned. Injection is deliberately preferred over exposing
+// `profile_read` through `chatAccess`: no allow-list entry to migrate on
+// existing installs, and no tool round-trip for a file we can always read.
+// Returns null when there is no workspace or no readable profile — never throws,
+// since a missing profile must not degrade a reply.
+export function loadWorkspaceProfile(workspacePath) {
+  if (!workspacePath) return null;
+  const content = readOptionalText(profilePathForWorkspace(workspacePath));
+  return content ? content.slice(0, MAX_PROFILE_CHARS) : null;
+}
+
 function formatPreference(preference) {
   const clean = String(preference ?? '').trim();
   if (!clean) return '';

package/src/core/runtimeLog.js

@@ -93,6 +93,21 @@ export function filterRuntimeLogs(logs = [], filter = '') {
   return logs.filter((line) => runtimeLogMatchesFilter(line, filter));
 }
 
+export function compactRuntimeLogForDisplay(line) {
+  const text = String(line ?? '');
+  if (!/\bWARN\s+retrieval:vector-fallback\b/i.test(text)) return text;
+  const header = text.split(/\r?\n/, 1)[0].trimEnd();
+  const reason = logFieldValue(text, 'reason');
+  const message = logFieldValue(text, 'message');
+  const details = [reason && `reason=${reason}`, message && `message=${message}`].filter(Boolean).join(' ');
+  return details ? `${header} ${details}` : header;
+}
+
+function logFieldValue(text, name) {
+  const match = String(text).match(new RegExp(`(?:^|\\s)${name}=("(?:\\\\.|[^"\\\\])*"|[^\\s]+)`, 'i'));
+  return match?.[1] ?? null;
+}
+
 function timeLabel(ts) {
   const date = ts ? new Date(ts) : new Date();
   if (Number.isNaN(date.getTime())) return null;

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 { formatRuntimeLogPayload } from './runtimeLog.js';
+import { compactRuntimeLogForDisplay, formatRuntimeLogPayload } from './runtimeLog.js';
 import { emitRuntimeLog } from '../runtime/supervisor.js';
 
 const CYCLE_EVENTS = [
@@ -84,3 +84,17 @@ test('emitRuntimeLog accepts structured payloads and preserves legacy strings',
   // events so the Logs/Trace panel stays chronologically readable.
   assert.match(session.agentProjection.logs[1], /^\d{2}:\d{2}:\d{2} legacy line$/);
 });
+
+test('vector fallback warnings keep only their reason and message for display', () => {
+  const displayed = compactRuntimeLogForDisplay(`09:25:34 trace: WARN retrieval:vector-fallback
+    reason=vector-error indexPath=/workspace/.wiki/vector-index queryPreview="a long query" fallback=lexical
+    consecutiveErrors=1 disabled=false message="Vector index is missing."`);
+
+  assert.equal(displayed, '09:25:34 trace: WARN retrieval:vector-fallback reason=vector-error message="Vector index is missing."');
+  assert.doesNotMatch(displayed, /indexPath|queryPreview|fallback=|consecutiveErrors|disabled=/);
+});
+
+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);
+});

package/src/core/skillChainView.js

@@ -0,0 +1,84 @@
+/**
+ * @statuses-vocabulary
+ * Plan V4.1 LOT G — the execution chain of a skill, as a pure projection over
+ * the control queue. No new state and no new event: `chainId`, `chainSequence`,
+ * `skillName`, `status` and `skipReason` are already carried by control items,
+ * so this module only decides how they read. Both UIs consume the same output,
+ * which is why the shaping lives here and not in either renderer.
+ */
+
+const SYMBOLS = {
+  done: '✓',
+  running: '●',
+  queued: '○',
+  cancelled: '×',
+  failed: '×',
+  skipped: '–',
+};
+
+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
+// in half.
+export function chainStepLabel(text, { maxLength = 52 } = {}) {
+  const withoutParameters = String(text ?? '').split(/\n\s*User parameters:/)[0];
+  const firstSentence = withoutParameters.trim().split(/(?<=[.!?])\s/)[0]?.trim() ?? '';
+  const label = firstSentence.replace(/\.$/, '');
+  if (label.length <= maxLength) return label;
+  const clipped = label.slice(0, maxLength);
+  const lastSpace = clipped.lastIndexOf(' ');
+  return `${(lastSpace > maxLength * 0.6 ? clipped.slice(0, lastSpace) : clipped).trimEnd()}…`;
+}
+
+export function projectSkillChains(controlQueue = []) {
+  const items = (Array.isArray(controlQueue) ? controlQueue : []).filter((item) => item?.chainId);
+  const byChain = new Map();
+  for (const item of items) {
+    if (!byChain.has(item.chainId)) byChain.set(item.chainId, []);
+    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 } : {}),
+      }));
+    return {
+      chainId,
+      skillName: chainItems.find((item) => item.skillName)?.skillName ?? null,
+      selectionKind: chainItems.find((item) => item.selectionKind)?.selectionKind ?? null,
+      steps,
+      status: chainStatus(steps),
+    };
+  });
+}
+
+function chainStatus(steps) {
+  if (steps.some((step) => step.status === 'running')) return 'running';
+  if (!steps.every((step) => TERMINAL.has(step.status))) return 'queued';
+  if (steps.some((step) => step.status === 'failed')) return 'failed';
+  if (steps.some((step) => step.status === 'cancelled')) return 'cancelled';
+  if (steps.some((step) => step.status === 'skipped')) return 'incomplete';
+  return 'done';
+}
+
+// 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 lines = [`${chain.skillName ?? 'skill'}${selection}`, ''];
+  for (const step of chain.steps) {
+    lines.push(`${step.symbol} ${step.label}`);
+    lines.push(`  ${step.status}${step.skipReason ? ` · ${step.skipReason}` : ''}`);
+  }
+  return lines.join('\n');
+}

package/src/core/skillChainView.test.js

@@ -0,0 +1,50 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { chainStepLabel, projectSkillChains, renderSkillChain } from './skillChainView.js';
+
+const WIKI_SYNC = [
+  {
+    id: 'c0', chainId: 'chain-1', chainSequence: 0, skillName: 'wiki-sync', selectionKind: 'description_match', status: 'done',
+    input: 'Export the requested Confluence source, or all configured sources when none is specified. Check configuration first.\n\nUser parameters:\nsource: docs',
+  },
+  {
+    id: 'c1', chainId: 'chain-1', chainSequence: 1, skillName: 'wiki-sync', status: 'running', runId: 'run-b',
+    input: 'Ingest the newly exported Markdown into the wiki, with the normal mutation approval.',
+  },
+];
+
+test('a chain reads as ordered steps with one short label each', () => {
+  const [chain] = projectSkillChains(WIKI_SYNC);
+  assert.equal(chain.skillName, 'wiki-sync');
+  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[1].runId, 'run-b');
+});
+
+test('the label drops the appended parameter block and never cuts a word', () => {
+  assert.equal(chainStepLabel('Do the thing.\n\nUser parameters:\nsource: docs'), 'Do the thing');
+  const label = chainStepLabel('An objective long enough to need clipping somewhere sensible indeed.');
+  assert.ok(label.endsWith('…'));
+  assert.ok(!label.includes('  '));
+  assert.ok(label.length <= 53);
+});
+
+test('after a cancel the chain shows the cancelled step and the skipped remainder', () => {
+  const [chain] = projectSkillChains([
+    { id: 'c0', chainId: 'k', chainSequence: 0, skillName: 'wiki-sync', status: 'done', input: 'Export source.' },
+    { id: 'c1', chainId: 'k', chainSequence: 1, status: 'cancelled', input: 'Ingest files.' },
+    { id: 'c2', chainId: 'k', chainSequence: 2, status: 'skipped', skipReason: 'chain_cancelled', input: 'Publish results.' },
+  ]);
+  assert.equal(chain.status, 'cancelled');
+  assert.equal(
+    renderSkillChain(chain),
+    ['wiki-sync', '', '✓ Export source', '  done', '× Ingest files', '  cancelled', '– Publish results', '  skipped · chain_cancelled'].join('\n'),
+  );
+});
+
+test('standalone control items are not chains', () => {
+  assert.deepEqual(projectSkillChains([{ id: 'x', status: 'queued', input: 'do something' }]), []);
+  assert.deepEqual(projectSkillChains(), []);
+});

package/src/core/skillCompiler.js

@@ -0,0 +1,135 @@
+const OPTIONAL_RE = /^(?:si disponible|si possible|optionnellement|if available|if possible|optionally)\b[\s,:-]*/i;
+const STRONG_CONNECTOR_RE = /\n\s*(?=(?:puis|ensuite|après cela|après .{0,80}?terminé|then|next|after .{0,80}?complete|si disponible|si possible|optionnellement|if available|if possible|optionally)\b)/gi;
+const FORBIDDEN_FIELDS = /\b(?:agent|capability|capabilityPlan|MCP|tool(?: name)?)\s*:/i;
+const MAX_OBJECTIVES = 12;
+
+export async function compileSkillObjectives(skill, args = {}, { llmFallback = null } = {}) {
+  const body = String(skill?.body ?? '').trim();
+  if (!body) throw compileError('Skill body is empty.');
+  // Splitting must happen on the body alone. Appending the parameters first
+  // makes them part of the last objective only — `/wiki-sync ESPACE` would hand
+  // `source: ESPACE` to the ingest step and leave the export step, the one that
+  // actually needs it, exporting everything. The compiler cannot know which
+  // step consumes which parameter, so every objective carries them.
+  const deterministic = deterministicObjectives(body);
+  if (!deterministic.ambiguous) {
+    return withNaturalArguments(validateCompiledObjectives(deterministic.objectives), args);
+  }
+  if (typeof llmFallback === 'function') {
+    try {
+      // Parameters do not influence workflow boundaries. Give the fallback the
+      // authored body only, then append parameters exactly once to every
+      // validated objective below.
+      const compiled = normalizeFallback(await llmFallback({ skill, body, args, maxObjectives: MAX_OBJECTIVES }));
+      return withNaturalArguments(validateCompiledObjectives(compiled), args);
+    } catch { /* preserve the safe mono-intention fallback */ }
+  }
+  return withNaturalArguments(validateCompiledObjectives([objectiveFromText(body)]), args);
+}
+
+export function createSkillCompilerFallback(llm, { signal, timeoutMs = 8_000 } = {}) {
+  if (typeof llm?.completeWithTools !== 'function') return null;
+  return async ({ body, maxObjectives }) => {
+    const system = [
+      'Split workflow prose into delegable business intentions without naming agents, capabilities or tools.',
+      `Return 1..${maxObjectives} ordered objectives. Preserve a complex single business capability as one objective.`,
+    ].join('\n');
+    const tool = {
+      type: 'function',
+      function: {
+        name: 'compiled_skill_objectives',
+        description: 'Return validated workflow objectives.',
+        parameters: {
+          type: 'object', required: ['objectives'], additionalProperties: false,
+          properties: { objectives: { type: 'array', items: { type: 'object', required: ['text'], properties: { text: { type: 'string' }, optional: { type: 'boolean' }, continueOnFailure: { type: 'boolean' } } } } },
+        },
+      },
+    };
+    const timeoutSignal = AbortSignal.timeout(Math.max(1, Number(timeoutMs) || 8_000));
+    const requestSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
+    try {
+      const preferred = await llm.completeWithTools({ system, tools: [tool], toolChoice: { type: 'function', function: { name: 'compiled_skill_objectives' } }, messages: [{ role: 'user', content: body }], signal: requestSignal });
+      const call = preferred?.tool_calls?.find((item) => item?.function?.name === 'compiled_skill_objectives');
+      if (call?.function?.arguments) return JSON.parse(call.function.arguments);
+      if (preferred?.content) return preferred.content;
+    } catch { /* retry through JSON text below */ }
+    const plain = await llm.completeWithTools({
+      system: `${system}\nReturn JSON only as {"objectives":[{"text":"...","optional":false,"continueOnFailure":false}]}.`,
+      tools: [], messages: [{ role: 'user', content: body }], signal: requestSignal,
+    });
+    return plain?.content;
+  };
+}
+
+export function deterministicObjectives(body) {
+  const text = String(body ?? '').trim();
+  const numbered = splitExplicitList(text, /^\s*\d+[.)]\s+/gm);
+  if (numbered) return { objectives: numbered.map(objectiveFromText), ambiguous: false };
+  const bullets = splitExplicitList(text, /^\s*[-*+]\s+/gm);
+  if (bullets) return { objectives: bullets.map(objectiveFromText), ambiguous: false };
+  const connected = text.split(STRONG_CONNECTOR_RE).map((part) => part.trim()).filter(Boolean);
+  if (connected.length > 1) return { objectives: connected.map(objectiveFromText), ambiguous: false };
+  return { objectives: [objectiveFromText(text)], ambiguous: looksAmbiguous(text) };
+}
+
+export function validateCompiledObjectives(value) {
+  if (!Array.isArray(value) || value.length < 1 || value.length > MAX_OBJECTIVES) throw compileError(`A skill must compile to 1..${MAX_OBJECTIVES} objectives.`);
+  return value.map((raw, index) => {
+    const item = typeof raw === 'string' ? objectiveFromText(raw) : { ...raw };
+    item.text = String(item.text ?? '').trim();
+    if (!item.text) throw compileError(`Objective ${index + 1} is empty.`);
+    if (FORBIDDEN_FIELDS.test(item.text) || Object.keys(item).some((key) => /^(?:agent|capability|capabilityPlan|mcp|tool)$/i.test(key))) throw compileError(`Objective ${index + 1} contains technical routing details.`);
+    return { text: item.text, optional: item.optional === true, continueOnFailure: item.optional === true || item.continueOnFailure === true };
+  });
+}
+
+function naturalArgumentBlock(args) {
+  const suffix = Object.entries(args ?? {})
+    .filter(([, value]) => String(value ?? '').trim())
+    .map(([name, value]) => `${name}: ${value}`)
+    .join('\n');
+  return suffix ? `\n\nUser parameters:\n${suffix}` : '';
+}
+
+// Applied after validation: a parameter named `agent` or `tool` would otherwise
+// trip the routing-details guard, which must judge the authored intention, not
+// what the caller typed on the command line.
+function withNaturalArguments(objectives, args) {
+  const block = naturalArgumentBlock(args);
+  if (!block) return objectives;
+  return objectives.map((objective) => ({ ...objective, text: `${objective.text}${block}` }));
+}
+
+function splitExplicitList(text, markerRe) {
+  const matches = [...text.matchAll(markerRe)];
+  if (matches.length < 2) return null;
+  return matches.map((match, index) => text.slice(match.index + match[0].length, matches[index + 1]?.index ?? text.length).trim()).filter(Boolean);
+}
+
+function objectiveFromText(raw) {
+  const text = String(raw ?? '').trim();
+  const optional = OPTIONAL_RE.test(text);
+  return {
+    text: capitalize(text.replace(OPTIONAL_RE, '').replace(/^(?:puis|ensuite|après cela|then|next)\b[\s,:-]*/i, '').trim()),
+    optional,
+    continueOnFailure: optional,
+  };
+}
+
+function looksAmbiguous(text) {
+  return (text.match(/(?:^|[.!?]\s+)[A-ZÀ-Ý][^.!?]{0,80}\b(?:export|ingest|build|send|create|delete|sync|publish|diagnos|analyse|constru|envoi|cré|supprim)/gi)?.length ?? 0) > 2;
+}
+
+function normalizeFallback(value) {
+  if (Array.isArray(value)) return value;
+  if (Array.isArray(value?.objectives)) return value.objectives;
+  if (typeof value === 'string') {
+    const parsed = JSON.parse(value.replace(/^```json\s*|\s*```$/gi, ''));
+    return Array.isArray(parsed) ? parsed : parsed.objectives;
+  }
+  throw compileError('Invalid compiler fallback response.');
+}
+
+function compileError(message) { const error = new Error(message); error.code = 'skill_compile_failed'; return error; }
+
+function capitalize(text) { return text ? `${text[0].toLocaleUpperCase()}${text.slice(1)}` : text; }