@warlock.js/ai 4.4.0 → 4.6.0

package/esm/orchestrator/orchestrator.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"orchestrator.mjs","names":["orchestratorAsTool"],"sources":["../../../../../../../@warlock.js/ai/src/orchestrator/orchestrator.ts"],"sourcesContent":["import type { OrchestratorConfig } from \"../contracts/orchestrator/orchestrator-config.type\";\nimport type {\n  OrchestratorEventHandler,\n  OrchestratorEventName,\n} from \"../contracts/orchestrator/orchestrator-event.type\";\nimport type {\n  OrchestratorAsToolOptions,\n  OrchestratorContract,\n} from \"../contracts/orchestrator/orchestrator.contract\";\nimport type { OrchestratorCommands } from \"../contracts/orchestrator/orchestrator-commands.type\";\nimport type {\n  OrchestratorExecuteOptions,\n  OrchestratorResumeOptions,\n} from \"../contracts/orchestrator/orchestrator-execute-options.type\";\nimport type { OrchestratorEvent } from \"../contracts/orchestrator/orchestrator-event.type\";\nimport type { OrchestratorResult } from \"../contracts/result/orchestrator-result.type\";\nimport type { StreamContract } from \"../contracts/stream/stream.contract\";\nimport type { SupervisorIntentValue } from \"../contracts/supervisor/intent-entry.type\";\nimport type { SupervisorInput } from \"../contracts/supervisor/supervisor-input.type\";\nimport { resolveDefaultSnapshotStore } from \"../config\";\nimport { OrchestratorConfigError } from \"../errors/orchestrator-config-error\";\nimport { resolveIntentEntries, type ResolvedIntentEntry } from \"../supervisor/entries\";\nimport { SupervisorFailedError } from \"../errors\";\nimport type { ToolContract } from \"../tool/tool\";\nimport { asTool as orchestratorAsTool } from \"./as-tool\";\nimport { createCommandDispatcher } from \"./commands\";\nimport { OrchestratorEmitter } from \"./emitter\";\nimport { OrchestratorExecution } from \"./execution\";\nimport { createOrchestratorStream } from \"./orchestrator-stream\";\nimport { computeOrchestratorSignature } from \"./signature\";\n\n/**\n * `ai.orchestrator(config)` — construct an {@link OrchestratorContract}:\n * a session-state manager wrapped around a supervisor (orchestrator.md\n * §1, §15). Validates the config at author time (throws\n * {@link OrchestratorConfigError} on bad shape), resolves the intent\n * entries, computes a stable structural signature for drift detection\n * (§10.1), wires the three-tier event emitter, and returns a handle that\n * runs one durable session turn per `execute` / `stream` call, resumes\n * an interrupted `iterate: true` turn via `resume`, and exposes typed\n * built-in commands plus an `asTool` wrapper.\n *\n * The \"what runs\" fields (`intents`, `route` / `router`, `evaluate`,\n * `state`, `output`, `initialAgent`, `maxIterations`) are the\n * supervisor's surface spread directly — the lifecycle builds the\n * supervisor lazily per turn and delegates to it (§3 Phase 5). Users\n * never see the supervisor object.\n *\n * @example\n * const supportBot = ai.orchestrator<SessionState>({\n *   name: \"refund-support\",\n *   intents: { classify, lookup, process, compose },\n *   route: (ctx) => (ctx.iteration === 0 ? \"classify\" : END),\n *   iterate: true,\n *   checkpointStore: ai.checkpoint.pg({ client: pg }),\n *   snapshotStore: ai.snapshot.pg({ client: pg }),\n * });\n *\n * const result = await supportBot.execute(message, { sessionId, history });\n */\nexport function orchestrator<\n  TOutput = unknown,\n  TState = TOutput,\n  TIntents extends Record<string, SupervisorIntentValue> = Record<\n    string,\n    SupervisorIntentValue\n  >,\n>(\n  config: OrchestratorConfig<TOutput, TState, TIntents>,\n): OrchestratorContract<TOutput, TState> {\n  validateFactoryConfig(config as unknown as OrchestratorConfig<unknown>);\n\n  const entries = resolveEntries(config as unknown as OrchestratorConfig<unknown>);\n\n  assertInitialAgent(config as unknown as OrchestratorConfig<unknown>, entries);\n\n  const signature = computeOrchestratorSignature(\n    config as unknown as OrchestratorConfig<unknown>,\n    entries,\n  );\n  const emitter = new OrchestratorEmitter(config.on);\n\n  async function execute(\n    input: SupervisorInput,\n    options: OrchestratorExecuteOptions<TState>,\n  ): Promise<OrchestratorResult<TOutput>> {\n    const execution = new OrchestratorExecution<TOutput, TState>({\n      config: config as unknown as OrchestratorConfig<TOutput, TState>,\n      entries,\n      signature,\n      emitter,\n      input,\n      options,\n    });\n\n    return execution.run();\n  }\n\n  function stream(\n    input: SupervisorInput,\n    options: OrchestratorExecuteOptions<TState>,\n  ): StreamContract<OrchestratorResult<TOutput>, OrchestratorEvent> {\n    const { controller, stream: contract } = createOrchestratorStream<\n      OrchestratorResult<TOutput>\n    >();\n\n    const execution = new OrchestratorExecution<TOutput, TState>({\n      config: config as unknown as OrchestratorConfig<TOutput, TState>,\n      entries,\n      signature,\n      emitter,\n      input,\n      options,\n      streamController: controller,\n    });\n\n    void execution.run();\n\n    return contract;\n  }\n\n  async function resume(\n    sessionId: string,\n    options?: OrchestratorResumeOptions,\n  ): Promise<OrchestratorResult<TOutput> | null> {\n    const execution = new OrchestratorExecution<TOutput, TState>({\n      config: config as unknown as OrchestratorConfig<TOutput, TState>,\n      entries,\n      signature,\n      emitter,\n      resumeSessionId: sessionId,\n      resumeOptions: options,\n    });\n\n    return execution.resume();\n  }\n\n  // The dispatcher owns command ROUTING only; the `compact` handler\n  // delegates to the shared compaction code path on the lifecycle engine\n  // (§11 / §12.2 — manual compact reuses the post-turn compaction path).\n  const command = createCommandDispatcher({\n    compact: (args: OrchestratorCommands[\"compact\"][\"args\"]) => {\n      const execution = new OrchestratorExecution<TOutput, TState>({\n        config: config as unknown as OrchestratorConfig<TOutput, TState>,\n        entries,\n        signature,\n        emitter,\n      });\n\n      return execution.compact(args);\n    },\n  });\n\n  const instance: OrchestratorContract<TOutput, TState> = {\n    name: config.name,\n    signature,\n    version: config.version,\n    execute,\n    stream,\n    resume,\n    command,\n    asTool<TToolInput = string>(\n      options: OrchestratorAsToolOptions<TToolInput>,\n    ): ToolContract<TToolInput, TOutput> {\n      return orchestratorAsTool<TOutput, TState, TToolInput>(instance, options);\n    },\n    on<K extends OrchestratorEventName>(\n      event: K,\n      handler: OrchestratorEventHandler<K>,\n    ): () => void {\n      return emitter.on(event, handler);\n    },\n    off<K extends OrchestratorEventName>(\n      event: K,\n      handler: OrchestratorEventHandler<K>,\n    ): void {\n      emitter.off(event, handler);\n    },\n  };\n\n  return instance;\n}\n\n/**\n * Author-time validation (orchestrator.md §17). Enforces the rules that\n * must fail at construction rather than on the first turn:\n *\n * - `name` present and a string.\n * - `intents` present.\n * - `route` XOR `router` (mutually exclusive; at least one required) —\n *   the supervisor's dispatch-source rule, surfaced as an orchestrator\n *   config error.\n * - `router` is a valid agent contract or `{ agent, ... }` entry.\n * - `maxIterations >= 1` when set.\n * - `snapshotStore` resolvable when `iterate: true` — explicit field or\n *   the global `ai.config({ defaultSnapshotStore })` fallback.\n *\n * `initialAgent` membership is checked separately once the intent\n * entries are resolved.\n */\nfunction validateFactoryConfig(config: OrchestratorConfig<unknown>): void {\n  if (!config.name || typeof config.name !== \"string\") {\n    throw new OrchestratorConfigError(\n      \"ai.orchestrator: `name` is required and must be a string\",\n      { context: { authoring: true } },\n    );\n  }\n\n  if (!config.intents || typeof config.intents !== \"object\") {\n    throw new OrchestratorConfigError(\n      `ai.orchestrator(\"${config.name}\"): \\`intents\\` is required`,\n      { context: { authoring: true } },\n    );\n  }\n\n  const hasRoute = typeof config.route === \"function\";\n  const hasRouter = Boolean(config.router);\n\n  if (hasRouter) {\n    const router = config.router;\n    const isBareAgent = typeof (router as { execute?: unknown }).execute === \"function\";\n    const isEntryForm =\n      !isBareAgent &&\n      typeof (router as { agent?: { execute?: unknown } }).agent === \"object\" &&\n      typeof (router as { agent?: { execute?: unknown } }).agent?.execute === \"function\";\n\n    if (!isBareAgent && !isEntryForm) {\n      throw new OrchestratorConfigError(\n        `ai.orchestrator(\"${config.name}\"): \\`router\\` must be an agent contract or a \\`{ agent, placeholders?, input? }\\` entry`,\n        { context: { authoring: true } },\n      );\n    }\n  }\n\n  if (hasRoute && hasRouter) {\n    throw new OrchestratorConfigError(\n      `ai.orchestrator(\"${config.name}\"): \\`route\\` and \\`router\\` are mutually exclusive — configure exactly one`,\n      { context: { authoring: true } },\n    );\n  }\n\n  if (!hasRoute && !hasRouter) {\n    throw new OrchestratorConfigError(\n      `ai.orchestrator(\"${config.name}\"): one of \\`route\\` or \\`router\\` is required`,\n      { context: { authoring: true } },\n    );\n  }\n\n  if (config.maxIterations !== undefined && config.maxIterations < 1) {\n    throw new OrchestratorConfigError(\n      `ai.orchestrator(\"${config.name}\"): \\`maxIterations\\` must be >= 1`,\n      { context: { authoring: true, maxIterations: config.maxIterations } },\n    );\n  }\n\n  if (config.iterate && !config.snapshotStore && !resolveDefaultSnapshotStore()) {\n    throw new OrchestratorConfigError(\n      `ai.orchestrator(\"${config.name}\"): \\`iterate: true\\` requires a \\`snapshotStore\\` (or \\`ai.config({ defaultSnapshotStore })\\`) for mid-turn resume`,\n      { context: { authoring: true } },\n    );\n  }\n}\n\n/**\n * Resolve the `intents` map into the supervisor's internal entry shape,\n * re-wrapping the supervisor's authoring failure as an\n * {@link OrchestratorConfigError} so misuse surfaces under the\n * orchestrator's error family rather than the supervisor's.\n */\nfunction resolveEntries(\n  config: OrchestratorConfig<unknown>,\n): Map<string, ResolvedIntentEntry> {\n  try {\n    return resolveIntentEntries(config.intents, config.name);\n  } catch (error) {\n    if (error instanceof SupervisorFailedError) {\n      throw new OrchestratorConfigError(error.message, {\n        context: { authoring: true },\n        cause: error,\n      });\n    }\n\n    throw error;\n  }\n}\n\n/**\n * Enforce the `initialAgent` membership rule (§17) once entries are\n * resolved — `initialAgent`, when set, must name a key in `intents`.\n */\nfunction assertInitialAgent(\n  config: OrchestratorConfig<unknown>,\n  entries: Map<string, ResolvedIntentEntry>,\n): void {\n  if (config.initialAgent && !entries.has(config.initialAgent)) {\n    throw new OrchestratorConfigError(\n      `ai.orchestrator(\"${config.name}\"): \\`initialAgent\\` \"${config.initialAgent}\" is not a key in \\`intents\\``,\n      { context: { authoring: true } },\n    );\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"orchestrator.mjs","names":["orchestratorAsTool"],"sources":["../../../../../../../@warlock.js/ai/src/orchestrator/orchestrator.ts"],"sourcesContent":["import type { OrchestratorConfig } from \"../contracts/orchestrator/orchestrator-config.type\";\nimport type {\n  OrchestratorEventHandler,\n  OrchestratorEventName,\n} from \"../contracts/orchestrator/orchestrator-event.type\";\nimport type {\n  OrchestratorAsToolOptions,\n  OrchestratorContract,\n} from \"../contracts/orchestrator/orchestrator.contract\";\nimport type { OrchestratorCommands } from \"../contracts/orchestrator/orchestrator-commands.type\";\nimport type {\n  OrchestratorExecuteOptions,\n  OrchestratorResumeOptions,\n} from \"../contracts/orchestrator/orchestrator-execute-options.type\";\nimport type { OrchestratorEvent } from \"../contracts/orchestrator/orchestrator-event.type\";\nimport type { OrchestratorResult } from \"../contracts/result/orchestrator-result.type\";\nimport type { StreamContract } from \"../contracts/stream/stream.contract\";\nimport type { SupervisorIntentValue } from \"../contracts/supervisor/intent-entry.type\";\nimport type { SupervisorInput } from \"../contracts/supervisor/supervisor-input.type\";\nimport { resolveDefaultSnapshotStore } from \"../config\";\nimport { OrchestratorConfigError } from \"../errors/orchestrator-config-error\";\nimport { resolveIntentEntries, type ResolvedIntentEntry } from \"../supervisor/entries\";\nimport { SupervisorFailedError } from \"../errors\";\nimport type { ToolContract } from \"../tool/tool\";\nimport type { SessionLock } from \"../contracts/orchestrator/session-lock.contract\";\nimport { asTool as orchestratorAsTool } from \"./as-tool\";\nimport { createCommandDispatcher } from \"./commands\";\nimport { OrchestratorEmitter } from \"./emitter\";\nimport { OrchestratorExecution } from \"./execution\";\nimport { createOrchestratorStream } from \"./orchestrator-stream\";\nimport { inProcessSessionLock, noopSessionLock } from \"./session-lock\";\nimport { computeOrchestratorSignature } from \"./signature\";\n\n/**\n * `ai.orchestrator(config)` — construct an {@link OrchestratorContract}:\n * a session-state manager wrapped around a supervisor (orchestrator.md\n * §1, §15). Validates the config at author time (throws\n * {@link OrchestratorConfigError} on bad shape), resolves the intent\n * entries, computes a stable structural signature for drift detection\n * (§10.1), wires the three-tier event emitter, and returns a handle that\n * runs one durable session turn per `execute` / `stream` call, resumes\n * an interrupted `iterate: true` turn via `resume`, and exposes typed\n * built-in commands plus an `asTool` wrapper.\n *\n * The \"what runs\" fields (`intents`, `route` / `router`, `evaluate`,\n * `state`, `output`, `initialAgent`, `maxIterations`) are the\n * supervisor's surface spread directly — the lifecycle builds the\n * supervisor lazily per turn and delegates to it (§3 Phase 5). Users\n * never see the supervisor object.\n *\n * @example\n * const supportBot = ai.orchestrator<SessionState>({\n *   name: \"refund-support\",\n *   intents: { classify, lookup, process, compose },\n *   route: (ctx) => (ctx.iteration === 0 ? \"classify\" : END),\n *   iterate: true,\n *   checkpointStore: ai.checkpoint.pg({ client: pg }),\n *   snapshotStore: ai.snapshot.pg({ client: pg }),\n * });\n *\n * const result = await supportBot.execute(message, { sessionId, history });\n */\nexport function orchestrator<\n  TOutput = unknown,\n  TState = TOutput,\n  TIntents extends Record<string, SupervisorIntentValue> = Record<\n    string,\n    SupervisorIntentValue\n  >,\n>(\n  config: OrchestratorConfig<TOutput, TState, TIntents>,\n): OrchestratorContract<TOutput, TState> {\n  validateFactoryConfig(config as unknown as OrchestratorConfig<unknown>);\n\n  const entries = resolveEntries(config as unknown as OrchestratorConfig<unknown>);\n\n  assertInitialAgent(config as unknown as OrchestratorConfig<unknown>, entries);\n\n  const signature = computeOrchestratorSignature(\n    config as unknown as OrchestratorConfig<unknown>,\n    entries,\n  );\n  const emitter = new OrchestratorEmitter(config.on);\n\n  // Per-session turn serialization (C4). Resolved ONCE so every turn on\n  // this orchestrator shares the same lock — that's what lets the\n  // in-process default actually serialize concurrent same-session calls.\n  const sessionLock = resolveSessionLock(config as unknown as OrchestratorConfig<unknown>);\n  warnOnUnlockedDurableStore(config as unknown as OrchestratorConfig<unknown>);\n\n  async function execute(\n    input: SupervisorInput,\n    options: OrchestratorExecuteOptions<TState>,\n  ): Promise<OrchestratorResult<TOutput>> {\n    const execution = new OrchestratorExecution<TOutput, TState>({\n      config: config as unknown as OrchestratorConfig<TOutput, TState>,\n      entries,\n      signature,\n      emitter,\n      input,\n      options,\n    });\n\n    // Serialize the whole turn (load → dispatch → persist) against any\n    // concurrent turn for the same session, so the checkpoint's\n    // read-modify-write can't lose an update.\n    return sessionLock.withLock(options.sessionId, () => execution.run(), {\n      signal: options.signal,\n    });\n  }\n\n  function stream(\n    input: SupervisorInput,\n    options: OrchestratorExecuteOptions<TState>,\n  ): StreamContract<OrchestratorResult<TOutput>, OrchestratorEvent> {\n    const { controller, stream: contract } = createOrchestratorStream<\n      OrchestratorResult<TOutput>\n    >();\n\n    const execution = new OrchestratorExecution<TOutput, TState>({\n      config: config as unknown as OrchestratorConfig<TOutput, TState>,\n      entries,\n      signature,\n      emitter,\n      input,\n      options,\n      streamController: controller,\n    });\n\n    // The background run waits for the session lock before it starts —\n    // same serialization guarantee as `execute`; the stream contract is\n    // still returned synchronously.\n    void sessionLock.withLock(options.sessionId, () => execution.run(), {\n      signal: options.signal,\n    });\n\n    return contract;\n  }\n\n  async function resume(\n    sessionId: string,\n    options?: OrchestratorResumeOptions,\n  ): Promise<OrchestratorResult<TOutput> | null> {\n    const execution = new OrchestratorExecution<TOutput, TState>({\n      config: config as unknown as OrchestratorConfig<TOutput, TState>,\n      entries,\n      signature,\n      emitter,\n      resumeSessionId: sessionId,\n      resumeOptions: options,\n    });\n\n    return sessionLock.withLock(sessionId, () => execution.resume(), {\n      signal: options?.signal,\n    });\n  }\n\n  // The dispatcher owns command ROUTING only; the `compact` handler\n  // delegates to the shared compaction code path on the lifecycle engine\n  // (§11 / §12.2 — manual compact reuses the post-turn compaction path).\n  const command = createCommandDispatcher({\n    compact: (args: OrchestratorCommands[\"compact\"][\"args\"]) => {\n      const execution = new OrchestratorExecution<TOutput, TState>({\n        config: config as unknown as OrchestratorConfig<TOutput, TState>,\n        entries,\n        signature,\n        emitter,\n      });\n\n      return execution.compact(args);\n    },\n  });\n\n  const instance: OrchestratorContract<TOutput, TState> = {\n    name: config.name,\n    signature,\n    version: config.version,\n    execute,\n    stream,\n    resume,\n    command,\n    asTool<TToolInput = string>(\n      options: OrchestratorAsToolOptions<TToolInput>,\n    ): ToolContract<TToolInput, TOutput> {\n      return orchestratorAsTool<TOutput, TState, TToolInput>(instance, options);\n    },\n    on<K extends OrchestratorEventName>(\n      event: K,\n      handler: OrchestratorEventHandler<K>,\n    ): () => void {\n      return emitter.on(event, handler);\n    },\n    off<K extends OrchestratorEventName>(\n      event: K,\n      handler: OrchestratorEventHandler<K>,\n    ): void {\n      emitter.off(event, handler);\n    },\n  };\n\n  return instance;\n}\n\n/**\n * Author-time validation (orchestrator.md §17). Enforces the rules that\n * must fail at construction rather than on the first turn:\n *\n * - `name` present and a string.\n * - `intents` present.\n * - `route` XOR `router` (mutually exclusive; at least one required) —\n *   the supervisor's dispatch-source rule, surfaced as an orchestrator\n *   config error.\n * - `router` is a valid agent contract or `{ agent, ... }` entry.\n * - `maxIterations >= 1` when set.\n * - `snapshotStore` resolvable when `iterate: true` — explicit field or\n *   the global `ai.config({ defaultSnapshotStore })` fallback.\n *\n * `initialAgent` membership is checked separately once the intent\n * entries are resolved.\n */\nfunction validateFactoryConfig(config: OrchestratorConfig<unknown>): void {\n  if (!config.name || typeof config.name !== \"string\") {\n    throw new OrchestratorConfigError(\n      \"ai.orchestrator: `name` is required and must be a string\",\n      { context: { authoring: true } },\n    );\n  }\n\n  if (!config.intents || typeof config.intents !== \"object\") {\n    throw new OrchestratorConfigError(\n      `ai.orchestrator(\"${config.name}\"): \\`intents\\` is required`,\n      { context: { authoring: true } },\n    );\n  }\n\n  const hasRoute = typeof config.route === \"function\";\n  const hasRouter = Boolean(config.router);\n\n  if (hasRouter) {\n    const router = config.router;\n    const isBareAgent = typeof (router as { execute?: unknown }).execute === \"function\";\n    const isEntryForm =\n      !isBareAgent &&\n      typeof (router as { agent?: { execute?: unknown } }).agent === \"object\" &&\n      typeof (router as { agent?: { execute?: unknown } }).agent?.execute === \"function\";\n\n    if (!isBareAgent && !isEntryForm) {\n      throw new OrchestratorConfigError(\n        `ai.orchestrator(\"${config.name}\"): \\`router\\` must be an agent contract or a \\`{ agent, placeholders?, input? }\\` entry`,\n        { context: { authoring: true } },\n      );\n    }\n  }\n\n  if (hasRoute && hasRouter) {\n    throw new OrchestratorConfigError(\n      `ai.orchestrator(\"${config.name}\"): \\`route\\` and \\`router\\` are mutually exclusive — configure exactly one`,\n      { context: { authoring: true } },\n    );\n  }\n\n  if (!hasRoute && !hasRouter) {\n    throw new OrchestratorConfigError(\n      `ai.orchestrator(\"${config.name}\"): one of \\`route\\` or \\`router\\` is required`,\n      { context: { authoring: true } },\n    );\n  }\n\n  if (config.maxIterations !== undefined && config.maxIterations < 1) {\n    throw new OrchestratorConfigError(\n      `ai.orchestrator(\"${config.name}\"): \\`maxIterations\\` must be >= 1`,\n      { context: { authoring: true, maxIterations: config.maxIterations } },\n    );\n  }\n\n  if (config.iterate && !config.snapshotStore && !resolveDefaultSnapshotStore()) {\n    throw new OrchestratorConfigError(\n      `ai.orchestrator(\"${config.name}\"): \\`iterate: true\\` requires a \\`snapshotStore\\` (or \\`ai.config({ defaultSnapshotStore })\\`) for mid-turn resume`,\n      { context: { authoring: true } },\n    );\n  }\n}\n\n/**\n * Resolve the `intents` map into the supervisor's internal entry shape,\n * re-wrapping the supervisor's authoring failure as an\n * {@link OrchestratorConfigError} so misuse surfaces under the\n * orchestrator's error family rather than the supervisor's.\n */\nfunction resolveEntries(\n  config: OrchestratorConfig<unknown>,\n): Map<string, ResolvedIntentEntry> {\n  try {\n    return resolveIntentEntries(config.intents, config.name);\n  } catch (error) {\n    if (error instanceof SupervisorFailedError) {\n      throw new OrchestratorConfigError(error.message, {\n        context: { authoring: true },\n        cause: error,\n      });\n    }\n\n    throw error;\n  }\n}\n\n/**\n * Enforce the `initialAgent` membership rule (§17) once entries are\n * resolved — `initialAgent`, when set, must name a key in `intents`.\n */\nfunction assertInitialAgent(\n  config: OrchestratorConfig<unknown>,\n  entries: Map<string, ResolvedIntentEntry>,\n): void {\n  if (config.initialAgent && !entries.has(config.initialAgent)) {\n    throw new OrchestratorConfigError(\n      `ai.orchestrator(\"${config.name}\"): \\`initialAgent\\` \"${config.initialAgent}\" is not a key in \\`intents\\``,\n      { context: { authoring: true } },\n    );\n  }\n}\n\n/**\n * Resolve the per-session lock (C4): an explicit {@link SessionLock} when\n * supplied, a no-op when `sessionLock: false`, otherwise the framework\n * default in-process mutex.\n */\nfunction resolveSessionLock(config: OrchestratorConfig<unknown>): SessionLock {\n  if (config.sessionLock === false) return noopSessionLock();\n  if (config.sessionLock) return config.sessionLock;\n  return inProcessSessionLock();\n}\n\n/** Orchestrator names already warned about an unlocked durable store. */\nconst warnedUnlockedStores = new Set<string>();\n\n/**\n * Warn once when a durable `checkpointStore` is configured but no explicit\n * `sessionLock` was supplied (C4). The in-process default serializes\n * same-session turns within one process only — a horizontally-scaled\n * deployment needs a distributed lock or sticky routing. Suppressed in\n * tests and when the dev explicitly chose a lock (or `sessionLock: false`).\n */\nfunction warnOnUnlockedDurableStore(config: OrchestratorConfig<unknown>): void {\n  if (config.sessionLock !== undefined) return;\n  if (!config.checkpointStore) return;\n  if (process.env.NODE_ENV === \"test\" || process.env.VITEST) return;\n  if (warnedUnlockedStores.has(config.name)) return;\n  warnedUnlockedStores.add(config.name);\n\n  console.warn(\n    `[warlock-ai] orchestrator \"${config.name}\" uses a durable checkpointStore with the default in-process sessionLock. ` +\n      \"That serializes same-session turns within ONE process only; in a horizontally-scaled deployment supply a distributed \" +\n      \"`sessionLock` (Redis/Postgres advisory locks) or use sticky routing. Pass `sessionLock: false` to silence this.\",\n  );\n}\n"],"mappings":"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"}

package/esm/orchestrator/session-lock.d.mts

@@ -0,0 +1,25 @@
+import { SessionLock } from "../contracts/orchestrator/session-lock.contract.mjs";
+
+//#region ../@warlock.js/ai/src/orchestrator/session-lock.d.ts
+/**
+ * Framework-default in-process {@link SessionLock} — a per-key promise-
+ * chain mutex. It holds one tail promise per session key; each acquirer
+ * waits on the previous holder's release, then installs its own tail.
+ * Keyed by `sessionId`, so different sessions never contend. The wait is
+ * abortable, so a cancelled caller never deadlocks behind a stuck
+ * predecessor (the deadlock-on-cancel trap).
+ *
+ * In-process only: serializes same-session turns within ONE process.
+ * Supply a distributed {@link SessionLock} for multi-process deployments.
+ */
+declare function inProcessSessionLock(): SessionLock;
+/**
+ * No-op {@link SessionLock} for `sessionLock: false` — runs `fn` with no
+ * serialization at all. Opt out only when an external mechanism (sticky
+ * routing, a single-writer guarantee) already serializes same-session
+ * turns.
+ */
+declare function noopSessionLock(): SessionLock;
+//#endregion
+export { inProcessSessionLock, noopSessionLock };
+//# sourceMappingURL=session-lock.d.mts.map

package/esm/orchestrator/session-lock.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-lock.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai/src/orchestrator/session-lock.ts"],"mappings":";;;;;AAqBA;;;;AAAmD;AA4FnD;;;;iBA5FgB,oBAAA,IAAwB,WAAW;;;;;;;iBA4FnC,eAAA,IAAmB,WAAW"}

package/esm/orchestrator/session-lock.mjs

@@ -0,0 +1,83 @@
+//#region ../@warlock.js/ai/src/orchestrator/session-lock.ts
+/**
+* Reason an aborted lock-wait rejects with — the signal's `reason` when
+* one was supplied to `controller.abort(reason)`, else a generic error.
+*/
+function abortReason(signal) {
+	return signal.reason ?? /* @__PURE__ */ new Error("session lock wait aborted");
+}
+/**
+* Framework-default in-process {@link SessionLock} — a per-key promise-
+* chain mutex. It holds one tail promise per session key; each acquirer
+* waits on the previous holder's release, then installs its own tail.
+* Keyed by `sessionId`, so different sessions never contend. The wait is
+* abortable, so a cancelled caller never deadlocks behind a stuck
+* predecessor (the deadlock-on-cancel trap).
+*
+* In-process only: serializes same-session turns within ONE process.
+* Supply a distributed {@link SessionLock} for multi-process deployments.
+*/
+function inProcessSessionLock() {
+	const tails = /* @__PURE__ */ new Map();
+	return { async withLock(key, fn, options) {
+		const existing = tails.get(key);
+		const prev = existing ?? Promise.resolve();
+		const waitSignal = existing ? options?.signal : void 0;
+		let release;
+		const held = new Promise((resolve) => {
+			release = resolve;
+		});
+		const mine = prev.then(() => held, () => held);
+		tails.set(key, mine);
+		const cleanup = () => {
+			if (tails.get(key) === mine) tails.delete(key);
+		};
+		try {
+			await waitForTurn(prev, waitSignal);
+		} catch (error) {
+			release();
+			cleanup();
+			throw error;
+		}
+		try {
+			return await fn();
+		} finally {
+			release();
+			cleanup();
+		}
+	} };
+}
+/**
+* Wait for `prev` (the previous holder's release) to settle, racing it
+* against `signal` so a cancelled caller stops waiting instead of
+* deadlocking. Predecessor rejections are swallowed — a failed turn still
+* releases the lock to the next waiter.
+*/
+function waitForTurn(prev, signal) {
+	const settled = prev.then(() => {}, () => {});
+	if (!signal) return settled;
+	if (signal.aborted) return Promise.reject(abortReason(signal));
+	return new Promise((resolve, reject) => {
+		const onAbort = () => reject(abortReason(signal));
+		signal.addEventListener("abort", onAbort, { once: true });
+		settled.then(() => {
+			signal.removeEventListener("abort", onAbort);
+			resolve();
+		});
+	});
+}
+/**
+* No-op {@link SessionLock} for `sessionLock: false` — runs `fn` with no
+* serialization at all. Opt out only when an external mechanism (sticky
+* routing, a single-writer guarantee) already serializes same-session
+* turns.
+*/
+function noopSessionLock() {
+	return { withLock(_key, fn) {
+		return fn();
+	} };
+}
+
+//#endregion
+export { inProcessSessionLock, noopSessionLock };
+//# sourceMappingURL=session-lock.mjs.map

package/esm/orchestrator/session-lock.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-lock.mjs","names":[],"sources":["../../../../../../../@warlock.js/ai/src/orchestrator/session-lock.ts"],"sourcesContent":["import type { SessionLock } from \"../contracts/orchestrator/session-lock.contract\";\n\n/**\n * Reason an aborted lock-wait rejects with — the signal's `reason` when\n * one was supplied to `controller.abort(reason)`, else a generic error.\n */\nfunction abortReason(signal: AbortSignal): unknown {\n  return signal.reason ?? new Error(\"session lock wait aborted\");\n}\n\n/**\n * Framework-default in-process {@link SessionLock} — a per-key promise-\n * chain mutex. It holds one tail promise per session key; each acquirer\n * waits on the previous holder's release, then installs its own tail.\n * Keyed by `sessionId`, so different sessions never contend. The wait is\n * abortable, so a cancelled caller never deadlocks behind a stuck\n * predecessor (the deadlock-on-cancel trap).\n *\n * In-process only: serializes same-session turns within ONE process.\n * Supply a distributed {@link SessionLock} for multi-process deployments.\n */\nexport function inProcessSessionLock(): SessionLock {\n  const tails = new Map<string, Promise<void>>();\n\n  return {\n    async withLock<T>(\n      key: string,\n      fn: () => Promise<T>,\n      options?: { signal?: AbortSignal },\n    ): Promise<T> {\n      const existing = tails.get(key);\n      const prev = existing ?? Promise.resolve();\n\n      // The caller's signal aborts a genuine WAIT only. When the lock is\n      // free (no existing tail) we acquire immediately and let `fn` own\n      // cancellation — so a pre-aborted signal never pre-empts graceful\n      // in-flight handling (e.g. the orchestrator emitting turn.cancelled).\n      const waitSignal = existing ? options?.signal : undefined;\n\n      let release!: () => void;\n      const held = new Promise<void>(resolve => {\n        release = resolve;\n      });\n\n      // Successors queue behind OUR release. A predecessor that rejects\n      // still lets us through (both branches resolve to `held`), so a\n      // single failed turn never wedges the whole session.\n      const mine = prev.then(\n        () => held,\n        () => held,\n      );\n      tails.set(key, mine);\n\n      const cleanup = () => {\n        // Drop the map entry once we're the tail, so idle sessions don't\n        // leak Promise references.\n        if (tails.get(key) === mine) {\n          tails.delete(key);\n        }\n      };\n\n      try {\n        await waitForTurn(prev, waitSignal);\n      } catch (error) {\n        // Never acquired the critical section — release immediately so\n        // successors aren't blocked by an aborted waiter, then surface\n        // the abort to the caller.\n        release();\n        cleanup();\n        throw error;\n      }\n\n      try {\n        return await fn();\n      } finally {\n        release();\n        cleanup();\n      }\n    },\n  };\n}\n\n/**\n * Wait for `prev` (the previous holder's release) to settle, racing it\n * against `signal` so a cancelled caller stops waiting instead of\n * deadlocking. Predecessor rejections are swallowed — a failed turn still\n * releases the lock to the next waiter.\n */\nfunction waitForTurn(prev: Promise<void>, signal?: AbortSignal): Promise<void> {\n  const settled = prev.then(\n    () => {},\n    () => {},\n  );\n\n  if (!signal) return settled;\n  if (signal.aborted) return Promise.reject(abortReason(signal));\n\n  return new Promise<void>((resolve, reject) => {\n    const onAbort = () => reject(abortReason(signal));\n    signal.addEventListener(\"abort\", onAbort, { once: true });\n    void settled.then(() => {\n      signal.removeEventListener(\"abort\", onAbort);\n      resolve();\n    });\n  });\n}\n\n/**\n * No-op {@link SessionLock} for `sessionLock: false` — runs `fn` with no\n * serialization at all. Opt out only when an external mechanism (sticky\n * routing, a single-writer guarantee) already serializes same-session\n * turns.\n */\nexport function noopSessionLock(): SessionLock {\n  return {\n    withLock<T>(_key: string, fn: () => Promise<T>): Promise<T> {\n      return fn();\n    },\n  };\n}\n"],"mappings":";;;;;AAMA,SAAS,YAAY,QAA8B;CACjD,OAAO,OAAO,0BAAU,IAAI,MAAM,2BAA2B;AAC/D;;;;;;;;;;;;AAaA,SAAgB,uBAAoC;CAClD,MAAM,wBAAQ,IAAI,IAA2B;CAE7C,OAAO,EACL,MAAM,SACJ,KACA,IACA,SACY;EACZ,MAAM,WAAW,MAAM,IAAI,GAAG;EAC9B,MAAM,OAAO,YAAY,QAAQ,QAAQ;EAMzC,MAAM,aAAa,WAAW,SAAS,SAAS;EAEhD,IAAI;EACJ,MAAM,OAAO,IAAI,SAAc,YAAW;GACxC,UAAU;EACZ,CAAC;EAKD,MAAM,OAAO,KAAK,WACV,YACA,IACR;EACA,MAAM,IAAI,KAAK,IAAI;EAEnB,MAAM,gBAAgB;GAGpB,IAAI,MAAM,IAAI,GAAG,MAAM,MACrB,MAAM,OAAO,GAAG;EAEpB;EAEA,IAAI;GACF,MAAM,YAAY,MAAM,UAAU;EACpC,SAAS,OAAO;GAId,QAAQ;GACR,QAAQ;GACR,MAAM;EACR;EAEA,IAAI;GACF,OAAO,MAAM,GAAG;EAClB,UAAU;GACR,QAAQ;GACR,QAAQ;EACV;CACF,EACF;AACF;;;;;;;AAQA,SAAS,YAAY,MAAqB,QAAqC;CAC7E,MAAM,UAAU,KAAK,WACb,CAAC,SACD,CAAC,CACT;CAEA,IAAI,CAAC,QAAQ,OAAO;CACpB,IAAI,OAAO,SAAS,OAAO,QAAQ,OAAO,YAAY,MAAM,CAAC;CAE7D,OAAO,IAAI,SAAe,SAAS,WAAW;EAC5C,MAAM,gBAAgB,OAAO,YAAY,MAAM,CAAC;EAChD,OAAO,iBAAiB,SAAS,SAAS,EAAE,MAAM,KAAK,CAAC;EACxD,AAAK,QAAQ,WAAW;GACtB,OAAO,oBAAoB,SAAS,OAAO;GAC3C,QAAQ;EACV,CAAC;CACH,CAAC;AACH;;;;;;;AAQA,SAAgB,kBAA+B;CAC7C,OAAO,EACL,SAAY,MAAc,IAAkC;EAC1D,OAAO,GAAG;CACZ,EACF;AACF"}

package/esm/planner/dag-scheduler.mjs

@@ -0,0 +1,97 @@
+import { PlannerPlanInvalidError } from "../errors/planner-plan-invalid-error.mjs";
+
+//#region ../@warlock.js/ai/src/planner/dag-scheduler.ts
+/**
+* Build the execution DAG from a plan's steps.
+*
+* Each step's `id` (falling back to its array index) and its `dependsOn`
+* become an adjacency list. A `dependsOn` that names a step not in the
+* plan, or any dependency cycle, raises a typed
+* {@link PlannerPlanInvalidError} BEFORE any step runs — the same error
+* class `generatePlan` uses for an unusable plan, with forensic context.
+*
+* @throws PlannerPlanInvalidError on a duplicate id, an unknown
+*   `dependsOn` target, or a cycle.
+*/
+function buildDag(steps, plannerName = "planner") {
+	const nodes = [];
+	const byId = /* @__PURE__ */ new Map();
+	for (let index = 0; index < steps.length; index++) {
+		const step = steps[index];
+		const id = step.id ?? String(index);
+		if (byId.has(id)) throw new PlannerPlanInvalidError(`ai.planner("${plannerName}"): duplicate step id "${id}" in DAG plan`, { context: { id } });
+		const node = {
+			id,
+			index,
+			step,
+			dependencies: []
+		};
+		nodes.push(node);
+		byId.set(id, node);
+	}
+	const dependents = /* @__PURE__ */ new Map();
+	for (const node of nodes) {
+		const seen = /* @__PURE__ */ new Set();
+		for (const dependency of node.step.dependsOn ?? []) {
+			if (dependency === node.id) continue;
+			if (!byId.has(dependency)) throw new PlannerPlanInvalidError(`ai.planner("${plannerName}"): step "${node.id}" depends on unknown step "${dependency}"`, { context: {
+				id: node.id,
+				dependency
+			} });
+			if (seen.has(dependency)) continue;
+			seen.add(dependency);
+			node.dependencies.push(dependency);
+			const reverse = dependents.get(dependency) ?? [];
+			reverse.push(node.id);
+			dependents.set(dependency, reverse);
+		}
+	}
+	assertAcyclic(nodes, byId, plannerName);
+	return {
+		nodes,
+		byId,
+		dependents
+	};
+}
+/**
+* Compute the next ready set: nodes not yet done whose every dependency
+* is in `completed`. Preserves original plan order so a level dispatches
+* deterministically. A node whose dependency is `unreachable` (a failed
+* or skipped ancestor) is NOT ready — it never becomes ready and is
+* recorded skipped by the caller.
+*/
+function readyNodes(dag, completed, done) {
+	return dag.nodes.filter((node) => !done.has(node.id) && node.dependencies.every((dependency) => completed.has(dependency)));
+}
+/**
+* The topological sink(s) — nodes nothing depends on. Used to define the
+* "final output" under parallelism: with an `output` schema set, a
+* single sink is the unambiguous final step; multiple sinks are a
+* convergence error the caller surfaces.
+*/
+function sinkNodes(dag) {
+	return dag.nodes.filter((node) => (dag.dependents.get(node.id) ?? []).length === 0);
+}
+/**
+* Depth-first cycle detection over the dependency edges. A back-edge to
+* a node on the current recursion stack means a cycle — raised as a
+* typed {@link PlannerPlanInvalidError} naming the offending node.
+*/
+function assertAcyclic(nodes, byId, plannerName) {
+	const VISITING = 1;
+	const DONE = 2;
+	const state = /* @__PURE__ */ new Map();
+	const visit = (node) => {
+		const current = state.get(node.id);
+		if (current === DONE) return;
+		if (current === VISITING) throw new PlannerPlanInvalidError(`ai.planner("${plannerName}"): dependency cycle detected at step "${node.id}"`, { context: { id: node.id } });
+		state.set(node.id, VISITING);
+		for (const dependency of node.dependencies) visit(byId.get(dependency));
+		state.set(node.id, DONE);
+	};
+	for (const node of nodes) visit(node);
+}
+
+//#endregion
+export { buildDag, readyNodes, sinkNodes };
+//# sourceMappingURL=dag-scheduler.mjs.map

package/esm/planner/dag-scheduler.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"dag-scheduler.mjs","names":[],"sources":["../../../../../../../@warlock.js/ai/src/planner/dag-scheduler.ts"],"sourcesContent":["import type { PlannerStep } from \"../contracts/planner/planner-plan.type\";\nimport { PlannerPlanInvalidError } from \"../errors/planner-plan-invalid-error\";\n\n/**\n * One node in the planner's execution DAG — a plan step plus the\n * resolved structural metadata the scheduler needs to order it.\n *\n * `id` is the step's own `id` when present, falling back to the step's\n * array index stringified (exactly as {@link PlannerStep.id} documents).\n * `dependencies` is the resolved set of node ids this step waits on,\n * de-duplicated and self-references dropped.\n */\nexport type DagNode = {\n  /** Stable id — the step's own `id`, or its array index as a string. */\n  id: string;\n  /** 0-based position of the step in the original plan array. */\n  index: number;\n  /** The plan step this node schedules. */\n  step: PlannerStep;\n  /** Resolved ids this step depends on (subset of the DAG's node ids). */\n  dependencies: string[];\n};\n\n/**\n * The built execution DAG — the ordered node list plus the lookups the\n * scheduler walks. Ordering follows the original plan array so a\n * dependency-free plan executes in author order, level by level.\n */\nexport type PlannerDag = {\n  /** Nodes in original plan order. */\n  nodes: DagNode[];\n  /** id → node, for dependency resolution and sink detection. */\n  byId: Map<string, DagNode>;\n  /** id → ids of the nodes that depend on it (reverse edges). */\n  dependents: Map<string, string[]>;\n};\n\n/**\n * Build the execution DAG from a plan's steps.\n *\n * Each step's `id` (falling back to its array index) and its `dependsOn`\n * become an adjacency list. A `dependsOn` that names a step not in the\n * plan, or any dependency cycle, raises a typed\n * {@link PlannerPlanInvalidError} BEFORE any step runs — the same error\n * class `generatePlan` uses for an unusable plan, with forensic context.\n *\n * @throws PlannerPlanInvalidError on a duplicate id, an unknown\n *   `dependsOn` target, or a cycle.\n */\nexport function buildDag(steps: PlannerStep[], plannerName = \"planner\"): PlannerDag {\n  const nodes: DagNode[] = [];\n  const byId = new Map<string, DagNode>();\n\n  // Pass 1 — assign every step a stable id (own id or array index) and\n  // index the nodes. Duplicate explicit ids are a malformed plan.\n  for (let index = 0; index < steps.length; index++) {\n    const step = steps[index] as PlannerStep;\n    const id = step.id ?? String(index);\n\n    if (byId.has(id)) {\n      throw new PlannerPlanInvalidError(\n        `ai.planner(\"${plannerName}\"): duplicate step id \"${id}\" in DAG plan`,\n        { context: { id } },\n      );\n    }\n\n    const node: DagNode = { id, index, step, dependencies: [] };\n    nodes.push(node);\n    byId.set(id, node);\n  }\n\n  // Pass 2 — resolve dependencies against the id set; reject unknowns,\n  // dedupe, and drop self-references (a no-op edge, never a cycle).\n  const dependents = new Map<string, string[]>();\n\n  for (const node of nodes) {\n    const seen = new Set<string>();\n\n    for (const dependency of node.step.dependsOn ?? []) {\n      if (dependency === node.id) {\n        continue;\n      }\n\n      if (!byId.has(dependency)) {\n        throw new PlannerPlanInvalidError(\n          `ai.planner(\"${plannerName}\"): step \"${node.id}\" depends on unknown step \"${dependency}\"`,\n          { context: { id: node.id, dependency } },\n        );\n      }\n\n      if (seen.has(dependency)) {\n        continue;\n      }\n\n      seen.add(dependency);\n      node.dependencies.push(dependency);\n\n      const reverse = dependents.get(dependency) ?? [];\n      reverse.push(node.id);\n      dependents.set(dependency, reverse);\n    }\n  }\n\n  assertAcyclic(nodes, byId, plannerName);\n\n  return { nodes, byId, dependents };\n}\n\n/**\n * Compute the next ready set: nodes not yet done whose every dependency\n * is in `completed`. Preserves original plan order so a level dispatches\n * deterministically. A node whose dependency is `unreachable` (a failed\n * or skipped ancestor) is NOT ready — it never becomes ready and is\n * recorded skipped by the caller.\n */\nexport function readyNodes(\n  dag: PlannerDag,\n  completed: ReadonlySet<string>,\n  done: ReadonlySet<string>,\n): DagNode[] {\n  return dag.nodes.filter(\n    (node) =>\n      !done.has(node.id) &&\n      node.dependencies.every((dependency) => completed.has(dependency)),\n  );\n}\n\n/**\n * The topological sink(s) — nodes nothing depends on. Used to define the\n * \"final output\" under parallelism: with an `output` schema set, a\n * single sink is the unambiguous final step; multiple sinks are a\n * convergence error the caller surfaces.\n */\nexport function sinkNodes(dag: PlannerDag): DagNode[] {\n  return dag.nodes.filter((node) => (dag.dependents.get(node.id) ?? []).length === 0);\n}\n\n/**\n * Depth-first cycle detection over the dependency edges. A back-edge to\n * a node on the current recursion stack means a cycle — raised as a\n * typed {@link PlannerPlanInvalidError} naming the offending node.\n */\nfunction assertAcyclic(\n  nodes: DagNode[],\n  byId: Map<string, DagNode>,\n  plannerName: string,\n): void {\n  const VISITING = 1;\n  const DONE = 2;\n  const state = new Map<string, number>();\n\n  const visit = (node: DagNode): void => {\n    const current = state.get(node.id);\n\n    if (current === DONE) {\n      return;\n    }\n\n    if (current === VISITING) {\n      throw new PlannerPlanInvalidError(\n        `ai.planner(\"${plannerName}\"): dependency cycle detected at step \"${node.id}\"`,\n        { context: { id: node.id } },\n      );\n    }\n\n    state.set(node.id, VISITING);\n\n    for (const dependency of node.dependencies) {\n      visit(byId.get(dependency) as DagNode);\n    }\n\n    state.set(node.id, DONE);\n  };\n\n  for (const node of nodes) {\n    visit(node);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;AAiDA,SAAgB,SAAS,OAAsB,cAAc,WAAuB;CAClF,MAAM,QAAmB,CAAC;CAC1B,MAAM,uBAAO,IAAI,IAAqB;CAItC,KAAK,IAAI,QAAQ,GAAG,QAAQ,MAAM,QAAQ,SAAS;EACjD,MAAM,OAAO,MAAM;EACnB,MAAM,KAAK,KAAK,MAAM,OAAO,KAAK;EAElC,IAAI,KAAK,IAAI,EAAE,GACb,MAAM,IAAI,wBACR,eAAe,YAAY,yBAAyB,GAAG,gBACvD,EAAE,SAAS,EAAE,GAAG,EAAE,CACpB;EAGF,MAAM,OAAgB;GAAE;GAAI;GAAO;GAAM,cAAc,CAAC;EAAE;EAC1D,MAAM,KAAK,IAAI;EACf,KAAK,IAAI,IAAI,IAAI;CACnB;CAIA,MAAM,6BAAa,IAAI,IAAsB;CAE7C,KAAK,MAAM,QAAQ,OAAO;EACxB,MAAM,uBAAO,IAAI,IAAY;EAE7B,KAAK,MAAM,cAAc,KAAK,KAAK,aAAa,CAAC,GAAG;GAClD,IAAI,eAAe,KAAK,IACtB;GAGF,IAAI,CAAC,KAAK,IAAI,UAAU,GACtB,MAAM,IAAI,wBACR,eAAe,YAAY,YAAY,KAAK,GAAG,6BAA6B,WAAW,IACvF,EAAE,SAAS;IAAE,IAAI,KAAK;IAAI;GAAW,EAAE,CACzC;GAGF,IAAI,KAAK,IAAI,UAAU,GACrB;GAGF,KAAK,IAAI,UAAU;GACnB,KAAK,aAAa,KAAK,UAAU;GAEjC,MAAM,UAAU,WAAW,IAAI,UAAU,KAAK,CAAC;GAC/C,QAAQ,KAAK,KAAK,EAAE;GACpB,WAAW,IAAI,YAAY,OAAO;EACpC;CACF;CAEA,cAAc,OAAO,MAAM,WAAW;CAEtC,OAAO;EAAE;EAAO;EAAM;CAAW;AACnC;;;;;;;;AASA,SAAgB,WACd,KACA,WACA,MACW;CACX,OAAO,IAAI,MAAM,QACd,SACC,CAAC,KAAK,IAAI,KAAK,EAAE,KACjB,KAAK,aAAa,OAAO,eAAe,UAAU,IAAI,UAAU,CAAC,CACrE;AACF;;;;;;;AAQA,SAAgB,UAAU,KAA4B;CACpD,OAAO,IAAI,MAAM,QAAQ,UAAU,IAAI,WAAW,IAAI,KAAK,EAAE,KAAK,CAAC,EAAC,CAAE,WAAW,CAAC;AACpF;;;;;;AAOA,SAAS,cACP,OACA,MACA,aACM;CACN,MAAM,WAAW;CACjB,MAAM,OAAO;CACb,MAAM,wBAAQ,IAAI,IAAoB;CAEtC,MAAM,SAAS,SAAwB;EACrC,MAAM,UAAU,MAAM,IAAI,KAAK,EAAE;EAEjC,IAAI,YAAY,MACd;EAGF,IAAI,YAAY,UACd,MAAM,IAAI,wBACR,eAAe,YAAY,yCAAyC,KAAK,GAAG,IAC5E,EAAE,SAAS,EAAE,IAAI,KAAK,GAAG,EAAE,CAC7B;EAGF,MAAM,IAAI,KAAK,IAAI,QAAQ;EAE3B,KAAK,MAAM,cAAc,KAAK,cAC5B,MAAM,KAAK,IAAI,UAAU,CAAY;EAGvC,MAAM,IAAI,KAAK,IAAI,IAAI;CACzB;CAEA,KAAK,MAAM,QAAQ,OACjB,MAAM,IAAI;AAEd"}

package/esm/planner/plan-prompt.d.mts

@@ -11,7 +11,7 @@ import { PlannerCapability } from "../contracts/planner/planner-capability.type.
  * planner's lifetime) — the produced string is baked onto the internal
  * planning agent.
  */
-declare function buildPlanSystemPrompt(capabilities: PlannerCapability[], maxSteps: number, prefix: SystemPromptContract | string | undefined): string;
+declare function buildPlanSystemPrompt(capabilities: PlannerCapability[], maxSteps: number, prefix: SystemPromptContract | string | undefined, dag?: boolean): string;
 //#endregion
 export { buildPlanSystemPrompt };
 //# sourceMappingURL=plan-prompt.d.mts.map

package/esm/planner/plan-prompt.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"plan-prompt.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai/src/planner/plan-prompt.ts"],"mappings":";;;;;;AAYA;;;;;;;iBAAgB,qBAAA,CACd,YAAA,EAAc,iBAAA,IACd,QAAA,UACA,MAAA,EAAQ,oBAAoB"}
+{"version":3,"file":"plan-prompt.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai/src/planner/plan-prompt.ts"],"mappings":";;;;;;AAYA;;;;;;;iBAAgB,qBAAA,CACd,YAAA,EAAc,iBAAA,IACd,QAAA,UACA,MAAA,EAAQ,oBAAoB,uBAC5B,GAAA"}

package/esm/planner/plan-prompt.mjs

@@ -8,12 +8,13 @@
 * planner's lifetime) — the produced string is baked onto the internal
 * planning agent.
 */
-function buildPlanSystemPrompt(capabilities, maxSteps, prefix) {
+function buildPlanSystemPrompt(capabilities, maxSteps, prefix, dag = false) {
 	const capabilityLines = capabilities.map((capability) => `- ${capability.name}: ${capability.description}`);
 	const sections = [];
 	const resolvedPrefix = resolvePrefix(prefix);
 	if (resolvedPrefix && resolvedPrefix.trim().length > 0) sections.push(resolvedPrefix.trim(), "");
 	sections.push("You are a planner. Break the user's goal into an ordered sequence of steps,", "each one dispatching exactly one of the available capabilities below.", "", "Available capabilities:", ...capabilityLines, "", "Rules:", `- Produce at most ${maxSteps} steps.`, "- Each step's `capability` must be exactly one name from the list above.", "- Each step's `input` is the concrete instruction passed to that capability.", "- Order the steps so each builds on the outputs of the ones before it.", "- Never invent a capability name that is not listed.", "- Keep the plan minimal — only the steps actually needed to satisfy the goal.");
+	if (dag) sections.push("- Give each step a stable `id` and list the ids it builds on in `dependsOn`.", "- Steps with no `dependsOn` between them run in PARALLEL — only add a", "  dependency when a step genuinely needs an earlier step's output.", "- The plan must converge: avoid dependency cycles.");
 	return sections.join("\n");
 }
 /**

package/esm/planner/plan-prompt.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"plan-prompt.mjs","names":[],"sources":["../../../../../../../@warlock.js/ai/src/planner/plan-prompt.ts"],"sourcesContent":["import type { PlannerCapability } from \"../contracts/planner/planner-capability.type\";\nimport type { SystemPromptContract } from \"../contracts/system-prompt.contract\";\n\n/**\n * Assemble the plan-generation system prompt: optional caller framing on\n * top, then the mechanical block listing every capability + its\n * description and the rules for emitting an ordered plan.\n *\n * Runs once at factory time (the capability set is fixed for the\n * planner's lifetime) — the produced string is baked onto the internal\n * planning agent.\n */\nexport function buildPlanSystemPrompt(\n  capabilities: PlannerCapability[],\n  maxSteps: number,\n  prefix: SystemPromptContract | string | undefined,\n): string {\n  const capabilityLines = capabilities.map(\n    (capability) => `- ${capability.name}: ${capability.description}`,\n  );\n\n  const sections: string[] = [];\n  const resolvedPrefix = resolvePrefix(prefix);\n\n  if (resolvedPrefix && resolvedPrefix.trim().length > 0) {\n    sections.push(resolvedPrefix.trim(), \"\");\n  }\n\n  sections.push(\n    \"You are a planner. Break the user's goal into an ordered sequence of steps,\",\n    \"each one dispatching exactly one of the available capabilities below.\",\n    \"\",\n    \"Available capabilities:\",\n    ...capabilityLines,\n    \"\",\n    \"Rules:\",\n    `- Produce at most ${maxSteps} steps.`,\n    \"- Each step's `capability` must be exactly one name from the list above.\",\n    \"- Each step's `input` is the concrete instruction passed to that capability.\",\n    \"- Order the steps so each builds on the outputs of the ones before it.\",\n    \"- Never invent a capability name that is not listed.\",\n    \"- Keep the plan minimal — only the steps actually needed to satisfy the goal.\",\n  );\n\n  return sections.join(\"\\n\");\n}\n\n/**\n * Resolve a caller-supplied `systemPrompt` (string or contract) to plain\n * text. Returns `undefined` when none was supplied.\n */\nfunction resolvePrefix(prompt: SystemPromptContract | string | undefined): string | undefined {\n  if (!prompt) {\n    return undefined;\n  }\n\n  return typeof prompt === \"string\" ? prompt : prompt.resolve();\n}\n"],"mappings":";;;;;;;;;;AAYA,SAAgB,sBACd,cACA,UACA,QACQ;CACR,MAAM,kBAAkB,aAAa,KAClC,eAAe,KAAK,WAAW,KAAK,IAAI,WAAW,aACtD;CAEA,MAAM,WAAqB,CAAC;CAC5B,MAAM,iBAAiB,cAAc,MAAM;CAE3C,IAAI,kBAAkB,eAAe,KAAK,CAAC,CAAC,SAAS,GACnD,SAAS,KAAK,eAAe,KAAK,GAAG,EAAE;CAGzC,SAAS,KACP,+EACA,yEACA,IACA,2BACA,GAAG,iBACH,IACA,UACA,qBAAqB,SAAS,UAC9B,4EACA,gFACA,0EACA,wDACA,+EACF;CAEA,OAAO,SAAS,KAAK,IAAI;AAC3B;;;;;AAMA,SAAS,cAAc,QAAuE;CAC5F,IAAI,CAAC,QACH;CAGF,OAAO,OAAO,WAAW,WAAW,SAAS,OAAO,QAAQ;AAC9D"}
+{"version":3,"file":"plan-prompt.mjs","names":[],"sources":["../../../../../../../@warlock.js/ai/src/planner/plan-prompt.ts"],"sourcesContent":["import type { PlannerCapability } from \"../contracts/planner/planner-capability.type\";\nimport type { SystemPromptContract } from \"../contracts/system-prompt.contract\";\n\n/**\n * Assemble the plan-generation system prompt: optional caller framing on\n * top, then the mechanical block listing every capability + its\n * description and the rules for emitting an ordered plan.\n *\n * Runs once at factory time (the capability set is fixed for the\n * planner's lifetime) — the produced string is baked onto the internal\n * planning agent.\n */\nexport function buildPlanSystemPrompt(\n  capabilities: PlannerCapability[],\n  maxSteps: number,\n  prefix: SystemPromptContract | string | undefined,\n  dag = false,\n): string {\n  const capabilityLines = capabilities.map(\n    (capability) => `- ${capability.name}: ${capability.description}`,\n  );\n\n  const sections: string[] = [];\n  const resolvedPrefix = resolvePrefix(prefix);\n\n  if (resolvedPrefix && resolvedPrefix.trim().length > 0) {\n    sections.push(resolvedPrefix.trim(), \"\");\n  }\n\n  sections.push(\n    \"You are a planner. Break the user's goal into an ordered sequence of steps,\",\n    \"each one dispatching exactly one of the available capabilities below.\",\n    \"\",\n    \"Available capabilities:\",\n    ...capabilityLines,\n    \"\",\n    \"Rules:\",\n    `- Produce at most ${maxSteps} steps.`,\n    \"- Each step's `capability` must be exactly one name from the list above.\",\n    \"- Each step's `input` is the concrete instruction passed to that capability.\",\n    \"- Order the steps so each builds on the outputs of the ones before it.\",\n    \"- Never invent a capability name that is not listed.\",\n    \"- Keep the plan minimal — only the steps actually needed to satisfy the goal.\",\n  );\n\n  if (dag) {\n    // DAG mode — the runtime schedules independent steps in parallel off\n    // `dependsOn`, so the model should declare dependencies explicitly\n    // rather than relying purely on array order.\n    sections.push(\n      \"- Give each step a stable `id` and list the ids it builds on in `dependsOn`.\",\n      \"- Steps with no `dependsOn` between them run in PARALLEL — only add a\",\n      \"  dependency when a step genuinely needs an earlier step's output.\",\n      \"- The plan must converge: avoid dependency cycles.\",\n    );\n  }\n\n  return sections.join(\"\\n\");\n}\n\n/**\n * Resolve a caller-supplied `systemPrompt` (string or contract) to plain\n * text. Returns `undefined` when none was supplied.\n */\nfunction resolvePrefix(prompt: SystemPromptContract | string | undefined): string | undefined {\n  if (!prompt) {\n    return undefined;\n  }\n\n  return typeof prompt === \"string\" ? prompt : prompt.resolve();\n}\n"],"mappings":";;;;;;;;;;AAYA,SAAgB,sBACd,cACA,UACA,QACA,MAAM,OACE;CACR,MAAM,kBAAkB,aAAa,KAClC,eAAe,KAAK,WAAW,KAAK,IAAI,WAAW,aACtD;CAEA,MAAM,WAAqB,CAAC;CAC5B,MAAM,iBAAiB,cAAc,MAAM;CAE3C,IAAI,kBAAkB,eAAe,KAAK,CAAC,CAAC,SAAS,GACnD,SAAS,KAAK,eAAe,KAAK,GAAG,EAAE;CAGzC,SAAS,KACP,+EACA,yEACA,IACA,2BACA,GAAG,iBACH,IACA,UACA,qBAAqB,SAAS,UAC9B,4EACA,gFACA,0EACA,wDACA,+EACF;CAEA,IAAI,KAIF,SAAS,KACP,gFACA,yEACA,sEACA,oDACF;CAGF,OAAO,SAAS,KAAK,IAAI;AAC3B;;;;;AAMA,SAAS,cAAc,QAAuE;CAC5F,IAAI,CAAC,QACH;CAGF,OAAO,OAAO,WAAW,WAAW,SAAS,OAAO,QAAQ;AAC9D"}

package/esm/planner/planner-run.d.mts

@@ -1,5 +1,6 @@
 import { AgentContract } from "../contracts/agent/agent.contract.mjs";
 import { PlannerCapability } from "../contracts/planner/planner-capability.type.mjs";
+import { PlannerSnapshot } from "../contracts/planner/planner-snapshot.type.mjs";
 import { PlannerConfig } from "../contracts/planner/planner-config.type.mjs";
 import { PlannerExecuteOptions } from "../contracts/planner/planner-execute-options.type.mjs";
 
@@ -17,6 +18,13 @@ type PlannerRunArgs<TOutput> = {
   planningAgent: AgentContract<unknown>;
   goal: string;
   options?: PlannerExecuteOptions<TOutput>;
+  /**
+   * Durable resume seed. When present the run re-hydrates the frozen plan
+   * + executed-node ledger + usage + child reports + replan budget from a
+   * prior crash, skips plan generation, and continues scheduling only the
+   * unfinished frontier. Absent ⇒ a normal cold run.
+   */
+  resumeFrom?: PlannerSnapshot;
 };
 //#endregion
 export { PlannerRunArgs };

package/esm/planner/planner-run.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"planner-run.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai/src/planner/planner-run.ts"],"mappings":";;;;;;;AA8BA;;;;KAAY,cAAA;EACV,MAAA,EAAQ,aAAA,CAAc,OAAA;EACtB,YAAA,EAAc,GAAA,SAAY,iBAAA;EAC1B,QAAA;EACA,SAAA;EACA,aAAA,EAAe,aAAA;EACf,IAAA;EACA,OAAA,GAAU,qBAAA,CAAsB,OAAA;AAAA"}
+{"version":3,"file":"planner-run.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai/src/planner/planner-run.ts"],"mappings":";;;;;;;;AA8CA;;;;KAAY,cAAA;EACV,MAAA,EAAQ,aAAA,CAAc,OAAA;EACtB,YAAA,EAAc,GAAA,SAAY,iBAAA;EAC1B,QAAA;EACA,SAAA;EACA,aAAA,EAAe,aAAA;EACf,IAAA;EACA,OAAA,GAAU,qBAAA,CAAsB,OAAA;EAOJ;;;;;;EAA5B,UAAA,GAAa,eAAA;AAAA"}