@dotdrelle/wiki-manager 0.9.3 → 0.10.4

package/src/core/workflow.test.js

@@ -0,0 +1,66 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { projectWorkflow } from './workflow.js';
+
+test('projectWorkflow links structured plan tasks to activities and executors', () => {
+  const workflow = projectWorkflow({
+    status: 'running',
+    runId: 'run-1',
+    workspace: 'docs',
+    plan: [
+      { step: 1, id: 'export', description: 'Export CME', status: 'done', executor: 'cme.cme_export_run', outputRefs: ['raw/untracked'] },
+      { step: 2, id: 'build', description: 'Build deliverable', status: 'running', dependsOn: ['export'], executor: 'production.production_start_job', activityKey: 'production:job-1' },
+    ],
+    activities: [{
+      key: 'production:job-1',
+      id: 'job-1',
+      source: 'production',
+      label: 'Production build',
+      status: 'running',
+      progress: { percent: 42, stepId: 'build' },
+    }],
+    queue: [],
+    approvals: [],
+  });
+
+  assert.equal(workflow.summary.status, 'running');
+  assert.equal(workflow.current.id, 'task:build');
+  assert.equal(workflow.next, null);
+  assert.equal(workflow.progress.mode, 'activity_percent');
+  assert.equal(workflow.progress.percent, 42);
+  assert.ok(workflow.relations.some((relation) => relation.type === 'depends_on' && relation.from === 'task:build' && relation.to === 'task:export'));
+  assert.ok(workflow.relations.some((relation) => relation.type === 'executed_by' && relation.from === 'task:build' && relation.to === 'activity:production:job-1'));
+  assert.ok(workflow.relations.some((relation) => relation.type === 'produces' && relation.from === 'task:export' && relation.to === 'output:raw/untracked'));
+});
+
+test('projectWorkflow keeps old sequential runs readable', () => {
+  const workflow = projectWorkflow({
+    status: 'done',
+    plan: [
+      { step: 1, description: 'Analyze', status: 'done' },
+      { step: 2, description: 'Execute', status: 'done' },
+    ],
+    activities: [],
+    queue: [],
+    approvals: [],
+  });
+
+  assert.equal(workflow.summary.status, 'done');
+  assert.equal(workflow.progress.mode, 'task_count');
+  assert.equal(workflow.progress.percent, 100);
+  assert.deepEqual(workflow.warnings, ['legacy_sequential_plan']);
+});
+
+test('projectWorkflow reports approval and queue waiting reasons', () => {
+  const workflow = projectWorkflow({
+    status: 'running',
+    plan: [{ step: 1, id: 'send', description: 'Send email', status: 'pending_approval' }],
+    activities: [],
+    queue: [{ id: 'queued-1', status: 'queued', label: 'Future run' }],
+    approvals: [{ id: 'approval-1', status: 'pending_approval', reason: 'Confirm email' }],
+  });
+
+  assert.equal(workflow.current.id, 'task:send');
+  assert.ok(workflow.waitingReasons.includes('approval:approval-1'));
+  assert.ok(workflow.waitingReasons.includes('queue:queued-1'));
+});

package/src/runtime/client.js

@@ -53,7 +53,34 @@ export async function postRuntimeRun(input, {
     },
     body: JSON.stringify(Object.assign({ input, workspace }, evaluate !== undefined && { evaluate }, replans !== undefined && { replans })),
   });
-  if (!response.ok) throw new Error(`Runtime run failed: HTTP ${response.status}`);
+  if (!response.ok) {
+    const err = new Error(`Runtime run failed: HTTP ${response.status}`);
+    err.status = response.status;
+    throw err;
+  }
+  return response.json();
+}
+
+export async function postRuntimeControl(action, {
+  url = runtimeUrlFromEnv(),
+  token = runtimeToken(),
+  workspace = null,
+  input = undefined,
+  intent = undefined,
+} = {}) {
+  const response = await fetch(runtimeEndpoint(url, '/control', workspace), {
+    method: 'POST',
+    headers: {
+      ...runtimeHeaders(token),
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify(Object.assign({ action }, input !== undefined && { input }, intent !== undefined && { intent })),
+  });
+  if (!response.ok) {
+    const err = new Error(`Runtime control failed: HTTP ${response.status}`);
+    err.status = response.status;
+    throw err;
+  }
   return response.json();
 }
 

package/src/runtime/runner.js

@@ -1,10 +1,12 @@
 import { createAgentEvent, dispatchAgentEvent } from '../core/agentEvents.js';
-import { sessionActivities, terminalFailures } from '../core/activity.js';
+import { activityKey, sessionActivities, terminalFailures } from '../core/activity.js';
 import { runAgenticLoop, throwIfAborted } from '../core/agentLoop.js';
 import { formatPlanStatus } from '../core/plan.js';
+import { formatReadyTaskPrompt, readyPlanTasks } from '../core/planPatch.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;
@@ -35,12 +37,13 @@ async function waitForRuntimeActivities(session, startedActivities, { timeoutMs,
   return { ok: false, timedOut: true, completed: tracked };
 }
 
-export async function runRuntimeAgenticLoop(agent, session, initialInput, { signal, timeoutMs, maxTurns, runId, pollBusy }) {
+export async function runRuntimeAgenticLoop(agent, session, initialInput, { signal, timeoutMs, maxTurns, runId, pollBusy, parallelHandoff = false }) {
   return runAgenticLoop(agent, session, initialInput, {
     signal,
     timeoutMs,
     maxTurns,
     runId,
+    parallelHandoff,
     abortMessage: 'Runtime run cancelled.',
     waitForActivities: (turnSession, startedActivities, waitOptions) =>
       waitForRuntimeActivities(turnSession, startedActivities, { ...waitOptions, pollBusy }),
@@ -58,7 +61,7 @@ export async function runRuntimeAgenticLoop(agent, session, initialInput, { sign
       }
     },
     onPlanExtracted: ({ steps }) => {
-      emitRuntimeLog(session, `agentic-loop: plan extracted from text (${steps.length} steps)`);
+      emitRuntimeLog(session, `agentic-loop: plan extracted from text (${steps.length} steps, deprecated fallback)`);
     },
     onComplete: () => {
       emitRuntimeLog(session, 'agentic-loop: no pending activity or plan step');
@@ -89,13 +92,23 @@ export async function runRuntimeAgenticWorkflow(agent, session, input, {
   let replansLeft = Math.max(0, Math.floor(Number(maxReplans) || 0));
 
   while (true) {
-    const result = await runRuntimeAgenticLoop(agent, session, currentInput, {
-      signal,
-      timeoutMs,
-      maxTurns,
-      runId,
-      pollBusy,
-    });
+    const result = shouldUseParallelScheduler(session.headlessPlan)
+      ? await runRuntimeParallelPlan(agent, session, input, {
+        signal,
+        timeoutMs,
+        maxTurns,
+        runId,
+        pollBusy,
+      })
+      : await runRuntimeAgenticLoop(agent, session, currentInput, {
+        signal,
+        timeoutMs,
+        maxTurns,
+        runId,
+        pollBusy,
+        parallelHandoff: true,
+      });
+    if (result.ok && result.handoff) continue;
     if (!result.ok) {
       const trigger = replanTriggerFromLoopResult(result);
       if (trigger && replansLeft > 0) {
@@ -173,6 +186,336 @@ export async function runRuntimeAgenticWorkflow(agent, session, input, {
   }
 }
 
+export async function runRuntimeParallelPlan(agent, session, input, {
+  signal = null,
+  timeoutMs,
+  maxTurns,
+  runId = null,
+  pollBusy,
+  concurrency = resolveSchedulerConcurrency(),
+} = {}) {
+  const limit = Math.max(1, Math.floor(Number(concurrency) || 1));
+  const active = new Map();
+  const locks = new Set();
+  const failures = [];
+  const previousIdentity = session._currentRunIdentity;
+  session._currentRunIdentity = {
+    ...(previousIdentity ?? {}),
+    runId,
+    workspace: session.workspace ?? previousIdentity?.workspace ?? null,
+  };
+  ensurePlanProjection(session, runId);
+  emitRuntimeLog(session, `scheduler: parallel plan enabled (concurrency ${limit})`);
+
+  try {
+    while (true) {
+      if (signal?.aborted) {
+        await drainActive(active, locks);
+        throwIfAborted(signal, 'Runtime run cancelled.');
+      }
+      const pending = (session.headlessPlan ?? []).filter((step) => step.status === 'pending' || step.status === 'pending_approval');
+      if (pending.length === 0 && active.size === 0) {
+        emitRuntimeLog(session, 'scheduler: all plan tasks terminal');
+        return failures.length > 0
+          ? { ok: false, completed: failedTaskActivities(session), failures }
+          : { ok: true };
+      }
+
+      const started = startReadyTasks(agent, session, input, {
+        active,
+        locks,
+        signal,
+        timeoutMs,
+        maxTurns,
+        runId,
+        pollBusy,
+        limit,
+      });
+      if (started === 0 && active.size === 0) {
+        const reason = pending.every((step) => step.status === 'pending_approval') ? 'awaiting_approval' : 'no_ready_plan_task';
+        emitRuntimeLog(session, `scheduler: stalled (${reason})`);
+        return { ok: false, stalled: true, reason, completed: sessionActivities(session), failures };
+      }
+
+      const settled = await Promise.race([...active.values()].map((entry) => entry.promise));
+      active.delete(settled.taskId);
+      for (const lock of settled.locks) locks.delete(lock);
+      if (settled.cancelled) {
+        await drainActive(active, locks);
+        throwIfAborted(signal, 'Runtime run cancelled.');
+        continue;
+      }
+      if (!settled.ok) failures.push(settled);
+    }
+  } finally {
+    if (previousIdentity) session._currentRunIdentity = previousIdentity;
+    else delete session._currentRunIdentity;
+  }
+}
+
+async function drainActive(active, locks) {
+  if (active.size === 0) return;
+  await Promise.all([...active.values()].map((entry) => entry.promise));
+  active.clear();
+  locks.clear();
+}
+
+// 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
+// resolved) activity must not shadow the real failure.
+function failedTaskActivities(session) {
+  const failedKeys = new Set(
+    (session.headlessPlan ?? [])
+      .filter((step) => step.status === 'failed')
+      .map((step) => step.ownerActivityKey ?? step.activityKey)
+      .filter(Boolean),
+  );
+  const all = sessionActivities(session);
+  return failedKeys.size > 0 ? all.filter((activity) => failedKeys.has(activity.key)) : all;
+}
+
+function ensurePlanProjection(session, runId) {
+  if (!session.headlessPlan || session.agentProjection?.plan) return;
+  dispatchAgentEvent(session, createAgentEvent('plan_set', {
+    origin: 'runtime',
+    runId,
+    payload: {
+      steps: session.headlessPlan,
+      planRevision: session.planRevision ?? 0,
+    },
+  }));
+}
+
+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 promise = runParallelTask(agent, session, input, task, {
+      signal,
+      timeoutMs,
+      maxTurns,
+      runId,
+      pollBusy,
+      locks: taskLocks,
+    });
+    active.set(taskId, { taskId, locks: taskLocks, promise });
+    started += 1;
+  }
+  return started;
+}
+
+async function runParallelTask(agent, parentSession, input, task, {
+  signal,
+  timeoutMs,
+  maxTurns,
+  runId,
+  pollBusy,
+  locks,
+}) {
+  const taskId = planTaskId(task);
+  const childSession = createTaskSession(parentSession, task, { runId, taskId });
+  try {
+    const result = await runRuntimeAgenticLoop(agent, childSession, buildTaskPrompt(input, parentSession.headlessPlan, task), {
+      signal,
+      timeoutMs,
+      maxTurns,
+      runId,
+      pollBusy,
+    });
+    if (!result.ok) {
+      dispatchAgentEvent(parentSession, createAgentEvent('plan_step_updated', {
+        origin: 'runtime',
+        runId,
+        taskId,
+        payload: { taskId, status: 'failed' },
+      }));
+      return { ok: false, taskId, locks, result };
+    }
+    dispatchAgentEvent(parentSession, createAgentEvent('plan_step_updated', {
+      origin: 'runtime',
+      runId,
+      taskId,
+      payload: { taskId, status: 'done' },
+    }));
+    emitRuntimeLog(parentSession, `scheduler: task ${taskId} done`);
+    return { ok: true, taskId, locks, result };
+  } catch (err) {
+    if (err?.name === 'AbortError') {
+      dispatchAgentEvent(parentSession, createAgentEvent('plan_step_updated', {
+        origin: 'runtime',
+        runId,
+        taskId,
+        payload: { taskId, status: 'cancelled' },
+      }));
+      return { ok: false, taskId, locks, cancelled: true };
+    }
+    dispatchAgentEvent(parentSession, createAgentEvent('plan_step_updated', {
+      origin: 'runtime',
+      runId,
+      taskId,
+      payload: { taskId, status: 'failed' },
+    }));
+    return {
+      ok: false,
+      taskId,
+      locks,
+      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).length > 0;
+}
+
+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,
@@ -298,6 +641,7 @@ export async function replanRuntimeRun(session, input, trigger, {
     return { ok: false, reason: 'Replanner unavailable: no LLM completeWithTools client.' };
   }
   try {
+    const currentPlan = session.headlessPlan;
     emitRuntimeLog(session, 'runtime: replanning remaining work');
     const result = await llm.completeWithTools({
       system: [
@@ -312,6 +656,7 @@ export async function replanRuntimeRun(session, input, trigger, {
     });
     const steps = normalizeReplan(parseJsonFenced(result.content, 'replan response').steps);
     if (steps.length === 0) throw new Error('empty replan');
+    const mergedSteps = mergeReplanWithCompleted(currentPlan, steps);
     dispatchAgentEvent(session, createAgentEvent('run_replanned', {
       origin: 'runtime',
       runId,
@@ -326,11 +671,7 @@ export async function replanRuntimeRun(session, input, trigger, {
       origin: 'runtime',
       runId,
       payload: {
-        steps: steps.map((description, index) => ({
-          step: index + 1,
-          description,
-          status: 'pending',
-        })),
+        steps: mergedSteps,
       },
     }));
     return { ok: true, steps };
@@ -340,14 +681,36 @@ export async function replanRuntimeRun(session, input, trigger, {
 }
 
 function replanTriggerFromLoopResult(result) {
+  // 'awaiting_approval' is not a dead end — it means to wait for a human
+  // decision, not to replan around it.
+  if (result.stalled && result.reason !== 'awaiting_approval') {
+    return {
+      kind: 'plan_stalled',
+      reason: `Plan is stalled: ${result.reason ?? 'no ready task'} (pending steps exist but none have their dependencies satisfied).`,
+      suggestedAction: 'Drop or replace the unsatisfiable dependency.',
+      activity: null,
+    };
+  }
   const failures = terminalFailures(result.completed ?? []);
   const failure = failures[0];
-  if (!failure) return null;
+  if (failure) {
+    return {
+      kind: 'activity_error',
+      reason: `${failure.label ?? failure.id ?? 'Activity'} ended with ${failure.status}${failure.error ? `: ${failure.error}` : ''}`,
+      suggestedAction: failure.error ?? null,
+      activity: failure,
+    };
+  }
+  // The parallel scheduler can fail a task before it ever produces an
+  // _activity (e.g. a thrown error on the first turn) — that failure lives
+  // in result.failures, not in any activity, so it must be checked too.
+  const taskFailure = (result.failures ?? [])[0];
+  if (!taskFailure) return null;
   return {
-    kind: 'activity_error',
-    reason: `${failure.label ?? failure.id ?? 'Activity'} ended with ${failure.status}${failure.error ? `: ${failure.error}` : ''}`,
-    suggestedAction: failure.error ?? null,
-    activity: failure,
+    kind: 'task_error',
+    reason: `Task ${taskFailure.taskId} failed${taskFailure.error ? `: ${taskFailure.error}` : ''}`,
+    suggestedAction: taskFailure.error ?? null,
+    activity: null,
   };
 }
 
@@ -399,6 +762,48 @@ function normalizeReplan(steps) {
     .slice(0, 12);
 }
 
+function mergeReplanWithCompleted(plan, steps) {
+  const completed = (plan ?? [])
+    .filter((step) => step.status === 'done')
+    .map((step, index) => ({
+      ...step,
+      step: index + 1,
+      status: 'done',
+      dependsOn: Array.isArray(step.dependsOn) ? step.dependsOn.map(String) : [],
+      outputRefs: Array.isArray(step.outputRefs) ? step.outputRefs.map(String) : [],
+    }));
+  const completedIds = completed.map((step) => String(step.id ?? step.step));
+  // Start numbering past any `replan-N` id already present in the incoming
+  // plan (e.g. a `done` step from an earlier replan in the same run) so a
+  // second/third replan in one run can't mint an id that collides with one
+  // already carried over in `completed`.
+  const nextReplanIndex = nextReplanIdIndex(plan);
+  // The replanner returns a flat, inherently-ordered list of description
+  // strings with no independence information — chain each step to the
+  // previous one (in addition to the prior completed steps for the first)
+  // so replanned work still runs sequentially instead of fanning out
+  // through the parallel scheduler now that any ready task triggers it.
+  const replanned = steps.map((description, index) => ({
+    step: completed.length + index + 1,
+    id: `replan-${nextReplanIndex + index}`,
+    description,
+    status: 'pending',
+    dependsOn: index === 0 ? completedIds : [`replan-${nextReplanIndex + index - 1}`],
+    executor: null,
+    outputRefs: [],
+  }));
+  return [...completed, ...replanned];
+}
+
+function nextReplanIdIndex(plan) {
+  const used = (plan ?? [])
+    .map((step) => String(step.id ?? ''))
+    .filter((id) => id.startsWith('replan-'))
+    .map((id) => Number(id.slice('replan-'.length)))
+    .filter((n) => Number.isFinite(n));
+  return used.length ? Math.max(...used) + 1 : 1;
+}
+
 function formatRecentConversation(session, n = 12) {
   const conversation = session.agentProjection?.conversation ?? [];
   return conversation
@@ -411,3 +816,10 @@ 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;
+}