octoflow-core 1.0.0

package/dist/runtime/orchestration/run/task-batch-graph.js

@@ -0,0 +1,110 @@
+import crypto from "node:crypto";
+import { contextIsolation } from "./isolation/context.js";
+import { gitBranchIsolation } from "./isolation/git.js";
+import { noIsolation } from "./isolation/none.js";
+function validateDependencies(items) {
+  const ids = new Set(items.map((t) => t.id));
+  for (const item of items) {
+    for (const dep of item.dependsOn ?? []) {
+      if (!ids.has(dep)) {
+        throw new Error(`Task "${item.id}" depends on unknown task "${dep}"`);
+      }
+    }
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const stack = /* @__PURE__ */ new Set();
+  const itemMap = new Map(items.map((t) => [t.id, t]));
+  function dfs(id) {
+    if (stack.has(id)) {
+      throw new Error(`Dependency cycle detected involving task "${id}"`);
+    }
+    if (visited.has(id)) return;
+    stack.add(id);
+    for (const dep of itemMap.get(id)?.dependsOn ?? []) {
+      dfs(dep);
+    }
+    stack.delete(id);
+    visited.add(id);
+  }
+  for (const item of items) dfs(item.id);
+}
+function topologicalSort(items) {
+  const inDegree = /* @__PURE__ */ new Map();
+  const dependents = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    inDegree.set(item.id, (item.dependsOn ?? []).length);
+    for (const dep of item.dependsOn ?? []) {
+      const list = dependents.get(dep) ?? [];
+      list.push(item);
+      dependents.set(dep, list);
+    }
+  }
+  const queue = items.filter((item) => (inDegree.get(item.id) ?? 0) === 0).sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0));
+  const sorted = [];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    sorted.push(current);
+    for (const dependent of dependents.get(current.id) ?? []) {
+      const newDegree = (inDegree.get(dependent.id) ?? 0) - 1;
+      inDegree.set(dependent.id, newDegree);
+      if (newDegree === 0) {
+        queue.push(dependent);
+        queue.sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0));
+      }
+    }
+  }
+  return sorted;
+}
+function resolveIsolationStrategy(config) {
+  const iso = config.isolation ?? "context";
+  if (typeof iso === "object") return iso;
+  if (iso === "none") return noIsolation();
+  if (iso === "branch") {
+    return gitBranchIsolation({ automation: config.automation ?? {} });
+  }
+  return contextIsolation();
+}
+function buildFailedResult(contextId) {
+  return {
+    kind: "task",
+    contextId,
+    taskId: crypto.randomUUID(),
+    task: {
+      id: crypto.randomUUID(),
+      kind: "task",
+      contextId,
+      status: { state: "failed" }
+    },
+    terminationReason: "error",
+    outcomeClass: "failure",
+    totalIterations: 0,
+    totalElapsedMs: 0
+  };
+}
+function buildWaves(items) {
+  const waves = [];
+  const placed = /* @__PURE__ */ new Set();
+  while (placed.size < items.length) {
+    const wave = [];
+    for (let i = 0; i < items.length; i++) {
+      const task = items[i];
+      if (placed.has(task.id)) continue;
+      const deps = task.dependsOn ?? [];
+      if (deps.every((d) => placed.has(d))) {
+        wave.push({ task, originalIndex: i });
+      }
+    }
+    if (wave.length === 0) break;
+    for (const { task } of wave) placed.add(task.id);
+    waves.push(wave);
+  }
+  return waves;
+}
+export {
+  buildFailedResult,
+  buildWaves,
+  resolveIsolationStrategy,
+  topologicalSort,
+  validateDependencies
+};
+//# sourceMappingURL=task-batch-graph.js.map

package/dist/runtime/orchestration/run/task-batch-graph.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/runtime/orchestration/run/task-batch-graph.ts"],
+  "sourcesContent": ["import crypto from 'node:crypto';\n\nimport { contextIsolation } from './isolation/context.js';\nimport { gitBranchIsolation } from './isolation/git.js';\nimport { noIsolation } from './isolation/none.js';\nimport type {\n  BridgeLoopResult,\n  IsolationStrategy,\n  TaskConfig,\n  TaskItem,\n} from './types.js';\n\nexport function validateDependencies(items: TaskItem[]): void {\n  const ids = new Set(items.map((t) => t.id));\n  for (const item of items) {\n    for (const dep of item.dependsOn ?? []) {\n      if (!ids.has(dep)) {\n        throw new Error(`Task \"${item.id}\" depends on unknown task \"${dep}\"`);\n      }\n    }\n  }\n\n  const visited = new Set<string>();\n  const stack = new Set<string>();\n  const itemMap = new Map(items.map((t) => [t.id, t]));\n\n  function dfs(id: string): void {\n    if (stack.has(id)) {\n      throw new Error(`Dependency cycle detected involving task \"${id}\"`);\n    }\n    if (visited.has(id)) return;\n    stack.add(id);\n    for (const dep of itemMap.get(id)?.dependsOn ?? []) {\n      dfs(dep);\n    }\n    stack.delete(id);\n    visited.add(id);\n  }\n\n  for (const item of items) dfs(item.id);\n}\n\nexport function topologicalSort(items: TaskItem[]): TaskItem[] {\n  const inDegree = new Map<string, number>();\n  const dependents = new Map<string, TaskItem[]>();\n\n  for (const item of items) {\n    inDegree.set(item.id, (item.dependsOn ?? []).length);\n    for (const dep of item.dependsOn ?? []) {\n      const list = dependents.get(dep) ?? [];\n      list.push(item);\n      dependents.set(dep, list);\n    }\n  }\n\n  const queue: TaskItem[] = items\n    .filter((item) => (inDegree.get(item.id) ?? 0) === 0)\n    .sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0));\n\n  const sorted: TaskItem[] = [];\n  while (queue.length > 0) {\n    const current = queue.shift()!;\n    sorted.push(current);\n    for (const dependent of dependents.get(current.id) ?? []) {\n      const newDegree = (inDegree.get(dependent.id) ?? 0) - 1;\n      inDegree.set(dependent.id, newDegree);\n      if (newDegree === 0) {\n        queue.push(dependent);\n        queue.sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0));\n      }\n    }\n  }\n\n  return sorted;\n}\n\nexport function resolveIsolationStrategy(\n  config: TaskConfig\n): IsolationStrategy {\n  const iso = config.isolation ?? 'context';\n  if (typeof iso === 'object') return iso;\n  if (iso === 'none') return noIsolation();\n  if (iso === 'branch') {\n    return gitBranchIsolation({ automation: config.automation ?? {} });\n  }\n  return contextIsolation();\n}\n\nexport function buildFailedResult(contextId: string): BridgeLoopResult {\n  return {\n    kind: 'task',\n    contextId,\n    taskId: crypto.randomUUID(),\n    task: {\n      id: crypto.randomUUID(),\n      kind: 'task',\n      contextId,\n      status: { state: 'failed' },\n    },\n    terminationReason: 'error',\n    outcomeClass: 'failure',\n    totalIterations: 0,\n    totalElapsedMs: 0,\n  };\n}\n\nexport function buildWaves(\n  items: TaskItem[]\n): Array<Array<{ task: TaskItem; originalIndex: number }>> {\n  const waves: Array<Array<{ task: TaskItem; originalIndex: number }>> = [];\n  const placed = new Set<string>();\n\n  while (placed.size < items.length) {\n    const wave: Array<{ task: TaskItem; originalIndex: number }> = [];\n    for (let i = 0; i < items.length; i++) {\n      const task = items[i]!;\n      if (placed.has(task.id)) continue;\n      const deps = task.dependsOn ?? [];\n      if (deps.every((d) => placed.has(d))) {\n        wave.push({ task, originalIndex: i });\n      }\n    }\n    if (wave.length === 0) break;\n    for (const { task } of wave) placed.add(task.id);\n    waves.push(wave);\n  }\n\n  return waves;\n}\n"],
+  "mappings": "AAAA,OAAO,YAAY;AAEnB,SAAS,wBAAwB;AACjC,SAAS,0BAA0B;AACnC,SAAS,mBAAmB;AAQrB,SAAS,qBAAqB,OAAyB;AAC5D,QAAM,MAAM,IAAI,IAAI,MAAM,IAAI,CAAC,MAAM,EAAE,EAAE,CAAC;AAC1C,aAAW,QAAQ,OAAO;AACxB,eAAW,OAAO,KAAK,aAAa,CAAC,GAAG;AACtC,UAAI,CAAC,IAAI,IAAI,GAAG,GAAG;AACjB,cAAM,IAAI,MAAM,SAAS,KAAK,EAAE,8BAA8B,GAAG,GAAG;AAAA,MACtE;AAAA,IACF;AAAA,EACF;AAEA,QAAM,UAAU,oBAAI,IAAY;AAChC,QAAM,QAAQ,oBAAI,IAAY;AAC9B,QAAM,UAAU,IAAI,IAAI,MAAM,IAAI,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC;AAEnD,WAAS,IAAI,IAAkB;AAC7B,QAAI,MAAM,IAAI,EAAE,GAAG;AACjB,YAAM,IAAI,MAAM,6CAA6C,EAAE,GAAG;AAAA,IACpE;AACA,QAAI,QAAQ,IAAI,EAAE,EAAG;AACrB,UAAM,IAAI,EAAE;AACZ,eAAW,OAAO,QAAQ,IAAI,EAAE,GAAG,aAAa,CAAC,GAAG;AAClD,UAAI,GAAG;AAAA,IACT;AACA,UAAM,OAAO,EAAE;AACf,YAAQ,IAAI,EAAE;AAAA,EAChB;AAEA,aAAW,QAAQ,MAAO,KAAI,KAAK,EAAE;AACvC;AAEO,SAAS,gBAAgB,OAA+B;AAC7D,QAAM,WAAW,oBAAI,IAAoB;AACzC,QAAM,aAAa,oBAAI,IAAwB;AAE/C,aAAW,QAAQ,OAAO;AACxB,aAAS,IAAI,KAAK,KAAK,KAAK,aAAa,CAAC,GAAG,MAAM;AACnD,eAAW,OAAO,KAAK,aAAa,CAAC,GAAG;AACtC,YAAM,OAAO,WAAW,IAAI,GAAG,KAAK,CAAC;AACrC,WAAK,KAAK,IAAI;AACd,iBAAW,IAAI,KAAK,IAAI;AAAA,IAC1B;AAAA,EACF;AAEA,QAAM,QAAoB,MACvB,OAAO,CAAC,UAAU,SAAS,IAAI,KAAK,EAAE,KAAK,OAAO,CAAC,EACnD,KAAK,CAAC,GAAG,OAAO,EAAE,YAAY,MAAM,EAAE,YAAY,EAAE;AAEvD,QAAM,SAAqB,CAAC;AAC5B,SAAO,MAAM,SAAS,GAAG;AACvB,UAAM,UAAU,MAAM,MAAM;AAC5B,WAAO,KAAK,OAAO;AACnB,eAAW,aAAa,WAAW,IAAI,QAAQ,EAAE,KAAK,CAAC,GAAG;AACxD,YAAM,aAAa,SAAS,IAAI,UAAU,EAAE,KAAK,KAAK;AACtD,eAAS,IAAI,UAAU,IAAI,SAAS;AACpC,UAAI,cAAc,GAAG;AACnB,cAAM,KAAK,SAAS;AACpB,cAAM,KAAK,CAAC,GAAG,OAAO,EAAE,YAAY,MAAM,EAAE,YAAY,EAAE;AAAA,MAC5D;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AACT;AAEO,SAAS,yBACd,QACmB;AACnB,QAAM,MAAM,OAAO,aAAa;AAChC,MAAI,OAAO,QAAQ,SAAU,QAAO;AACpC,MAAI,QAAQ,OAAQ,QAAO,YAAY;AACvC,MAAI,QAAQ,UAAU;AACpB,WAAO,mBAAmB,EAAE,YAAY,OAAO,cAAc,CAAC,EAAE,CAAC;AAAA,EACnE;AACA,SAAO,iBAAiB;AAC1B;AAEO,SAAS,kBAAkB,WAAqC;AACrE,SAAO;AAAA,IACL,MAAM;AAAA,IACN;AAAA,IACA,QAAQ,OAAO,WAAW;AAAA,IAC1B,MAAM;AAAA,MACJ,IAAI,OAAO,WAAW;AAAA,MACtB,MAAM;AAAA,MACN;AAAA,MACA,QAAQ,EAAE,OAAO,SAAS;AAAA,IAC5B;AAAA,IACA,mBAAmB;AAAA,IACnB,cAAc;AAAA,IACd,iBAAiB;AAAA,IACjB,gBAAgB;AAAA,EAClB;AACF;AAEO,SAAS,WACd,OACyD;AACzD,QAAM,QAAiE,CAAC;AACxE,QAAM,SAAS,oBAAI,IAAY;AAE/B,SAAO,OAAO,OAAO,MAAM,QAAQ;AACjC,UAAM,OAAyD,CAAC;AAChE,aAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACrC,YAAM,OAAO,MAAM,CAAC;AACpB,UAAI,OAAO,IAAI,KAAK,EAAE,EAAG;AACzB,YAAM,OAAO,KAAK,aAAa,CAAC;AAChC,UAAI,KAAK,MAAM,CAAC,MAAM,OAAO,IAAI,CAAC,CAAC,GAAG;AACpC,aAAK,KAAK,EAAE,MAAM,eAAe,EAAE,CAAC;AAAA,MACtC;AAAA,IACF;AACA,QAAI,KAAK,WAAW,EAAG;AACvB,eAAW,EAAE,KAAK,KAAK,KAAM,QAAO,IAAI,KAAK,EAAE;AAC/C,UAAM,KAAK,IAAI;AAAA,EACjB;AAEA,SAAO;AACT;",
+  "names": []
+}

package/dist/runtime/orchestration/run/task-batch-helpers.d.ts

@@ -0,0 +1,8 @@
+import type { BridgeLoopResult, RunEvent, TaskBranchInfo } from './types.js';
+export declare function isTaskOutcomeFailure(result: BridgeLoopResult): boolean;
+export declare function normalizeConcurrency(value?: number): number;
+export declare function buildTaskBranchInfo(handle: {
+    contextId: string;
+}): Promise<TaskBranchInfo | undefined>;
+export declare function runWaveWithConcurrency<T>(items: T[], concurrency: number, runItem: (item: T) => AsyncGenerator<RunEvent>): AsyncGenerator<RunEvent>;
+//# sourceMappingURL=task-batch-helpers.d.ts.map

package/dist/runtime/orchestration/run/task-batch-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-batch-helpers.d.ts","sourceRoot":"","sources":["../../../../src/runtime/orchestration/run/task-batch-helpers.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,gBAAgB,EAEhB,QAAQ,EACR,cAAc,EACf,MAAM,YAAY,CAAC;AAQpB,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAQtE;AAED,wBAAgB,oBAAoB,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAG3D;AAgBD,wBAAsB,mBAAmB,CAAC,MAAM,EAAE;IAChD,SAAS,EAAE,MAAM,CAAC;CACnB,GAAG,OAAO,CAAC,cAAc,GAAG,SAAS,CAAC,CActC;AAED,wBAAuB,sBAAsB,CAAC,CAAC,EAC7C,KAAK,EAAE,CAAC,EAAE,EACV,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,cAAc,CAAC,QAAQ,CAAC,GAC7C,cAAc,CAAC,QAAQ,CAAC,CA+D1B"}

package/dist/runtime/orchestration/run/task-batch-helpers.js

@@ -0,0 +1,105 @@
+import { countCommitsSince } from "./git-automation.js";
+import { classifyLoopOutcome } from "./loop-engine.js";
+const DEFAULT_CONCURRENCY = 1;
+const FAILURE_OUTCOMES = /* @__PURE__ */ new Set([
+  "failure",
+  "cancelled"
+]);
+function isTaskOutcomeFailure(result) {
+  const state = result.task?.status?.state;
+  if (state === "failed" || state === "rejected" || state === "canceled") {
+    return true;
+  }
+  const outcomeClass = result.outcomeClass ?? classifyLoopOutcome(result.terminationReason);
+  return FAILURE_OUTCOMES.has(outcomeClass);
+}
+function normalizeConcurrency(value) {
+  if (!Number.isFinite(value) || value == null) return DEFAULT_CONCURRENCY;
+  return Math.max(1, Math.floor(value));
+}
+function maybeGetBranchHandle(handle) {
+  if (typeof handle !== "object" || handle == null) return void 0;
+  const record = handle;
+  if (typeof record.branchName !== "string" || typeof record.baseCommit !== "string") {
+    return void 0;
+  }
+  return { branchName: record.branchName, baseCommit: record.baseCommit };
+}
+async function buildTaskBranchInfo(handle) {
+  const branchHandle = maybeGetBranchHandle(handle);
+  if (!branchHandle) return void 0;
+  try {
+    const commitCount = await countCommitsSince(branchHandle.baseCommit);
+    return {
+      branchName: branchHandle.branchName,
+      baseCommit: branchHandle.baseCommit,
+      commitCount
+    };
+  } catch {
+    return void 0;
+  }
+}
+async function* runWaveWithConcurrency(items, concurrency, runItem) {
+  if (items.length === 0) return;
+  const events = [];
+  const waiters = [];
+  const workerCount = Math.min(Math.max(1, concurrency), items.length);
+  let closed = false;
+  let cursor = 0;
+  let activeWorkers = 0;
+  const push = (event) => {
+    const waiter = waiters.shift();
+    if (waiter) {
+      waiter({ value: event, done: false });
+      return;
+    }
+    events.push(event);
+  };
+  const close = () => {
+    if (closed) return;
+    closed = true;
+    for (const waiter of waiters.splice(0)) {
+      waiter({ done: true, value: void 0 });
+    }
+  };
+  const take = async () => {
+    const next = events.shift();
+    if (next) return { value: next, done: false };
+    if (closed) return { done: true, value: void 0 };
+    return new Promise((resolve) => {
+      waiters.push(resolve);
+    });
+  };
+  const worker = async () => {
+    activeWorkers++;
+    try {
+      while (cursor < items.length) {
+        const current = items[cursor];
+        cursor++;
+        if (!current) continue;
+        for await (const event of runItem(current)) {
+          push(event);
+        }
+      }
+    } finally {
+      activeWorkers--;
+      if (activeWorkers === 0) {
+        close();
+      }
+    }
+  };
+  const workers = Array.from({ length: workerCount }, () => worker());
+  while (true) {
+    const next = await take();
+    if (next.done) break;
+    yield next.value;
+  }
+  await Promise.all(workers);
+}
+export {
+  buildTaskBranchInfo,
+  isTaskOutcomeFailure,
+  normalizeConcurrency,
+  runWaveWithConcurrency
+};
+//# sourceMappingURL=task-batch-helpers.js.map

package/dist/runtime/orchestration/run/task-batch-helpers.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/runtime/orchestration/run/task-batch-helpers.ts"],
+  "sourcesContent": ["import { countCommitsSince } from './git-automation.js';\nimport { classifyLoopOutcome } from './loop-engine.js';\nimport type {\n  BridgeLoopResult,\n  LoopOutcomeClass,\n  RunEvent,\n  TaskBranchInfo,\n} from './types.js';\n\nconst DEFAULT_CONCURRENCY = 1;\nconst FAILURE_OUTCOMES: ReadonlySet<LoopOutcomeClass> = new Set([\n  'failure',\n  'cancelled',\n]);\n\nexport function isTaskOutcomeFailure(result: BridgeLoopResult): boolean {\n  const state = result.task?.status?.state;\n  if (state === 'failed' || state === 'rejected' || state === 'canceled') {\n    return true;\n  }\n  const outcomeClass =\n    result.outcomeClass ?? classifyLoopOutcome(result.terminationReason);\n  return FAILURE_OUTCOMES.has(outcomeClass);\n}\n\nexport function normalizeConcurrency(value?: number): number {\n  if (!Number.isFinite(value) || value == null) return DEFAULT_CONCURRENCY;\n  return Math.max(1, Math.floor(value));\n}\n\nfunction maybeGetBranchHandle(handle: {\n  contextId: string;\n}): { branchName: string; baseCommit: string } | undefined {\n  if (typeof handle !== 'object' || handle == null) return undefined;\n  const record = handle as Record<string, unknown>;\n  if (\n    typeof record.branchName !== 'string' ||\n    typeof record.baseCommit !== 'string'\n  ) {\n    return undefined;\n  }\n  return { branchName: record.branchName, baseCommit: record.baseCommit };\n}\n\nexport async function buildTaskBranchInfo(handle: {\n  contextId: string;\n}): Promise<TaskBranchInfo | undefined> {\n  const branchHandle = maybeGetBranchHandle(handle);\n  if (!branchHandle) return undefined;\n\n  try {\n    const commitCount = await countCommitsSince(branchHandle.baseCommit);\n    return {\n      branchName: branchHandle.branchName,\n      baseCommit: branchHandle.baseCommit,\n      commitCount,\n    };\n  } catch {\n    return undefined;\n  }\n}\n\nexport async function* runWaveWithConcurrency<T>(\n  items: T[],\n  concurrency: number,\n  runItem: (item: T) => AsyncGenerator<RunEvent>\n): AsyncGenerator<RunEvent> {\n  if (items.length === 0) return;\n\n  const events: RunEvent[] = [];\n  const waiters: Array<(value: IteratorResult<RunEvent>) => void> = [];\n  const workerCount = Math.min(Math.max(1, concurrency), items.length);\n  let closed = false;\n  let cursor = 0;\n  let activeWorkers = 0;\n\n  const push = (event: RunEvent): void => {\n    const waiter = waiters.shift();\n    if (waiter) {\n      waiter({ value: event, done: false });\n      return;\n    }\n    events.push(event);\n  };\n\n  const close = (): void => {\n    if (closed) return;\n    closed = true;\n    for (const waiter of waiters.splice(0)) {\n      waiter({ done: true, value: undefined });\n    }\n  };\n\n  const take = async (): Promise<IteratorResult<RunEvent>> => {\n    const next = events.shift();\n    if (next) return { value: next, done: false };\n    if (closed) return { done: true, value: undefined };\n    return new Promise<IteratorResult<RunEvent>>((resolve) => {\n      waiters.push(resolve);\n    });\n  };\n\n  const worker = async (): Promise<void> => {\n    activeWorkers++;\n    try {\n      while (cursor < items.length) {\n        const current = items[cursor];\n        cursor++;\n        if (!current) continue;\n        for await (const event of runItem(current)) {\n          push(event);\n        }\n      }\n    } finally {\n      activeWorkers--;\n      if (activeWorkers === 0) {\n        close();\n      }\n    }\n  };\n\n  const workers = Array.from({ length: workerCount }, () => worker());\n  while (true) {\n    const next = await take();\n    if (next.done) break;\n    yield next.value;\n  }\n\n  await Promise.all(workers);\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/runtime/orchestration/run/task-batch-sources.d.ts

@@ -0,0 +1,3 @@
+import type { TaskItem, TaskSource } from './types.js';
+export declare function resolveTaskItems(source: TaskSource, signal?: AbortSignal, limit?: number): Promise<TaskItem[]>;
+//# sourceMappingURL=task-batch-sources.d.ts.map

package/dist/runtime/orchestration/run/task-batch-sources.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-batch-sources.d.ts","sourceRoot":"","sources":["../../../../src/runtime/orchestration/run/task-batch-sources.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAmDvD,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,UAAU,EAClB,MAAM,CAAC,EAAE,WAAW,EACpB,KAAK,CAAC,EAAE,MAAM,GACb,OAAO,CAAC,QAAQ,EAAE,CAAC,CAsDrB"}

package/dist/runtime/orchestration/run/task-batch-sources.js

@@ -0,0 +1,93 @@
+import crypto from "node:crypto";
+import { readFileSync } from "node:fs";
+import { getNextCronDate } from "./cron-source.js";
+async function waitForDelay(ms, signal) {
+  if (signal?.aborted) return false;
+  return new Promise((resolve) => {
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      signal?.removeEventListener("abort", onAbort);
+      resolve(true);
+    }, ms);
+    const onAbort = () => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+      resolve(false);
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function parseMarkdownTasks(content) {
+  const items = [];
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const match = line.match(/^[-*]\s+(.+)/);
+    if (match?.[1]) {
+      items.push({
+        id: crypto.randomUUID(),
+        message: match[1].trim()
+      });
+    }
+  }
+  return items;
+}
+function parseJsonTasks(content) {
+  const parsed = JSON.parse(content);
+  return parsed.map((t) => ({
+    id: t.id ?? crypto.randomUUID(),
+    message: t.message,
+    dependsOn: t.dependsOn,
+    priority: t.priority
+  }));
+}
+async function resolveTaskItems(source, signal, limit) {
+  if (source.type === "message") {
+    return [{ id: crypto.randomUUID(), message: source.message }];
+  }
+  if (source.type === "list") {
+    return source.tasks;
+  }
+  if (source.type === "file") {
+    const content = readFileSync(source.path, "utf-8");
+    const format = source.format ?? (source.path.endsWith(".json") ? "json" : "markdown");
+    if (format === "json") return parseJsonTasks(content);
+    return parseMarkdownTasks(content);
+  }
+  if (source.type === "custom") {
+    const items = [];
+    let next = await source.next();
+    while (next) {
+      if (signal?.aborted) return items;
+      items.push({ id: crypto.randomUUID(), message: next.message });
+      next = await source.next();
+    }
+    return items;
+  }
+  if (source.type === "cron") {
+    if (signal?.aborted) return [];
+    const maxEmissions = Math.max(0, source.maxEmissions ?? 1);
+    const target = typeof limit === "number" ? Math.min(maxEmissions, Math.max(0, limit)) : maxEmissions;
+    const items = [];
+    let from = /* @__PURE__ */ new Date();
+    for (let tick = 1; tick <= target; tick++) {
+      if (signal?.aborted) break;
+      const next = getNextCronDate(source.schedule, from);
+      const waitMs = Math.max(0, next.getTime() - Date.now());
+      const ok = await waitForDelay(waitMs, signal);
+      if (!ok) break;
+      const message = typeof source.message === "function" ? source.message(tick) : source.message;
+      items.push({ id: crypto.randomUUID(), message });
+      from = next;
+    }
+    return items;
+  }
+  return [];
+}
+export {
+  resolveTaskItems
+};
+//# sourceMappingURL=task-batch-sources.js.map

package/dist/runtime/orchestration/run/task-batch-sources.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/runtime/orchestration/run/task-batch-sources.ts"],
+  "sourcesContent": ["import crypto from 'node:crypto';\nimport { readFileSync } from 'node:fs';\n\nimport { getNextCronDate } from './cron-source.js';\nimport type { TaskItem, TaskSource } from './types.js';\n\nasync function waitForDelay(\n  ms: number,\n  signal?: AbortSignal\n): Promise<boolean> {\n  if (signal?.aborted) return false;\n  return new Promise<boolean>((resolve) => {\n    let settled = false;\n    const timer = setTimeout(() => {\n      if (settled) return;\n      settled = true;\n      signal?.removeEventListener('abort', onAbort);\n      resolve(true);\n    }, ms);\n    const onAbort = () => {\n      if (settled) return;\n      settled = true;\n      clearTimeout(timer);\n      signal?.removeEventListener('abort', onAbort);\n      resolve(false);\n    };\n    signal?.addEventListener('abort', onAbort, { once: true });\n  });\n}\n\nfunction parseMarkdownTasks(content: string): TaskItem[] {\n  const items: TaskItem[] = [];\n  const lines = content.split('\\n');\n  for (const line of lines) {\n    const match = line.match(/^[-*]\\s+(.+)/);\n    if (match?.[1]) {\n      items.push({\n        id: crypto.randomUUID(),\n        message: match[1].trim(),\n      });\n    }\n  }\n  return items;\n}\n\nfunction parseJsonTasks(content: string): TaskItem[] {\n  const parsed = JSON.parse(content) as TaskItem[];\n  return parsed.map((t) => ({\n    id: t.id ?? crypto.randomUUID(),\n    message: t.message,\n    dependsOn: t.dependsOn,\n    priority: t.priority,\n  }));\n}\n\nexport async function resolveTaskItems(\n  source: TaskSource,\n  signal?: AbortSignal,\n  limit?: number\n): Promise<TaskItem[]> {\n  if (source.type === 'message') {\n    return [{ id: crypto.randomUUID(), message: source.message }];\n  }\n\n  if (source.type === 'list') {\n    return source.tasks;\n  }\n\n  if (source.type === 'file') {\n    const content = readFileSync(source.path, 'utf-8');\n    const format =\n      source.format ?? (source.path.endsWith('.json') ? 'json' : 'markdown');\n    if (format === 'json') return parseJsonTasks(content);\n    return parseMarkdownTasks(content);\n  }\n\n  if (source.type === 'custom') {\n    const items: TaskItem[] = [];\n    let next = await source.next();\n    while (next) {\n      if (signal?.aborted) return items;\n      items.push({ id: crypto.randomUUID(), message: next.message });\n      next = await source.next();\n    }\n    return items;\n  }\n\n  if (source.type === 'cron') {\n    if (signal?.aborted) return [];\n    const maxEmissions = Math.max(0, source.maxEmissions ?? 1);\n    const target =\n      typeof limit === 'number'\n        ? Math.min(maxEmissions, Math.max(0, limit))\n        : maxEmissions;\n    const items: TaskItem[] = [];\n    let from = new Date();\n    for (let tick = 1; tick <= target; tick++) {\n      if (signal?.aborted) break;\n      const next = getNextCronDate(source.schedule, from);\n      const waitMs = Math.max(0, next.getTime() - Date.now());\n      const ok = await waitForDelay(waitMs, signal);\n      if (!ok) break;\n      const message =\n        typeof source.message === 'function'\n          ? source.message(tick)\n          : source.message;\n      items.push({ id: crypto.randomUUID(), message });\n      from = next;\n    }\n    return items;\n  }\n\n  return [];\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/runtime/orchestration/run/task-batch.d.ts

@@ -0,0 +1,7 @@
+import type { BridgeLoopResult, LoopConfig, LoopExecutor, RunBatchResult, RunEvent, TaskConfig } from './types.js';
+export interface BatchOptions {
+    signal?: AbortSignal;
+}
+export declare function runTaskBatchStream(executor: LoopExecutor, taskConfig: TaskConfig, loopConfig: LoopConfig, baseContextId: string, options?: BatchOptions): AsyncGenerator<RunEvent>;
+export declare function runTaskBatch(executor: LoopExecutor, taskConfig: TaskConfig, loopConfig: LoopConfig, baseContextId: string, options?: BatchOptions): Promise<RunBatchResult<BridgeLoopResult>>;
+//# sourceMappingURL=task-batch.d.ts.map

package/dist/runtime/orchestration/run/task-batch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-batch.d.ts","sourceRoot":"","sources":["../../../../src/runtime/orchestration/run/task-batch.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EACV,gBAAgB,EAGhB,UAAU,EACV,YAAY,EACZ,cAAc,EACd,QAAQ,EAER,UAAU,EAGX,MAAM,YAAY,CAAC;AAIpB,MAAM,WAAW,YAAY;IAC3B,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED,wBAAuB,kBAAkB,CACvC,QAAQ,EAAE,YAAY,EACtB,UAAU,EAAE,UAAU,EACtB,UAAU,EAAE,UAAU,EACtB,aAAa,EAAE,MAAM,EACrB,OAAO,CAAC,EAAE,YAAY,GACrB,cAAc,CAAC,QAAQ,CAAC,CAmF1B;AA8ID,wBAAsB,YAAY,CAChC,QAAQ,EAAE,YAAY,EACtB,UAAU,EAAE,UAAU,EACtB,UAAU,EAAE,UAAU,EACtB,aAAa,EAAE,MAAM,EACrB,OAAO,CAAC,EAAE,YAAY,GACrB,OAAO,CAAC,cAAc,CAAC,gBAAgB,CAAC,CAAC,CA+D3C"}

package/dist/runtime/orchestration/run/task-batch.js

@@ -0,0 +1,267 @@
+import { assertNever } from "../../../utils/assert-never.js";
+import { composeSignals } from "../../../utils/signals.js";
+import { buildLoopResult, runLoopStream } from "./loop-engine.js";
+import {
+  buildFailedResult,
+  buildWaves,
+  resolveIsolationStrategy,
+  topologicalSort,
+  validateDependencies
+} from "./task-batch-graph.js";
+import {
+  buildTaskBranchInfo,
+  isTaskOutcomeFailure,
+  normalizeConcurrency,
+  runWaveWithConcurrency
+} from "./task-batch-helpers.js";
+import { resolveTaskItems } from "./task-batch-sources.js";
+const DEFAULT_MAX_TASKS = 100;
+async function* runTaskBatchStream(executor, taskConfig, loopConfig, baseContextId, options) {
+  const maxTasks = taskConfig.maxTasks ?? DEFAULT_MAX_TASKS;
+  const items = await resolveTaskItems(
+    taskConfig.source,
+    options?.signal,
+    maxTasks
+  );
+  validateDependencies(items);
+  const sorted = topologicalSort(items);
+  if (sorted.length > maxTasks) {
+    yield {
+      kind: "task-batch-truncated",
+      source: "task-batch",
+      totalItems: sorted.length,
+      maxTasks
+    };
+  }
+  const tasksToRun = sorted.slice(0, maxTasks);
+  const strategy = resolveIsolationStrategy(taskConfig);
+  const failFast = taskConfig.failFast ?? false;
+  const skipOnUpstream = taskConfig.skipOnUpstreamFailure ?? true;
+  const concurrency = normalizeConcurrency(taskConfig.concurrency);
+  if (concurrency > 1 && taskConfig.isolation === "branch") {
+    throw new Error(
+      'concurrency > 1 is not supported with branch isolation. Use isolation: "context" (separate contextId per task) or isolation: "none" for parallel tasks, or run tasks sequentially with concurrency: 1.'
+    );
+  }
+  let completedTasks = 0;
+  let failedTasks = 0;
+  const failedIds = /* @__PURE__ */ new Set();
+  const executedIds = /* @__PURE__ */ new Set();
+  const waves = buildWaves(tasksToRun);
+  for (const wave of waves) {
+    if (options?.signal?.aborted) break;
+    if (failFast && failedTasks > 0) break;
+    const failedAtWaveStart = failedIds.size;
+    yield* runWaveWithConcurrency(
+      wave,
+      concurrency,
+      async function* ({ task, originalIndex }) {
+        if (options?.signal?.aborted) return;
+        if (failFast && failedIds.size > failedAtWaveStart) return;
+        executedIds.add(task.id);
+        yield* runSingleTask(
+          executor,
+          task,
+          originalIndex,
+          baseContextId,
+          loopConfig,
+          strategy,
+          taskConfig,
+          skipOnUpstream,
+          failedIds,
+          options?.signal
+        );
+      }
+    );
+    for (const { task } of wave) {
+      if (!executedIds.has(task.id)) continue;
+      if (failedIds.has(task.id)) {
+        failedTasks++;
+      } else {
+        completedTasks++;
+      }
+    }
+  }
+  yield {
+    kind: "task-batch-complete",
+    source: "task-batch",
+    totalTasks: tasksToRun.length,
+    completedTasks,
+    failedTasks
+  };
+}
+async function* runSingleTask(executor, task, index, baseContextId, loopConfig, strategy, taskConfig, skipOnUpstream, failedIds, signal) {
+  if (skipOnUpstream && task.dependsOn?.some((d) => failedIds.has(d))) {
+    yield {
+      kind: "task-start",
+      source: "task-batch",
+      task: task.message,
+      index
+    };
+    yield {
+      kind: "task-failed",
+      source: "task-batch",
+      task: task.message,
+      index,
+      error: "skipped: upstream dependency failed"
+    };
+    failedIds.add(task.id);
+    return;
+  }
+  yield { kind: "task-start", source: "task-batch", task: task.message, index };
+  await taskConfig.onTaskStart?.(task.message, index);
+  let handle = { contextId: baseContextId };
+  let cleanupError;
+  let branch;
+  try {
+    handle = await strategy.before(task, index, baseContextId);
+    const perTaskConfig = signal ? {
+      ...loopConfig,
+      signal: loopConfig.signal ? composeSignals(signal, loopConfig.signal) : signal
+    } : loopConfig;
+    let lastResult;
+    let finalReason = "cancelled";
+    let finalIterations = 0;
+    let finalElapsedMs = 0;
+    let finalCost;
+    let finalOutcomeClass;
+    const startTime = Date.now();
+    const wrappedExecutor = async (msg, ctx, iteration) => {
+      const result2 = await executor(msg, ctx, iteration);
+      lastResult = result2;
+      return result2;
+    };
+    for await (const event of runLoopStream(
+      wrappedExecutor,
+      task.message,
+      handle.contextId,
+      perTaskConfig
+    )) {
+      yield event;
+      if (event.kind === "loop-terminated") {
+        finalReason = event.reason;
+        finalIterations = event.totalIterations;
+        finalElapsedMs = event.totalElapsedMs;
+        finalCost = event.totalCost;
+        finalOutcomeClass = event.outcomeClass;
+      }
+    }
+    const result = buildLoopResult(
+      lastResult,
+      finalReason,
+      finalIterations,
+      finalElapsedMs || Date.now() - startTime,
+      handle.contextId,
+      finalCost,
+      finalOutcomeClass
+    );
+    const taskFailed = isTaskOutcomeFailure(result);
+    if (taskFailed) {
+      failedIds.add(task.id);
+      cleanupError = new Error(`Task terminated: ${result.terminationReason}`);
+      branch = await buildTaskBranchInfo(handle);
+      yield {
+        kind: "task-failed",
+        source: "task-batch",
+        task: task.message,
+        index,
+        error: `loop failed: ${result.terminationReason}`,
+        branch
+      };
+    } else {
+      await strategy.after(handle, result);
+      await taskConfig.onTaskComplete?.(task.message, index, result);
+      branch = await buildTaskBranchInfo(handle);
+      yield {
+        kind: "task-complete",
+        source: "task-batch",
+        task: task.message,
+        index,
+        result,
+        branch
+      };
+    }
+  } catch (err) {
+    cleanupError = err instanceof Error ? err : new Error(String(err));
+    failedIds.add(task.id);
+    branch ??= await buildTaskBranchInfo(handle);
+    yield {
+      kind: "task-failed",
+      source: "task-batch",
+      task: task.message,
+      index,
+      error: cleanupError.message,
+      branch
+    };
+  } finally {
+    try {
+      await strategy.cleanup(handle, cleanupError);
+    } catch {
+    }
+  }
+}
+async function runTaskBatch(executor, taskConfig, loopConfig, baseContextId, options) {
+  const startTime = Date.now();
+  const taskResults = [];
+  let totalTasks = 0;
+  let completedTasks = 0;
+  let failedTasks = 0;
+  for await (const event of runTaskBatchStream(
+    executor,
+    taskConfig,
+    loopConfig,
+    baseContextId,
+    options
+  )) {
+    switch (event.kind) {
+      case "task-start":
+        break;
+      case "task-complete":
+        taskResults.push({
+          task: event.task,
+          index: event.index,
+          result: event.result,
+          branch: event.branch
+        });
+        break;
+      case "task-failed":
+        taskResults.push({
+          task: event.task,
+          index: event.index,
+          result: buildFailedResult(baseContextId),
+          error: event.error,
+          branch: event.branch
+        });
+        break;
+      case "task-batch-complete":
+        totalTasks = event.totalTasks;
+        completedTasks = event.completedTasks;
+        failedTasks = event.failedTasks;
+        break;
+      case "task-batch-truncated":
+        break;
+      case "flow-step-start":
+      case "flow-step-complete":
+      case "flow-terminated":
+      case "loop-iteration":
+      case "loop-paused":
+      case "loop-terminated":
+        break;
+      default:
+        assertNever(event, "runTaskBatch event accumulator");
+    }
+  }
+  return {
+    kind: "batch",
+    taskResults,
+    totalTasks,
+    completedTasks,
+    failedTasks,
+    totalElapsedMs: Date.now() - startTime
+  };
+}
+export {
+  runTaskBatch,
+  runTaskBatchStream
+};
+//# sourceMappingURL=task-batch.js.map