@dotdrelle/wiki-manager 0.11.10 → 0.12.1

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);
+});

package/src/orchestrator/agentRegistry.js

@@ -0,0 +1,172 @@
+import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
+import { callMcpTool, formatMcpToolResult } from '../core/mcp.js';
+import { assertContract } from '../contracts/schemas.js';
+
+const AVAILABLE = 'available';
+const UNAVAILABLE = 'unavailable';
+
+export function createAgentRegistry({
+  callTool = callMcpTool,
+  now = () => new Date(),
+} = {}) {
+  const agentsByInstance = new Map();
+  const instanceByServer = new Map();
+
+  return {
+    async discover(session, { signal = null } = {}) {
+      const discovered = [];
+      for (const [serverName, endpoint] of Object.entries(session?.mcp ?? {})) {
+        const agent = await discoverServerAgent(session, serverName, endpoint, { callTool, signal, now });
+        discovered.push(registerAgent(session, agent, { agentsByInstance, instanceByServer }));
+      }
+      session.agentRegistry = this;
+      session.agentRegistrySnapshot = this.snapshot();
+      return discovered;
+    },
+    snapshot() {
+      return [...agentsByInstance.values()]
+        .map((agent) => cloneAgent(agent))
+        .sort((a, b) => a.agentInstanceId.localeCompare(b.agentInstanceId));
+    },
+    get(agentInstanceId) {
+      const agent = agentsByInstance.get(String(agentInstanceId));
+      return agent ? cloneAgent(agent) : null;
+    },
+  };
+}
+
+async function discoverServerAgent(session, serverName, endpoint = {}, { callTool, signal, now }) {
+  const lastSeenAt = now().toISOString();
+  if (endpoint.status !== 'connected') {
+    return legacyAgent(serverName, endpoint, { health: UNAVAILABLE, lastSeenAt });
+  }
+
+  const toolName = findAgentDescribeTool(serverName, endpoint.tools ?? []);
+  if (!toolName) {
+    return legacyAgent(serverName, endpoint, { health: AVAILABLE, lastSeenAt });
+  }
+
+  try {
+    const result = await callTool(session.mcp, serverName, toolName, {}, signal);
+    const description = assertContract('agentDescription', parseToolJsonResult(result));
+    return {
+      serverName,
+      toolName,
+      agentInstanceId: description.agentInstanceId,
+      description,
+      health: description.health?.status ?? AVAILABLE,
+      firstSeenAt: lastSeenAt,
+      lastSeenAt,
+      legacy: false,
+      orchestrable: true,
+    };
+  } catch (error) {
+    return legacyAgent(serverName, endpoint, {
+      health: UNAVAILABLE,
+      lastSeenAt,
+      toolName,
+      error: error instanceof Error ? error.message : String(error),
+    });
+  }
+}
+
+function registerAgent(session, agent, { agentsByInstance, instanceByServer }) {
+  const previousInstanceId = instanceByServer.get(agent.serverName);
+  const previous = previousInstanceId ? agentsByInstance.get(previousInstanceId) : null;
+  const firstSeenAt = previous?.firstSeenAt ?? agent.firstSeenAt ?? agent.lastSeenAt;
+  const next = {
+    ...agent,
+    firstSeenAt,
+  };
+
+  if (previous && previous.agentInstanceId !== next.agentInstanceId) {
+    agentsByInstance.delete(previous.agentInstanceId);
+  }
+  agentsByInstance.set(next.agentInstanceId, next);
+  instanceByServer.set(next.serverName, next.agentInstanceId);
+
+  if (!previous || previous.agentInstanceId !== next.agentInstanceId) {
+    dispatchRegistryEvent(session, 'agent.registered', { agent: next });
+  } else if (previous.health !== next.health) {
+    dispatchRegistryEvent(session, 'agent.health_changed', {
+      agent: next,
+      agentInstanceId: next.agentInstanceId,
+      previousHealth: previous.health,
+      health: next.health,
+    });
+  }
+  return cloneAgent(next);
+}
+
+function dispatchRegistryEvent(session, type, payload) {
+  if (!session) return;
+  dispatchAgentEvent(session, createAgentEvent(type, {
+    origin: 'agent_registry',
+    workspace: session.workspace ?? null,
+    payload,
+  }));
+}
+
+function findAgentDescribeTool(serverName, tools) {
+  const names = tools.map((tool) => String(tool.name ?? '')).filter(Boolean);
+  return names.find((name) => name === 'agent_describe')
+    ?? names.find((name) => name === `${serverName}__agent_describe`)
+    ?? names.find((name) => name.endsWith('__agent_describe'))
+    ?? null;
+}
+
+function parseToolJsonResult(result) {
+  if (result && typeof result === 'object' && !Array.isArray(result) && !Array.isArray(result.content)) {
+    return result;
+  }
+  const text = formatMcpToolResult(result);
+  return JSON.parse(text);
+}
+
+function legacyAgent(serverName, endpoint = {}, { health, lastSeenAt, toolName = null, error = null }) {
+  const displayName = endpoint.displayName ?? serverName;
+  const description = {
+    contractVersion: 'legacy',
+    agentType: serverName,
+    agentInstanceId: `${serverName}-legacy`,
+    displayName,
+    capabilities: [],
+    orchestration: {
+      canPlan: false,
+      canExpandPlan: false,
+      canExecute: false,
+      canCancel: false,
+      canResume: false,
+      supportsIdempotency: false,
+      supportsParallelWorkers: false,
+    },
+    limits: {
+      recommendedConcurrency: 0,
+      maxConcurrency: 0,
+    },
+    health: { status: health },
+  };
+  return {
+    serverName,
+    toolName,
+    agentInstanceId: description.agentInstanceId,
+    description,
+    health,
+    firstSeenAt: lastSeenAt,
+    lastSeenAt,
+    legacy: true,
+    orchestrable: false,
+    error,
+  };
+}
+
+function cloneAgent(agent) {
+  return {
+    ...agent,
+    description: cloneJson(agent.description),
+  };
+}
+
+function cloneJson(value) {
+  return value == null ? value : JSON.parse(JSON.stringify(value));
+}

package/src/orchestrator/agentRegistry.test.js

@@ -0,0 +1,114 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { createAgentRegistry } from './agentRegistry.js';
+
+function description({ agentInstanceId = 'production-main', health = 'available', contractVersion = '1' } = {}) {
+  return {
+    contractVersion,
+    agentType: 'production',
+    agentInstanceId,
+    displayName: 'Production',
+    capabilities: [{
+      id: 'knowledge.update',
+      version: '1',
+      description: 'Update wiki knowledge',
+      inputSchema: {},
+      outputSchema: {},
+      supportedOperations: ['ingest'],
+      defaultRequiresApproval: true,
+    }],
+    orchestration: {
+      canPlan: true,
+      canExpandPlan: false,
+      canExecute: true,
+      canCancel: true,
+      canResume: false,
+      supportsIdempotency: false,
+      supportsParallelWorkers: true,
+    },
+    limits: {
+      recommendedConcurrency: 2,
+      maxConcurrency: 4,
+    },
+    health: { status: health },
+  };
+}
+
+test('agentRegistry discovers connected contract agents through agent_describe', async () => {
+  const events = [];
+  const session = {
+    workspace: 'docs',
+    mcp: {
+      production: {
+        status: 'connected',
+        tools: [{ name: 'production__agent_describe' }],
+      },
+    },
+    _onAgentEvent: (event) => events.push(event),
+  };
+  const registry = createAgentRegistry({
+    callTool: async (_mcp, server, tool) => {
+      assert.equal(server, 'production');
+      assert.equal(tool, 'production__agent_describe');
+      return { content: [{ type: 'text', text: JSON.stringify(description()) }] };
+    },
+  });
+
+  const agents = await registry.discover(session);
+
+  assert.equal(agents.length, 1);
+  assert.equal(agents[0].agentInstanceId, 'production-main');
+  assert.equal(agents[0].legacy, false);
+  assert.equal(agents[0].health, 'available');
+  assert.equal(events[0].type, 'agent.registered');
+  assert.equal(events[0].payload.agent.agentInstanceId, 'production-main');
+});
+
+test('agentRegistry records legacy visible agents when no contract tool exists', async () => {
+  const session = {
+    mcp: {
+      cme: {
+        status: 'connected',
+        tools: [{ name: 'cme_export_run' }],
+      },
+    },
+  };
+  const registry = createAgentRegistry({
+    callTool: async () => assert.fail('agent_describe should not be called'),
+  });
+
+  const [agent] = await registry.discover(session);
+
+  assert.equal(agent.agentInstanceId, 'cme-legacy');
+  assert.equal(agent.legacy, true);
+  assert.equal(agent.orchestrable, false);
+  assert.equal(agent.health, 'available');
+});
+
+test('agentRegistry marks unavailable boot agents and emits health changes on re-scan', async () => {
+  const events = [];
+  let health = 'unavailable';
+  const session = {
+    mcp: {
+      production: {
+        status: 'connected',
+        tools: [{ name: 'agent_describe' }],
+      },
+    },
+    _onAgentEvent: (event) => events.push(event),
+  };
+  const registry = createAgentRegistry({
+    callTool: async () => ({ content: [{ type: 'text', text: JSON.stringify(description({ health })) }] }),
+  });
+
+  await registry.discover(session);
+  health = 'available';
+  await registry.discover(session);
+
+  assert.equal(events[0].type, 'agent.registered');
+  assert.equal(events[0].payload.agent.health, 'unavailable');
+  assert.equal(events[1].type, 'agent.health_changed');
+  assert.equal(events[1].payload.previousHealth, 'unavailable');
+  assert.equal(events[1].payload.health, 'available');
+  assert.equal(registry.snapshot()[0].health, 'available');
+});

package/src/orchestrator/approvalPolicy.js

@@ -0,0 +1,126 @@
+import { randomUUID } from 'node:crypto';
+
+export const APPROVAL_DEFAULT_CLASS = 'default';
+
+const GRANTED_STATUSES = new Set(['approved', 'granted']);
+const TERMINAL_STATUSES = new Set(['done', 'failed', 'cancelled', 'canceled', 'error', 'complete', 'completed', 'success']);
+
+export function approvalClassForTask(task) {
+  return String(task?.approvalClass ?? task?.mutationClass ?? APPROVAL_DEFAULT_CLASS);
+}
+
+export function normalizeApprovalGrant(input = {}) {
+  const scope = normalizeScope(input.scope);
+  const approvalClasses = normalizeClasses(input.approvalClasses ?? input.approvalClass);
+  return {
+    id: String(input.id ?? input.approvalId ?? randomUUID()),
+    approvalId: input.approvalId == null ? null : String(input.approvalId),
+    scope,
+    status: normalizeStatus(input.status ?? 'approved'),
+    runId: input.runId == null ? null : String(input.runId),
+    workspaceId: input.workspaceId ?? input.workspace ?? null,
+    planRevision: input.planRevision == null ? null : Number(input.planRevision),
+    taskId: input.taskId ?? input.itemId ?? null,
+    itemId: input.itemId ?? input.taskId ?? null,
+    groupId: input.groupId ?? null,
+    approvalClasses,
+    reason: input.reason ?? null,
+    createdAt: input.createdAt ?? new Date().toISOString(),
+    grantedAt: input.grantedAt ?? (GRANTED_STATUSES.has(normalizeStatus(input.status ?? 'approved')) ? new Date().toISOString() : null),
+    rejectedAt: input.rejectedAt ?? (normalizeStatus(input.status) === 'rejected' ? new Date().toISOString() : null),
+  };
+}
+
+export function grantCoversTask(grant, task, {
+  runId = null,
+  workspaceId = null,
+  planRevision = null,
+} = {}) {
+  if (task?.requiresApproval !== true) return true;
+  if (task?.approved === true || task?.approvalStatus === 'approved') return true;
+  if (!grant || !GRANTED_STATUSES.has(normalizeStatus(grant.status))) return false;
+  if (grant.runId != null && runId != null && String(grant.runId) !== String(runId)) return false;
+  const grantWorkspace = grant.workspaceId ?? grant.workspace ?? null;
+  if (grantWorkspace != null && workspaceId != null && String(grantWorkspace) !== String(workspaceId)) return false;
+  if (grant.planRevision != null && planRevision != null && Number(grant.planRevision) !== Number(planRevision)) return false;
+
+  const classes = normalizeClasses(grant.approvalClasses ?? grant.approvalClass);
+  if (classes.length > 0 && !classes.includes(approvalClassForTask(task))) return false;
+
+  const taskIds = new Set([task.id, task.localId, task.taskId].filter(Boolean).map(String));
+  const scope = normalizeScope(grant.scope);
+  if (scope === 'run' || scope === 'all') return true;
+  if (scope === 'group') return grant.groupId != null && String(grant.groupId) === String(task.groupId ?? '');
+  if (scope === 'task' || scope === 'tool') {
+    return [grant.taskId, grant.itemId, grant.approvalId, grant.id]
+      .filter(Boolean)
+      .some((id) => taskIds.has(String(id)));
+  }
+  return false;
+}
+
+export function approvalCovered(task, approvals = [], context = {}) {
+  return task?.requiresApproval !== true
+    || task?.approved === true
+    || task?.approvalStatus === 'approved'
+    || approvals.some((approval) => grantCoversTask(approval, task, context));
+}
+
+export function applyApprovalCoverage(tasks = [], {
+  approvals = [],
+  runId = null,
+  workspaceId = null,
+  planRevision = null,
+} = {}) {
+  const requested = [];
+  for (const task of tasks) {
+    if (task?.requiresApproval !== true || TERMINAL_STATUSES.has(String(task.status ?? '').toLowerCase())) continue;
+    const covered = approvalCovered(task, approvals, { runId, workspaceId, planRevision });
+    if (!covered) {
+      task.status = 'waiting_approval';
+      requested.push(approvalRequestForTask(task, { runId, workspaceId, planRevision }));
+    } else if (task.status === 'waiting_approval' || task.status === 'pending_approval') {
+      task.status = 'pending';
+    }
+  }
+  return requested;
+}
+
+export function approvalRequestForTask(task, {
+  runId = null,
+  workspaceId = null,
+  planRevision = null,
+} = {}) {
+  const approvalClass = approvalClassForTask(task);
+  return {
+    id: `approval:${runId ?? 'run'}:${task.id ?? task.localId ?? randomUUID()}:${approvalClass}`,
+    scope: 'task',
+    status: 'pending_approval',
+    runId,
+    workspaceId,
+    planRevision,
+    taskId: task.id ?? null,
+    groupId: task.groupId ?? null,
+    approvalClasses: [approvalClass],
+    reason: task.approvalSummary ?? task.label ?? task.description ?? null,
+  };
+}
+
+export function normalizeClasses(value) {
+  if (value == null) return [];
+  const values = Array.isArray(value) ? value : [value];
+  return [...new Set(values.map((item) => String(item).trim()).filter(Boolean))];
+}
+
+function normalizeScope(scope) {
+  const normalized = String(scope ?? 'run').toLowerCase();
+  if (normalized === 'all') return 'run';
+  if (['run', 'task', 'group', 'tool'].includes(normalized)) return normalized;
+  return 'run';
+}
+
+function normalizeStatus(status) {
+  const normalized = String(status ?? '').toLowerCase();
+  if (normalized === 'granted') return 'approved';
+  return normalized || 'approved';
+}

package/src/orchestrator/approvalPolicy.test.js

@@ -0,0 +1,78 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import {
+  applyApprovalCoverage,
+  approvalCovered,
+  normalizeApprovalGrant,
+} from './approvalPolicy.js';
+
+function task(overrides = {}) {
+  return {
+    id: 'run-1:build',
+    groupId: 'build',
+    requiresApproval: true,
+    approvalClass: 'workspace-write',
+    status: 'pending',
+    ...overrides,
+  };
+}
+
+test('approvalPolicy: approve all is bounded to run, workspace, revision and classes', () => {
+  const grant = normalizeApprovalGrant({
+    scope: 'run',
+    runId: 'run-1',
+    workspaceId: 'docs',
+    planRevision: 2,
+    approvalClasses: ['workspace-write'],
+  });
+
+  assert.equal(approvalCovered(task(), [grant], { runId: 'run-1', workspaceId: 'docs', planRevision: 2 }), true);
+  assert.equal(approvalCovered(task(), [grant], { runId: 'run-2', workspaceId: 'docs', planRevision: 2 }), false);
+  assert.equal(approvalCovered(task(), [grant], { runId: 'run-1', workspaceId: 'docs', planRevision: 3 }), false);
+  assert.equal(approvalCovered(task({ approvalClass: 'publish' }), [grant], { runId: 'run-1', workspaceId: 'docs', planRevision: 2 }), false);
+});
+
+test('approvalPolicy: task and group grants cover only their target scope', () => {
+  const taskGrant = normalizeApprovalGrant({
+    scope: 'task',
+    runId: 'run-1',
+    workspaceId: 'docs',
+    planRevision: 1,
+    taskId: 'run-1:build',
+    approvalClasses: ['workspace-write'],
+  });
+  const groupGrant = normalizeApprovalGrant({
+    scope: 'group',
+    runId: 'run-1',
+    workspaceId: 'docs',
+    planRevision: 1,
+    groupId: 'publish',
+    approvalClasses: ['workspace-write'],
+  });
+
+  assert.equal(approvalCovered(task(), [taskGrant], { runId: 'run-1', workspaceId: 'docs', planRevision: 1 }), true);
+  assert.equal(approvalCovered(task({ id: 'run-1:other' }), [taskGrant], { runId: 'run-1', workspaceId: 'docs', planRevision: 1 }), false);
+  assert.equal(approvalCovered(task({ groupId: 'publish' }), [groupGrant], { runId: 'run-1', workspaceId: 'docs', planRevision: 1 }), true);
+  assert.equal(approvalCovered(task({ groupId: 'build' }), [groupGrant], { runId: 'run-1', workspaceId: 'docs', planRevision: 1 }), false);
+});
+
+test('approvalPolicy: uncovered approved tasks become waiting_approval requests', () => {
+  const tasks = [task({ id: 'run-1:a' }), task({ id: 'run-1:b', approvalClass: 'publish' })];
+  const requests = applyApprovalCoverage(tasks, {
+    runId: 'run-1',
+    workspaceId: 'docs',
+    planRevision: 1,
+    approvals: [normalizeApprovalGrant({
+      scope: 'run',
+      runId: 'run-1',
+      workspaceId: 'docs',
+      planRevision: 1,
+      approvalClasses: ['workspace-write'],
+    })],
+  });
+
+  assert.deepEqual(tasks.map((item) => item.status), ['pending', 'waiting_approval']);
+  assert.deepEqual(requests.map((request) => request.taskId), ['run-1:b']);
+  assert.deepEqual(requests[0].approvalClasses, ['publish']);
+});

package/src/orchestrator/assignmentManager.js

@@ -0,0 +1,80 @@
+import { createCapabilityRegistry } from './capabilityRegistry.js';
+import { CapabilityUnavailableError, resolve } from './capabilityResolver.js';
+
+export function createAssignmentManager({
+  session = null,
+  registry = null,
+  workspaceConfig = null,
+} = {}) {
+  return {
+    assign(task, options = {}) {
+      return assign(task, {
+        session,
+        registry,
+        workspaceConfig,
+        ...options,
+      });
+    },
+  };
+}
+
+export async function assign(task, {
+  session = null,
+  registry = null,
+  workspaceConfig = null,
+} = {}) {
+  const capability = task?.requiredCapability;
+  if (!capability) {
+    throw new CapabilityUnavailableError(capability, 'task_missing_required_capability', { taskId: task?.id ?? task?.step });
+  }
+  const effectiveRegistry = registry ?? session?.capabilityRegistry ?? createCapabilityRegistry({
+    agents: session?.agentRegistrySnapshot ?? session?.agents ?? [],
+  });
+  const effectiveWorkspaceConfig = workspaceConfig ?? session?.wikircConfig ?? session?.wikirc?.config ?? {};
+  const retryAssignment = task?.retryAssignment;
+  if (retryAssignment?.agentInstanceId) {
+    const provider = providerFor(effectiveRegistry, capability, retryAssignment.agentInstanceId);
+    if (!provider) {
+      throw new CapabilityUnavailableError(capability, 'retry_agent_unavailable', {
+        agentInstanceId: retryAssignment.agentInstanceId,
+        taskId: task?.id ?? task?.step,
+      });
+    }
+    const agent = agentFor(session, retryAssignment.agentInstanceId) ?? provider;
+    return {
+      agentInstanceId: retryAssignment.agentInstanceId,
+      capability,
+      operation: task?.operation ?? null,
+      serverName: agent?.serverName ?? provider?.serverName ?? null,
+      agent,
+      retry: true,
+      previousAgentInstanceId: retryAssignment.previousAgentInstanceId ?? null,
+    };
+  }
+  const resolved = resolve(capability, {
+    workspaceConfig: effectiveWorkspaceConfig,
+    registry: effectiveRegistry,
+  });
+  const provider = providerFor(effectiveRegistry, capability, resolved.agentInstanceId);
+  const agent = agentFor(session, resolved.agentInstanceId) ?? provider ?? null;
+  return {
+    ...resolved,
+    capability,
+    operation: task?.operation ?? null,
+    serverName: agent?.serverName ?? provider?.serverName ?? null,
+    agent,
+  };
+}
+
+function providerFor(registry, capability, agentInstanceId) {
+  if (typeof registry?.providersFor !== 'function') return null;
+  return (registry.providersFor(capability) ?? [])
+    .find((provider) => provider.agentInstanceId === agentInstanceId) ?? null;
+}
+
+function agentFor(session, agentInstanceId) {
+  return [
+    ...(session?.agentRegistrySnapshot ?? []),
+    ...(session?.agents ?? []),
+  ].find((agent) => agent?.agentInstanceId === agentInstanceId) ?? null;
+}