@dotdrelle/wiki-manager 0.7.3 → 0.8.2

package/src/core/agentEvents.test.js

@@ -22,7 +22,9 @@ test('reduceAgentEvents: run_started clears stale plan', () => {
     }),
     createAgentEvent('run_started', { origin: 'user' }),
   ]);
-  assert.equal(projection.plan, null);
+  assert.equal(projection.plan.length, 3);
+  assert.equal(projection.plan[0].description, 'Analyze the request');
+  assert.equal(projection.plan[0].owner, 'orchestrator');
   assert.equal(projection.activities.length, 0);
   assert.equal(projection.status, 'running');
 });
@@ -67,7 +69,7 @@ test('reduceAgentEvents: activity with plan creates visible plan and progress',
   assert.equal(projection.plan[1].status, 'pending');
 });
 
-test('reduceAgentEvents: real activity replaces minimal MCP plan', () => {
+test('reduceAgentEvents: activity attaches to orchestrator plan without replacing it', () => {
   const projection = reduceAgentEvents([
     createAgentEvent('plan_set', {
       origin: 'tool',
@@ -87,8 +89,147 @@ test('reduceAgentEvents: real activity replaces minimal MCP plan', () => {
     }),
   ]);
   assert.equal(projection.plan.length, 1);
-  assert.equal(projection.plan[0].description, 'CME export');
-  assert.equal(projection.plan[0]._activityKey, 'cme:export-1');
+  assert.equal(projection.plan[0].description, 'cme.cme_export_run');
+  assert.equal(projection.plan[0].owner, 'orchestrator');
+  assert.equal(projection.plan[0].activityKey, 'cme:export-1');
+  assert.equal(projection.plan[0].ownerActivityKey, 'cme:export-1');
+});
+
+test('reduceAgentEvents: run activity attaches to execution step of default plan', () => {
+  const projection = reduceAgentEvents([
+    createAgentEvent('run_started', { origin: 'runtime' }),
+    createAgentEvent('activity_upserted', {
+      origin: 'tool',
+      payload: {
+        activity: {
+          key: 'production:build-1',
+          id: 'build-1',
+          source: 'production',
+          label: 'Production build',
+          status: 'running',
+        },
+      },
+    }),
+  ]);
+
+  assert.equal(projection.plan[0].status, 'done');
+  assert.equal(projection.plan[1].status, 'running');
+  assert.equal(projection.plan[1].activityKey, 'production:build-1');
+  assert.equal(projection.plan[2].status, 'pending');
+});
+
+test('reduceAgentEvents: run_done finalizes running and pending plan steps', () => {
+  const projection = reduceAgentEvents([
+    createAgentEvent('run_started', { origin: 'runtime' }),
+    createAgentEvent('run_done', { origin: 'runtime' }),
+  ]);
+
+  assert.deepEqual(projection.plan.map((step) => step.status), ['done', 'done', 'done']);
+  assert.equal(projection.status, 'done');
+});
+
+test('dispatchAgentEvent: run_done finalizes session plan', () => {
+  const session = {};
+  dispatchAgentEvent(session, createAgentEvent('run_started', { origin: 'runtime' }));
+  dispatchAgentEvent(session, createAgentEvent('run_done', { origin: 'runtime' }));
+
+  assert.deepEqual(session.headlessPlan.map((step) => step.status), ['done', 'done', 'done']);
+  assert.equal(session.agentProjection.status, 'done');
+});
+
+test('reduceAgentEvents: run_evaluated exposes evaluator verdict', () => {
+  const projection = reduceAgentEvents([
+    createAgentEvent('run_started', { origin: 'runtime', runId: 'run-1' }),
+    createAgentEvent('run_evaluated', {
+      origin: 'runtime',
+      runId: 'run-1',
+      payload: {
+        ok: false,
+        reason: 'Missing export.',
+        suggestedAction: 'Run export step.',
+      },
+    }),
+  ]);
+
+  assert.deepEqual(projection.evaluation, {
+    ok: false,
+    reason: 'Missing export.',
+    suggestedAction: 'Run export step.',
+    runId: 'run-1',
+  });
+  assert.equal(projection.status, 'running');
+});
+
+test('reduceAgentEvents: run_replanned records replan trace', () => {
+  const projection = reduceAgentEvents([
+    createAgentEvent('run_started', { origin: 'runtime', runId: 'run-1' }),
+    createAgentEvent('run_replanned', {
+      origin: 'runtime',
+      runId: 'run-1',
+      payload: {
+        reason: 'Export file missing.',
+        plan: ['Run export again'],
+        replansLeft: 1,
+      },
+    }),
+  ]);
+
+  assert.deepEqual(projection.replans, [{
+    reason: 'Export file missing.',
+    plan: ['Run export again'],
+    replansLeft: 1,
+    runId: 'run-1',
+  }]);
+});
+
+test('reduceAgentEvents: approvals move from pending to approved', () => {
+  const projection = reduceAgentEvents([
+    createAgentEvent('run_pending_approval', {
+      origin: 'runtime',
+      runId: 'run-1',
+      payload: {
+        approvalId: 'approval-1',
+        runId: 'run-1',
+        reason: 'Approve plan.',
+        plan: ['Build'],
+      },
+    }),
+    createAgentEvent('run_approved', {
+      origin: 'runtime',
+      runId: 'run-1',
+      payload: {
+        approvalId: 'approval-1',
+        runId: 'run-1',
+      },
+    }),
+  ]);
+
+  assert.equal(projection.approvals.length, 1);
+  assert.equal(projection.approvals[0].status, 'approved');
+  assert.equal(projection.approvals[0].scope, 'run');
+  assert.deepEqual(projection.approvals[0].plan, ['Build']);
+});
+
+test('reduceAgentEvents: activity-owned plan is used when no orchestrator plan exists', () => {
+  const projection = reduceAgentEvents([
+    createAgentEvent('activity_upserted', {
+      origin: 'tool',
+      payload: {
+        activity: {
+          key: 'production:job-1',
+          id: 'job-1',
+          source: 'production',
+          label: 'Production build',
+          status: 'running',
+        },
+      },
+    }),
+  ]);
+
+  assert.equal(projection.plan.length, 1);
+  assert.equal(projection.plan[0].description, 'Production build');
+  assert.equal(projection.plan[0].owner, 'activity');
+  assert.equal(projection.plan[0].ownerActivityKey, 'production:job-1');
 });
 
 test('dispatchAgentEvent: writes compatibility projections to session', () => {

package/src/core/agentLoop.js

@@ -72,6 +72,9 @@ export async function runAgenticLoop(agent, session, initialInput, {
 
   for (let turn = 1; turn <= maxTurns; turn += 1) {
     throwIfAborted(signal, abortMessage);
+    if (session._currentRunIdentity && runId) {
+      session._currentRunIdentity.turnId = `${runId}:turn-${turn}`;
+    }
     onTurnStart?.({ turn, maxTurns });
 
     const snapshot = activitySnapshot(session);

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', 'agent-runtime', 'production-mcp'];
+export const COMPOSE_SERVICES = ['serve', 'mcp-http', 'production-mcp'];
 const SERVICE_DESCRIPTION_LABEL = 'wiki-manager.description';
 
 const DEFAULT_SERVICE_ALIASES = {
@@ -17,7 +17,6 @@ const DEFAULT_SERVICE_ALIASES = {
   ui: ['serve'],
   wiki: ['mcp-http'],
   mcp: ['mcp-http'],
-  runtime: ['agent-runtime'],
   production: ['production-mcp'],
 };
 

package/src/core/dockerCompose.test.js

@@ -3,12 +3,12 @@ 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 () => {
+test('workspace compose does not start a per-workspace agent runtime', 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'];
+  const aliases = compose['x-wiki-manager']['service-aliases'];
 
-  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 '));
+  assert.equal(compose.services['agent-runtime'], undefined);
+  assert.deepEqual(aliases.all.targets, ['serve', 'mcp-http', 'production-mcp']);
+  assert.equal(aliases.runtime, undefined);
 });

package/src/core/jobQueue.js

@@ -1,3 +1,4 @@
+import { randomUUID } from 'node:crypto';
 import { extractActivity, parseJsonText, sessionActivities } from './activity.js';
 import { createAgentEvent, dispatchAgentEvent } from './agentEvents.js';
 import { callMcpTool, formatMcpToolResult } from './mcp.js';
@@ -14,7 +15,7 @@ function notifyQueueUpdate(session) {
 }
 
 function shortId() {
-  return `q-${Math.random().toString(16).slice(2, 6)}`;
+  return `q-${randomUUID()}`;
 }
 
 function terminalStatus(status) {
@@ -61,17 +62,33 @@ export function queueSummary(args = {}) {
 }
 
 export function queueCounts(session) {
-  let active = 0;
-  let current = 0;
-  let frozen = 0;
-  for (const item of ensureJobQueue(session)) {
-    if (['waiting', 'starting', 'running'].includes(item.status)) {
-      active += 1;
-      if (item.workspace === session.workspace) current += 1;
-      else frozen += 1;
-    }
-  }
-  return { active, current, frozen };
+  const queue = projectQueue(session.headlessPlan, ensureJobQueue(session), { workspace: session.workspace ?? null });
+  return {
+    active: queue.length,
+    current: queue.filter((item) => item.workspace === session.workspace || !item.workspace).length,
+    frozen: queue.filter((item) => item.workspace && item.workspace !== session.workspace).length,
+  };
+}
+
+export function projectQueue(plan, queue, { workspace = null } = {}) {
+  const blockedJobs = (queue ?? [])
+    .filter((item) => ['waiting', 'blocked', 'pending_approval'].includes(String(item.status ?? '').toLowerCase()))
+    .map((item) => ({
+      ...item,
+      queueType: 'blocked_job',
+    }));
+  const pendingSteps = (plan ?? [])
+    .filter((step) => step.status === 'pending')
+    .map((step) => ({
+      id: `plan-${step.step}`,
+      queueType: 'pending_step',
+      status: 'pending',
+      workspace,
+      step: step.step,
+      activityKey: step.activityKey ?? step.ownerActivityKey ?? undefined,
+      args: { type: step.description },
+    }));
+  return [...blockedJobs, ...pendingSteps];
 }
 
 export function formatQueue(session) {

package/src/core/mcp.js

@@ -70,11 +70,28 @@ function endpointStatus(configured, detail = '') {
   };
 }
 
+function approvalToolsFor(serverName) {
+  const raw = envValue('WIKI_MANAGER_REQUIRE_APPROVAL_TOOLS');
+  if (!raw) return undefined;
+  const tools = String(raw)
+    .split(',')
+    .map((item) => item.trim())
+    .filter(Boolean)
+    .filter((item) => item === '*' || item.startsWith(`${serverName}.`) || !item.includes('.'))
+    .map((item) => item.startsWith(`${serverName}.`) ? item.slice(serverName.length + 1) : item);
+  return tools.length > 0 ? tools : undefined;
+}
+
 const MCP_SERVICE_MAP = {
   wiki: 'mcp-http',
   production: 'production-mcp',
 };
 
+const DEFAULT_MCP_RETRY_POLICY = {
+  maxAttempts: 2,
+  backoffMs: 500,
+};
+
 export function buildMcpStatus(session) {
   const workspaceEnv = session.workspaceEnv ?? {};
   const wikiMcpToken = session.wikircConfig?.mcp?.accessKey;
@@ -91,6 +108,7 @@ export function buildMcpStatus(session) {
       ),
       url: workspaceEnv.WIKI_MCP_PORT ? `http://127.0.0.1:${workspaceEnv.WIKI_MCP_PORT}/mcp` : null,
       token: wikiMcpToken || null,
+      requireApproval: approvalToolsFor('wiki'),
     },
     production: {
       ...endpointStatus(
@@ -100,6 +118,7 @@ export function buildMcpStatus(session) {
       url: workspaceEnv.PRODUCTION_MCP_PORT ? `http://127.0.0.1:${workspaceEnv.PRODUCTION_MCP_PORT}/mcp/` : null,
       token: workspaceEnv.PRODUCTION_MCP_AUTH_TOKEN || null,
       activeConfigPath: session.wikirc?.fileName || null,
+      requireApproval: approvalToolsFor('production'),
     },
     ...external,
   };
@@ -211,7 +230,7 @@ async function mcpRequest(endpoint, method, params, signal, options = {}) {
           params: {
             protocolVersion: '2025-06-18',
             capabilities: {},
-            clientInfo: { name: 'wiki-manager', version: '0.7.3' },
+            clientInfo: { name: 'wiki-manager', version: '0.8.2' },
           },
         }),
       });
@@ -240,7 +259,7 @@ async function mcpRequest(endpoint, method, params, signal, options = {}) {
   }
 }
 
-export async function callMcpTool(mcpStatus, serverName, toolName, args = {}, signal) {
+export async function callMcpTool(mcpStatus, serverName, toolName, args = {}, signal, options = {}) {
   const endpoint = mcpStatus?.[serverName];
   if (!endpoint) throw new Error(`Unknown MCP: ${serverName}`);
   if (endpoint.status !== 'connected') throw new Error(`MCP is not connected: ${serverName}`);
@@ -254,14 +273,17 @@ export async function callMcpTool(mcpStatus, serverName, toolName, args = {}, si
     ...(shouldInjectConfigPath ? { configPath: endpoint.activeConfigPath } : {}),
   };
   const timeoutMs = serverName === 'documents' && toolName === 'documents_convert_to_markdown' ? 600_000 : 8000;
-  const payload = await mcpRequest(endpoint, 'tools/call', {
-    name: toolName,
-    arguments: toolArgs,
-  }, signal, { timeoutMs });
-  if (payload?.result?.isError) {
-    throw new Error(formatMcpToolResult(payload.result));
-  }
-  return payload?.result ?? null;
+  const retry = resolveRetryPolicy(endpoint, toolName, options.retry);
+  return withRetry(async () => {
+    const payload = await mcpRequest(endpoint, 'tools/call', {
+      name: toolName,
+      arguments: toolArgs,
+    }, signal, { timeoutMs });
+    if (payload?.result?.isError) {
+      throw new Error(formatMcpToolResult(payload.result));
+    }
+    return payload?.result ?? null;
+  }, retry, { signal, onRetry: options.onRetry });
 }
 
 export function formatMcpToolResult(result) {
@@ -278,6 +300,94 @@ export function formatMcpToolResult(result) {
     .trim() || 'No result.';
 }
 
+let _cachedEnvRetryPolicy = null;
+function getEnvRetryPolicy() {
+  if (!_cachedEnvRetryPolicy) {
+    _cachedEnvRetryPolicy = {
+      maxAttempts: numberFromEnv('WIKI_MANAGER_MCP_RETRY_MAX_ATTEMPTS')
+        ?? numberFromEnv('WIKI_MANAGER_MCP_RETRY_ATTEMPTS')
+        ?? DEFAULT_MCP_RETRY_POLICY.maxAttempts,
+      backoffMs: numberFromEnv('WIKI_MANAGER_MCP_RETRY_BACKOFF_MS')
+        ?? DEFAULT_MCP_RETRY_POLICY.backoffMs,
+    };
+  }
+  return _cachedEnvRetryPolicy;
+}
+
+export function resolveRetryPolicy(endpoint = {}, toolName = null, override = null) {
+  const toolPolicy = toolName ? endpoint.toolRetries?.[toolName] : null;
+  return normalizeRetryPolicy(getEnvRetryPolicy(), endpoint.retry, toolPolicy, override);
+}
+
+function normalizeRetryPolicy(...policies) {
+  const merged = {};
+  for (const policy of policies) {
+    if (policy === false) {
+      merged.maxAttempts = 1;
+      continue;
+    }
+    if (!policy || typeof policy !== 'object') continue;
+    if (policy.maxAttempts != null) merged.maxAttempts = Number(policy.maxAttempts);
+    if (policy.backoffMs != null) merged.backoffMs = Number(policy.backoffMs);
+  }
+  const maxAttempts = Number.isFinite(merged.maxAttempts)
+    ? Math.max(1, Math.floor(merged.maxAttempts))
+    : DEFAULT_MCP_RETRY_POLICY.maxAttempts;
+  const backoffMs = Number.isFinite(merged.backoffMs)
+    ? Math.max(0, Math.floor(merged.backoffMs))
+    : DEFAULT_MCP_RETRY_POLICY.backoffMs;
+  return { maxAttempts, backoffMs };
+}
+
+function numberFromEnv(key) {
+  const raw = envValue(key);
+  if (raw == null || raw === '') return null;
+  const value = Number(raw);
+  return Number.isFinite(value) ? value : null;
+}
+
+async function withRetry(operation, policy, { signal = null, onRetry = null } = {}) {
+  let lastError;
+  for (let attempt = 1; attempt <= policy.maxAttempts; attempt += 1) {
+    try {
+      return await operation({ attempt });
+    } catch (err) {
+      lastError = err;
+      if (attempt >= policy.maxAttempts || signal?.aborted) throw err;
+      onRetry?.({ attempt, maxAttempts: policy.maxAttempts, error: err });
+      await retryDelay(policy.backoffMs * (2 ** (attempt - 1)), signal);
+    }
+  }
+  throw lastError;
+}
+
+function retryDelay(ms, signal) {
+  if (ms <= 0) return Promise.resolve();
+  return new Promise((resolve, reject) => {
+    let timer = null;
+    const cleanup = () => {
+      if (timer) clearTimeout(timer);
+      signal?.removeEventListener('abort', onAbort);
+    };
+    const onAbort = () => {
+      cleanup();
+      const err = new Error('Operation aborted.');
+      err.name = 'AbortError';
+      reject(err);
+    };
+    timer = setTimeout(() => {
+      cleanup();
+      resolve();
+    }, ms);
+    if (!signal) return;
+    if (signal.aborted) {
+      onAbort();
+      return;
+    }
+    signal.addEventListener('abort', onAbort, { once: true });
+  });
+}
+
 export async function discoverMcpTools(mcpStatus) {
   const next = {};
   await Promise.all(Object.entries(mcpStatus ?? {}).map(async ([name, value]) => {

package/src/core/mcp.test.js

@@ -3,7 +3,7 @@ import assert from 'node:assert/strict';
 import { mkdtemp, writeFile } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
-import { buildMcpStatus, callMcpTool, discoverMcpTools } from './mcp.js';
+import { buildMcpStatus, callMcpTool, discoverMcpTools, resolveRetryPolicy } from './mcp.js';
 
 test('buildMcpStatus reads external MCP endpoints from mcp.endpoints.json', async () => {
   const originalCwd = process.cwd();
@@ -163,6 +163,29 @@ test('buildMcpStatus uses active wikirc mcp.accessKey for wiki MCP', () => {
   assert.equal(status.wiki.token, 'wikirc-wiki-token');
 });
 
+test('buildMcpStatus applies internal tool approval policy from env', () => {
+  const original = process.env.WIKI_MANAGER_REQUIRE_APPROVAL_TOOLS;
+  process.env.WIKI_MANAGER_REQUIRE_APPROVAL_TOOLS = 'production.production_start_job,wiki.wiki_search';
+  try {
+    const status = buildMcpStatus({
+      workspaceEnv: {
+        PRODUCTION_MCP_PORT: '3102',
+        PRODUCTION_MCP_AUTH_TOKEN: 'production-token',
+        WIKI_MCP_PORT: '3101',
+      },
+      wikircConfig: {
+        mcp: { accessKey: 'wiki-token' },
+      },
+    });
+
+    assert.deepEqual(status.production.requireApproval, ['production_start_job']);
+    assert.deepEqual(status.wiki.requireApproval, ['wiki_search']);
+  } finally {
+    if (original === undefined) delete process.env.WIKI_MANAGER_REQUIRE_APPROVAL_TOOLS;
+    else process.env.WIKI_MANAGER_REQUIRE_APPROVAL_TOOLS = original;
+  }
+});
+
 test('callMcpTool injects active configPath for production_start_job', async () => {
   const originalFetch = globalThis.fetch;
   let requestBody = null;
@@ -269,6 +292,103 @@ test('callMcpTool sends configured endpoint headers', async () => {
   }
 });
 
+test('callMcpTool retries transient MCP failures', async () => {
+  const originalFetch = globalThis.fetch;
+  let attempts = 0;
+  const retries = [];
+  globalThis.fetch = async () => {
+    attempts += 1;
+    if (attempts === 1) {
+      return {
+        ok: false,
+        status: 503,
+        headers: { get: () => null },
+        text: async () => 'temporarily unavailable',
+      };
+    }
+    return {
+      ok: true,
+      status: 200,
+      headers: { get: () => null },
+      text: async () => JSON.stringify({ result: { content: [{ type: 'text', text: '{"ok":true}' }] } }),
+    };
+  };
+
+  try {
+    const result = await callMcpTool(
+      {
+        production: {
+          status: 'connected',
+          url: 'http://127.0.0.1:3000/mcp/',
+          retry: { maxAttempts: 2, backoffMs: 0 },
+        },
+      },
+      'production',
+      'production_start_job',
+      { type: 'doctor' },
+      null,
+      { onRetry: (event) => retries.push(event) },
+    );
+
+    assert.equal(attempts, 2);
+    assert.equal(retries.length, 1);
+    assert.match(retries[0].error.message, /503/);
+    assert.equal(result.content[0].text, '{"ok":true}');
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test('callMcpTool retries tool result errors', async () => {
+  const originalFetch = globalThis.fetch;
+  let attempts = 0;
+  globalThis.fetch = async () => {
+    attempts += 1;
+    return {
+      ok: true,
+      status: 200,
+      headers: { get: () => null },
+      text: async () => JSON.stringify({
+        result: attempts === 1
+          ? { isError: true, content: [{ type: 'text', text: 'rate limited' }] }
+          : { content: [{ type: 'text', text: '{"ok":true}' }] },
+      }),
+    };
+  };
+
+  try {
+    const result = await callMcpTool(
+      {
+        production: {
+          status: 'connected',
+          url: 'http://127.0.0.1:3000/mcp/',
+        },
+      },
+      'production',
+      'production_start_job',
+      { type: 'doctor' },
+      null,
+      { retry: { maxAttempts: 2, backoffMs: 0 } },
+    );
+
+    assert.equal(attempts, 2);
+    assert.equal(result.content[0].text, '{"ok":true}');
+  } finally {
+    globalThis.fetch = originalFetch;
+  }
+});
+
+test('resolveRetryPolicy supports endpoint and tool overrides', () => {
+  const policy = resolveRetryPolicy({
+    retry: { maxAttempts: 2, backoffMs: 100 },
+    toolRetries: {
+      production_start_job: { maxAttempts: 4 },
+    },
+  }, 'production_start_job');
+
+  assert.deepEqual(policy, { maxAttempts: 4, backoffMs: 100 });
+});
+
 test('discoverMcpTools downgrades connected endpoint when tool discovery fails', async () => {
   const originalFetch = globalThis.fetch;
   globalThis.fetch = async () => ({

package/src/core/plan.js

@@ -1,6 +1,11 @@
 export function ensurePlanFromActivity(session, activity) {
   if (!activity) return;
   const actKey = activity.key ?? null;
+  if (session.headlessPlan?.some((step) => step.owner === 'orchestrator')) {
+    attachActivityToExistingPlan(session.headlessPlan, activity);
+    session._onPlanUpdate?.();
+    return;
+  }
   // Same activity still being tracked — preserve current plan state (polling update).
   if (session.headlessPlan && actKey !== null && session.headlessPlan[0]?._activityKey === actKey) return;
   const steps = activity.plan?.steps;
@@ -10,6 +15,8 @@ export function ensurePlanFromActivity(session, activity) {
       id: s.id ?? null,
       description: s.label,
       status: 'pending',
+      owner: 'activity',
+      ownerActivityKey: activity.key,
       _activityKey: activity.key,
     }));
   } else {
@@ -18,6 +25,8 @@ export function ensurePlanFromActivity(session, activity) {
       id: null,
       description: activity.label,
       status: 'pending',
+      owner: 'activity',
+      ownerActivityKey: activity.key,
       _activityKey: activity.key,
     }];
   }
@@ -179,3 +188,27 @@ function statusRank(status) {
   if (status === 'done') return 2;
   return 3;
 }
+
+export function attachActivityToExistingPlan(plan, activity) {
+  const actKey = activity.key ?? activity.id ?? activity.jobId ?? null;
+  if (!actKey) return;
+  const matched = plan.find((step) => step.activityKey === actKey)
+    ?? plan.find((step) => step.ownerActivityKey === actKey)
+    ?? plan.find((step) => step.status === 'pending')
+    ?? plan.find((step) => step.status === 'running');
+  if (!matched) return;
+  matched.activityKey = actKey;
+  if (!matched.ownerActivityKey) matched.ownerActivityKey = actKey;
+  const failed = ['failed', 'error', 'cancelled', 'canceled'].includes(String(activity.status).toLowerCase());
+  if (activity.terminal) {
+    matched.status = failed ? 'failed' : 'done';
+    return;
+  }
+  if (!failed) {
+    for (const step of plan) {
+      if (step.status === 'failed') continue;
+      if (step.step < matched.step) step.status = 'done';
+      else if (step.step === matched.step) step.status = 'running';
+    }
+  }
+}

package/src/core/queueStore.test.js

@@ -25,6 +25,7 @@ test('job queue uses an injected queue store', () => {
   const item = enqueueProductionJob(session, { type: 'build' }, 'workspace_busy');
 
   assert.equal(item.workspace, 'docs');
+  assert.match(item.id, /^q-[0-9a-f-]{36}$/);
   assert.equal(queue.length, 1);
   assert.equal(ensureJobQueue(session), queue);
   assert.equal(changed, 1);