akm-cli 0.9.16 → 0.9.17-alpha.10

package/dist/workflows/exec/scheduler.js

@@ -2,52 +2,25 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 /**
- * Unit scheduler for the native workflow executor (orchestration plan P1).
- *
- * A thin policy layer over `core/concurrent.ts` (`concurrentMap`) — the
- * existing semaphore-bounded pool is generalized, not forked. The scheduler
- * owns the limits the plan requires:
- *
- *   - The effective width is the minimum of the map request, the frozen
- *     workflow cap, the selected LLM engine's frozen cap (when applicable),
- *     and the current host's CPU-derived safety cap. Reapplying host safety at
- *     dispatch matters when a frozen run resumes on a smaller machine.
- *   - Cooperative cancellation via AbortSignal (workers stop claiming items;
- *     the same signal is passed into each dispatch so in-flight units can be
- *     preempted too).
+ * Unit scheduler: a policy layer over `concurrentMap`. The effective width is
+ * the minimum of the map request, the frozen workflow cap, the LLM engine's
+ * frozen cap, and the current host's CPU cap (reapplied, since a run may
+ * resume on a smaller machine). Cancellation is cooperative via AbortSignal.
  */
 import { concurrentMap } from "../../core/concurrent.js";
 import { cpuDerivedUnitConcurrency, workflowMaxConcurrency } from "../concurrency-policy.js";
 export { clampMaxConcurrency, cpuDerivedUnitConcurrency, WORKFLOW_MAX_CONCURRENCY_CEILING, } from "../concurrency-policy.js";
 /**
- * Hard ceiling on an EXPLICIT `workflow.maxConcurrency`. A user value above
- * this is clamped down (not rejected) so a config shared across machines with
- * very different core counts never hard-fails; a value below 1 is floored to 1.
- * 64 is deliberately far above any sane fan-out width — it exists only to keep
- * a fat-fingered `100000` from spawning a runaway pool.
- */
-/**
- * Engine-wide ceiling on concurrent units. Precedence:
- *   1. An explicit `workflow.maxConcurrency` config value, clamped to
- *      `[1, WORKFLOW_MAX_CONCURRENCY_CEILING]`.
- *   2. Otherwise the CPU-derived default `min(16, max(1, cores−2))`.
- * The per-run test seam (`ScheduleOptions.maxConcurrency`) is applied ABOVE
- * this in {@link scheduleUnits}, so it always wins for tests.
- *
- * @param cpuCount   CPU count for the fallback formula (injected by tests).
- * @param configured Explicit config value seam (defaults to reading config);
- *                   pass `undefined` explicitly to force the CPU path in a test.
+ * Engine-wide ceiling on concurrent units: an explicit `workflow.maxConcurrency`
+ * clamped to `[1, 64]`, else `min(16, max(1, cores − 2))`.
  */
 export function maxUnitConcurrency(cpuCount, configured) {
     return workflowMaxConcurrency(configured, cpuCount);
 }
 /**
- * Run `dispatch` over `items` under the engine concurrency caps. Individual
- * failures do not cancel siblings (allSettled semantics from `concurrentMap`);
- * a slot whose dispatch threw or that was never claimed after an abort stays
- * `undefined` in the result array. A declared `budget.max_units` ceiling is
- * NOT checked here — the executor consumes it per actual dispatch, so
- * durable-row reuses on resume stay free.
+ * Run `dispatch` over `items` under the concurrency caps. Failures do not
+ * cancel siblings; a slot that threw or was never claimed after an abort
+ * stays `undefined`.
  */
 export async function scheduleUnits(items, dispatch, options = {}) {
     const concurrency = Math.max(1, Math.min(options.concurrency ?? 1, options.maxConcurrency ?? Number.POSITIVE_INFINITY, options.llmConcurrency ?? Number.POSITIVE_INFINITY, options.hostConcurrency ?? cpuDerivedUnitConcurrency()));