@dotdrelle/wiki-manager 0.15.43 → 0.15.49

package/src/agent/skillRecursion.test.js

@@ -0,0 +1,98 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { handleRuntimeControlTool } from './graph.js';
+
+/*
+ Récursion observée en headless : `wiki-ingest` se réinvoquait au lieu de
+ lancer la production, quatre fois avant interruption manuelle.
+
+ La cause n'est pas le modèle. Le corps d'une compétence est compilé en
+ intentions MÉTIER, et une intention ressemble forcément à la description de la
+ compétence dont elle sort — « ingérer les fichiers en attente » est à la fois
+ l'objectif de /wiki-ingest et sa raison d'être. Le sélecteur la reconnaissait
+ donc légitimement. Ce qui manquait, c'est que le run ne savait pas d'où il
+ venait : `chainId` et `skillName` s'arrêtaient à l'item de contrôle.
+*/
+
+function session(skillStack, ran = []) {
+  return {
+    // La garde d'entrée exige une URL de runtime ; le chemin run_skill passe
+    // ensuite par _runSkillWithinRun sans jamais l'appeler.
+    runtime: { url: 'http://runtime.invalid' },
+    _skillStack: skillStack,
+    _runSkillWithinRun: async (name) => { ran.push(name); return { ok: true, ran: name }; },
+  };
+}
+
+const call = (state, skillName) =>
+  handleRuntimeControlTool(state, 'run_skill', { skillName, _userInput: skillName })
+    .then((raw) => JSON.parse(raw));
+
+test('refuse de relancer une compétence déjà dans la pile', async () => {
+  const result = await call(session(['wiki-ingest']), 'wiki-ingest');
+
+  assert.equal(result.ok, false);
+  assert.equal(result.terminal, true);
+  assert.equal(result.code, 'skill_recursion_blocked');
+  // Le diagnostic doit dire quoi faire à la place, sinon le modèle réessaie
+  // avec une autre formulation du même appel.
+  assert.match(result.message, /execute its objective directly/i);
+});
+
+test('ignore la casse : le nom est le même concept', async () => {
+  const result = await call(session(['wiki-ingest']), 'Wiki-Ingest');
+
+  assert.equal(result.code, 'skill_recursion_blocked');
+});
+
+test('détecte un cycle indirect, pas seulement l’auto-appel', async () => {
+  // a → b → a : chacun des deux appels est légitime pris isolément.
+  const result = await call(session(['wiki-sync', 'wiki-ingest']), 'wiki-sync');
+
+  assert.equal(result.code, 'skill_recursion_blocked');
+});
+
+test('laisse passer une composition sans cycle', async () => {
+  // Le refus porte sur les cycles, pas sur la composition : une compétence a
+  // le droit d'en appeler une autre.
+  const result = await call(session(['wiki-sync']), 'deliver');
+
+  assert.equal(result.ok, true);
+  assert.equal(result.ran, 'deliver');
+});
+
+test('laisse passer une invocation hors de toute chaîne', async () => {
+  const result = await call(session(undefined), 'wiki-ingest');
+
+  assert.equal(result.ok, true);
+});
+
+/*
+ `/new-template` observé en conditions réelles : la compétence se rappelait
+ elle-même, le run finissait `done`, et rien n'avait été créé. Les tests
+ ci-dessus vérifiaient le code de refus ; celui-ci vérifie qu'AUCUN travail
+ n'est lancé — c'est ce qui distingue un refus d'un simple avertissement.
+*/
+test('un refus n’exécute rien du tout', async () => {
+  const ran = [];
+  const result = await handleRuntimeControlTool(
+    session(['new-template'], ran),
+    'run_skill',
+    { skillName: 'new-template', _userInput: 'crée un modèle de présentation' },
+  ).then((raw) => JSON.parse(raw));
+
+  assert.equal(result.code, 'skill_recursion_blocked');
+  assert.deepEqual(ran, [], 'aucun run imbriqué ne doit démarrer');
+  // La pile revient au modèle : sans elle il ne peut pas savoir laquelle des
+  // compétences ouvertes le bloque, et il reformule le même appel.
+  assert.deepEqual(result.skillStack, ['new-template']);
+  assert.match(result.message, /new-template/);
+});
+
+test('borne la profondeur même sans cycle', async () => {
+  // La détection de cycle ne voit pas une chaîne longue de compétences
+  // distinctes, qui épuiserait le budget aussi sûrement.
+  const result = await call(session(['a', 'b', 'c']), 'd');
+
+  assert.equal(result.code, 'skill_depth_exceeded');
+});

package/src/cli/wiki-manager.js

@@ -31,6 +31,7 @@ import { runAgentTurn, runAgenticLoop } from '../core/agentLoop.js';
 import { resolveCapabilityConcurrency } from '../orchestrator/scheduler.js';
 import { capabilityRegistryForSession } from '../orchestrator/capabilityRegistry.js';
 import { listWorkspaces } from '../core/workspaces.js';
+import { findSkill } from '../core/skills.js';
 // Runtime modules use node:sqlite (Node.js built-in unavailable in Bun).
 // They are imported dynamically so the shell / TUI path never loads them.
 
@@ -288,6 +289,7 @@ export function createInteractiveSession(context, { runtimeUrl, turnId, signal =
     'workspace', 'workspacePath', 'workspaceEnvFile', 'workspaceEnv',
     'wikirc', 'wikircConfig', 'language', 'llm', 'mcp', 'commands',
     'packageJson', 'queueStore', 'systemPrompt',
+    '_runSkillWithinRun',
   ]) {
     if (source[key] !== undefined) session[key] = source[key];
   }
@@ -599,7 +601,14 @@ async function runHeadless(argv, agent) {
   const maxTurnsArg = valueAfter(argv, '--max-turns');
   const timeoutMs = (Number.isFinite(Number(timeoutArg)) ? Math.max(1, Number(timeoutArg)) : 3600) * 1000;
   const maxTurns = Number.isFinite(Number(maxTurnsArg)) ? Math.max(1, Number(maxTurnsArg)) : 20;
+  // --skill accepts its arguments inline, exactly like the Shell and serve
+  // invocation: --skill "deliver rapport polish".
+  const skillArgv = String(skillName ?? '').trim().split(/\s+/).filter(Boolean);
+  const skillId = skillArgv[0] ?? null;
+  const skillArgs = skillArgv.slice(1).join(' ');
   // --skill uses the agentic loop (multi-turn); --prompt uses a single turn unless --wait is set.
+  // The loop is the legacy local path only: when the runtime answers, the skill
+  // is compiled and executed server-side and there is no local loop to run.
   const useAgenticLoop = Boolean(skillName) && !argv.includes('--no-wait');
   const wait = !useAgenticLoop && (argv.includes('--wait'));
   const log = [`wiki-manager ${packageJson.version} headless`, `startedAt=${new Date().toISOString()}`];
@@ -653,7 +662,51 @@ async function runHeadless(argv, agent) {
     session._onStep = step;
 
     let input = prompt;
+    // Plan §24: headless must resolve executable skills through the same
+    // runtime resolver as the Shell and serve. Injecting the skill body into a
+    // local prompt bypasses the compiler, so a multi-capability skill such as
+    // wiki-sync would collapse into a single run here while producing two
+    // everywhere else — and the rewritten bodies are business intentions, not
+    // the step-by-step procedures the local prompt still expects.
+    if (skillId && session.runtime?.url) {
+      if (prompt) {
+        step('headless: --prompt is ignored when --skill runs through the runtime.');
+      }
+      const invocation = `/${skillId}${skillArgs ? ` ${skillArgs}` : ''}`;
+      log.push(`skill=${invocation}`);
+      const { postRuntimeRun } = await import('../runtime/client.js');
+      let accepted;
+      try {
+        accepted = await postRuntimeRun(invocation, {
+          url: session.runtime.url,
+          workspace: session.workspace ?? null,
+          skillName: skillId,
+        });
+      } catch (err) {
+        throw new Error(`Skill invocation failed: ${err instanceof Error ? err.message : String(err)}`);
+      }
+      if (accepted?.kind !== 'skill_chain') {
+        throw new Error(`Skill not found: ${skillId}`);
+      }
+      step(`skill: ${accepted.skill} compiled into ${accepted.objectives} objective(s), chain ${accepted.chainId}`);
+      const { exitCode: chainExit } = await waitForRuntimeChain(session, log, {
+        chainId: accepted.chainId,
+        timeoutMs,
+        autoApprove: argv.includes('--auto-approve'),
+      });
+      const saved = await writeHeadlessLog(session, log, logFile);
+      console.log(`Headless log: ${saved}`);
+      if (chainExit !== 0) process.exitCode = chainExit;
+      return;
+    }
     if (skillName) {
+      const legacySkill = findSkill(session, skillId);
+      if (!legacySkill) throw new Error(`Skill not found: ${skillId}`);
+      if (!argv.includes('--auto-approve')) {
+        throw new Error('Headless --no-runtime skill execution requires explicit --auto-approve before any mutation can run.');
+      }
+      session._skillStack = [legacySkill.name];
+      session._skillExecution = legacySkill.execution === 'direct' ? 'direct' : 'orchestrated';
       const skillResult = await handleSlashCommand(`/skills run ${skillName}`, { packageJson, session, onStep: step });
       if (skillResult.output && !skillResult.rawOutput) log.push(skillResult.output);
       if (String(skillResult.output ?? '').startsWith('Skill not found')) throw new Error(`Skill not found: ${skillName}`);
@@ -717,6 +770,115 @@ async function runHeadless(argv, agent) {
   }
 }
 
+// A skill may compile into several sequential runs, so waiting on "the run this
+// turn created" is not enough: wiki-sync would report success as soon as the
+// export finished, before the ingest had even started. The control queue is the
+// only place where the whole chain is observable, so the wait is scoped to
+// chainId and ends when every item of that chain is terminal.
+const CHAIN_TERMINAL_STATUSES = new Set(['done', 'failed', 'cancelled', 'skipped']);
+
+export async function waitForRuntimeChain(session, log, {
+  chainId,
+  timeoutMs,
+  pollMs = 1500,
+  autoApprove = false,
+  client = null,
+} = {}) {
+  const { fetchRuntimeState, postRuntimeApprove } = client ?? await import('../runtime/client.js');
+  const url = session.runtime?.url;
+  const workspace = session.workspace ?? null;
+  if (!url || !chainId) return { exitCode: 0 };
+  const deadline = Date.now() + timeoutMs;
+  const approvedRevisions = new Set();
+  const reported = new Map();
+  let lastLogCount = 0;
+  while (Date.now() < deadline) {
+    let state;
+    try {
+      state = await fetchRuntimeState({ url, workspace });
+    } catch (err) {
+      const line = `chain-wait: state fetch failed (${err instanceof Error ? err.message : String(err)})`;
+      log.push(line); console.error(line);
+      return { exitCode: 1 };
+    }
+    const logs = Array.isArray(state?.logs) ? state.logs : [];
+    for (const entry of logs.slice(lastLogCount)) {
+      const text = typeof entry === 'string' ? entry : String(entry?.message ?? JSON.stringify(entry));
+      log.push(`runtime: ${text}`); console.log(`[runtime] ${text}`);
+    }
+    lastLogCount = logs.length;
+
+    const items = (Array.isArray(state?.controlQueue) ? state.controlQueue : [])
+      .filter((item) => item?.chainId === chainId)
+      .sort((a, b) => Number(a.chainSequence ?? 0) - Number(b.chainSequence ?? 0));
+    if (items.length === 0) {
+      const line = `chain-wait: chain ${chainId} is not visible in the runtime queue.`;
+      log.push(line); console.error(line);
+      return { exitCode: 1 };
+    }
+    for (const item of items) {
+      const status = String(item.status ?? 'queued');
+      if (reported.get(item.id) === status) continue;
+      reported.set(item.id, status);
+      const line = `chain-step ${Number(item.chainSequence ?? 0) + 1}/${items.length}: ${status}${item.skipReason ? ` (${item.skipReason})` : ''}`;
+      log.push(line); console.log(`[runtime] ${line}`);
+    }
+
+    const active = items.find((item) => item.status === 'running');
+    if (autoApprove && active?.runId) {
+      const pending = (Array.isArray(state?.approvals) ? state.approvals : [])
+        .filter((approval) => approval.status === 'pending_approval'
+          && (approval.runId == null || String(approval.runId) === String(active.runId)));
+      const planRevision = state?.planRevision ?? 0;
+      const revisionKey = `${active.runId}:${planRevision}`;
+      if (pending.length > 0 && !approvedRevisions.has(revisionKey)) {
+        approvedRevisions.add(revisionKey);
+        const approvalClasses = [...new Set(pending.flatMap((approval) => {
+          const value = approval.approvalClasses ?? approval.approvalClass ?? [];
+          return Array.isArray(value) ? value : [value];
+        }).map(String).filter(Boolean))];
+        try {
+          await postRuntimeApprove({
+            url,
+            workspace,
+            runId: active.runId,
+            scope: 'run',
+            planRevision,
+            approvalClasses: approvalClasses.length > 0 ? approvalClasses : ['default'],
+          });
+          const line = `chain-wait: auto-approved run ${active.runId} (revision ${planRevision})`;
+          log.push(line); console.log(line);
+        } catch (err) {
+          const line = `chain-wait: auto-approve failed (${err instanceof Error ? err.message : String(err)})`;
+          log.push(line); console.error(line);
+          return { exitCode: 1 };
+        }
+      }
+    }
+    if (!autoApprove) {
+      const blocked = (Array.isArray(state?.approvals) ? state.approvals : [])
+        .some((approval) => approval.status === 'pending_approval');
+      if (blocked && active) {
+        const line = `chain-wait: chain ${chainId} is waiting for approval; re-run with --auto-approve to drive it through.`;
+        log.push(line); console.log(line);
+        return { exitCode: 0 };
+      }
+    }
+
+    if (items.every((item) => CHAIN_TERMINAL_STATUSES.has(String(item.status)))) {
+      const failed = items.filter((item) => item.status === 'failed');
+      const skipped = items.filter((item) => item.status === 'skipped');
+      const summary = `chain ${chainId}: ${items.length} step(s), ${failed.length} failed, ${skipped.length} skipped`;
+      log.push(summary); console.log(`[runtime] ${summary}`);
+      return { exitCode: failed.length > 0 ? 1 : 0 };
+    }
+    await new Promise((resolve) => setTimeout(resolve, pollMs));
+  }
+  const line = `chain-wait: timeout waiting for chain ${chainId} to finish.`;
+  log.push(line); console.error(line);
+  return { exitCode: 1 };
+}
+
 async function runRuntime(argv, agent) {
   if (argv.includes('--help') || argv.includes('-h')) {
     console.log([
@@ -1013,7 +1175,7 @@ async function runRuntime(argv, agent) {
       }
       emitRuntimeLog(context.session, manual ? 'runtime: manual resume completed' : 'runtime: recovery completed');
       const controlStarted = pollingActivities.length === 0
-        ? serverHandle?.drainControl?.(context) === true
+        ? await serverHandle?.drainControl?.(context) === true
         : false;
       return {
         workspace: context.workspace ?? workspace ?? null,
@@ -1155,27 +1317,62 @@ async function runRuntime(argv, agent) {
     const maxTurns = Number.isFinite(Number(body.maxTurns)) ? Math.max(1, Number(body.maxTurns)) : 20;
     const maxReplans = Number.isFinite(Number(body.replans)) ? Math.max(0, Math.floor(Number(body.replans))) : undefined;
     const runId = String(body.runId);
+    // Déclarée hors du try : le finally doit pouvoir restaurer la pile même
+    // quand le run échoue avant de l'avoir installée.
+    const parentStack = Array.isArray(session._skillStack) ? session._skillStack : [];
     try {
       if (workspace && session.workspace !== workspace) {
         const result = await handleSlashCommand(`/use ${workspace}`, { packageJson, session });
         if (!session.workspacePath) throw new Error(result.output || `Workspace not loaded: ${workspace}`);
       }
       context.workspace = session.workspace ?? workspace ?? context.workspace ?? null;
+      /*
+       Pile des compétences en cours d'exécution.
+
+       Une intention compilée depuis une compétence ressemble, par
+       construction, à la description de cette compétence : le sélecteur de
+       l'agent la reconnaît et la relance. Garder la pile permet de refuser un
+       cycle sans interdire une composition légitime.
+      */
+      const skillChain = body.skillChain ?? null;
+      /*
+       La pile vient de l'ÉLÉMENT quand il en porte une.
+
+       Elle était reconstruite à partir de `session._skillStack`, c'est-à-dire
+       de l'état laissé par le run précédent sur cette session. Mais un run de
+       compétence imbriquée démarre après le `finally` de son parent, qui a déjà
+       tout restauré : la pile héritée était donc celle du grand-parent, pas
+       celle du parent. A→B→A traversait sans être vu.
+
+       Le repli sur `parentStack` couvre les éléments d'avant ce changement,
+       encore en file dans un runtime qui redémarre, et l'invocation directe
+       depuis une session interactive.
+      */
+      session._skillStack = Array.isArray(skillChain?.skillStack) && skillChain.skillStack.length
+        ? skillChain.skillStack.map((entry) => String(entry))
+        : skillChain?.skillName
+          ? [...parentStack, String(skillChain.skillName)]
+          : parentStack;
       session._currentRunIdentity = {
         runId,
         turnId: `${runId}:turn-0`,
         workspace: context.workspace,
+        ...(skillChain ? { skillChain } : {}),
       };
       dispatchAgentEvent(session, createAgentEvent('run_started', {
         origin: 'runtime',
         runId,
-        payload: { input, workspace: session._currentRunIdentity.workspace },
-      }));
-      dispatchAgentEvent(session, createAgentEvent('user_message', {
-        origin: 'user',
-        runId,
-        payload: { content: input },
+        payload: { input: String(body.publicInput ?? input), workspace: session._currentRunIdentity.workspace },
       }));
+      // Compiled skill objectives are private execution material. The
+      // original slash invocation is the user-facing conversation turn.
+      if (!skillChain) {
+        dispatchAgentEvent(session, createAgentEvent('user_message', {
+          origin: 'user',
+          runId,
+          payload: { content: input },
+        }));
+      }
       session._abortSignal = signal ?? null;
       session._runApprovalRequired = body.requireApproval === true;
       session._runApprovalResolved = false;
@@ -1322,6 +1519,11 @@ async function runRuntime(argv, agent) {
       delete session._runApprovalRequired;
       delete session._runApprovalResolved;
       delete session._approvalTimeoutMs;
+      // La session survit au run : une pile laissée en place bloquerait une
+      // invocation parfaitement légitime au run suivant, et le diagnostic
+      // serait incompréhensible.
+      if (parentStack.length) session._skillStack = parentStack;
+      else delete session._skillStack;
     }
   }
 

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

@@ -8,8 +8,23 @@ import {
   resolveExecutorArguments,
   resolvePreparedDelegationApproval,
   startupWizardGaps,
+  waitForRuntimeChain,
 } from './wiki-manager.js';
 
+const CHAIN_SESSION = { runtime: { url: 'http://127.0.0.1:7788' }, workspace: 'demo' };
+
+function chainClient(states, { onApprove } = {}) {
+  let call = 0;
+  return {
+    fetchRuntimeState: async () => states[Math.min(call++, states.length - 1)],
+    postRuntimeApprove: async (args) => { onApprove?.(args); return { approved: true }; },
+  };
+}
+
+function chainItem(sequence, status, extra = {}) {
+  return { id: `control-${sequence}`, chainId: 'chain-1', chainSequence: sequence, status, ...extra };
+}
+
 const COLLECT_CAPABILITY = {
   description: 'Collect content from an external connector source.',
   inputSchema: {
@@ -348,3 +363,77 @@ test('argument extraction keeps a value the vocabulary allows', async () => {
     { source_name: 'EAS_Avant_projet_ACPI' },
   );
 });
+
+test('headless waits for every run of a skill chain, not just the first', async () => {
+  // wiki-sync compiles into two sequential runs: returning as soon as the
+  // export finishes would report success before the ingest had started.
+  const client = chainClient([
+    { controlQueue: [chainItem(0, 'running', { runId: 'run-a' }), chainItem(1, 'queued')] },
+    { controlQueue: [chainItem(0, 'done'), chainItem(1, 'running', { runId: 'run-b' })] },
+    { controlQueue: [chainItem(0, 'done'), chainItem(1, 'done')] },
+  ]);
+  const log = [];
+  const result = await waitForRuntimeChain(CHAIN_SESSION, log, {
+    chainId: 'chain-1', timeoutMs: 5000, pollMs: 1, client,
+  });
+  assert.equal(result.exitCode, 0);
+  assert.ok(log.some((line) => line.startsWith('chain-step 2/2: running')), 'second step must be observed');
+  assert.ok(log.some((line) => line.includes('2 step(s), 0 failed, 0 skipped')));
+});
+
+test('a failed chain step propagates a non-zero exit code and reports the skip', async () => {
+  const client = chainClient([
+    { controlQueue: [chainItem(0, 'running', { runId: 'run-a' }), chainItem(1, 'queued')] },
+    {
+      controlQueue: [
+        chainItem(0, 'failed'),
+        chainItem(1, 'skipped', { skipReason: 'required_predecessor_failed' }),
+      ],
+    },
+  ]);
+  const log = [];
+  const result = await waitForRuntimeChain(CHAIN_SESSION, log, {
+    chainId: 'chain-1', timeoutMs: 5000, pollMs: 1, client,
+  });
+  assert.equal(result.exitCode, 1);
+  assert.ok(log.some((line) => line.includes('required_predecessor_failed')));
+});
+
+test('a chain blocked on approval returns instead of hanging until the timeout', async () => {
+  const blocked = {
+    controlQueue: [chainItem(0, 'running', { runId: 'run-a' })],
+    approvals: [{ status: 'pending_approval', runId: 'run-a' }],
+  };
+  const log = [];
+  const result = await waitForRuntimeChain(CHAIN_SESSION, log, {
+    chainId: 'chain-1', timeoutMs: 5000, pollMs: 1, client: chainClient([blocked]),
+  });
+  assert.equal(result.exitCode, 0);
+  assert.ok(log.some((line) => line.includes('--auto-approve')));
+});
+
+test('--auto-approve grants the run-scoped approval of the active chain step once', async () => {
+  const approvals = [];
+  const client = chainClient([
+    {
+      controlQueue: [chainItem(0, 'running', { runId: 'run-a' })],
+      approvals: [{ status: 'pending_approval', runId: 'run-a', approvalClasses: ['mutation'] }],
+      planRevision: 3,
+    },
+    {
+      controlQueue: [chainItem(0, 'running', { runId: 'run-a' })],
+      approvals: [{ status: 'pending_approval', runId: 'run-a', approvalClasses: ['mutation'] }],
+      planRevision: 3,
+    },
+    { controlQueue: [chainItem(0, 'done')] },
+  ], { onApprove: (args) => approvals.push(args) });
+  const result = await waitForRuntimeChain(CHAIN_SESSION, [], {
+    chainId: 'chain-1', timeoutMs: 5000, pollMs: 1, autoApprove: true, client,
+  });
+  assert.equal(result.exitCode, 0);
+  assert.equal(approvals.length, 1, 'the same revision must not be approved twice');
+  assert.deepEqual(
+    { runId: approvals[0].runId, scope: approvals[0].scope, planRevision: approvals[0].planRevision },
+    { runId: 'run-a', scope: 'run', planRevision: 3 },
+  );
+});

package/src/commands/slash.js

@@ -11,7 +11,7 @@ import { isTerminal } from '../orchestrator/taskStatuses.js';
 import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
 import { openExternalUrl } from '../shell/openExternal.js';
 import { classifyCommandFailure, failureHint, rawFailureText } from '../core/commandFailure.js';
-import { join, relative } from 'node:path';
+import { basename, join, relative } from 'node:path';
 import { composeServices, listServices, otherWorkspacesRunning, runWikiCli, serviceLogs, serviceNames, serviceStates, startService, stopService } from '../core/compose.js';
 import { agentServiceNames, profileServiceStatus } from '../core/agentsCompose.js';
 import { GOOGLE_GRANTS, GOOGLE_GRANT_LABELS, defaultGoogleGrants } from '../core/googleGrants.js';
@@ -26,7 +26,7 @@ import {
   formatMcpTools,
 } from '../core/mcp.js';
 import { createWorkspace, findWorkspace, listWorkspaces } from '../core/workspaces.js';
-import { findSkill, listSkills } from '../core/skills.js';
+import { findSkill, inspectSkills, listSkills } from '../core/skills.js';
 import { extractActivity, formatActivityError, formatActivityLine, formatActivitySummary, parseJsonText } from '../core/activity.js';
 import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
 import {
@@ -464,23 +464,27 @@ export function compactMcpStatus(mcpStatus) {
 }
 
 function skillsText(session) {
-  const skills = listSkills(session);
-  if (skills.length === 0) return 'No skills discovered.';
-  return skills
+  const { skills, rejected, warnings } = inspectSkills(session);
+  const active = skills
     .map((skill) => {
       const description = String(skill.description || 'workflow skill').replace(/\s+/g, ' ').trim();
       const compact = description.length > 96 ? `${description.slice(0, 93)}...` : description;
       return `${skill.name}\t${skill.scope}\t${compact}`;
     })
     .join('\n');
+  return [
+    active || 'No skills discovered.',
+    rejected.length ? `\nRejected\n${rejected.map((item) => `${item.relativePath}\t${item.reason}${item.name ? `\t${item.name}` : ''}`).join('\n')}` : null,
+    warnings.length ? `\nWarnings\n${warnings.map((item) => `${item.relativePath}\t${item.reason}\t${item.name}`).join('\n')}` : null,
+  ].filter(Boolean).join('\n');
 }
 
-function skillDetailText(skill) {
+function skillDetailText(skill, session) {
   return [
     `# ${skill.name}`,
     '',
     `Scope: ${skill.scope}`,
-    `Path: ${skill.path}`,
+    `Path: ${session?.workspacePath ? relative(session.workspacePath, skill.path) : basename(skill.path)}`,
     skill.description ? `Description: ${skill.description}` : null,
     skill.params?.length ? `Params: ${skill.params.join(', ')}` : null,
     '',
@@ -523,7 +527,7 @@ function skillActionCommand(session, action, name) {
       agentTrigger: buildSkillRunPrompt(skill),
     };
   }
-  return { output: skillDetailText(skill) };
+  return { output: skillDetailText(skill, session) };
 }
 
 function skillEditCommand(session, name) {
@@ -636,6 +640,8 @@ async function statusText(session) {
     `path: ${compactPath(session.workspacePath ?? '-')}`,
     `env: ${compactPath(session.workspaceEnvFile ?? '-')}`,
   ]);
+  const skillDiagnostics = inspectSkills(session);
+  const skillDiagnosticCount = skillDiagnostics.rejected.length + skillDiagnostics.warnings.length;
   const configColumn = sectionBlock('Config', [
     `wikirc: ${session.wikirc?.profile ?? '-'}${session.wikirc?.fileName ? ` (${session.wikirc.fileName})` : ''}`,
     `language: ${session.language ?? '-'}`,
@@ -643,6 +649,7 @@ async function statusText(session) {
     `provider: ${session.wikircConfig?.llm?.provider ?? '-'}`,
     `model: ${session.wikircConfig?.llm?.model ?? '-'}`,
     `baseUrl: ${compactBaseUrl(session.wikircConfig?.llm?.baseUrl)}`,
+    ...(skillDiagnosticCount ? [`skill diagnostics: ${skillDiagnostics.rejected.length} rejected, ${skillDiagnostics.warnings.length} warning(s) (/skills)`] : []),
   ]);
   const runtimeColumn = sectionBlock('Runtime', (states ? serviceStatesText(states) : 'Docker runtime not available or no workspace loaded.').split('\n'));
   const mcpColumn = sectionBlock('MCP', compactMcpStatus(session.mcp).split('\n'));
@@ -721,9 +728,10 @@ Options:
   --once <prompt>      Run one agent turn and exit
   --headless           Run a workspace task non-interactively
   --workspace <name>   Initial workspace (interactive or --headless)
-  --skill <name>       Skill to run in --headless (implies --wait)
+  --skill "<name> [args]"  Skill invocation for --headless (implies --wait)
   --prompt <text>      Task or extra instruction for --headless
   --log-file <path>    Optional headless log path
+  --auto-approve       Approve validated headless run revisions automatically
   --wait               Wait for active jobs to complete after agent turn (--prompt only)
   --no-wait            Disable agentic loop for --skill (single turn)
   --timeout <seconds>  Per-wave job wait timeout in seconds (default: 3600)
@@ -1431,7 +1439,17 @@ export async function handleSlashCommand(line, context) {
         // would silently revert the item to waiting (fake cancel).
         const localItem = (context.session.jobQueue ?? []).find((item) => String(item.id) === String(id));
         if (localItem?.origin === 'runtime' || (!localItem && runtimeManagedItemId(context, id))) {
-          return { output: 'Item géré par le runtime — utilisez /run kill (global) ou /run cancel au lieu de /queue cancel.' };
+          if (!context.runtime?.url) return { output: 'Item géré par le runtime — reconnectez le runtime pour l’annuler, ou utilisez /run cancel ou /run kill.' };
+          try {
+            const result = await postRuntimeControl('cancel_item', {
+              url: context.runtime.url,
+              workspace: context.session.workspace ?? null,
+              id,
+            });
+            return { output: result.cancelled ? `Cancelled runtime queue item ${id}.` : `Runtime queue item ${id} was not cancelled.` };
+          } catch (err) {
+            return { output: `Runtime queue cancellation failed: ${err instanceof Error ? err.message : String(err)}` };
+          }
         }
         const result = await cancelQueueItem(context.session, id);
         return { output: result.message };

package/src/contracts/schemas.js

@@ -401,7 +401,7 @@ export const contractSchemas = {
     required: ['action'],
     additionalProperties: true,
     properties: {
-      action: { type: 'string', enum: ['status', 'explain', 'message', 'enqueue', 'approve_patch', 'reject_patch'] },
+      action: { type: 'string', enum: ['status', 'explain', 'message', 'enqueue', 'cancel_item', 'approve_patch', 'reject_patch'] },
       input: { type: 'string' },
       message: { type: 'string' },
       prompt: { type: 'string' },