@dotdrelle/wiki-manager 0.7.3 → 0.9.3

package/src/core/agentEvents.js

@@ -1,11 +1,20 @@
 import { normalizeActivity } from './activity.js';
-import { syncActivitiesToPlan } from './plan.js';
+import { attachActivityToExistingPlan, syncActivitiesToPlan } from './plan.js';
 
 const SESSION_PROJECTION_EVENTS = new Set([
   'run_started',
   'plan_set',
   'plan_step_updated',
   'activity_upserted',
+  'run_evaluated',
+  'run_replanned',
+  'run_pending_approval',
+  'run_approved',
+  'tool_pending_approval',
+  'tool_approved',
+  'control_enqueued',
+  'control_started',
+  'run_done',
   'run_error',
   'run_cancelled',
   'runtime_log',
@@ -19,9 +28,16 @@ const PLAN_MUTATING_EVENTS = new Set([
   'plan_set',
   'plan_step_updated',
   'activity_upserted',
+  'run_done',
 ]);
 
-export function createAgentEvent(type, { origin = 'system', payload = {}, runId = null, turnId = null } = {}) {
+export function createAgentEvent(type, {
+  origin = 'system',
+  payload = {},
+  runId = null,
+  turnId = null,
+  workspace = null,
+} = {}) {
   return {
     id: `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`,
     ts: new Date().toISOString(),
@@ -29,12 +45,16 @@ export function createAgentEvent(type, { origin = 'system', payload = {}, runId
     origin,
     runId,
     turnId,
+    workspace,
     payload,
   };
 }
 
 export function dispatchAgentEvent(session, event) {
-  const normalized = event.id && event.ts ? event : createAgentEvent(event.type, event);
+  const normalized = withSessionRunIdentity(
+    event.id && event.ts ? event : createAgentEvent(event.type, event),
+    session,
+  );
   const tracksPlan = PLAN_MUTATING_EVENTS.has(normalized.type);
   const previousPlan = tracksPlan ? JSON.stringify(session.headlessPlan ?? null) : null;
   session.agentEvents ??= [];
@@ -52,6 +72,17 @@ export function dispatchAgentEvent(session, event) {
   return normalized;
 }
 
+function withSessionRunIdentity(event, session) {
+  const identity = session?._currentRunIdentity;
+  if (!identity) return event;
+  return {
+    ...event,
+    runId: event.runId ?? identity.runId ?? null,
+    turnId: event.turnId ?? identity.turnId ?? null,
+    workspace: event.workspace ?? identity.workspace ?? null,
+  };
+}
+
 export function reduceAgentEvents(events = []) {
   const state = createProjectionState();
 
@@ -69,6 +100,10 @@ function createProjectionState() {
     plan: null,
     activities: {},
     logs: [],
+    evaluation: null,
+    replans: [],
+    approvals: [],
+    controlQueue: [],
     summary: null,
     status: 'idle',
   };
@@ -81,6 +116,10 @@ function publicProjection(state) {
     plan: state.plan ? state.plan.map((step) => ({ ...step })) : null,
     activities: sortedActivities(state.activities).map((activity) => ({ ...activity })),
     logs: [...state.logs],
+    evaluation: state.evaluation ? { ...state.evaluation } : null,
+    replans: state.replans.map((replan) => ({ ...replan, plan: [...(replan.plan ?? [])] })),
+    approvals: state.approvals.map((approval) => ({ ...approval })),
+    controlQueue: state.controlQueue.map((item) => ({ ...item })),
     summary: state.summary,
     status: state.status,
   };
@@ -89,6 +128,7 @@ function publicProjection(state) {
 export function applyAgentProjectionToSession(session, projection) {
   session.headlessPlan = projection.plan ? projection.plan.map((step) => ({ ...step })) : null;
   session.activities = Object.fromEntries((projection.activities ?? []).map((activity) => [activity.key, { ...activity }]));
+  session.controlQueue = (projection.controlQueue ?? []).map((item) => ({ ...item }));
   const production = (projection.activities ?? []).filter((activity) => activity.source === 'production').at(-1);
   session.productionActivity = production ? {
     jobId: production.id,
@@ -103,10 +143,13 @@ function applyEvent(state, event) {
   switch (event.type) {
     case 'run_started':
       state.status = 'running';
-      state.plan = null;
+      state.plan = defaultRunPlan();
       state.chain = [];
       state.activities = {};
       state.logs = [];
+      state.evaluation = null;
+      state.replans = [];
+      state.approvals = [];
       state.summary = null;
       return;
     case 'user_message':
@@ -144,16 +187,80 @@ function applyEvent(state, event) {
       state.summary = String(event.payload?.content ?? '');
       if (state.summary) state.conversation.push({ role: 'assistant', content: state.summary });
       return;
+    case 'run_evaluated':
+      state.evaluation = {
+        ok: event.payload?.ok === true,
+        reason: String(event.payload?.reason ?? ''),
+        suggestedAction: event.payload?.suggestedAction ?? null,
+        runId: event.runId ?? event.payload?.runId ?? null,
+      };
+      return;
+    case 'run_replanned':
+      state.replans.push({
+        reason: String(event.payload?.reason ?? ''),
+        plan: Array.isArray(event.payload?.plan) ? event.payload.plan.map(String) : [],
+        replansLeft: Number(event.payload?.replansLeft ?? 0),
+        runId: event.runId ?? event.payload?.runId ?? null,
+      });
+      return;
+    case 'run_pending_approval':
+    case 'tool_pending_approval':
+      upsertApproval(state, {
+        id: event.payload?.approvalId ?? event.payload?.runId ?? event.payload?.itemId ?? event.id,
+        scope: event.type === 'run_pending_approval' ? 'run' : 'tool',
+        status: 'pending_approval',
+        runId: event.runId ?? event.payload?.runId ?? null,
+        itemId: event.payload?.itemId ?? null,
+        reason: event.payload?.reason ?? null,
+        tool: event.payload?.tool ?? null,
+        plan: event.payload?.plan ?? null,
+        createdAt: event.ts,
+      });
+      return;
+    case 'run_approved':
+    case 'tool_approved':
+      upsertApproval(state, {
+        id: event.payload?.approvalId ?? event.payload?.runId ?? event.payload?.itemId ?? event.id,
+        scope: event.type === 'run_approved' ? 'run' : 'tool',
+        status: 'approved',
+        runId: event.runId ?? event.payload?.runId ?? null,
+        itemId: event.payload?.itemId ?? null,
+        approvedAt: event.ts,
+      });
+      return;
     case 'run_done':
       state.status = 'done';
+      finishPendingPlanSteps(state.plan);
+      finishControlByRun(state.controlQueue, event.runId ?? event.payload?.runId ?? null, 'done', event.ts);
       return;
     case 'run_cancelled':
       state.status = 'cancelled';
       state.logs.push(String(event.payload?.message ?? 'Agent run cancelled.'));
+      finishControlByRun(state.controlQueue, event.runId ?? event.payload?.runId ?? null, 'cancelled', event.ts);
       return;
     case 'run_error':
       state.status = 'error';
       state.logs.push(String(event.payload?.message ?? 'Agent run failed.'));
+      finishControlByRun(state.controlQueue, event.runId ?? event.payload?.runId ?? null, 'failed', event.ts);
+      return;
+    case 'control_enqueued':
+      upsertControlItem(state.controlQueue, {
+        id: event.payload?.id ?? event.id,
+        workspace: event.workspace ?? event.payload?.workspace ?? null,
+        input: String(event.payload?.input ?? ''),
+        status: 'queued',
+        createdAt: event.payload?.createdAt ?? event.ts,
+        updatedAt: event.ts,
+      });
+      return;
+    case 'control_started':
+      upsertControlItem(state.controlQueue, {
+        id: event.payload?.id ?? null,
+        runId: event.runId ?? event.payload?.runId ?? null,
+        status: 'running',
+        startedAt: event.payload?.startedAt ?? event.ts,
+        updatedAt: event.ts,
+      });
       return;
     case 'runtime_log':
       state.logs.push(String(event.payload?.message ?? ''));
@@ -164,6 +271,32 @@ function applyEvent(state, event) {
   }
 }
 
+function upsertById(list, next) {
+  const index = list.findIndex((item) => item.id === next.id);
+  if (index === -1) {
+    list.push(next);
+    return;
+  }
+  list[index] = {
+    ...list[index],
+    ...next,
+  };
+}
+
+function upsertControlItem(queue, next) {
+  if (!next.id) return;
+  upsertById(queue, next);
+}
+
+function finishControlByRun(queue, runId, status, finishedAt) {
+  if (!runId) return;
+  const item = queue.find((entry) => entry.runId === runId && entry.status === 'running');
+  if (!item) return;
+  item.status = status;
+  item.finishedAt = finishedAt;
+  item.updatedAt = finishedAt;
+}
+
 function appendAssistantDelta(state, delta) {
   if (!delta) return;
   const last = state.conversation.at(-1);
@@ -198,6 +331,18 @@ function finishToolCall(state, payload = {}) {
   if (!existing) state.chain.push(step);
 }
 
+function upsertApproval(state, next) {
+  upsertById(state.approvals, next);
+}
+
+function finishPendingPlanSteps(plan) {
+  for (const step of plan ?? []) {
+    if (step.status === 'running' || step.status === 'pending') {
+      step.status = 'done';
+    }
+  }
+}
+
 function upsertActivity(state, rawActivity) {
   const activity = normalizeActivity(rawActivity);
   if (!activity) return;
@@ -211,6 +356,10 @@ function upsertActivity(state, rawActivity) {
 
 function ensurePlanFromActivityProjection(state, activity) {
   const actKey = activity.key ?? null;
+  if (state.plan?.some((step) => step.owner === 'orchestrator')) {
+    attachActivityToExistingPlan(state.plan, activity);
+    return;
+  }
   if (state.plan && actKey !== null && state.plan[0]?._activityKey === actKey) return;
   const steps = activity.plan?.steps;
   if (Array.isArray(steps) && steps.length > 0) {
@@ -219,6 +368,8 @@ function ensurePlanFromActivityProjection(state, activity) {
       id: step.id ?? null,
       description: step.label,
       status: 'pending',
+      owner: 'activity',
+      ownerActivityKey: activity.key,
       _activityKey: activity.key,
     }));
     return;
@@ -228,12 +379,16 @@ function ensurePlanFromActivityProjection(state, activity) {
     id: null,
     description: activity.label,
     status: 'pending',
+    owner: 'activity',
+    ownerActivityKey: activity.key,
     _activityKey: activity.key,
   }];
 }
 
 function normalizePlan(steps, payload = {}) {
   if (!Array.isArray(steps)) return null;
+  const owner = payload.owner ?? 'orchestrator';
+  const ownerActivityKey = payload.ownerActivityKey ?? payload.activityKey ?? null;
   return steps.map((raw, i) => {
     const item = typeof raw === 'string' ? { description: raw } : (raw ?? {});
     return {
@@ -241,11 +396,21 @@ function normalizePlan(steps, payload = {}) {
       id: item.id ?? null,
       description: String(item.description ?? item.label ?? item.name ?? `Step ${i + 1}`),
       status: item.status ?? 'pending',
+      owner: item.owner ?? owner,
+      ownerActivityKey: item.ownerActivityKey ?? ownerActivityKey,
       _activityKey: item._activityKey ?? payload.activityKey ?? null,
     };
   });
 }
 
+function defaultRunPlan() {
+  return [
+    { step: 1, id: 'analyze', description: 'Analyze the request', status: 'running', owner: 'orchestrator', ownerActivityKey: null, _activityKey: null },
+    { step: 2, id: 'execute', description: 'Execute the required actions', status: 'pending', owner: 'orchestrator', ownerActivityKey: null, _activityKey: null },
+    { step: 3, id: 'verify', description: 'Verify the result', status: 'pending', owner: 'orchestrator', ownerActivityKey: null, _activityKey: null },
+  ];
+}
+
 function updatePlanStep(plan, payload) {
   if (!plan) return;
   const step = plan.find((item) => item.step === Number(payload.step));

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,178 @@ 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: control queue is event sourced and follows run status', () => {
+  const projection = reduceAgentEvents([
+    createAgentEvent('control_enqueued', {
+      origin: 'runtime',
+      workspace: 'docs',
+      payload: {
+        id: 'control-1',
+        workspace: 'docs',
+        input: 'Run after current task',
+        createdAt: '2026-01-01T00:00:00.000Z',
+      },
+    }),
+    createAgentEvent('control_started', {
+      origin: 'runtime',
+      runId: 'run-control-1',
+      workspace: 'docs',
+      payload: { id: 'control-1', runId: 'run-control-1' },
+    }),
+    createAgentEvent('run_done', {
+      origin: 'runtime',
+      runId: 'run-control-1',
+      workspace: 'docs',
+    }),
+  ]);
+
+  assert.equal(projection.controlQueue.length, 1);
+  assert.equal(projection.controlQueue[0].id, 'control-1');
+  assert.equal(projection.controlQueue[0].status, 'done');
+  assert.equal(projection.controlQueue[0].runId, 'run-control-1');
+});
+
+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) {