@dotdrelle/wiki-manager 0.6.34 → 0.7.3

package/src/commands/slash.test.js

@@ -5,6 +5,7 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import test from 'node:test';
 import { handleSlashCommand } from './slash.js';
+import { completionContext } from '../shell/repl.js';
 
 test('/workspace delete removes files and clears current session context after confirmation', async () => {
   const root = await mkdtemp(join(tmpdir(), 'wiki-manager-delete-workspace-'));
@@ -66,3 +67,80 @@ test('/new without a name shows usage', async () => {
 
   assert.match(result.output ?? '', /Usage/i);
 });
+
+test('/use loads only workspaces and /config use switches wikirc profiles', async () => {
+  const root = await mkdtemp(join(tmpdir(), 'wiki-manager-use-profile-'));
+  const registryRoot = join(root, 'registry');
+  const registryPath = join(registryRoot, 'demo');
+  const workspacePath = join(root, 'workspace');
+  mkdirSync(registryPath, { recursive: true });
+  mkdirSync(workspacePath, { recursive: true });
+  writeFileSync(join(registryPath, '.env'), [
+    'WORKSPACE_NAME=demo',
+    `WIKI_WORKSPACE_PATH=${workspacePath}`,
+    '',
+  ].join('\n'), 'utf8');
+  writeFileSync(join(workspacePath, '.wikirc.yaml'), [
+    'language: fr',
+    'llm:',
+    '  provider: default-provider',
+    '  model: default-model',
+    '',
+  ].join('\n'), 'utf8');
+  writeFileSync(join(workspacePath, '.wikirc.yaml.vpn'), [
+    'language: fr',
+    'llm:',
+    '  provider: vpn-provider',
+    '  model: vpn-model',
+    '',
+  ].join('\n'), 'utf8');
+
+  const previousDir = process.env.WIKI_WORKSPACES_DIR;
+  process.env.WIKI_WORKSPACES_DIR = registryRoot;
+
+  try {
+    const session = {};
+    const listResult = await handleSlashCommand('/use', {
+      packageJson: { version: 'test' },
+      session,
+    });
+    assert.match(listResult.output ?? '', /Workspaces/);
+    assert.match(listResult.output ?? '', /demo\tavailable/);
+    assert.doesNotMatch(listResult.output ?? '', /vpn\t\.wikirc\.yaml\.vpn/);
+
+    const useResult = await handleSlashCommand('/use demo', {
+      packageJson: { version: 'test' },
+      session,
+    });
+
+    assert.equal(session.workspace, 'demo');
+    assert.equal(session.wikirc.profile, 'default');
+    assert.match(useResult.output ?? '', /profile: default/);
+    assert.match(useResult.output ?? '', /\* default\t\.wikirc\.yaml/);
+    assert.match(useResult.output ?? '', /vpn\t\.wikirc\.yaml\.vpn/);
+    assert.match(useResult.output ?? '', /Switch config: \/config use <profile>/);
+
+    const invalidUse = await handleSlashCommand('/use demo vpn', {
+      packageJson: { version: 'test' },
+      session,
+    });
+    assert.match(invalidUse.output ?? '', /Usage: \/use <workspace>/);
+    assert.equal(session.wikirc.profile, 'default');
+
+    const result = await handleSlashCommand('/config use vpn', {
+      packageJson: { version: 'test' },
+      session,
+    });
+    assert.equal(session.workspace, 'demo');
+    assert.equal(session.wikirc.profile, 'vpn');
+    assert.match(result.output ?? '', /profile=vpn/);
+
+    const completion = completionContext('/use ', { commands: ['use'] });
+    assert.deepEqual(completion?.matches, ['demo']);
+    const configCompletion = completionContext('/config use ', session);
+    assert.deepEqual(configCompletion?.matches, ['default', 'vpn']);
+  } finally {
+    if (previousDir === undefined) delete process.env.WIKI_WORKSPACES_DIR;
+    else process.env.WIKI_WORKSPACES_DIR = previousDir;
+  }
+});

package/src/core/activity.js

@@ -222,6 +222,20 @@ export function formatActivitySummary(source, action, resultText) {
   return usefulLine ? `${source}.${action}: ${usefulLine.slice(0, 120)}` : null;
 }
 
+export function activitySnapshot(session) {
+  return new Set(sessionActivities(session).map((a) => a.key));
+}
+
+export function newNonTerminalActivities(snapshotBefore, session) {
+  return sessionActivities(session).filter((a) => !snapshotBefore.has(a.key) && !a.terminal);
+}
+
+export function terminalFailures(activities) {
+  return activities.filter(
+    (a) => a.terminal && ['failed', 'error', 'cancelled', 'canceled'].includes(String(a.status).toLowerCase()),
+  );
+}
+
 export function formatActivityError(source, action, err) {
   const message = err instanceof Error ? err.message : String(err);
   const lines = message

package/src/core/agentEvents.js

@@ -7,6 +7,18 @@ const SESSION_PROJECTION_EVENTS = new Set([
   'plan_step_updated',
   'activity_upserted',
   'run_error',
+  'run_cancelled',
+  'runtime_log',
+]);
+
+// Events that can mutate state.plan in applyEvent() — only these warrant the
+// before/after plan comparison below (runtime_log fires far more often and
+// never touches the plan).
+const PLAN_MUTATING_EVENTS = new Set([
+  'run_started',
+  'plan_set',
+  'plan_step_updated',
+  'activity_upserted',
 ]);
 
 export function createAgentEvent(type, { origin = 'system', payload = {}, runId = null, turnId = null } = {}) {
@@ -23,7 +35,8 @@ export function createAgentEvent(type, { origin = 'system', payload = {}, runId
 
 export function dispatchAgentEvent(session, event) {
   const normalized = event.id && event.ts ? event : createAgentEvent(event.type, event);
-  const previousPlan = JSON.stringify(session.headlessPlan ?? null);
+  const tracksPlan = PLAN_MUTATING_EVENTS.has(normalized.type);
+  const previousPlan = tracksPlan ? JSON.stringify(session.headlessPlan ?? null) : null;
   session.agentEvents ??= [];
   session.agentEvents.push(normalized);
   session._agentProjectionState ??= createProjectionState();
@@ -31,10 +44,11 @@ export function dispatchAgentEvent(session, event) {
   session.agentProjection = publicProjection(session._agentProjectionState);
   if (SESSION_PROJECTION_EVENTS.has(normalized.type)) {
     applyAgentProjectionToSession(session, session.agentProjection);
-    if (JSON.stringify(session.headlessPlan ?? null) !== previousPlan) {
+    if (tracksPlan && JSON.stringify(session.headlessPlan ?? null) !== previousPlan) {
       session._onPlanUpdate?.();
     }
   }
+  session._onAgentEvent?.(normalized, session.agentProjection);
   return normalized;
 }
 
@@ -133,10 +147,18 @@ function applyEvent(state, event) {
     case 'run_done':
       state.status = 'done';
       return;
+    case 'run_cancelled':
+      state.status = 'cancelled';
+      state.logs.push(String(event.payload?.message ?? 'Agent run cancelled.'));
+      return;
     case 'run_error':
       state.status = 'error';
       state.logs.push(String(event.payload?.message ?? 'Agent run failed.'));
       return;
+    case 'runtime_log':
+      state.logs.push(String(event.payload?.message ?? ''));
+      state.logs = state.logs.slice(-200);
+      return;
     default:
       return;
   }

package/src/core/agentLoop.js

@@ -0,0 +1,164 @@
+import { buildAgentSystemPrompt, buildLimitedAgentResponse } from '../agent/graph.js';
+import { createAgentEvent, dispatchAgentEvent } from './agentEvents.js';
+import { activitySnapshot, newNonTerminalActivities } from './activity.js';
+import { extractHeadlessPlan, formatCompletedActivities, formatPlanStatus } from './plan.js';
+
+export function abortError(message = 'Agent run cancelled.') {
+  const err = new Error(message);
+  err.name = 'AbortError';
+  return err;
+}
+
+export function throwIfAborted(signal, message) {
+  if (signal?.aborted) throw abortError(message);
+}
+
+export async function runAgentTurn(agent, session, input, {
+  messages = [],
+  signal = null,
+} = {}) {
+  let streamedContent = '';
+  session._onStream = (delta) => { streamedContent += delta; };
+  session._onStreamReset = () => { streamedContent = ''; };
+  let result;
+  try {
+    result = await agent.invoke({ input, session, messages });
+  } finally {
+    delete session._onStream;
+    delete session._onStreamReset;
+  }
+  if (result.streamedInline) {
+    return streamedContent.trim() || buildLimitedAgentResponse({ input, session }, 'LLM stream ended without content');
+  }
+  if (result.response != null) return result.response;
+  if (result.readyToStream && session.llm?.stream) {
+    const { system, messages: streamMessages = [] } = result.streamContext ?? {};
+    let content = '';
+    for await (const delta of session.llm.stream({
+      system: system ?? buildAgentSystemPrompt({ input, session }),
+      messages: streamMessages,
+      signal,
+    })) {
+      content += delta;
+    }
+    return content.trim() || buildLimitedAgentResponse({ input, session }, 'LLM stream ended without content');
+  }
+  return buildLimitedAgentResponse({ input, session });
+}
+
+export async function runAgenticLoop(agent, session, initialInput, {
+  maxTurns,
+  timeoutMs,
+  signal = null,
+  runId = null,
+  runTurn = runAgentTurn,
+  waitForActivities,
+  planOrigin = 'llm',
+  onTurnStart = null,
+  onTurnResponse = null,
+  onAssistantMessage = null,
+  onPlanExtracted = null,
+  onPlanAlreadySet = null,
+  onComplete = null,
+  onPendingSteps = null,
+  onActivitiesStarted = null,
+  onActivitiesCompleted = null,
+  onMaxTurns = null,
+  abortMessage = 'Agent run cancelled.',
+} = {}) {
+  if (!waitForActivities) throw new Error('runAgenticLoop requires waitForActivities.');
+  const conversationHistory = [];
+  let currentInput = initialInput;
+
+  for (let turn = 1; turn <= maxTurns; turn += 1) {
+    throwIfAborted(signal, abortMessage);
+    onTurnStart?.({ turn, maxTurns });
+
+    const snapshot = activitySnapshot(session);
+    const response = await runTurn(agent, session, currentInput, {
+      messages: conversationHistory,
+      signal,
+    });
+    onTurnResponse?.({ turn, response });
+    onAssistantMessage?.({ response, runId });
+
+    conversationHistory.push(
+      { role: 'user', content: currentInput },
+      { role: 'assistant', content: response },
+    );
+
+    if (turn === 1) {
+      if (session.headlessPlan === null) {
+        const extractedPlan = extractHeadlessPlan(response);
+        if (extractedPlan) {
+          dispatchAgentEvent(session, createAgentEvent('plan_set', {
+            origin: planOrigin,
+            runId,
+            payload: { steps: extractedPlan },
+          }));
+          onPlanExtracted?.({ steps: session.headlessPlan ?? extractedPlan, fallback: true });
+        }
+      } else {
+        onPlanAlreadySet?.({ steps: session.headlessPlan });
+      }
+    }
+
+    const newPending = newNonTerminalActivities(snapshot, session);
+    if (newPending.length === 0) {
+      const pendingSteps = (session.headlessPlan ?? []).filter((step) => step.status === 'pending');
+      if (pendingSteps.length === 0) {
+        onComplete?.();
+        return { ok: true };
+      }
+      onPendingSteps?.({ pendingSteps });
+      currentInput = pendingStepsPrompt(initialInput, session.headlessPlan);
+      continue;
+    }
+
+    onActivitiesStarted?.({ activities: newPending });
+    const waitResult = await waitForActivities(session, newPending, { timeoutMs, signal });
+    if (!waitResult.ok) {
+      return {
+        ok: false,
+        timedOut: Boolean(waitResult.timedOut),
+        completed: waitResult.completed ?? [],
+        waitResult,
+      };
+    }
+
+    const completed = waitResult.completed ?? [];
+    const summary = formatCompletedActivities(completed);
+    onActivitiesCompleted?.({ completed, summary });
+    currentInput = completedActivitiesPrompt(initialInput, session.headlessPlan, summary);
+  }
+
+  onMaxTurns?.({ maxTurns });
+  return { ok: false, maxTurns: true };
+}
+
+function pendingStepsPrompt(initialInput, plan) {
+  return [
+    'Original task:',
+    initialInput,
+    '',
+    `Plan status:\n${formatPlanStatus(plan)}`,
+    '',
+    'No new background activity was started in the previous turn.',
+    'Continue the original plan. Start the next pending step only.',
+    'If required information is missing and cannot be inferred, stop with a clear blocker.',
+  ].join('\n');
+}
+
+function completedActivitiesPrompt(initialInput, plan, summary) {
+  return [
+    'Original task:',
+    initialInput,
+    '',
+    plan ? `Plan status:\n${formatPlanStatus(plan)}\n` : null,
+    'Completed activities:',
+    summary,
+    '',
+    'Continue the original plan. Start the next required step only.',
+    'If all steps are complete, provide the final summary.',
+  ].filter(Boolean).join('\n');
+}

package/src/core/agentLoop.test.js

@@ -0,0 +1,85 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { createAgentEvent, dispatchAgentEvent } from './agentEvents.js';
+import { runAgenticLoop } from './agentLoop.js';
+
+test('runAgenticLoop waits for new activities and continues with a completion summary', async () => {
+  const session = {
+    activities: {},
+    headlessPlan: null,
+  };
+  const inputs = [];
+  const callbacks = [];
+  const agent = {
+    async invoke({ input, session: turnSession }) {
+      inputs.push(input);
+      if (inputs.length === 1) {
+        dispatchAgentEvent(turnSession, createAgentEvent('activity_upserted', {
+          payload: {
+            activity: {
+              id: 'job-1',
+              source: 'production',
+              kind: 'job',
+              label: 'production job',
+              status: 'running',
+              terminal: false,
+            },
+          },
+        }));
+        return { response: 'Started production job.' };
+      }
+      return { response: 'All done.' };
+    },
+  };
+
+  const result = await runAgenticLoop(agent, session, 'Build workspace', {
+    maxTurns: 3,
+    timeoutMs: 1000,
+    waitForActivities: async (turnSession, startedActivities) => {
+      assert.equal(startedActivities.length, 1);
+      dispatchAgentEvent(turnSession, createAgentEvent('activity_upserted', {
+        payload: {
+          activity: {
+            id: 'job-1',
+            source: 'production',
+            kind: 'job',
+            label: 'production job',
+            status: 'done',
+            terminal: true,
+          },
+        },
+      }));
+      if (turnSession.headlessPlan?.[0]) turnSession.headlessPlan[0].status = 'done';
+      return { ok: true, completed: Object.values(turnSession.activities) };
+    },
+    onActivitiesStarted: ({ activities }) => callbacks.push(`started:${activities.length}`),
+    onActivitiesCompleted: ({ summary }) => callbacks.push(summary),
+  });
+
+  assert.equal(result.ok, true);
+  assert.equal(inputs.length, 2);
+  assert.match(inputs[1], /Completed activities:/);
+  assert.match(inputs[1], /production job-1: done/);
+  assert.deepEqual(callbacks, ['started:1', '- production job-1: done']);
+});
+
+test('runAgenticLoop extracts a fallback numbered plan from first response', async () => {
+  const session = {
+    activities: {},
+    headlessPlan: null,
+  };
+  const result = await runAgenticLoop({
+    async invoke() {
+      return { response: '1. Collect sources\n2. Build page' };
+    },
+  }, session, 'Plan task', {
+    maxTurns: 1,
+    timeoutMs: 1000,
+    waitForActivities: async () => assert.fail('No activities should be waited for.'),
+  });
+
+  assert.equal(result.ok, false);
+  assert.equal(result.maxTurns, true);
+  assert.equal(session.headlessPlan.length, 2);
+  assert.equal(session.headlessPlan[0].description, 'Collect sources');
+});

package/src/core/cacert.js

@@ -40,8 +40,7 @@ function composeOverrideContent(cacertPath, services) {
     services: serviceEntries,
   };
   return [
-    '# Generated by wiki-manager. Safe to delete.',
-    '# Rewritten when --cacert is used with a Docker Compose command.',
+    '# Generated by wiki-manager. Edit freely; delete to regenerate.',
     YAML.stringify(doc).trimEnd(),
     '',
   ].join('\n');
@@ -61,6 +60,8 @@ export function ensureCacertComposeOverride(composeFilePath, fileName = 'cacert.
   const runtimeDir = managerRuntimeDir();
   mkdirSync(runtimeDir, { recursive: true });
   const overridePath = join(runtimeDir, fileName);
-  writeFileSync(overridePath, composeOverrideContent(cacertPath, services), 'utf8');
+  if (!existsSync(overridePath)) {
+    writeFileSync(overridePath, composeOverrideContent(cacertPath, services), 'utf8');
+  }
   return (_cacertOverrideCache = overridePath);
 }

package/src/core/compose.js

@@ -9,7 +9,7 @@ import { managerRoot } from './workspaces.js';
 
 const execFileAsync = promisify(execFile);
 
-export const COMPOSE_SERVICES = ['serve', 'mcp-http', 'production-mcp'];
+export const COMPOSE_SERVICES = ['serve', 'mcp-http', 'agent-runtime', 'production-mcp'];
 const SERVICE_DESCRIPTION_LABEL = 'wiki-manager.description';
 
 const DEFAULT_SERVICE_ALIASES = {
@@ -17,6 +17,7 @@ const DEFAULT_SERVICE_ALIASES = {
   ui: ['serve'],
   wiki: ['mcp-http'],
   mcp: ['mcp-http'],
+  runtime: ['agent-runtime'],
   production: ['production-mcp'],
 };
 
@@ -113,6 +114,7 @@ function composeEnv(session) {
     ...cacertEnv(),
     WORKSPACE_NAME: session.workspace,
     WIKI_WORKSPACE_PATH: session.workspacePath,
+    ...(session.wikirc?.fileName && { WIKI_CONFIG_PATH: session.wikirc.fileName }),
   };
 }
 
@@ -303,8 +305,7 @@ export async function runWikiCli(session, args, options = {}) {
   if (!Array.isArray(args) || args.length === 0) {
     throw new Error('Usage: /wiki run <args...>');
   }
-  const configEnv = session.wikirc?.fileName ? ['-e', `WIKI_CONFIG_PATH=${session.wikirc.fileName}`] : [];
-  return runCompose(session, ['run', '--rm', ...configEnv, 'wiki', ...args], {
+  return runCompose(session, ['run', '--rm', 'wiki', ...args], {
     timeout: options.timeout ?? 180_000,
     maxBuffer: options.maxBuffer ?? 1024 * 1024 * 8,
     onOutput: options.onOutput,

package/src/core/dockerCompose.test.js

@@ -0,0 +1,14 @@
+import { readFile } from 'node:fs/promises';
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import YAML from 'yaml';
+
+test('agent-runtime compose command passes runtime args to the image entrypoint', async () => {
+  const raw = await readFile(new URL('../../docker-compose.yml', import.meta.url), 'utf8');
+  const compose = YAML.parse(raw);
+  const service = compose.services['agent-runtime'];
+
+  assert.equal(service.image, 'dotdrelle/llm-wiki-manager:latest');
+  assert.equal(service.command, 'runtime --host 0.0.0.0 --port 7788 --state-dir /state');
+  assert.ok(!service.command.startsWith('wiki-manager '));
+});

package/src/core/documentIntake.test.js

@@ -16,16 +16,16 @@ test('document intake stores uploads without requiring documents MCP', async ()
   const source = path.join(root, 'rapport.pdf');
   await writeFile(source, 'fake pdf content');
   const session = {
-    workspace: 'juno',
+    workspace: 'my-project',
     mcp: {},
   };
 
   try {
     const { record, converted } = await storeAndMaybeConvertDocument(session, source);
     assert.equal(converted, false);
-    assert.equal(record.workspace, 'juno');
+    assert.equal(record.workspace, 'my-project');
     assert.equal(record.status, 'stored');
-    assert.equal(record.agentPath.startsWith('/documents/input/juno/'), true);
+    assert.equal(record.agentPath.startsWith('/documents/input/my-project/'), true);
     assert.equal(await readFile(record.storedPath, 'utf8'), 'fake pdf content');
 
     const uploads = await listDocumentUploads(session);
@@ -45,7 +45,7 @@ test('document intake accepts quoted absolute paths with spaces', async () => {
   const source = path.join(root, 'Screenshot 2026-06-21 at 10.03.36.png');
   await writeFile(source, 'fake png content');
   const session = {
-    workspace: 'juno',
+    workspace: 'my-project',
     mcp: {},
   };
 
@@ -66,7 +66,7 @@ test('document intake accepts double-quoted absolute paths with spaces', async (
   const source = path.join(root, 'scan avec espace.pdf');
   await writeFile(source, 'fake pdf content');
   const session = {
-    workspace: 'juno',
+    workspace: 'my-project',
     mcp: {},
   };
 
@@ -87,7 +87,7 @@ test('document intake replaces an existing upload with the same original filenam
   process.env.AGENTS_DATA_DIR = agentsDataDir;
   const source = path.join(root, 'rapport.pdf');
   const session = {
-    workspace: 'juno',
+    workspace: 'my-project',
     mcp: {},
   };
 
@@ -98,7 +98,7 @@ test('document intake replaces an existing upload with the same original filenam
     await mkdir(path.dirname(outputPath), { recursive: true });
     await writeFile(outputPath, 'old markdown');
 
-    const manifest = path.join(agentsDataDir, 'documents', 'uploads', 'juno.jsonl');
+    const manifest = path.join(agentsDataDir, 'documents', 'uploads', 'my-project.jsonl');
     const firstRecord = JSON.parse(await readFile(manifest, 'utf8'));
     await writeFile(manifest, `${JSON.stringify({ ...firstRecord, outputPath })}\n`, 'utf8');
 

package/src/core/env.js

@@ -15,6 +15,12 @@ export function managerRuntimeDir() {
   return join(managerStateDir(), '.wiki-manager');
 }
 
+export function defaultRuntimeStateDir() {
+  return process.env.WIKI_MANAGER_STATE_DIR
+    ? resolve(process.env.WIKI_MANAGER_STATE_DIR)
+    : managerRuntimeDir();
+}
+
 export function managerEnvFile() {
   return process.env.WIKI_MANAGER_ENV_FILE
     ? resolve(process.env.WIKI_MANAGER_ENV_FILE)

package/src/core/jobQueue.js

@@ -1,6 +1,7 @@
 import { extractActivity, parseJsonText, sessionActivities } from './activity.js';
 import { createAgentEvent, dispatchAgentEvent } from './agentEvents.js';
 import { callMcpTool, formatMcpToolResult } from './mcp.js';
+import { queueStoreFor } from './queueStore.js';
 
 const TERMINAL = new Set(['done', 'failed', 'cancelled', 'canceled', 'complete', 'completed', 'success', 'error']);
 
@@ -8,6 +9,10 @@ function now() {
   return new Date().toISOString();
 }
 
+function notifyQueueUpdate(session) {
+  queueStoreFor(session).changed();
+}
+
 function shortId() {
   return `q-${Math.random().toString(16).slice(2, 6)}`;
 }
@@ -17,8 +22,7 @@ function terminalStatus(status) {
 }
 
 export function ensureJobQueue(session) {
-  session.jobQueue ??= [];
-  return session.jobQueue;
+  return queueStoreFor(session).list();
 }
 
 export function productionLockBusy(session) {
@@ -41,6 +45,7 @@ export function enqueueProductionJob(session, args = {}, reason = 'waiting') {
     createdAt: now(),
   };
   ensureJobQueue(session).push(item);
+  notifyQueueUpdate(session);
   return item;
 }
 
@@ -85,10 +90,11 @@ export function formatQueue(session) {
 export function clearFinishedQueueItems(session) {
   const queue = ensureJobQueue(session);
   const before = queue.length;
-  session.jobQueue = queue.filter((item) =>
+  const next = queue.filter((item) =>
     item.workspace !== session.workspace || !terminalStatus(item.status),
   );
-  return before - session.jobQueue.length;
+  queueStoreFor(session).replace(next);
+  return before - next.length;
 }
 
 function findQueueItem(session, id) {
@@ -102,6 +108,7 @@ export async function cancelQueueItem(session, id) {
     const label = item.status === 'starting' ? 'starting' : 'queued';
     item.status = 'cancelled';
     item.finishedAt = now();
+    notifyQueueUpdate(session);
     return { ok: true, message: `Cancelled ${label} job ${id}.` };
   }
   if (item.status === 'running') {
@@ -109,6 +116,7 @@ export async function cancelQueueItem(session, id) {
       await callMcpTool(session.mcp, 'production', 'production_cancel_job', { jobId: item.jobId });
       item.status = 'cancelled';
       item.finishedAt = now();
+      notifyQueueUpdate(session);
       return { ok: true, message: `Cancellation requested for ${id} (${item.jobId}).` };
     }
     return { ok: false, message: `No cancel tool available for ${id}.` };
@@ -140,6 +148,7 @@ export async function startNextQueuedJob(session, hooks = {}) {
 
   item.status = 'starting';
   item.startedAt = now();
+  notifyQueueUpdate(session);
   hooks.refresh?.();
   hooks.addLog?.(`queue: starting ${item.id} ${queueSummary(item.args)}`);
 
@@ -154,6 +163,7 @@ export async function startNextQueuedJob(session, hooks = {}) {
     if (payload?.ok === false && payload?.error === 'workspace_busy') {
       item.status = 'waiting';
       item.reason = 'workspace_busy';
+      notifyQueueUpdate(session);
       hooks.addLog?.(`queue: ${item.id} still waiting, production lock busy`);
       hooks.refresh?.();
       return item;
@@ -164,6 +174,7 @@ export async function startNextQueuedJob(session, hooks = {}) {
       item.jobId = activity.id;
       item.activityKey = activity.key;
       item.finishedAt = activity.terminal ? now() : undefined;
+      notifyQueueUpdate(session);
       dispatchAgentEvent(session, createAgentEvent('activity_upserted', {
         origin: 'queue',
         payload: { activity },
@@ -171,6 +182,7 @@ export async function startNextQueuedJob(session, hooks = {}) {
     } else {
       item.status = 'done';
       item.finishedAt = now();
+      notifyQueueUpdate(session);
     }
     hooks.addLog?.(`queue: ${item.id} ${item.status}${item.jobId ? ` job=${item.jobId}` : ''}`);
     hooks.refresh?.();
@@ -179,6 +191,7 @@ export async function startNextQueuedJob(session, hooks = {}) {
     item.status = 'failed';
     item.error = err instanceof Error ? err.message : String(err);
     item.finishedAt = now();
+    notifyQueueUpdate(session);
     hooks.addLog?.(`queue: ${item.id} failed · ${item.error}`);
     hooks.refresh?.();
     return item;
@@ -193,5 +206,6 @@ export function syncQueueWithActivity(session, activity) {
   item.activityKey = activity.key;
   item.finishedAt = activity.terminal ? now() : item.finishedAt;
   item.error = activity.error ?? item.error;
+  notifyQueueUpdate(session);
   return item;
 }

package/src/core/mcp.js

@@ -211,7 +211,7 @@ async function mcpRequest(endpoint, method, params, signal, options = {}) {
           params: {
             protocolVersion: '2025-06-18',
             capabilities: {},
-            clientInfo: { name: 'wiki-manager', version: '0.6.34' },
+            clientInfo: { name: 'wiki-manager', version: '0.7.3' },
           },
         }),
       });