@dotdrelle/wiki-manager 0.11.9 → 0.12.0

package/src/core/agentEvents.js

@@ -1,6 +1,7 @@
 import { normalizeActivity } from './activity.js';
 import { attachActivityToExistingPlan, syncActivitiesToPlan } from './plan.js';
 import { applyPlanPatch, normalizePlanPatch, normalizePlanRevision, rebasePlanPatch } from './planPatch.js';
+import { formatRuntimeLogPayload } from './runtimeLog.js';
 import { projectWorkflow } from './workflow.js';
 import { validateContractInDev } from '../contracts/schemas.js';
 
@@ -14,6 +15,18 @@ const SESSION_PROJECTION_EVENTS = new Set([
   'plan_patch_applied',
   'plan_patch_rebased',
   'plan_patch_rejected',
+  'plan.received',
+  'plan.validated',
+  'plan.rejected',
+  'task_group.created',
+  'task.created',
+  'task.assigned',
+  'task.started',
+  'task.retry_scheduled',
+  'task.result_returned',
+  'task.completed',
+  'task.failed',
+  'plan.revision_changed',
   'activity_upserted',
   'run_evaluated',
   'run_replanned',
@@ -21,8 +34,13 @@ const SESSION_PROJECTION_EVENTS = new Set([
   'run_approved',
   'tool_pending_approval',
   'tool_approved',
+  'approval.requested',
+  'approval.granted',
+  'approval.rejected',
   'control_enqueued',
   'control_started',
+  'agent.registered',
+  'agent.health_changed',
   'run_done',
   'run_error',
   'run_cancelled',
@@ -36,6 +54,7 @@ const PLAN_MUTATING_EVENTS = new Set([
   'run_started',
   'plan_set',
   'plan_patch_applied',
+  'task.created',
   'plan_step_updated',
   'activity_upserted',
   'run_done',
@@ -120,6 +139,7 @@ function createProjectionState() {
     planRevision: 0,
     planPatches: [],
     controlQueue: [],
+    agents: {},
     summary: null,
     status: 'idle',
   };
@@ -142,6 +162,9 @@ function publicProjection(state) {
       patch: patch.patch ? { ...patch.patch, operations: (patch.patch.operations ?? []).map((operation) => ({ ...operation })) } : null,
     })),
     controlQueue: state.controlQueue.map((item) => ({ ...item })),
+    agents: Object.values(state.agents)
+      .map((agent) => ({ ...agent, description: cloneJson(agent.description) }))
+      .sort((a, b) => a.agentInstanceId.localeCompare(b.agentInstanceId)),
     summary: state.summary,
     status: state.status,
   };
@@ -155,6 +178,7 @@ 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 }));
+  session.agents = (projection.agents ?? []).map((agent) => ({ ...agent, description: cloneJson(agent.description) }));
   session.planRevision = projection.planRevision ?? 0;
   session.planPatches = (projection.planPatches ?? []).map((patch) => ({ ...patch }));
   session.workflow = projection.workflow ? { ...projection.workflow } : null;
@@ -220,6 +244,53 @@ function applyEvent(state, event) {
         ? normalizePlanRevision(event.payload.planRevision)
         : state.planRevision + 1;
       return;
+    case 'plan.received':
+      state.logs.push(`Plan received for run ${String(event.runId ?? event.payload?.runId ?? '')}`.trim());
+      state.logs = state.logs.slice(-200);
+      return;
+    case 'plan.validated':
+      state.logs.push(`Plan validated for run ${String(event.runId ?? event.payload?.runId ?? '')}`.trim());
+      state.logs = state.logs.slice(-200);
+      return;
+    case 'plan.rejected':
+      state.logs.push(`Plan rejected: ${formatPlanErrors(event.payload?.errors)}`);
+      state.logs = state.logs.slice(-200);
+      return;
+    case 'task_group.created':
+      return;
+    case 'task.created':
+      appendCreatedTask(state, event.payload?.task);
+      return;
+    case 'task.assigned':
+      state.logs.push(`Task assigned: ${String(event.taskId ?? event.payload?.taskId ?? '')}`.trim());
+      state.logs = state.logs.slice(-200);
+      return;
+    case 'task.started':
+      state.logs.push(`Task started: ${String(event.taskId ?? event.payload?.taskId ?? '')}`.trim());
+      state.logs = state.logs.slice(-200);
+      return;
+    case 'task.retry_scheduled':
+      state.logs.push(`Task retry scheduled: ${String(event.taskId ?? event.payload?.taskId ?? '')}`.trim());
+      state.logs = state.logs.slice(-200);
+      return;
+    case 'task.result_returned':
+      state.logs.push(`Task result returned: ${String(event.taskId ?? event.payload?.taskId ?? '')}`.trim());
+      state.logs = state.logs.slice(-200);
+      return;
+    case 'task.completed':
+      state.logs.push(`Task completed: ${String(event.taskId ?? event.payload?.taskId ?? '')}`.trim());
+      state.logs = state.logs.slice(-200);
+      return;
+    case 'task.failed':
+      state.logs.push(`Task failed: ${String(event.taskId ?? event.payload?.taskId ?? '')}`.trim());
+      state.logs = state.logs.slice(-200);
+      return;
+    case 'plan.revision_changed':
+      if (Array.isArray(event.payload?.tasks)) {
+        state.plan = normalizePlan(event.payload.tasks, { owner: 'orchestrator', planRevision: state.planRevision });
+      }
+      state.planRevision = normalizePlanRevision(event.payload?.planRevision ?? state.planRevision + 1);
+      return;
     case 'plan_step_updated':
       updatePlanStep(state.plan, event.payload ?? {});
       return;
@@ -346,6 +417,60 @@ function applyEvent(state, event) {
         approvedAt: event.ts,
       });
       return;
+    case 'approval.requested':
+      upsertApproval(state, {
+        id: approvalProjectionId(event),
+        approvalId: event.payload?.approvalId ?? event.payload?.id ?? null,
+        scope: event.payload?.scope ?? 'task',
+        status: 'pending_approval',
+        runId: event.runId ?? event.payload?.runId ?? null,
+        workspaceId: event.workspace ?? event.payload?.workspaceId ?? event.payload?.workspace ?? null,
+        planRevision: event.payload?.planRevision ?? null,
+        taskId: event.taskId ?? event.payload?.taskId ?? null,
+        itemId: event.payload?.itemId ?? event.payload?.taskId ?? null,
+        groupId: event.payload?.groupId ?? null,
+        approvalClasses: normalizeApprovalClasses(event.payload?.approvalClasses ?? event.payload?.approvalClass),
+        reason: event.payload?.reason ?? null,
+        createdAt: event.ts,
+      });
+      return;
+    case 'approval.granted': {
+      const grant = {
+        id: approvalProjectionId(event),
+        approvalId: event.payload?.approvalId ?? event.payload?.id ?? null,
+        scope: event.payload?.scope ?? 'run',
+        status: 'approved',
+        runId: event.runId ?? event.payload?.runId ?? null,
+        workspaceId: event.workspace ?? event.payload?.workspaceId ?? event.payload?.workspace ?? null,
+        planRevision: event.payload?.planRevision ?? null,
+        taskId: event.taskId ?? event.payload?.taskId ?? null,
+        itemId: event.payload?.itemId ?? event.payload?.taskId ?? null,
+        groupId: event.payload?.groupId ?? null,
+        approvalClasses: normalizeApprovalClasses(event.payload?.approvalClasses ?? event.payload?.approvalClass),
+        reason: event.payload?.reason ?? null,
+        approvedAt: event.ts,
+      };
+      upsertApproval(state, grant);
+      markCoveredApprovalsApproved(state.approvals, grant, event.ts);
+      return;
+    }
+    case 'approval.rejected':
+      upsertApproval(state, {
+        id: approvalProjectionId(event),
+        approvalId: event.payload?.approvalId ?? event.payload?.id ?? null,
+        scope: event.payload?.scope ?? 'run',
+        status: 'rejected',
+        runId: event.runId ?? event.payload?.runId ?? null,
+        workspaceId: event.workspace ?? event.payload?.workspaceId ?? event.payload?.workspace ?? null,
+        planRevision: event.payload?.planRevision ?? null,
+        taskId: event.taskId ?? event.payload?.taskId ?? null,
+        itemId: event.payload?.itemId ?? event.payload?.taskId ?? null,
+        groupId: event.payload?.groupId ?? null,
+        approvalClasses: normalizeApprovalClasses(event.payload?.approvalClasses ?? event.payload?.approvalClass),
+        reason: event.payload?.reason ?? null,
+        rejectedAt: event.ts,
+      });
+      return;
     case 'run_done':
       state.status = 'done';
       finishPendingPlanSteps(state.plan);
@@ -380,15 +505,36 @@ function applyEvent(state, event) {
         updatedAt: event.ts,
       });
       return;
+    case 'agent.registered':
+      upsertAgent(state, event.payload?.agent, event.ts);
+      return;
+    case 'agent.health_changed':
+      upsertAgent(state, {
+        ...(event.payload?.agent ?? {}),
+        agentInstanceId: event.payload?.agentInstanceId ?? event.payload?.agent?.agentInstanceId,
+        health: event.payload?.health ?? event.payload?.agent?.health,
+      }, event.ts);
+      return;
     case 'runtime_log':
-      state.logs.push(String(event.payload?.message ?? ''));
-      state.logs = state.logs.slice(-200);
+      state.logs.push(formatRuntimeLogPayload(event.payload ?? {}, event.ts));
       return;
     default:
       return;
   }
 }
 
+function upsertAgent(state, rawAgent, ts) {
+  if (!rawAgent?.agentInstanceId) return;
+  const existing = state.agents[rawAgent.agentInstanceId] ?? {};
+  state.agents[rawAgent.agentInstanceId] = {
+    ...existing,
+    ...rawAgent,
+    description: cloneJson(rawAgent.description ?? existing.description ?? null),
+    health: rawAgent.health ?? rawAgent.description?.health?.status ?? existing.health ?? 'unavailable',
+    lastSeenAt: rawAgent.lastSeenAt ?? ts,
+  };
+}
+
 function upsertById(list, next) {
   const index = list.findIndex((item) => item.id === next.id);
   if (index === -1) {
@@ -411,6 +557,14 @@ function upsertPlanPatch(state, next) {
   upsertById(state.planPatches, next);
 }
 
+function appendCreatedTask(state, rawTask) {
+  if (!rawTask?.id) return;
+  state.plan ??= [];
+  const existing = state.plan.find((task) => String(task.id ?? task.step) === String(rawTask.id));
+  if (existing) return;
+  state.plan.push(normalizePlanTask(rawTask, state.plan.length, { owner: 'orchestrator' }));
+}
+
 function patchIdFromEvent(event) {
   return event.payload?.id ?? event.payload?.patchId ?? event.id;
 }
@@ -462,6 +616,42 @@ function upsertApproval(state, next) {
   upsertById(state.approvals, next);
 }
 
+function approvalProjectionId(event) {
+  return event.payload?.id
+    ?? event.payload?.approvalId
+    ?? event.payload?.taskId
+    ?? event.payload?.itemId
+    ?? event.payload?.groupId
+    ?? event.payload?.runId
+    ?? event.id;
+}
+
+function normalizeApprovalClasses(value) {
+  if (value == null) return [];
+  const values = Array.isArray(value) ? value : [value];
+  return [...new Set(values.map((item) => String(item).trim()).filter(Boolean))];
+}
+
+function markCoveredApprovalsApproved(approvals, grant, ts) {
+  const classes = normalizeApprovalClasses(grant.approvalClasses);
+  for (const approval of approvals) {
+    if (approval.status !== 'pending_approval') continue;
+    if (grant.runId != null && approval.runId != null && String(grant.runId) !== String(approval.runId)) continue;
+    if (grant.workspaceId != null && approval.workspaceId != null && String(grant.workspaceId) !== String(approval.workspaceId)) continue;
+    if (grant.planRevision != null && approval.planRevision != null && Number(grant.planRevision) !== Number(approval.planRevision)) continue;
+    const approvalClasses = normalizeApprovalClasses(approval.approvalClasses);
+    if (classes.length > 0 && approvalClasses.length > 0 && !approvalClasses.some((item) => classes.includes(item))) continue;
+    if (grant.scope === 'group' && String(grant.groupId ?? '') !== String(approval.groupId ?? '')) continue;
+    if (grant.scope === 'task' || grant.scope === 'tool') {
+      const grantIds = new Set([grant.taskId, grant.itemId, grant.approvalId, grant.id].filter(Boolean).map(String));
+      const approvalIds = [approval.taskId, approval.itemId, approval.approvalId, approval.id].filter(Boolean).map(String);
+      if (!approvalIds.some((id) => grantIds.has(id))) continue;
+    }
+    approval.status = 'approved';
+    approval.approvedAt = ts;
+  }
+}
+
 function finishPendingPlanSteps(plan) {
   for (const step of plan ?? []) {
     if (step.status === 'running' || step.status === 'pending') {
@@ -524,30 +714,56 @@ function normalizePlan(steps, payload = {}) {
   if (!Array.isArray(steps)) return null;
   const owner = payload.owner ?? 'orchestrator';
   const ownerActivityKey = payload.ownerActivityKey ?? payload.activityKey ?? null;
-  const plan = steps.map((raw, i) => {
-    const item = typeof raw === 'string' ? { description: raw } : (raw ?? {});
-    return {
-      step: Number(item.step ?? i + 1),
-      id: item.id ?? null,
-      description: String(item.description ?? item.label ?? item.name ?? `Step ${i + 1}`),
-      status: item.status ?? 'pending',
-      dependsOn: Array.isArray(item.dependsOn) ? item.dependsOn.map(String) : [],
-      executor: item.executor ?? null,
-      executorQuery: item.executorQuery ?? null,
-      outputRefs: Array.isArray(item.outputRefs) ? item.outputRefs.map(String) : [],
-      locks: Array.isArray(item.locks) ? item.locks.map(String) : item.locks ?? null,
-      writeLocks: Array.isArray(item.writeLocks) ? item.writeLocks.map(String) : item.writeLocks ?? null,
-      deliverableWrites: Array.isArray(item.deliverableWrites) ? item.deliverableWrites.map(String) : [],
-      wikiPageWrites: Array.isArray(item.wikiPageWrites) ? item.wikiPageWrites.map(String) : [],
-      workspaceWrite: item.workspaceWrite === true,
-      owner: item.owner ?? owner,
-      ownerActivityKey: item.ownerActivityKey ?? ownerActivityKey,
-      _activityKey: item._activityKey ?? payload.activityKey ?? null,
-    };
-  });
+  const plan = steps.map((raw, i) => normalizePlanTask(raw, i, { owner, ownerActivityKey, activityKey: payload.activityKey ?? null }));
   return validateContractInDev('plan', plan);
 }
 
+function normalizePlanTask(raw, index, { owner = 'orchestrator', ownerActivityKey = null, activityKey = null } = {}) {
+  const item = typeof raw === 'string' ? { description: raw } : (raw ?? {});
+  const task = {
+    step: Number(item.step ?? index + 1),
+    id: item.id ?? null,
+    label: item.label ?? item.description ?? item.name ?? `Step ${index + 1}`,
+    description: String(item.description ?? item.label ?? item.name ?? `Step ${index + 1}`),
+    status: item.status ?? 'pending',
+    dependsOn: Array.isArray(item.dependsOn) ? item.dependsOn.map(String) : [],
+    requiredCapability: item.requiredCapability ?? null,
+    operation: item.operation ?? null,
+    arguments: item.arguments && typeof item.arguments === 'object' && !Array.isArray(item.arguments) ? { ...item.arguments } : {},
+    groupId: item.groupId ?? null,
+    dependsOnGroup: item.dependsOnGroup ?? null,
+    barrier: item.barrier === true,
+    parallelizable: item.parallelizable === true,
+    recommendedConcurrency: item.recommendedConcurrency,
+    inputRefs: Array.isArray(item.inputRefs) ? item.inputRefs.map(cloneRef) : [],
+    expectedOutputRefs: Array.isArray(item.expectedOutputRefs) ? item.expectedOutputRefs.map(cloneRef) : [],
+    executor: item.executor ?? null,
+    executorQuery: item.executorQuery ?? null,
+    outputRefs: Array.isArray(item.outputRefs) ? item.outputRefs.map(String) : [],
+    locks: Array.isArray(item.locks) ? item.locks.map(String) : [],
+    requiresApproval: item.requiresApproval === true,
+    approvalClass: item.approvalClass ?? null,
+    approvalSummary: item.approvalSummary ?? null,
+    idempotencyKey: item.idempotencyKey ?? null,
+    progressWeight: Number.isFinite(Number(item.progressWeight)) ? Number(item.progressWeight) : 1,
+    priority: item.priority,
+    retryPolicy: item.retryPolicy ? cloneJson(item.retryPolicy) : undefined,
+    retryState: item.retryState ? cloneJson(item.retryState) : undefined,
+    retryAssignment: item.retryAssignment ? cloneJson(item.retryAssignment) : undefined,
+    writeLocks: Array.isArray(item.writeLocks) ? item.writeLocks.map(String) : item.writeLocks ?? null,
+    deliverableWrites: Array.isArray(item.deliverableWrites) ? item.deliverableWrites.map(String) : [],
+    wikiPageWrites: Array.isArray(item.wikiPageWrites) ? item.wikiPageWrites.map(String) : [],
+    workspaceWrite: item.workspaceWrite === true,
+    owner: item.owner ?? owner,
+    ownerActivityKey: item.ownerActivityKey ?? ownerActivityKey,
+    _activityKey: item._activityKey ?? activityKey,
+  };
+  for (const key of ['recommendedConcurrency', 'priority', 'retryPolicy']) {
+    if (task[key] === undefined) delete task[key];
+  }
+  return task;
+}
+
 function updatePlanStep(plan, payload) {
   if (!plan) return;
   const requestedTaskId = payload.taskId ?? payload.id ?? payload.targetTaskId;
@@ -557,12 +773,33 @@ function updatePlanStep(plan, payload) {
   if (!step) return;
   if (payload.status === 'failed') step.status = 'failed';
   else if (payload.status === 'running') step.status = 'running';
+  else if (payload.status === 'pending') step.status = 'pending';
+  else if (payload.status === 'pending_approval') step.status = 'pending_approval';
+  else if (payload.status === 'waiting_approval') step.status = 'waiting_approval';
   else if (payload.status === 'cancelled') step.status = 'cancelled';
   else step.status = 'done';
   if (payload.activityKey) step.activityKey = payload.activityKey;
+  if (Array.isArray(payload.outputRefs)) step.outputRefs = payload.outputRefs.map(cloneRef);
+  if (payload.result) step.result = cloneJson(payload.result);
+  if (payload.retryState) step.retryState = cloneJson(payload.retryState);
+  if (payload.retryAssignment) step.retryAssignment = cloneJson(payload.retryAssignment);
+}
+
+function formatPlanErrors(errors) {
+  return Array.isArray(errors) && errors.length > 0
+    ? errors.map((error) => error.code ?? error.message ?? String(error)).join(', ')
+    : 'unknown';
+}
+
+function cloneRef(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? { ...value } : String(value);
 }
 
 function sortedActivities(activities) {
   return Object.values(activities ?? {})
     .sort((a, b) => String(a.updatedAt ?? '').localeCompare(String(b.updatedAt ?? '')));
 }
+
+function cloneJson(value) {
+  return value == null ? value : JSON.parse(JSON.stringify(value));
+}

package/src/core/agentEvents.test.js

@@ -214,6 +214,59 @@ test('reduceAgentEvents: approvals move from pending to approved', () => {
   assert.deepEqual(projection.approvals[0].plan, ['Build']);
 });
 
+test('reduceAgentEvents: bounded approval grant covers matching pending requests only', () => {
+  const projection = reduceAgentEvents([
+    createAgentEvent('approval.requested', {
+      origin: 'orchestrator',
+      runId: 'run-1',
+      workspace: 'docs',
+      taskId: 'run-1:a',
+      payload: {
+        id: 'approval-a',
+        scope: 'task',
+        runId: 'run-1',
+        workspaceId: 'docs',
+        planRevision: 2,
+        taskId: 'run-1:a',
+        approvalClasses: ['workspace-write'],
+      },
+    }),
+    createAgentEvent('approval.requested', {
+      origin: 'orchestrator',
+      runId: 'run-1',
+      workspace: 'docs',
+      taskId: 'run-1:b',
+      payload: {
+        id: 'approval-b',
+        scope: 'task',
+        runId: 'run-1',
+        workspaceId: 'docs',
+        planRevision: 2,
+        taskId: 'run-1:b',
+        approvalClasses: ['publish'],
+      },
+    }),
+    createAgentEvent('approval.granted', {
+      origin: 'runtime',
+      runId: 'run-1',
+      workspace: 'docs',
+      payload: {
+        id: 'grant-1',
+        scope: 'run',
+        runId: 'run-1',
+        workspaceId: 'docs',
+        planRevision: 2,
+        approvalClasses: ['workspace-write'],
+      },
+    }),
+  ]);
+
+  const byId = Object.fromEntries(projection.approvals.map((approval) => [approval.id, approval]));
+  assert.equal(byId['approval-a'].status, 'approved');
+  assert.equal(byId['approval-b'].status, 'pending_approval');
+  assert.equal(byId['grant-1'].status, 'approved');
+});
+
 test('reduceAgentEvents: control queue is event sourced and follows run status', () => {
   const projection = reduceAgentEvents([
     createAgentEvent('control_enqueued', {

package/src/core/compose.js

@@ -4,7 +4,7 @@ import { join } from 'node:path';
 import { promisify } from 'node:util';
 import YAML from 'yaml';
 import { cacertEnv, ensureCacertComposeOverride } from './cacert.js';
-import { managerEnvFile, readEnvFile } from './env.js';
+import { managerEnvFile, readEnvFile, resolveAgentsDataDir } from './env.js';
 import { managerRoot } from './workspaces.js';
 
 const execFileAsync = promisify(execFile);
@@ -106,11 +106,16 @@ function composeBaseArgs(session) {
 }
 
 function composeEnv(session) {
+  const uid = typeof process.getuid === 'function' ? String(process.getuid()) : (process.env.UID ?? '1000');
+  const gid = typeof process.getgid === 'function' ? String(process.getgid()) : (process.env.GID ?? '1000');
   return {
     ...process.env,
     ...readManagerEnv(),
     ...(session.workspaceEnv ?? {}),
     ...cacertEnv(),
+    UID: uid,
+    GID: gid,
+    AGENTS_DATA_DIR: resolveAgentsDataDir(session),
     WORKSPACE_NAME: session.workspace,
     WIKI_WORKSPACE_PATH: session.workspacePath,
     ...(session.wikirc?.fileName && { WIKI_CONFIG_PATH: session.wikirc.fileName }),

package/src/core/dockerCompose.test.js

@@ -12,3 +12,15 @@ test('workspace compose does not start a per-workspace agent runtime', async ()
   assert.deepEqual(aliases.all.targets, ['serve', 'mcp-http', 'production-mcp']);
   assert.equal(aliases.runtime, undefined);
 });
+
+test('agent compose services run as the host uid and gid', async () => {
+  const workspaceRaw = await readFile(new URL('../../docker-compose.yml', import.meta.url), 'utf8');
+  const workspaceCompose = YAML.parse(workspaceRaw);
+  assert.equal(workspaceCompose.services['production-mcp'].user, '${UID:-1000}:${GID:-1000}');
+
+  const agentsRaw = await readFile(new URL('../../agents.docker-compose.yml', import.meta.url), 'utf8');
+  const agentsCompose = YAML.parse(agentsRaw);
+  assert.equal(agentsCompose.services.cme.user, '${UID:-1000}:${GID:-1000}');
+  assert.equal(agentsCompose.services.documents.user, '${UID:-1000}:${GID:-1000}');
+  assert.equal(agentsCompose.services.mailer.user, '${UID:-1000}:${GID:-1000}');
+});