@dotdrelle/wiki-manager 0.11.9 → 0.12.0

package/src/runtime/runner.js

@@ -1,12 +1,18 @@
 import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
-import { activityKey, sessionActivities, terminalFailures } from '../core/activity.js';
+import { sessionActivities, terminalFailures } from '../core/activity.js';
 import { runAgenticLoop, throwIfAborted } from '../core/agentLoop.js';
 import { formatPlanStatus } from '../core/plan.js';
-import { formatReadyTaskPrompt, readyPlanTasks, sanitizePlanForExecution } from '../core/planPatch.js';
+import { readyPlanTasks, sanitizePlanForExecution } from '../core/planPatch.js';
+import { createAssignmentManager } from '../orchestrator/assignmentManager.js';
+import { createAttemptManager } from '../orchestrator/attemptManager.js';
+import { createBudgetManager, BudgetExceededError } from '../orchestrator/budgetManager.js';
+import { createDispatcher } from '../orchestrator/dispatcher.js';
+import { assertValidatedFragment } from '../orchestrator/planValidator.js';
+import { createResultAggregator } from '../orchestrator/resultAggregator.js';
+import { drainActive, resolveSchedulerConcurrency, startReadyTasks } from '../orchestrator/scheduler.js';
 import { emitRuntimeLog, pollActivitiesOnce } from './supervisor.js';
 
 const DEFAULT_MAX_REPLANS = 2;
-const DEFAULT_SCHEDULER_CONCURRENCY = 3;
 
 async function waitForRuntimeActivities(session, startedActivities, { timeoutMs, signal, pollBusy }) {
   const deadline = Date.now() + timeoutMs;
@@ -87,6 +93,8 @@ export async function runRuntimeAgenticWorkflow(agent, session, input, {
   pollBusy,
   evaluate = true,
   maxReplans = resolveMaxReplans(),
+  callTool = null,
+  dispatcherPollIntervalMs = 250,
 } = {}) {
   let currentInput = initialInput ?? input;
   let replansLeft = Math.max(0, Math.floor(Number(maxReplans) || 0));
@@ -100,6 +108,8 @@ export async function runRuntimeAgenticWorkflow(agent, session, input, {
         maxTurns,
         runId,
         pollBusy,
+        callTool,
+        dispatcherPollIntervalMs,
       })
       : await runRuntimeAgenticLoop(agent, session, currentInput, {
         signal,
@@ -209,10 +219,28 @@ export async function runRuntimeParallelPlan(agent, session, input, {
   runId = null,
   pollBusy,
   concurrency = resolveSchedulerConcurrency(),
+  fragment = null,
+  assignmentManager = null,
+  attemptManager = null,
+  dispatcher = null,
+  resultAggregator = null,
+  budgetManager = null,
+  budgets = {},
+  callTool = null,
+  dispatcherPollIntervalMs = 250,
 } = {}) {
+  if (fragment != null) assertValidatedFragment(fragment);
   const limit = Math.max(1, Math.floor(Number(concurrency) || 1));
   const active = new Map();
-  const locks = new Set();
+  const attempts = attemptManager ?? createAttemptManager();
+  const assigner = assignmentManager ?? createAssignmentManager({ session });
+  const executor = dispatcher ?? createDispatcher({
+    session,
+    ...(callTool ? { callTool } : {}),
+    pollIntervalMs: dispatcherPollIntervalMs,
+  });
+  const aggregator = resultAggregator ?? createResultAggregator({ session, runId });
+  const budget = budgetManager ?? createBudgetManager({ budgets, runId });
   const failures = [];
   const previousIdentity = session._currentRunIdentity;
   const previousPlanUpdate = session._onPlanUpdate;
@@ -232,10 +260,10 @@ export async function runRuntimeParallelPlan(agent, session, input, {
   try {
     while (true) {
       if (signal?.aborted) {
-        await drainActive(active, locks);
+        await drainActive(active, attempts);
         throwIfAborted(signal, 'Runtime run cancelled.');
       }
-      const pending = (session.headlessPlan ?? []).filter((step) => step.status === 'pending' || step.status === 'pending_approval');
+      const pending = (session.headlessPlan ?? []).filter((step) => pendingSchedulerStatus(step.status));
       if (pending.length === 0 && active.size === 0) {
         emitRuntimeLog(session, 'scheduler: all plan tasks terminal');
         return failures.length > 0
@@ -243,18 +271,85 @@ export async function runRuntimeParallelPlan(agent, session, input, {
           : { ok: true };
       }
 
-      const started = startReadyTasks(agent, session, input, {
+      const started = startReadyTasks({
+        plan: session.headlessPlan,
         active,
-        locks,
-        signal,
-        timeoutMs,
-        maxTurns,
-        runId,
-        pollBusy,
+        attemptManager: attempts,
+        lockManager: attempts,
+        budgetManager: budget,
+        registry: session.capabilityRegistry ?? null,
+        approvals: session.agentProjection?.approvals ?? session.approvals ?? [],
         limit,
+        onDuplicateTask: (taskId) => {
+          // Two distinct ready tasks resolved to the same id/step — starting
+          // both would let plan_step_updated resolve to whichever one the
+          // reducer finds first, silently marking the wrong task done. Skip the
+          // duplicate rather than risk misattribution; it stays pending and
+          // will surface as a stalled plan instead of corrupting sibling state.
+          emitRuntimeLog(session, `scheduler: skipping task with duplicate id/step "${taskId}"`);
+        },
+        onTaskReady: (task) => {
+          emitRuntimeLog(session, taskLogPayload('task.ready', task, { runId, detail: 'ready for assignment' }));
+        },
+        onAttemptCreated: (task, attempt) => {
+          emitRuntimeLog(session, taskLogPayload('attempt.created', task, {
+            runId,
+            attempt,
+            detail: 'attempt created',
+          }));
+          emitRuntimeLog(session, taskLogPayload('lock.acquired', task, {
+            runId,
+            attempt,
+            detail: attempt?.locks?.join(',') || 'no locks',
+          }));
+        },
+        onTaskStarting: (task) => {
+          const taskId = planTaskId(task);
+          dispatchAgentEvent(session, createAgentEvent('plan_step_updated', {
+            origin: 'runtime',
+            runId,
+            taskId,
+            payload: { taskId, status: 'running' },
+          }));
+          emitRuntimeLog(session, taskLogPayload('task.starting', task, { runId, detail: `starting task ${taskId}` }));
+        },
+        startTask: (task, attempt) => {
+          const taskAbort = createTaskAbortSignal(signal);
+          const promise = runDispatchedTask(task, {
+            session,
+            assignmentManager: assigner,
+            dispatcher: executor,
+            resultAggregator: aggregator,
+            signal: taskAbort.signal,
+            timeoutMs,
+            runId,
+            pollBusy,
+            attempt,
+          });
+          return {
+            promise,
+            controller: taskAbort.controller,
+            signal: taskAbort.signal,
+            cleanup: taskAbort.cleanup,
+          };
+        },
       });
       if (started === 0 && active.size === 0) {
-        const reason = pending.every((step) => step.status === 'pending_approval') ? 'awaiting_approval' : 'no_ready_plan_task';
+        const exceeded = budget.exceeded?.();
+        if (exceeded) {
+          dispatchAgentEvent(session, createAgentEvent('run_error', {
+            origin: 'runtime',
+            runId,
+            payload: {
+              runId,
+              message: `Run budget exceeded: ${exceeded.reason}`,
+              budget: exceeded,
+            },
+          }));
+          emitRuntimeLog(session, `scheduler: budget exceeded (${exceeded.reason})`);
+          return { ok: false, budgetExceeded: true, reason: exceeded.reason, budget: exceeded, completed: sessionActivities(session), failures };
+        }
+        const reason = pending.every((step) => approvalWaitingStatus(step.status)) ? 'awaiting_approval' : 'no_ready_plan_task';
         emitRuntimeLog(session, `scheduler: stalled (${reason})`);
         return { ok: false, stalled: true, reason, completed: sessionActivities(session), failures };
       }
@@ -263,15 +358,45 @@ export async function runRuntimeParallelPlan(agent, session, input, {
       const activeEntry = active.get(settled.taskId);
       active.delete(settled.taskId);
       activeEntry?.cleanup?.();
-      for (const lock of settled.locks) locks.delete(lock);
       if (settled.cancelled) {
         if (signal?.aborted) {
-          await drainActive(active, locks);
+          await drainActive(active, attempts);
           throwIfAborted(signal, 'Runtime run cancelled.');
         }
         continue;
       }
-      if (!settled.ok) failures.push(settled);
+      try {
+        budget.recordTaskResult?.(settled.result ?? {});
+      } catch (err) {
+        if (err instanceof BudgetExceededError) {
+          dispatchAgentEvent(session, createAgentEvent('run_error', {
+            origin: 'runtime',
+            runId,
+            payload: {
+              runId,
+              message: err.message,
+              budget: { reason: err.reason, details: err.details },
+            },
+          }));
+          emitRuntimeLog(session, `scheduler: budget exceeded (${err.reason})`);
+          return { ok: false, budgetExceeded: true, reason: err.reason, budget: err.details, completed: sessionActivities(session), failures };
+        }
+        throw err;
+      }
+      if (!settled.ok) {
+        const task = (session.headlessPlan ?? []).find((item) => planTaskId(item) === settled.taskId);
+        const retry = attempts.scheduleRetry?.(task, settled, {
+          assignment: settled.assignment,
+          registry: session.capabilityRegistry ?? null,
+          session,
+          runId,
+        });
+        if (retry?.scheduled) {
+          emitRuntimeLog(session, `scheduler: retry scheduled for task ${settled.taskId}${retry.newAgentInstanceId ? ` on ${retry.newAgentInstanceId}` : ''}`);
+          continue;
+        }
+        failures.push(settled);
+      }
     }
   } finally {
     if (previousIdentity) session._currentRunIdentity = previousIdentity;
@@ -295,15 +420,6 @@ function sanitizeSessionPlanForExecution(session, runId = null) {
   }));
 }
 
-async function drainActive(active, locks) {
-  if (active.size === 0) return;
-  const entries = [...active.values()];
-  await Promise.all(entries.map((entry) => entry.promise));
-  for (const entry of entries) entry.cleanup?.();
-  active.clear();
-  locks.clear();
-}
-
 function abortCancelledActiveTasks(session, active) {
   for (const [taskId, entry] of active.entries()) {
     const current = (session.headlessPlan ?? []).find((step) => planTaskId(step) === taskId);
@@ -313,6 +429,14 @@ function abortCancelledActiveTasks(session, active) {
   }
 }
 
+function pendingSchedulerStatus(status) {
+  return ['pending', 'pending_approval', 'waiting_approval'].includes(String(status ?? ''));
+}
+
+function approvalWaitingStatus(status) {
+  return ['pending_approval', 'waiting_approval'].includes(String(status ?? ''));
+}
+
 // Scope the evaluator/replanner's view of "completed" activities to the
 // tasks that actually failed, instead of every activity the whole run has
 // ever recorded — a long-running sibling's stale (or unrelated, already
@@ -340,64 +464,6 @@ function ensurePlanProjection(session, runId) {
   }));
 }
 
-function startReadyTasks(agent, session, input, {
-  active,
-  locks,
-  signal,
-  timeoutMs,
-  maxTurns,
-  runId,
-  pollBusy,
-  limit,
-}) {
-  let started = 0;
-  const seenTaskIds = new Set(active.keys());
-  for (const task of readyPlanTasks(session.headlessPlan)) {
-    if (active.size >= limit) break;
-    const taskId = planTaskId(task);
-    if (active.has(taskId)) continue;
-    if (seenTaskIds.has(taskId)) {
-      // Two distinct ready tasks resolved to the same id/step — starting
-      // both would let plan_step_updated resolve to whichever one the
-      // reducer finds first, silently marking the wrong task done. Skip the
-      // duplicate rather than risk misattribution; it stays pending and
-      // will surface as a stalled plan instead of corrupting sibling state.
-      emitRuntimeLog(session, `scheduler: skipping task with duplicate id/step "${taskId}"`);
-      continue;
-    }
-    seenTaskIds.add(taskId);
-    const taskLocks = locksForTask(task);
-    if (taskLocks.some((lock) => locks.has(lock))) continue;
-    for (const lock of taskLocks) locks.add(lock);
-    dispatchAgentEvent(session, createAgentEvent('plan_step_updated', {
-      origin: 'runtime',
-      runId,
-      taskId,
-      payload: { taskId, status: 'running' },
-    }));
-    emitRuntimeLog(session, `scheduler: starting task ${taskId}`);
-    const taskAbort = createTaskAbortSignal(signal);
-    const promise = runParallelTask(agent, session, input, task, {
-      signal: taskAbort.signal,
-      timeoutMs,
-      maxTurns,
-      runId,
-      pollBusy,
-      locks: taskLocks,
-    });
-    active.set(taskId, {
-      taskId,
-      locks: taskLocks,
-      promise,
-      controller: taskAbort.controller,
-      signal: taskAbort.signal,
-      cleanup: taskAbort.cleanup,
-    });
-    started += 1;
-  }
-  return started;
-}
-
 function createTaskAbortSignal(parentSignal) {
   const controller = new AbortController();
   if (!parentSignal) return { controller, signal: controller.signal, cleanup: null };
@@ -414,55 +480,112 @@ function createTaskAbortSignal(parentSignal) {
   };
 }
 
-async function runParallelTask(agent, parentSession, input, task, {
+async function runDispatchedTask(task, {
+  session,
+  assignmentManager,
+  dispatcher,
+  resultAggregator,
   signal,
   timeoutMs,
-  maxTurns,
   runId,
   pollBusy,
-  locks,
+  attempt,
 }) {
   const taskId = planTaskId(task);
-  const childSession = createTaskSession(parentSession, task, { runId, taskId });
+  let assignment = null;
   try {
-    const result = await runRuntimeAgenticLoop(agent, childSession, buildTaskPrompt(input, parentSession.headlessPlan, task), {
+    emitRuntimeLog(session, taskLogPayload('capability.resolving', task, {
+      runId,
+      attempt,
+      detail: `resolving ${task.requiredCapability}`,
+    }));
+    assignment = await assignmentManager.assign(task, {
+      session,
+      signal,
+    });
+    emitRuntimeLog(session, taskLogPayload('agent.selected', task, {
+      runId,
+      attempt,
+      assignment,
+      detail: assignment.agentInstanceId,
+    }));
+    dispatchAgentEvent(session, createAgentEvent('task.assigned', {
+      origin: 'assignment_manager',
+      runId,
+      taskId,
+      payload: {
+        runId,
+        taskId,
+        attemptId: attempt?.attemptId ?? null,
+        assignment: {
+          ...assignment,
+          attemptId: attempt?.attemptId ?? null,
+          agent: undefined,
+        },
+      },
+    }));
+    emitRuntimeLog(session, taskLogPayload('task.assigned', task, {
+      runId,
+      attempt,
+      assignment,
+      detail: 'assignment created',
+    }));
+    const result = await dispatcher.execute(task, assignment, {
+      session,
       signal,
       timeoutMs,
-      maxTurns,
       runId,
       pollBusy,
+      attempt,
     });
-    if (!result.ok) {
-      dispatchAgentEvent(parentSession, createAgentEvent('plan_step_updated', {
-        origin: 'runtime',
+    const aggregate = await resultAggregator.accept(result, { task, assignment });
+    if (!aggregate.ok) {
+      emitRuntimeLog(session, taskLogPayload('task.failed', task, {
         runId,
-        taskId,
-        payload: { taskId, status: 'failed' },
+        attempt,
+        assignment,
+        jobId: result?.jobId,
+        error: result?.error?.code ?? result?.error?.message ?? result?.status ?? 'failed',
+        detail: 'task terminal',
       }));
-      return { ok: false, taskId, locks, result };
-    }
-    if ((parentSession.headlessPlan ?? []).find((step) => planTaskId(step) === taskId)?.status === 'cancelled') {
-      return { ok: false, taskId, locks, cancelled: true };
+      return { ok: false, taskId, result, assignment };
     }
-    dispatchAgentEvent(parentSession, createAgentEvent('plan_step_updated', {
-      origin: 'runtime',
+    emitRuntimeLog(session, taskLogPayload('task.completed', task, {
       runId,
-      taskId,
-      payload: { taskId, status: 'done' },
+      attempt,
+      assignment,
+      jobId: result?.jobId,
+      outputs: result?.outputRefs ?? [],
+      detail: 'returned to donna',
     }));
-    emitRuntimeLog(parentSession, `scheduler: task ${taskId} done`);
-    return { ok: true, taskId, locks, result };
+    return { ok: true, taskId, result, assignment };
   } catch (err) {
     if (err?.name === 'AbortError') {
-      dispatchAgentEvent(parentSession, createAgentEvent('plan_step_updated', {
+      attempt?.release?.();
+      dispatchAgentEvent(session, createAgentEvent('plan_step_updated', {
         origin: 'runtime',
         runId,
         taskId,
         payload: { taskId, status: 'cancelled' },
       }));
-      return { ok: false, taskId, locks, cancelled: true };
+      return { ok: false, taskId, cancelled: true, assignment };
     }
-    dispatchAgentEvent(parentSession, createAgentEvent('plan_step_updated', {
+    attempt?.release?.();
+    const result = {
+      ok: false,
+      taskId,
+      attemptId: attempt?.attemptId ?? null,
+      status: 'failed',
+      outputRefs: [],
+      metrics: {},
+      error: {
+        code: 'dispatcher_error',
+        message: err instanceof Error ? err.message : String(err),
+        retryable: false,
+      },
+    };
+    await resultAggregator.accept(result, { task, assignment });
+    dispatchAgentEvent(session, createAgentEvent('plan_step_updated', {
       origin: 'runtime',
       runId,
       taskId,
@@ -471,131 +594,49 @@ async function runParallelTask(agent, parentSession, input, task, {
     return {
       ok: false,
       taskId,
-      locks,
+      result,
+      assignment,
       error: err instanceof Error ? err.message : String(err),
     };
   }
 }
 
-function createTaskSession(parent, task, { runId, taskId }) {
-  const child = {
-    ...parent,
-    // Copy (not share) the parent's activities: a child's own diffing needs
-    // isolation from mutation, but local guards like productionLockBusy must
-    // still see activities already running when this task started.
-    activities: { ...parent.activities },
-    agentEvents: [],
-    agentProjection: null,
-    _agentProjectionState: null,
-    headlessPlan: null,
-    _currentRunIdentity: {
-      ...(parent._currentRunIdentity ?? {}),
-      runId,
-      taskId,
-      workspace: parent.workspace ?? parent._currentRunIdentity?.workspace ?? null,
-    },
-    _onAgentEvent: (event) => {
-      if (event.type === 'plan_set') return;
-      if (event.type === 'plan_step_updated') {
-        // The child always targets its own single task, regardless of what
-        // step/id the child's LLM passed to wiki__plan_done — a child has no
-        // visibility into the parent's real multi-task numbering.
-        dispatchAgentEvent(parent, {
-          ...event,
-          taskId: taskId,
-          runId: event.runId ?? runId,
-          payload: { ...event.payload, taskId },
-        });
-        return;
-      }
-      if (event.type === 'activity_upserted') {
-        stampOwnerActivityKey(parent, taskId, event.payload?.activity);
-      }
-      dispatchAgentEvent(parent, {
-        ...event,
-        taskId: event.taskId ?? taskId,
-        runId: event.runId ?? runId,
-      });
-    },
-  };
-  Object.defineProperty(child, '_runApprovalResolved', {
-    get: () => parent._runApprovalResolved,
-    set: (value) => { parent._runApprovalResolved = value; },
-    enumerable: true,
-    configurable: true,
-  });
-  if (parent._requestApproval) {
-    child._requestApproval = (request) => {
-      if (request?.scope === 'tool') return parent._requestApproval(request);
-      // Run-level approval is one decision for the whole run: concurrent
-      // children must join the same in-flight request instead of each
-      // minting their own (only one of which /approve could ever resolve).
-      parent._pendingRunApproval ??= parent._requestApproval(request)
-        .finally(() => { delete parent._pendingRunApproval; });
-      return parent._pendingRunApproval;
-    };
-  }
-  // Seed the plan through the real reducer (not a raw property write): the
-  // child's own _agentProjectionState knows nothing about this task
-  // otherwise, and the very next session-projection event (even a plain
-  // runtime_log from onTurnStart) would overwrite headlessPlan back to null
-  // via applyAgentProjectionToSession. The _onAgentEvent filter above already
-  // keeps this plan_set from being forwarded to the parent.
-  dispatchAgentEvent(child, createAgentEvent('plan_set', {
-    origin: 'runtime',
-    runId,
-    taskId,
-    payload: { steps: [{ ...task, status: 'running' }] },
-  }));
-  return child;
-}
-
-function stampOwnerActivityKey(parent, taskId, rawActivity) {
-  if (!rawActivity) return;
-  const entry = (parent.headlessPlan ?? []).find((item) => String(item.id ?? item.step) === taskId);
-  if (!entry || entry.ownerActivityKey) return;
-  entry.ownerActivityKey = activityKey(rawActivity);
-}
-
-function buildTaskPrompt(input, plan, task) {
-  return [
-    'Original task:',
-    input || '(unknown)',
-    '',
-    `Plan status:\n${formatPlanStatus(plan)}`,
-    '',
-    formatReadyTaskPrompt(task),
-    '',
-    'Execute exactly this task as an autonomous child task.',
-    'Do not start sibling tasks. Do not modify unrelated plan steps.',
-    'If this task cannot complete, report the blocker clearly.',
-  ].join('\n');
+function shouldUseParallelScheduler(plan) {
+  return readyPlanTasks(plan).some((task) => task.requiredCapability && task.operation);
 }
 
-function shouldUseParallelScheduler(plan) {
-  return readyPlanTasks(plan).length > 0;
+function taskLogPayload(event, task, {
+  runId = null,
+  attempt = null,
+  assignment = null,
+  jobId = null,
+  outputs = null,
+  error = null,
+  detail = null,
+} = {}) {
+  return {
+    event,
+    runId,
+    planRevision: task?.planRevision ?? null,
+    groupId: task?.groupId ?? null,
+    taskId: planTaskId(task),
+    attemptId: attempt?.attemptId ?? null,
+    agentType: assignment?.agent?.description?.agentType ?? assignment?.description?.agentType ?? null,
+    agentInstanceId: assignment?.agentInstanceId ?? null,
+    agentId: assignment?.agentId ?? null,
+    jobId,
+    capability: task?.requiredCapability ?? assignment?.capability ?? null,
+    operation: task?.operation ?? assignment?.operation ?? null,
+    outputs,
+    error,
+    detail,
+  };
 }
 
 function planTaskId(task) {
   return String(task.id ?? task.step);
 }
 
-function locksForTask(task) {
-  const locks = new Set();
-  const explicit = task.locks ?? task.writeLocks ?? null;
-  if (Array.isArray(explicit)) {
-    for (const lock of explicit) if (lock) locks.add(String(lock));
-  } else if (explicit && typeof explicit === 'object') {
-    if (explicit.workspaceWrite || explicit.workspace) locks.add('workspace:write');
-    for (const value of explicit.deliverableWrites ?? explicit.deliverables ?? []) locks.add(`deliverable:${value}`);
-    for (const value of explicit.wikiPageWrites ?? explicit.wikiPages ?? []) locks.add(`wiki-page:${value}`);
-  }
-  for (const value of task.deliverableWrites ?? []) locks.add(`deliverable:${value}`);
-  for (const value of task.wikiPageWrites ?? []) locks.add(`wiki-page:${value}`);
-  if (task.workspaceWrite) locks.add('workspace:write');
-  return [...locks].sort();
-}
-
 export async function finishRuntimeRun(session, input, {
   runId,
   signal = null,
@@ -934,10 +975,3 @@ function resolveMaxReplans(value = process.env.WIKI_MANAGER_REPLANNER_MAX_REPLAN
   const parsed = Number(value);
   return Number.isFinite(parsed) ? Math.max(0, Math.floor(parsed)) : DEFAULT_MAX_REPLANS;
 }
-
-function resolveSchedulerConcurrency(value = process.env.WIKI_MANAGER_SCHEDULER_CONCURRENCY) {
-  const parsed = Number(value);
-  return Number.isFinite(parsed) && parsed > 0
-    ? Math.max(1, Math.floor(parsed))
-    : DEFAULT_SCHEDULER_CONCURRENCY;
-}