@dotdrelle/wiki-manager 0.12.0 → 0.12.7

package/src/agent/graph.test.js

@@ -3,7 +3,7 @@ import test from 'node:test';
 import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { buildAgentSystemPrompt, createAgentGraph } from './graph.js';
+import { buildAgentSystemPrompt, classifyAgentInput, createAgentGraph, knownCapabilityIds } from './graph.js';
 
 function sessionBase(overrides = {}) {
   return {
@@ -387,3 +387,406 @@ test('buildAgentSystemPrompt forbids inventing slash commands or arguments', ()
   assert.doesNotMatch(prompt, /executorQuery/);
   assert.doesNotMatch(prompt, /executor:"/);
 });
+
+// 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
+// name list comes from the session's declared servers, never from a manual
+// list (amendment A6). New prompt text or injected skill descriptions that
+// reintroduce a bare name must fail here.
+test('buildAgentSystemPrompt contains no unqualified tool names for connected servers', () => {
+  const session = sessionBase({
+    mcp: {
+      production: {
+        status: 'connected',
+        tools: [
+          { name: 'production_start_job' }, { name: 'production_job_status' },
+          { name: 'production_job_logs' }, { name: 'production_cancel_job' },
+          { name: 'production_list_jobs' }, { name: 'production_list_templates' },
+          { name: 'production_status' }, { name: 'agent_describe' },
+          { name: 'agent_plan' }, { name: 'agent_execute' },
+          { name: 'agent_status' }, { name: 'agent_cancel' },
+        ],
+      },
+      cme: {
+        status: 'connected',
+        tools: [
+          { name: 'cme_status' }, { name: 'cme_setup' },
+          { name: 'cme_sources_list' }, { name: 'cme_source_add' },
+          { name: 'cme_source_remove' }, { name: 'cme_export_run' },
+          { name: 'cme_export_status' }, { name: 'cme_export_cancel' },
+          { name: 'agent_describe' }, { name: 'agent_execute' },
+          { name: 'agent_status' }, { name: 'agent_cancel' },
+        ],
+      },
+    },
+  });
+  const prompt = buildAgentSystemPrompt({ session });
+  const offenders = [];
+  for (const [serverName, value] of Object.entries(session.mcp)) {
+    for (const tool of value.tools) {
+      // A bare occurrence is the tool name not embedded in a wider
+      // identifier: `production__production_start_job` does not match
+      // because the inner occurrence is preceded by `_`.
+      const bare = new RegExp(`(?<![\\w])${tool.name}(?![\\w])`);
+      if (bare.test(prompt)) offenders.push(`${serverName}:${tool.name}`);
+    }
+  }
+  assert.deepEqual(offenders, [], `Unqualified tool names found in system prompt: ${offenders.join(', ')}`);
+});
+
+test('classifyAgentInput routes information requests to observe, not runs', () => {
+  const session = sessionBase();
+  // The original incident: a config question must never become a run.
+  assert.equal(classifyAgentInput('donne moi la config du cme', session).kind, 'observe');
+  assert.equal(classifyAgentInput('montre la configuration du workspace', session).kind, 'observe');
+  assert.equal(classifyAgentInput('où en est le run', session).kind, 'observe');
+  assert.equal(classifyAgentInput('explique le build', session).kind, 'observe');
+  assert.equal(classifyAgentInput("qu'est-ce que le pipeline polish ?", session).kind, 'observe');
+});
+
+test('classifyAgentInput routes action requests to start_run without an active run', () => {
+  const session = sessionBase();
+  assert.equal(classifyAgentInput('lance le pipeline complet', session).kind, 'start_run');
+  assert.equal(classifyAgentInput('configure le cme avec ce token', session).kind, 'start_run');
+  assert.equal(classifyAgentInput('lance le run', session).kind, 'start_run');
+  assert.equal(classifyAgentInput('exporte les deliverables', session).kind, 'start_run');
+});
+
+test('classifyAgentInput keeps small talk as converse and active-run branches intact', () => {
+  const session = sessionBase();
+  assert.equal(classifyAgentInput('bonjour', session).kind, 'converse');
+  assert.equal(classifyAgentInput('merci beaucoup', session).kind, 'converse');
+  const activeSession = sessionBase({ agentProjection: { status: 'running' } });
+  assert.equal(classifyAgentInput('lance un build', activeSession).kind, 'ambiguous');
+  assert.equal(classifyAgentInput('annule tout', activeSession).kind, 'cancel');
+});
+
+function orchestrableAgentSnapshot() {
+  return [{
+    agentInstanceId: 'production-1',
+    serverName: 'production',
+    health: 'available',
+    description: {
+      contractVersion: '1',
+      agentType: 'production',
+      displayName: 'Production agent',
+      capabilities: [
+        { id: 'knowledge.pipeline', version: '1' },
+        { id: 'external-source.export', version: '1' },
+      ],
+    },
+  }];
+}
+
+test('knownCapabilityIds reflects the discovered registry snapshot', () => {
+  const session = sessionBase({ agentRegistrySnapshot: orchestrableAgentSnapshot() });
+  assert.deepEqual(knownCapabilityIds(session), ['external-source.export', 'knowledge.pipeline']);
+  assert.deepEqual(knownCapabilityIds(sessionBase()), []);
+});
+
+test('agent graph rejects plan steps declaring unknown capabilities', async () => {
+  let calls = 0;
+  let rejectionSeen = null;
+  const session = sessionBase({
+    agentRegistrySnapshot: orchestrableAgentSnapshot(),
+    llm: {
+      async completeWithTools({ messages }) {
+        calls += 1;
+        if (calls === 1) {
+          return {
+            content: null,
+            message: { role: 'assistant', content: null },
+            tool_calls: [{
+              id: 'plan-call',
+              type: 'function',
+              function: {
+                name: 'wiki__plan_set',
+                arguments: JSON.stringify({
+                  steps: [
+                    { id: 'create', description: 'Create config file', requiredCapability: 'file.creation' },
+                    { id: 'validate', description: 'Validate config', requiredCapability: 'file.validation', dependsOn: ['create'] },
+                  ],
+                }),
+              },
+            }],
+          };
+        }
+        rejectionSeen = messages.map((message) => String(message.content ?? '')).join('\n');
+        return {
+          content: 'Understood, no plan registered.',
+          message: { role: 'assistant', content: 'Understood, no plan registered.' },
+          tool_calls: null,
+        };
+      },
+    },
+  });
+
+  const agent = createAgentGraph();
+  await agent.invoke({ input: 'Configure CME', session });
+
+  assert.equal(session.headlessPlan ?? null, null, 'rejected plan must not be registered');
+  assert.match(rejectionSeen ?? '', /Plan rejected: unknown capabilities \[file\.creation, file\.validation\]/);
+  assert.match(rejectionSeen ?? '', /external-source\.export, knowledge\.pipeline/);
+});
+
+test('agent graph accepts plan steps with known capabilities and null capability', async () => {
+  let calls = 0;
+  const session = sessionBase({
+    agentRegistrySnapshot: orchestrableAgentSnapshot(),
+    llm: {
+      async completeWithTools() {
+        calls += 1;
+        if (calls === 1) {
+          return {
+            content: null,
+            message: { role: 'assistant', content: null },
+            tool_calls: [{
+              id: 'plan-call',
+              type: 'function',
+              function: {
+                name: 'wiki__plan_set',
+                arguments: JSON.stringify({
+                  steps: [
+                    { id: 'export', description: 'Export sources', requiredCapability: 'external-source.export' },
+                    { id: 'report', description: 'Summarize results', requiredCapability: null, dependsOn: ['export'] },
+                  ],
+                }),
+              },
+            }],
+          };
+        }
+        return {
+          content: 'Plan ready.',
+          message: { role: 'assistant', content: 'Plan ready.' },
+          tool_calls: null,
+        };
+      },
+    },
+  });
+
+  const agent = createAgentGraph();
+  const result = await agent.invoke({ input: 'Export then report', session });
+
+  assert.equal(result.response, 'Plan ready.');
+  assert.deepEqual(session.headlessPlan.map((step) => step.id), ['export', 'report']);
+});
+
+test('buildAgentSystemPrompt anchors the real capability list', () => {
+  const withAgents = buildAgentSystemPrompt({ session: sessionBase({ agentRegistrySnapshot: orchestrableAgentSnapshot() }) });
+  assert.match(withAgents, /Known orchestration capabilities — the ONLY values allowed in requiredCapability: external-source\.export, knowledge\.pipeline/);
+  assert.match(withAgents, /Never invent capability names/);
+
+  const withoutAgents = buildAgentSystemPrompt({ session: sessionBase() });
+  assert.match(withoutAgents, /No orchestration capabilities discovered yet/);
+});
+
+test('agent graph executes action inputs inside a runtime run instead of asking for clarification', async () => {
+  // Regression: during a runtime run agentProjection.status is 'running', so
+  // the interactive classifier turned every action verb into 'ambiguous' and
+  // returned a canned clarification — "lance l'ingestion" did nothing.
+  const originalFetch = globalThis.fetch;
+  let fetchCalls = 0;
+  globalThis.fetch = async () => {
+    fetchCalls += 1;
+    return {
+      ok: true,
+      status: 200,
+      headers: { get: () => null },
+      text: async () => JSON.stringify({ result: { content: [{ type: 'text', text: '{"ok":true}' }] } }),
+    };
+  };
+  const session = sessionBase({
+    agentProjection: { status: 'running', conversation: [], activities: [] },
+    _currentRunIdentity: { runId: 'run-ingest', turnId: 'run-ingest:turn-1', workspace: 'docs' },
+    llm: toolCallingLlm(),
+  });
+
+  try {
+    const agent = createAgentGraph();
+    const result = await agent.invoke({ input: "lance l'ingestion des documents", session });
+
+    assert.equal(result.response, 'Done.');
+    assert.equal(fetchCalls, 1, 'the MCP tool must actually be called');
+    assert.doesNotMatch(result.response, /Peux-tu préciser/);
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test('agent graph lets Donna handle ambiguous input during a run with the control suite', async () => {
+  // The canned "Peux-tu préciser ?" regex answer is gone: Donna converses,
+  // armed with status/enqueue/cancel/kill/approve — and without write tools
+  // (a new MCP job must not fire alongside the active run).
+  const seenTools = [];
+  const session = sessionBase({
+    runtime: { url: 'http://runtime.test' },
+    agentProjection: { status: 'running', conversation: [], activities: [] },
+    llm: {
+      async completeWithTools({ tools }) {
+        seenTools.push(...tools.map((tool) => tool.function.name));
+        return {
+          content: 'Un run est en cours — je peux le mettre en file pour après, veux-tu ?',
+          message: { role: 'assistant', content: 'Un run est en cours — je peux le mettre en file pour après, veux-tu ?' },
+          tool_calls: null,
+        };
+      },
+    },
+  });
+
+  const agent = createAgentGraph();
+  const result = await agent.invoke({ input: 'lance un build', session });
+
+  assert.match(result.response, /mettre en file/);
+  assert.ok(seenTools.includes('runtime__enqueue'));
+  assert.ok(seenTools.includes('runtime__status'));
+  assert.ok(seenTools.includes('runtime__approve'));
+  assert.ok(!seenTools.includes('production__production_start_job'), 'no write MCP tools during an active run for ambiguous intents');
+});
+
+test('agent graph survives more than 12 tool iterations (recursion limit)', async () => {
+  // LangGraph's default recursionLimit (25) killed real runs around the 12th
+  // tool round with GRAPH_RECURSION_LIMIT. 20 rounds must now pass.
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = async () => ({
+    ok: true,
+    status: 200,
+    headers: { get: () => null },
+    text: async () => JSON.stringify({ result: { content: [{ type: 'text', text: '{"ok":true}' }] } }),
+  });
+  let calls = 0;
+  const session = sessionBase({
+    _currentRunIdentity: { runId: 'run-long', turnId: 'run-long:turn-1', workspace: 'docs' },
+    llm: {
+      async completeWithTools() {
+        calls += 1;
+        if (calls <= 20) {
+          return {
+            content: null,
+            message: { role: 'assistant', content: null },
+            tool_calls: [{
+              id: `call-${calls}`,
+              type: 'function',
+              function: { name: 'production__production_start_job', arguments: '{"type":"doctor"}' },
+            }],
+          };
+        }
+        return { content: 'Terminé.', message: { role: 'assistant', content: 'Terminé.' }, tool_calls: null };
+      },
+    },
+  });
+
+  try {
+    const agent = createAgentGraph();
+    const result = await agent.invoke({ input: 'inspecte tout puis lance le doctor', session });
+    assert.equal(result.response, 'Terminé.');
+    assert.equal(calls, 21);
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test('agent graph auto-declares the plan from an agent_plan task-graph fragment', async () => {
+  // The bridge that makes parallel ingestion real: when the LLM calls
+  // production__agent_plan, the shell integrates the fragment as the plan
+  // deterministically (no lossy LLM copying) with the execution fields the
+  // dispatcher needs (operation, arguments, groups, barrier).
+  const fragment = {
+    capability: 'knowledge.update',
+    tasks: [
+      { id: 'ingest:a', label: 'Ingest a.md', requiredCapability: 'knowledge.update', operation: 'ingest_plan', arguments: { inputs: ['raw/untracked/a.md'] }, dependsOn: [], parallelizable: true, groupId: 'ingest', expectedOutputRefs: [{ type: 'file', ref: '.wiki/plans/a.json' }], requiresApproval: true, idempotencyKey: 'k'.repeat(64) },
+      { id: 'ingest:b', label: 'Ingest b.md', requiredCapability: 'knowledge.update', operation: 'ingest_plan', arguments: { inputs: ['raw/untracked/b.md'] }, dependsOn: [], parallelizable: true, groupId: 'ingest', expectedOutputRefs: [{ type: 'file', ref: '.wiki/plans/b.json' }], requiresApproval: true, idempotencyKey: 'k'.repeat(64) },
+      { id: 'ingest-apply', label: 'Apply ingest plans', requiredCapability: 'knowledge.update', operation: 'ingest_apply', arguments: { inputs: ['.wiki/plans/a.json', '.wiki/plans/b.json'] }, dependsOn: ['ingest:a', 'ingest:b'], barrier: true, dependsOnGroup: 'ingest', requiresApproval: true, idempotencyKey: 'k'.repeat(64) },
+    ],
+  };
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = async () => ({
+    ok: true,
+    status: 200,
+    headers: { get: () => null },
+    text: async () => JSON.stringify({ result: { content: [{ type: 'text', text: JSON.stringify(fragment) }] } }),
+  });
+  let calls = 0;
+  const session = sessionBase({
+    mcp: {
+      production: {
+        status: 'connected',
+        url: 'http://127.0.0.1:3000/mcp/',
+        tools: [{ name: 'agent_plan', description: 'Propose a task graph', inputSchema: { type: 'object', properties: {} } }],
+      },
+    },
+    llm: {
+      async completeWithTools() {
+        calls += 1;
+        if (calls === 1) {
+          return {
+            content: null,
+            message: { role: 'assistant', content: null },
+            tool_calls: [{
+              id: 'plan-call',
+              type: 'function',
+              function: { name: 'production__agent_plan', arguments: JSON.stringify({ capability: 'knowledge.update', operation: 'ingest' }) },
+            }],
+          };
+        }
+        return { content: 'Plan intégré, en attente du dispatch.', message: { role: 'assistant', content: 'Plan intégré, en attente du dispatch.' }, tool_calls: null };
+      },
+    },
+  });
+
+  try {
+    const agent = createAgentGraph();
+    const result = await agent.invoke({ input: 'ingère les documents en attente', session });
+
+    assert.equal(result.response, 'Plan intégré, en attente du dispatch.');
+    assert.equal(session.headlessPlan.length, 3);
+    assert.deepEqual(session.headlessPlan.map((step) => step.operation), ['ingest_plan', 'ingest_plan', 'ingest_apply']);
+    assert.deepEqual(session.headlessPlan[0].arguments, { inputs: ['raw/untracked/a.md'] });
+    assert.equal(session.headlessPlan[0].parallelizable, true);
+    assert.equal(session.headlessPlan[2].barrier, true);
+    assert.deepEqual(session.headlessPlan[2].dependsOn, ['ingest:a', 'ingest:b']);
+    assert.equal(session.headlessPlan[0].requiredCapability, 'knowledge.update');
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test('Donna interprets a cleanup request and calls runtime__kill herself', async () => {
+  // "supprime le job et la queue" previously hit a regex classifier that
+  // answered with canned text. Donna now owns runtime control tools.
+  let killPath = null;
+  const originalFetch = globalThis.fetch;
+  globalThis.fetch = async (url) => {
+    killPath = new URL(String(url)).pathname;
+    return { ok: true, status: 202, json: async () => ({ killed: true, runs: 1, tasks: 2, queued: 2 }), text: async () => '{}', headers: { get: () => null } };
+  };
+  let calls = 0;
+  const session = sessionBase({
+    runtime: { url: 'http://runtime.test' },
+    agentProjection: { status: 'running', activities: [], conversation: [] },
+    llm: {
+      async completeWithTools({ tools }) {
+        calls += 1;
+        if (calls === 1) {
+          const names = tools.map((tool) => tool.function.name);
+          assert.ok(names.includes('runtime__kill'), 'control tools must be bound during an active run');
+          return {
+            content: null,
+            message: { role: 'assistant', content: null },
+            tool_calls: [{ id: 'kill-call', type: 'function', function: { name: 'runtime__kill', arguments: '{}' } }],
+          };
+        }
+        return { content: 'Run et queue purgés.', message: { role: 'assistant', content: 'Run et queue purgés.' }, tool_calls: null };
+      },
+    },
+  });
+
+  try {
+    const agent = createAgentGraph();
+    const result = await agent.invoke({ input: 'supprime le job et la queue', session });
+    assert.equal(result.response, 'Run et queue purgés.');
+    assert.equal(killPath, '/kill');
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});

package/src/cli/wiki-manager.js

@@ -295,7 +295,7 @@ async function runRuntime(argv, agent) {
   const { defaultRuntimeStateDir, openRuntimeStore, RECOVERABLE_QUEUE_STATUSES } = await import('../runtime/store.js');
   const { startRuntimeServer } = await import('../runtime/server.js');
   const { recoverActiveRuns } = await import('../runtime/recoveryManager.js');
-  const { emitRuntimeLog, startActivitySupervisor } = await import('../runtime/supervisor.js');
+  const { emitRuntimeLog, startActivitySupervisor, cancelActiveActivityJobs } = await import('../runtime/supervisor.js');
   const { resolveRuntimeAuthToken } = await import('../runtime/auth.js');
   const { createSqliteQueueStore } = await import('../runtime/queueStore.js');
   const { createApprovalManager } = await import('../runtime/approvals.js');
@@ -345,6 +345,25 @@ async function runRuntime(argv, agent) {
         store.persistEvent(event);
         serverHandle?.publish(event);
       };
+      // Control requests queued in a PREVIOUS runtime process must not
+      // auto-run at boot: a "stop le job" typed last night starting hours
+      // later as a fresh run violates least surprise. Expire them — the
+      // user can always resubmit.
+      const staleControl = (session.controlQueue ?? []).filter((item) => item.status === 'queued');
+      for (const item of staleControl) {
+        dispatchAgentEvent(session, createAgentEvent('control_cancelled', {
+          origin: 'runtime',
+          workspace,
+          payload: { id: item.id, reason: 'stale_at_boot' },
+        }));
+      }
+      if (staleControl.length > 0) {
+        dispatchAgentEvent(session, createAgentEvent('runtime_log', {
+          origin: 'runtime',
+          workspace,
+          payload: { message: `runtime: expired ${staleControl.length} stale queued control request(s) from a previous session` },
+        }));
+      }
       session._onRuntimeError = (err) => {
         const message = err instanceof Error ? err.message : String(err);
         dispatchAgentEvent(session, createAgentEvent('run_error', {
@@ -620,6 +639,10 @@ async function runRuntime(argv, agent) {
       });
     } catch (err) {
       if (err?.name === 'AbortError') {
+        // Cancel the asynchronous agent jobs the run started: aborting only
+        // the manager loop left ingest subprocesses running for minutes with
+        // frozen panels.
+        await cancelActiveActivityJobs(session).catch(() => {});
         dispatchAgentEvent(session, createAgentEvent('run_cancelled', {
           origin: 'runtime',
           runId,

package/src/commands/slash.js

@@ -43,9 +43,11 @@ import {
   listDocumentUploads,
   storeAndMaybeConvertDocument,
 } from '../core/documentIntake.js';
+import { fetchRuntimeState, postRuntimeCancel, postRuntimeKill } from '../runtime/client.js';
+import { versionWithBuild } from '../core/buildInfo.js';
 
 export function printVersion(packageJson) {
-  console.log(packageJson.version);
+  console.log(versionWithBuild(packageJson));
 }
 
 const styles = {
@@ -632,6 +634,8 @@ ${helpPair('/upload convert pending', 'Convert pending', '/uploads clean', 'Clea
 ${helpPair('/wiki', 'Run wiki index', '/wiki run <args>', 'Raw wiki CLI')}
 ${helpPair('/chat', 'Chat mode', '/agent', 'Agent mode')}
 ${helpPair('/openui', 'Open web UI in browser', '', '')}
+${helpPair('/run status', 'Runtime status', '/run kill', 'Kill runtime run(s)')}
+${helpPair('/run cancel', 'Cancel active run', '', '')}
 ${helpPair('/queue', 'MCP job queue', '/queue clear', 'Clear finished')}
 ${helpPair('/queue cancel <id>', 'Cancel queued/running', '', '')}
 ${helpPair('/clear', 'Clear screen', '/exit', 'Exit')}
@@ -676,6 +680,37 @@ function rawCommandResult(command, output) {
   };
 }
 
+function formatRuntimeRunStatus(state) {
+  const status = state?.status ?? 'unknown';
+  const runId = state?.runId ? ` run=${state.runId}` : '';
+  const queued = Array.isArray(state?.controlQueue)
+    ? state.controlQueue.filter((item) => item.status === 'queued').length
+    : 0;
+  const tasks = Array.isArray(state?.workflow?.nodes)
+    ? state.workflow.nodes.filter((node) => node.type === 'task' && !['done', 'failed', 'cancelled'].includes(String(node.status))).length
+    : 0;
+  return `runtime: ${status}${runId} · queued=${queued} · activeTasks=${tasks}`;
+}
+
+function runtimeManagedItemId(context, id) {
+  const runtimeState = typeof context.runtimeState === 'function' ? context.runtimeState() : context.runtimeState;
+  const states = [runtimeState, context.session].filter(Boolean);
+  return states.some((state) =>
+    runtimeQueueMatches(state, id)
+    || runtimeWorkflowMatches(state.workflow, id));
+}
+
+function runtimeQueueMatches(state, id) {
+  return Array.isArray(state?.queue) && state.queue.some((item) => String(item.id) === String(id));
+}
+
+function runtimeWorkflowMatches(workflow, id) {
+  if (!workflow || typeof workflow !== 'object') return false;
+  const target = String(id);
+  return (Array.isArray(workflow.nodes) && workflow.nodes.some((node) => String(node.id) === target || String(node.itemId ?? node.taskId ?? '') === target))
+    || (Array.isArray(workflow.relations) && workflow.relations.some((relation) => String(relation.from) === target || String(relation.to) === target));
+}
+
 export async function handleSlashCommand(line, context) {
   const args = line.slice(1).trim().split(/\s+/).filter(Boolean);
   const [command] = args;
@@ -937,16 +972,54 @@ export async function handleSlashCommand(line, context) {
       }
       return { output: 'Usage: /mcp <status|endpoints|tools|call> [mcp]' };
     }
+    case 'run': {
+      const subcommand = args[1] ?? 'status';
+      const runtime = context.runtime ?? {};
+      const url = runtime.url;
+      if (!url) return { output: 'Runtime unavailable. Start/connect the runtime before using /run.' };
+      if (subcommand === 'status') {
+        const state = await fetchRuntimeState({ url, workspace: context.session.workspace ?? null });
+        return { output: formatRuntimeRunStatus(state) };
+      }
+      if (subcommand === 'cancel') {
+        const result = await postRuntimeCancel({ url, workspace: context.session.workspace ?? null });
+        return { output: result.cancelled ? 'Runtime cancel requested.' : `Runtime cancel skipped: ${result.reason ?? 'no active run'}` };
+      }
+      if (subcommand === 'kill') {
+        const result = await postRuntimeKill({ url, workspace: context.session.workspace ?? null, runId: args[2] ?? null });
+        return { output: `Runtime kill requested: ${result.runs ?? 0} run${result.runs === 1 ? '' : 's'}, ${result.tasks ?? 0} task${result.tasks === 1 ? '' : 's'} cancelled.` };
+      }
+      return { output: 'Usage: /run [status|cancel|kill [runId]]' };
+    }
     case 'queue': {
       const subcommand = args[1] ?? 'list';
       if (subcommand === 'list') return { output: formatQueue(context.session) };
       if (subcommand === 'clear') {
         const count = clearFinishedQueueItems(context.session);
+        // "Cleared 0" with a busy runtime is a dead end: the items the user
+        // wants gone are ACTIVE and runtime-managed — point at the commands
+        // that actually stop them.
+        const activeRuntimeItems = (context.session.jobQueue ?? [])
+          .filter((item) => item.origin === 'runtime' && !['done', 'failed', 'cancelled', 'expired'].includes(String(item.status ?? '').toLowerCase())).length;
+        const runActive = String(context.session.agentProjection?.status ?? '').toLowerCase() === 'running';
+        if (count === 0 && (activeRuntimeItems > 0 || runActive)) {
+          return {
+            output: `Cleared 0 finished queue items — ${activeRuntimeItems || 'des'} item(s) actifs sont gérés par le runtime${runActive ? ' (run en cours)' : ''}. Utilisez /run cancel (arrêt doux) ou /run kill (abort + purge complète).`,
+          };
+        }
         return { output: `Cleared ${count} finished queue item${count === 1 ? '' : 's'}.` };
       }
       if (subcommand === 'cancel') {
         const id = args[2];
         if (!id) return { output: 'Usage: /queue cancel <id>' };
+        // Runtime-managed items must be refused BEFORE the local cancel:
+        // syncRuntimeState replaces session.jobQueue with the runtime queue,
+        // so cancelQueueItem would "succeed" locally and the next SSE sync
+        // 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.' };
+        }
         const result = await cancelQueueItem(context.session, id);
         return { output: result.message };
       }

package/src/commands/slash.test.js

@@ -144,3 +144,39 @@ test('/use loads only workspaces and /config use switches wikirc profiles', asyn
     else process.env.WIKI_WORKSPACES_DIR = previousDir;
   }
 });
+
+test('/queue cancel refuses runtime-managed items instead of fake-cancelling locally', async () => {
+  // syncRuntimeState replaces session.jobQueue with the runtime queue and tags
+  // origin:'runtime' — a local cancel would be reverted by the next SSE sync,
+  // so the command must redirect the user to /run kill / /run cancel.
+  const session = {
+    jobQueue: [
+      { id: 'q-runtime-1', status: 'waiting', workspace: 'demo', tool: 'agent_execute', origin: 'runtime' },
+      { id: 'q-local-1', status: 'waiting', workspace: 'demo', server: 'production', tool: 'production_start_job' },
+    ],
+  };
+
+  const refused = await handleSlashCommand('/queue cancel q-runtime-1', {
+    packageJson: { version: 'test' },
+    session,
+  });
+  assert.match(refused.output ?? '', /runtime/i);
+  assert.match(refused.output ?? '', /\/run kill/);
+  assert.equal(session.jobQueue[0].status, 'waiting', 'runtime item must not be flipped locally');
+
+  const cancelled = await handleSlashCommand('/queue cancel q-local-1', {
+    packageJson: { version: 'test' },
+    session,
+  });
+  assert.match(cancelled.output ?? '', /Cancelled/i);
+  assert.equal(session.jobQueue[1].status, 'cancelled');
+});
+
+test('/queue cancel reports unknown ids that are not runtime-managed', async () => {
+  const session = { jobQueue: [] };
+  const result = await handleSlashCommand('/queue cancel nope', {
+    packageJson: { version: 'test' },
+    session,
+  });
+  assert.match(result.output ?? '', /Unknown queue item/i);
+});

package/src/contracts/schemas.test.js

@@ -50,7 +50,7 @@ test('agent event contract carries the unified audit identity fields', () => {
     runId: 'run-1',
     turnId: 'turn-1',
     taskId: 'task-1',
-    workspace: 'juno',
+    workspace: 'acme',
     payload: { toolCallId: 'call-1', ok: true },
   };
 
@@ -58,7 +58,7 @@ test('agent event contract carries the unified audit identity fields', () => {
 });
 
 test('run and control request contracts reject empty run input but accept explicit controls', () => {
-  assert.equal(validateContract('runRequest', { input: 'Build docs', workspace: 'juno' }).ok, true);
+  assert.equal(validateContract('runRequest', { input: 'Build docs', workspace: 'acme' }).ok, true);
   assert.equal(validateContract('runRequest', { input: '' }).ok, false);
   assert.equal(validateContract('controlMessage', { action: 'message', input: 'Ou en est le build ?', intent: 'observe' }).ok, true);
 });

package/src/core/activity.js

@@ -251,6 +251,10 @@ export function terminalFailures(activities) {
   );
 }
 
+export function isCancelledStatus(status) {
+  return ['cancelled', 'canceled'].includes(String(status ?? '').toLowerCase());
+}
+
 export function formatActivityError(source, action, err) {
   const message = err instanceof Error ? err.message : String(err);
   const lines = message

package/src/core/activity.test.js

@@ -1,6 +1,6 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
-import { normalizeActivity, extractActivity, rememberActivity, rememberActivityFromPayload } from './activity.js';
+import { normalizeActivity, extractActivity, isCancelledStatus, rememberActivity, rememberActivityFromPayload } from './activity.js';
 
 test('normalizeActivity: plan.steps preserved with id and label', () => {
   const a = normalizeActivity({
@@ -29,6 +29,14 @@ test('normalizeActivity: plan null when no plan field', () => {
   assert.equal(a.plan, null);
 });
 
+test('isCancelledStatus recognizes both cancellation spellings', () => {
+  assert.equal(isCancelledStatus('cancelled'), true);
+  assert.equal(isCancelledStatus('canceled'), true);
+  assert.equal(isCancelledStatus('CANCELLED'), true);
+  assert.equal(isCancelledStatus('failed'), false);
+  assert.equal(isCancelledStatus(null), false);
+});
+
 test('normalizeActivity: step id falls back to 1-based index when missing', () => {
   const a = normalizeActivity({
     id: '1',