@dotdrelle/wiki-manager 0.11.10 → 0.12.0

package/src/core/queueStore.test.js

@@ -1,5 +1,8 @@
 import assert from 'node:assert/strict';
 import test from 'node:test';
+import { mkdtempSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
 import { enqueueProductionJob, ensureJobQueue } from './jobQueue.js';
 
 test('job queue uses an injected queue store', () => {
@@ -7,6 +10,7 @@ test('job queue uses an injected queue store', () => {
   let changed = 0;
   const session = {
     workspace: 'docs',
+    workspacePath: mkdtempSync(join(tmpdir(), 'wiki-manager-queue-')),
     queueStore: {
       list() {
         return queue;
@@ -30,3 +34,20 @@ test('job queue uses an injected queue store', () => {
   assert.equal(ensureJobQueue(session), queue);
   assert.equal(changed, 1);
 });
+
+test('job queue refuses production jobs without an active workspace path', () => {
+  assert.throws(
+    () => enqueueProductionJob({ workspace: 'docs' }, { type: 'ingest', inputs: ['raw/untracked/*.md'] }),
+    /no active workspace path/i,
+  );
+});
+
+test('job queue normalizes production input paths against workspace path', () => {
+  const workspacePath = mkdtempSync(join(tmpdir(), 'wiki-manager-queue-inputs-'));
+  const item = enqueueProductionJob(
+    { workspace: 'docs', workspacePath },
+    { type: 'ingest', inputs: ['raw/untracked/*.md', join(workspacePath, 'raw', 'untracked', 'doc.md')] },
+  );
+
+  assert.deepEqual(item.args.inputs, ['raw/untracked/*.md', 'raw/untracked/doc.md']);
+});

package/src/core/runtimeLog.js

@@ -0,0 +1,119 @@
+const FIELD_ALIASES = {
+  runId: 'run',
+  planRevision: 'plan',
+  groupId: 'group',
+  taskId: 'task',
+  attemptId: 'attempt',
+  agentType: 'agentType',
+  agentInstanceId: 'agentInstance',
+  agentId: 'agent',
+  jobId: 'job',
+  workspaceId: 'workspace',
+  capability: 'capability',
+  operation: 'operation',
+  file: 'file',
+  error: 'error',
+};
+
+const ORDERED_FIELDS = [
+  'runId',
+  'planRevision',
+  'groupId',
+  'taskId',
+  'attemptId',
+  'agentType',
+  'agentInstanceId',
+  'agentId',
+  'jobId',
+  'workspaceId',
+  'capability',
+  'operation',
+  'file',
+  'error',
+];
+
+export function normalizeRuntimeLog(input, { session = null } = {}) {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) {
+    return { message: String(input ?? '') };
+  }
+  const workspaceId = input.workspaceId ?? input.workspace ?? session?.workspace ?? session?._currentRunIdentity?.workspace ?? null;
+  return {
+    event: input.event ? String(input.event) : 'runtime.log',
+    runId: input.runId ?? session?._currentRunIdentity?.runId ?? null,
+    planRevision: input.planRevision ?? session?.planRevision ?? null,
+    groupId: input.groupId ?? null,
+    taskId: input.taskId ?? null,
+    attemptId: input.attemptId ?? null,
+    agentType: input.agentType ?? null,
+    agentInstanceId: input.agentInstanceId ?? null,
+    agentId: input.agentId ?? null,
+    jobId: input.jobId ?? null,
+    workspaceId,
+    capability: input.capability ?? null,
+    operation: input.operation ?? null,
+    file: input.file ?? input.fileRef ?? null,
+    error: input.error ?? null,
+    status: input.status ?? null,
+    outputs: input.outputs ?? input.outputRefs ?? null,
+    percent: input.percent ?? null,
+    detail: input.detail ?? input.message ?? null,
+  };
+}
+
+export function formatRuntimeLogPayload(payload = {}, ts = null) {
+  if (payload?.message != null && !payload.event) return String(payload.message);
+  const time = timeLabel(ts);
+  const event = eventLabel(payload.event);
+  const fields = ORDERED_FIELDS
+    .map((key) => formatField(FIELD_ALIASES[key], payload[key]))
+    .filter(Boolean);
+  if (payload.status != null) fields.push(formatField('status', payload.status));
+  if (payload.percent != null) fields.push(formatField('percent', payload.percent));
+  if (payload.outputs != null) fields.push(formatField('outputs', payload.outputs));
+  if (payload.detail != null && payload.detail !== '') fields.push(`detail=${quoteIfNeeded(payload.detail)}`);
+  return [time, event, ...fields].filter(Boolean).join(' ');
+}
+
+export function runtimeLogMatchesFilter(line, filter = '') {
+  const query = String(filter ?? '').trim();
+  if (!query) return true;
+  const haystack = String(line ?? '').toLowerCase();
+  return query
+    .split(/\s+/)
+    .filter(Boolean)
+    .every((token) => haystack.includes(token.toLowerCase()));
+}
+
+export function filterRuntimeLogs(logs = [], filter = '') {
+  return logs.filter((line) => runtimeLogMatchesFilter(line, filter));
+}
+
+function timeLabel(ts) {
+  const date = ts ? new Date(ts) : new Date();
+  if (Number.isNaN(date.getTime())) return null;
+  return date.toISOString().slice(11, 19);
+}
+
+function eventLabel(event) {
+  const raw = String(event ?? 'runtime.log').trim();
+  const part = raw.includes('.') ? raw.split('.').at(-1) : raw;
+  return part.replace(/[^a-zA-Z0-9]+/g, '_').replace(/^_+|_+$/g, '').toUpperCase() || 'LOG';
+}
+
+function formatField(key, value) {
+  if (value == null || value === '') return null;
+  return `${key}=${quoteIfNeeded(value)}`;
+}
+
+function quoteIfNeeded(value) {
+  const text = Array.isArray(value)
+    ? value.map((item) => refString(item)).filter(Boolean).join(',')
+    : refString(value);
+  return /[\s"]/u.test(text) ? JSON.stringify(text) : text;
+}
+
+function refString(value) {
+  if (value == null) return '';
+  if (typeof value === 'object') return String(value.ref ?? value.path ?? value.id ?? JSON.stringify(value));
+  return String(value);
+}

package/src/core/runtimeLog.test.js

@@ -0,0 +1,84 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { createAgentEvent, dispatchAgentEvent } from './agentEvents.js';
+import { formatRuntimeLogPayload } from './runtimeLog.js';
+import { emitRuntimeLog } from '../runtime/supervisor.js';
+
+const CYCLE_EVENTS = [
+  'task.ready',
+  'capability.resolving',
+  'agent.selected',
+  'task.assigned',
+  'attempt.created',
+  'lock.acquired',
+  'agent_execute',
+  'job.accepted',
+  'agent_status',
+  'task.result_returned',
+  'lock.released',
+  'task.completed',
+];
+
+function payload(event) {
+  return {
+    event,
+    runId: 'run-123',
+    planRevision: 4,
+    groupId: 'group-build',
+    taskId: 'task-build',
+    attemptId: 'attempt-1',
+    agentType: 'production',
+    agentInstanceId: 'production-main',
+    agentId: 'worker-02',
+    jobId: 'job-789',
+    workspaceId: 'docs',
+    capability: 'document.build',
+    operation: 'build',
+    detail: 'cycle detail',
+  };
+}
+
+test('formatRuntimeLogPayload formats every dispatcher cycle event with required ids', () => {
+  for (const event of CYCLE_EVENTS) {
+    const line = formatRuntimeLogPayload(payload(event), '2026-07-08T14:42:18.000Z');
+    assert.match(line, /^14:42:18 [A-Z_]+ /);
+    assert.match(line, /run=run-123/);
+    assert.match(line, /plan=4/);
+    assert.match(line, /group=group-build/);
+    assert.match(line, /task=task-build/);
+    assert.match(line, /attempt=attempt-1/);
+    assert.match(line, /agentType=production/);
+    assert.match(line, /agentInstance=production-main/);
+    assert.match(line, /agent=worker-02/);
+    assert.match(line, /job=job-789/);
+    assert.match(line, /workspace=docs/);
+    assert.match(line, /capability=document\.build/);
+    assert.match(line, /operation=build/);
+  }
+});
+
+test('emitRuntimeLog accepts structured payloads and preserves legacy strings', () => {
+  const session = {
+    workspace: 'docs',
+    planRevision: 2,
+    _currentRunIdentity: { runId: 'run-structured', workspace: 'docs' },
+  };
+  emitRuntimeLog(session, {
+    event: 'task.assigned',
+    taskId: 'task-a',
+    attemptId: 'attempt-a',
+    capability: 'knowledge.update',
+    operation: 'ingest',
+    detail: 'assigned',
+  });
+  dispatchAgentEvent(session, createAgentEvent('runtime_log', {
+    origin: 'test',
+    payload: { message: 'legacy line' },
+  }));
+
+  assert.match(session.agentProjection.logs[0], /ASSIGNED/);
+  assert.match(session.agentProjection.logs[0], /run=run-structured/);
+  assert.match(session.agentProjection.logs[0], /workspace=docs/);
+  assert.equal(session.agentProjection.logs[1], 'legacy line');
+});

package/src/core/wikirc.js

@@ -47,6 +47,7 @@ export function loadWikircProfile(workspacePath, profileName = 'default') {
   if (!config || typeof config !== 'object' || Array.isArray(config)) {
     throw new Error('wikirc YAML invalide: objet attendu a la racine');
   }
+  config.capabilityRouting = normalizeCapabilityRouting(config.capabilityRouting);
   return { profile, config };
 }
 
@@ -54,6 +55,27 @@ function isPlainObject(value) {
   return value && typeof value === 'object' && !Array.isArray(value);
 }
 
+export function normalizeCapabilityRouting(value) {
+  if (!isPlainObject(value)) return {};
+  return Object.fromEntries(
+    Object.entries(value)
+      .filter(([capability]) => String(capability).trim())
+      .map(([capability, routing]) => [
+        String(capability).trim(),
+        {
+          preferredAgents: normalizeAgentList(routing?.preferredAgents),
+          fallbackAgents: normalizeAgentList(routing?.fallbackAgents),
+          allowedAgents: normalizeAgentList(routing?.allowedAgents),
+        },
+      ]),
+  );
+}
+
+function normalizeAgentList(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((item) => item != null).map((item) => String(item).trim()).filter(Boolean);
+}
+
 function setYamlValue(map, key, value) {
   if (isPlainObject(value)) {
     let child = map.get(key, true);

package/src/core/wikirc.test.js

@@ -4,7 +4,7 @@ import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import test from 'node:test';
 import YAML from 'yaml';
-import { patchWikircProfile } from './wikirc.js';
+import { loadWikircProfile, normalizeCapabilityRouting, patchWikircProfile } from './wikirc.js';
 import { finalizeCreatedWorkspace, writeVectorConfig } from './wikiSetup.js';
 
 test('patchWikircProfile merges keys and preserves existing values', () => {
@@ -42,6 +42,54 @@ test('patchWikircProfile merges keys and preserves existing values', () => {
   assert.equal(parsed.retrieval.vector.enabled, true);
 });
 
+test('loadWikircProfile parses capabilityRouting agent lists', () => {
+  const root = mkdtempSync(join(tmpdir(), 'wikirc-routing-'));
+  writeFileSync(join(root, '.wikirc.yaml'), [
+    'language: en-US',
+    'capabilityRouting:',
+    '  external-source.export:',
+    '    preferredAgents:',
+    '      - commercial-main',
+    '    fallbackAgents:',
+    '      - cme-main',
+    '  knowledge.update:',
+    '    allowedAgents:',
+    '      - production-main',
+    '',
+  ].join('\n'), 'utf8');
+
+  const { config } = loadWikircProfile(root);
+
+  assert.deepEqual(config.capabilityRouting, {
+    'external-source.export': {
+      preferredAgents: ['commercial-main'],
+      fallbackAgents: ['cme-main'],
+      allowedAgents: [],
+    },
+    'knowledge.update': {
+      preferredAgents: [],
+      fallbackAgents: [],
+      allowedAgents: ['production-main'],
+    },
+  });
+});
+
+test('normalizeCapabilityRouting ignores invalid routing values safely', () => {
+  assert.deepEqual(normalizeCapabilityRouting({
+    'knowledge.update': {
+      preferredAgents: ['production-main', '', null],
+      fallbackAgents: 'production-secondary',
+      allowedAgents: ['production-main'],
+    },
+  }), {
+    'knowledge.update': {
+      preferredAgents: ['production-main'],
+      fallbackAgents: [],
+      allowedAgents: ['production-main'],
+    },
+  });
+});
+
 test('writeVectorConfig writes llm-wiki vector and rerank keys', () => {
   const root = mkdtempSync(join(tmpdir(), 'wikirc-vector-'));
   writeFileSync(join(root, '.wikirc.yaml'), [

package/src/core/workflow.js

@@ -1,3 +1,7 @@
+import { aggregateActivity } from '../activity/activityAggregator.js';
+import { calculateWeightedProgress } from '../activity/progressCalculator.js';
+import { aggregateGraph } from '../graph/graphAggregator.js';
+
 const TERMINAL_STATUSES = new Set(['done', 'failed', 'cancelled', 'canceled', 'error', 'complete', 'completed', 'success']);
 const RUNNING_STATUSES = new Set(['running', 'starting', 'queued', 'waiting', 'pending_approval']);
 
@@ -88,20 +92,24 @@ export function projectWorkflow(state = {}, events = []) {
 
   const current = findCurrentNode(nodes);
   const next = findNextTask(planNodes);
-  const progress = computeProgress({ planNodes, activityNodes, state });
+  const activity = aggregateActivity(state, events);
+  const progress = computeProgress({ planNodes, activityNodes, state, activity });
   const waitingReasons = computeWaitingReasons({ nodes, queueNodes, approvalNodes });
   const summary = buildSummary({ state, run, current, next, progress, evaluation });
 
-  return {
+  const projected = {
     summary,
     nodes,
     relations,
     current,
     next,
     progress,
+    activity,
     waitingReasons,
     warnings,
   };
+  projected.graph = aggregateGraph(projected, events);
+  return projected;
 }
 
 function currentRun(state, events) {
@@ -218,7 +226,10 @@ function findNextTask(tasks) {
     ?? null;
 }
 
-function computeProgress({ planNodes, activityNodes, state }) {
+function computeProgress({ planNodes, activityNodes, state, activity }) {
+  if (planNodes.some((task) => Number.isFinite(Number(task.raw?.progressWeight)))) {
+    return activity.progress ?? calculateWeightedProgress(planNodes.map((node) => node.raw), activityNodes);
+  }
   const activityWithPercent = activityNodes.find((activity) => Number.isFinite(Number(activity.progress?.percent)));
   if (activityWithPercent) {
     return {

package/src/graph/graphAggregator.js

@@ -0,0 +1,5 @@
+import { createGraphSnapshot } from './graphSnapshot.js';
+
+export function aggregateGraph(workflow = {}, events = [], options = {}) {
+  return createGraphSnapshot(workflow, events, options);
+}

package/src/graph/graphPatch.js

@@ -0,0 +1,8 @@
+export function diffGraphSnapshots(before = {}, after = {}) {
+  const beforeNodes = new Map((before.nodes ?? []).map((node) => [node.id, node]));
+  const afterNodes = new Map((after.nodes ?? []).map((node) => [node.id, node]));
+  const addedNodes = [...afterNodes.values()].filter((node) => !beforeNodes.has(node.id));
+  const removedNodes = [...beforeNodes.values()].filter((node) => !afterNodes.has(node.id));
+  const updatedNodes = [...afterNodes.values()].filter((node) => beforeNodes.has(node.id) && JSON.stringify(beforeNodes.get(node.id)) !== JSON.stringify(node));
+  return { addedNodes, removedNodes, updatedNodes };
+}

package/src/graph/graphSnapshot.js

@@ -0,0 +1,14 @@
+import { projectRunGraph } from './runGraphProjector.js';
+import { applyGraphVisibility } from './graphVisibilityPolicy.js';
+
+export function createGraphSnapshot(workflow = {}, events = [], options = {}) {
+  const graph = projectRunGraph(workflow, events);
+  const visible = applyGraphVisibility(graph, options);
+  return {
+    nodes: graph.nodes,
+    edges: graph.edges,
+    visibleNodes: visible.visibleNodes,
+    visibleEdges: visible.visibleEdges,
+    aggregations: visible.aggregations,
+  };
+}

package/src/graph/graphVisibilityPolicy.js

@@ -0,0 +1,40 @@
+const ALWAYS_VISIBLE = new Set(['run', 'task_group', 'barrier', 'approval']);
+const ACTIVE = new Set(['running', 'queued', 'pending_approval', 'waiting_approval']);
+const ERROR = new Set(['failed', 'error', 'cancelled']);
+
+export function applyGraphVisibility(graph, { maxNodes = 18 } = {}) {
+  const nodes = graph.nodes ?? [];
+  if (nodes.length <= maxNodes) return { ...graph, visibleNodes: nodes, visibleEdges: graph.edges ?? [], aggregations: [] };
+  const visible = [];
+  const hidden = [];
+  for (const node of nodes) {
+    if (mustShow(node) || visible.length < maxNodes) visible.push(node);
+    else hidden.push(node);
+  }
+  if (hidden.length > 0) {
+    const aggregate = {
+      id: 'aggregate:hidden',
+      type: 'aggregate',
+      label: `${hidden.length} hidden node${hidden.length > 1 ? 's' : ''}`,
+      status: 'collapsed',
+      raw: { count: hidden.length, nodeIds: hidden.map((node) => node.id) },
+    };
+    if (visible.length >= maxNodes) visible.pop();
+    visible.push(aggregate);
+  }
+  const ids = new Set(visible.map((node) => node.id));
+  return {
+    ...graph,
+    visibleNodes: visible,
+    visibleEdges: (graph.edges ?? []).filter((edge) => ids.has(edge.from) && ids.has(edge.to)),
+    aggregations: hidden.length > 0 ? [{ id: 'aggregate:hidden', count: hidden.length }] : [],
+  };
+}
+
+function mustShow(node) {
+  const status = String(node.status ?? '').toLowerCase();
+  return ALWAYS_VISIBLE.has(node.type)
+    || ACTIVE.has(status)
+    || ERROR.has(status)
+    || node.type === 'plan_expansion';
+}

package/src/graph/runGraphProjector.js

@@ -0,0 +1,87 @@
+export function projectRunGraph(workflow = {}, events = []) {
+  const nodes = new Map();
+  const edges = [];
+  for (const node of workflow.nodes ?? []) addNode(nodes, graphNodeFromWorkflow(node));
+  for (const relation of workflow.relations ?? []) edges.push({ ...relation });
+  for (const event of events ?? []) projectEvent(event, nodes, edges);
+  return { nodes: [...nodes.values()], edges };
+}
+
+function projectEvent(event, nodes, edges) {
+  const runId = event.runId ?? event.payload?.runId ?? null;
+  const taskId = event.taskId ?? event.payload?.taskId ?? null;
+  if (event.type === 'task_group.created') {
+    const group = event.payload?.group ?? {};
+    addNode(nodes, {
+      id: `group:${group.id}`,
+      type: 'task_group',
+      label: group.label ?? group.id,
+      status: 'pending',
+      raw: group,
+    });
+    if (runId) edges.push({ type: 'contains', from: `run:${runId}`, to: `group:${group.id}` });
+  }
+  if (event.type === 'task.created') {
+    const task = event.payload?.task ?? {};
+    if (task.groupId) edges.push({ type: 'in_group', from: `task:${task.id ?? taskId}`, to: `group:${task.groupId}` });
+    if (task.barrier || task.dependsOnGroup) {
+      const id = `barrier:${task.dependsOnGroup ?? task.groupId ?? task.id ?? taskId}`;
+      addNode(nodes, { id, type: 'barrier', label: `Barrier ${task.dependsOnGroup ?? task.groupId ?? ''}`.trim(), status: task.status ?? 'pending', raw: task });
+      edges.push({ type: 'barrier_for', from: id, to: `task:${task.id ?? taskId}` });
+    }
+  }
+  if (event.type === 'task.assigned') {
+    const assignment = event.payload?.assignment ?? {};
+    const assignmentId = `assignment:${taskId}:${event.payload?.attemptId ?? assignment.attemptId ?? 'current'}`;
+    addNode(nodes, { id: assignmentId, type: 'assignment', label: assignment.agentInstanceId ?? 'Assignment', status: 'done', raw: assignment });
+    addNode(nodes, { id: `agent:${assignment.agentInstanceId}`, type: 'agent_instance', label: assignment.agentInstanceId ?? 'Agent', status: 'available', raw: assignment.agent ?? {} });
+    edges.push({ type: 'assigned_to', from: `task:${taskId}`, to: assignmentId });
+    edges.push({ type: 'uses_agent', from: assignmentId, to: `agent:${assignment.agentInstanceId}` });
+  }
+  if (['task.started', 'task.retry_scheduled'].includes(event.type)) {
+    const attemptId = event.payload?.attemptId ?? event.payload?.retryAssignment?.attemptId ?? `${taskId}:attempt`;
+    addNode(nodes, { id: `attempt:${attemptId}`, type: 'attempt', label: String(attemptId), status: event.type === 'task.retry_scheduled' ? 'retry_scheduled' : 'running', raw: event.payload ?? {} });
+    edges.push({ type: 'attempt_of', from: `attempt:${attemptId}`, to: `task:${taskId}` });
+  }
+  if (['task.result_returned', 'task.completed', 'task.failed'].includes(event.type)) {
+    const result = event.payload?.result ?? {};
+    const attemptId = result.attemptId ?? event.payload?.attemptId ?? `${taskId}:attempt`;
+    const resultId = `result:${attemptId}`;
+    addNode(nodes, { id: resultId, type: 'result', label: result.status ?? event.type, status: event.type === 'task.failed' ? 'failed' : 'done', raw: result });
+    edges.push({ type: 'result_of', from: resultId, to: `attempt:${attemptId}` });
+  }
+  if (event.type === 'plan.revision_changed' && event.payload?.previousRevision != null) {
+    const id = `plan_expansion:${runId}:${event.payload.planRevision}`;
+    addNode(nodes, { id, type: 'plan_expansion', label: `Plan revision ${event.payload.planRevision}`, status: 'done', raw: event.payload });
+    if (runId) edges.push({ type: 'expands', from: id, to: `run:${runId}` });
+  }
+}
+
+function graphNodeFromWorkflow(node) {
+  return {
+    id: node.id,
+    type: node.type,
+    label: node.label,
+    status: node.status,
+    tooltip: tooltipFor(node),
+    raw: node.raw ?? node,
+  };
+}
+
+function tooltipFor(node) {
+  if (node.type !== 'task') return `${node.type}: ${node.label}`;
+  const raw = node.raw ?? {};
+  return [
+    `Tache : ${node.label}`,
+    raw.requiredCapability ? `Capacite : ${raw.requiredCapability}` : null,
+    raw.agentInstanceId ? `Agent : ${raw.agentInstanceId}` : null,
+    raw.retryState?.attempts ? `Tentative : ${raw.retryState.attempts}` : null,
+    `Etat : ${node.status}`,
+    node.progress?.percent != null ? `Progression : ${Math.round(Number(node.progress.percent))} %` : null,
+  ].filter(Boolean).join('\n');
+}
+
+function addNode(nodes, node) {
+  if (!node?.id) return;
+  nodes.set(node.id, { ...(nodes.get(node.id) ?? {}), ...node });
+}

package/src/graph/runGraphProjector.test.js

@@ -0,0 +1,111 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { createAgentEvent } from '../core/agentEvents.js';
+import { projectWorkflow } from '../core/workflow.js';
+
+function sampleEvents() {
+  return [
+    createAgentEvent('run_started', { runId: 'run-graph', payload: { input: 'Run graph' } }),
+    createAgentEvent('task_group.created', {
+      runId: 'run-graph',
+      payload: { group: { id: 'ingest', label: 'Ingest group' } },
+    }),
+    createAgentEvent('task.created', {
+      runId: 'run-graph',
+      taskId: 'run-graph:ingest',
+      payload: {
+        task: {
+          id: 'run-graph:ingest',
+          label: 'Ingest',
+          description: 'Ingest',
+          status: 'running',
+          groupId: 'ingest',
+          requiredCapability: 'knowledge.update',
+          operation: 'ingest',
+          dependsOn: [],
+          outputRefs: [],
+        },
+      },
+    }),
+    createAgentEvent('task.created', {
+      runId: 'run-graph',
+      taskId: 'run-graph:apply',
+      payload: {
+        task: {
+          id: 'run-graph:apply',
+          label: 'Apply',
+          description: 'Apply',
+          status: 'pending',
+          dependsOnGroup: 'ingest',
+          barrier: true,
+          requiredCapability: 'knowledge.update',
+          operation: 'ingest_apply',
+          dependsOn: ['run-graph:ingest'],
+          outputRefs: [],
+        },
+      },
+    }),
+    createAgentEvent('task.assigned', {
+      runId: 'run-graph',
+      taskId: 'run-graph:ingest',
+      payload: {
+        taskId: 'run-graph:ingest',
+        attemptId: 'attempt-1',
+        assignment: { agentInstanceId: 'production-main' },
+      },
+    }),
+    createAgentEvent('task.started', {
+      runId: 'run-graph',
+      taskId: 'run-graph:ingest',
+      payload: { taskId: 'run-graph:ingest', attemptId: 'attempt-1', jobId: 'job-1' },
+    }),
+    createAgentEvent('task.result_returned', {
+      runId: 'run-graph',
+      taskId: 'run-graph:ingest',
+      payload: { result: { attemptId: 'attempt-1', status: 'succeeded', outputRefs: [{ type: 'file', ref: 'out.json' }] } },
+    }),
+    createAgentEvent('plan.revision_changed', {
+      runId: 'run-graph',
+      payload: { runId: 'run-graph', previousRevision: 1, planRevision: 2, taskIds: ['run-graph:ingest'] },
+    }),
+  ];
+}
+
+test('run graph snapshot includes task groups, barrier, agent, assignment, attempt, result and expansion', () => {
+  const workflow = projectWorkflow({
+    status: 'running',
+    runId: 'run-graph',
+    plan: [
+      { id: 'run-graph:ingest', description: 'Ingest', status: 'running', groupId: 'ingest', requiredCapability: 'knowledge.update', operation: 'ingest', dependsOn: [] },
+      { id: 'run-graph:apply', description: 'Apply', status: 'pending', dependsOnGroup: 'ingest', barrier: true, requiredCapability: 'knowledge.update', operation: 'ingest_apply', dependsOn: ['run-graph:ingest'] },
+    ],
+    activities: [],
+    queue: [],
+    approvals: [],
+  }, sampleEvents());
+
+  const types = new Set(workflow.graph.nodes.map((node) => node.type));
+  for (const type of ['task_group', 'barrier', 'agent_instance', 'assignment', 'attempt', 'result', 'plan_expansion']) {
+    assert.ok(types.has(type), `missing graph node type ${type}`);
+  }
+  assert.ok(workflow.graph.visibleNodes.length <= 18);
+  assert.ok(workflow.graph.nodes.find((node) => node.id === 'task:run-graph:ingest')?.tooltip.includes('Capacite : knowledge.update'));
+});
+
+test('run graph replay from the same events is deterministic', () => {
+  const state = {
+    status: 'running',
+    runId: 'run-graph',
+    plan: [
+      { id: 'run-graph:ingest', description: 'Ingest', status: 'running', groupId: 'ingest', requiredCapability: 'knowledge.update', operation: 'ingest', dependsOn: [] },
+    ],
+    activities: [],
+    queue: [],
+    approvals: [],
+  };
+  const first = projectWorkflow(state, sampleEvents()).graph;
+  const second = projectWorkflow(state, sampleEvents()).graph;
+
+  assert.deepEqual(second, first);
+});