@warlock.js/ai 4.2.11 → 4.4.0

package/esm/contracts/supervisor/supervisor-config.type.d.mts

@@ -1,16 +1,18 @@
 import { Message } from "../conversation-message.type.mjs";
 import { AgentContract } from "../agent/agent.contract.mjs";
+import { SupervisorInput } from "./supervisor-input.type.mjs";
+import { SnapshotStore } from "../orchestrator/snapshot-store.contract.mjs";
+import { AgentMiddleware } from "../middleware/middleware.contract.mjs";
 import { SystemPromptContract } from "../system-prompt.contract.mjs";
-import { Next } from "./next.type.mjs";
-import { EvaluateContext, EvaluateResult } from "./evaluate-context.type.mjs";
 import { RouteContext } from "./route-context.type.mjs";
 import { AckConfig } from "./ack-entry.type.mjs";
 import { SupervisorIntentValue } from "./intent-entry.type.mjs";
+import { Next } from "./next.type.mjs";
 import { RouterEntry } from "./router-entry.type.mjs";
 import { ClassifierConfig } from "./classifier-context.type.mjs";
+import { EvaluateContext, EvaluateResult } from "./evaluate-context.type.mjs";
 import { SupervisorEventMap } from "../events/event-map.type.mjs";
 import { StandardSchemaV1 } from "@standard-schema/spec";
-import { CacheDriver } from "@warlock.js/cache";
 
 //#region ../@warlock.js/ai/src/contracts/supervisor/supervisor-config.type.d.ts
 /**
@@ -54,7 +56,7 @@ type SupervisorEventHandlers = Partial<{ [K in keyof SupervisorEventMap]: Superv
  *     ctx.state.response ? { satisfied: true } : undefined,
  *   maxIterations: 6,
  *   output: v.object({ response: v.string(), refund: v.boolean() }),
- *   snapshotStore: cache.driver("redis", { client }),
+ *   snapshotStore: ai.snapshot.redis({ client }),
  * });
  */
 type SupervisorConfig<TOutput = unknown, TState = TOutput, TIntents extends Record<string, SupervisorIntentValue> = Record<string, SupervisorIntentValue>, TArtifacts = Record<string, unknown>> = {
@@ -68,6 +70,18 @@ type SupervisorConfig<TOutput = unknown, TState = TOutput, TIntents extends Reco
    * independent.
    */
   version?: string;
+  /**
+   * Opt-in Standard Schema describing this supervisor's input. Purely
+   * additive — when set, the supervisor can be dropped straight into an
+   * agent's `tools: []` array WITHOUT calling `.asTool()`: the runtime
+   * derives the LLM tool manifest from `name` + the resolved
+   * description + this schema and dispatches through `execute()`. Omit
+   * it and `.asTool()` (which takes its own `inputSchema`) remains the
+   * way to expose the supervisor as a tool. Not enforced by the
+   * supervisor runtime itself — `execute()` still accepts the raw
+   * `SupervisorInput` union.
+   */
+  inputSchema?: StandardSchemaV1<SupervisorInput>;
   /**
    * Prepended to the router agent's own system prompt (router mode
    * only). Does not touch child agents' system prompts — they stay
@@ -205,17 +219,18 @@ type SupervisorConfig<TOutput = unknown, TState = TOutput, TIntents extends Reco
    */
   output?: StandardSchemaV1<TOutput>;
   /**
-   * Optional durable store enabling `supervisor.resume(runId)`.
-   * Snapshots are written after every iteration settles plus once
-   * more at final completion / cancel / fail. Accepts any
-   * `@warlock.js/cache` driver — `MemoryCacheDriver` for dev/tests,
-   * `RedisCacheDriver` / `PgCacheDriver` for production.
-   *
-   * Falls back to `ai.config({ defaultStore })` when omitted. When
-   * neither is set, `resume()` throws and snapshot writes silently
+   * Optional durable {@link SnapshotStore} enabling
+   * `supervisor.resume(runId)`. Snapshots are written after every
+   * iteration settles plus once more at final completion / cancel /
+   * fail. Construct with `ai.snapshot.{memory,pg,redis}()` —
+   * `ai.snapshot.memory()` for dev/tests, `ai.snapshot.redis()` /
+   * `ai.snapshot.pg()` for production.
+   *
+   * Falls back to `ai.config({ defaultSnapshotStore })` when omitted.
+   * When neither is set, `resume()` throws and snapshot writes silently
    * skip (current behavior preserved).
    */
-  snapshotStore?: CacheDriver<any, any>;
+  snapshotStore?: SnapshotStore;
   /**
    * Definition-level event handlers — tier 1 of the 3-tier model.
    * Fire on every run of this supervisor, before instance and
@@ -327,6 +342,33 @@ type SupervisorConfig<TOutput = unknown, TState = TOutput, TIntents extends Reco
    * }),
    */
   artifactsSchema?: StandardSchemaV1<TArtifacts>;
+  /**
+   * Supervisor-level middleware — fires the optional `supervisor` hook
+   * map (`before` / `after` / `onError`) of each `AgentMiddleware`
+   * once around the entire `execute()` / `stream()` / `resume()` run,
+   * the supervisor-level peer of an agent's `execute`-level middleware.
+   *
+   * Same onion semantics as the agent pipeline: `before` runs top-down
+   * (return a `SupervisorResult` to short-circuit the whole run, throw
+   * to abort it), `after` / `onError` run bottom-up (return a
+   * `SupervisorResult` to replace / recover). A middleware without a
+   * `supervisor` hook map is skipped — so the same builtin objects
+   * (budget, guardrail, …) can be registered here and on agents,
+   * declaring whichever level applies.
+   *
+   * Each middleware needs a unique `name` (the `ctx.state` namespace);
+   * the supervisor does not re-validate the array — register the same
+   * objects you validated for the agents.
+   *
+   * @example
+   * ai.supervisor({
+   *   name: "support",
+   *   router,
+   *   intents: { ... },
+   *   middleware: [auditTrail],
+   * });
+   */
+  middleware?: AgentMiddleware[];
   /**
    * Per-iteration merger for the artifacts bag (Phase 5 /
    * decisions §35). When omitted the framework auto-spreads:

package/esm/contracts/supervisor/supervisor-config.type.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"supervisor-config.type.d.mts","names":[],"sources":["../../../../../../../../@warlock.js/ai/src/contracts/supervisor/supervisor-config.type.ts"],"mappings":";;;;;;;;;;;;;;;;;AAkBA;;KAAY,sBAAA,iBAAuC,kBAAA,KACjD,OAAA,EAAS,kBAAA,CAAmB,CAAA;AAAA,KAGlB,uBAAA,GAA0B,OAAA,eACxB,kBAAA,GAAqB,sBAAA,CAAuB,CAAA;;;;;;;;;AAJ1B;AAGhC;;;;;;;;;;;;;;;AAC2D;AAyC3D;;;;;;;;;;;;;KAAY,gBAAA,6BAED,OAAA,mBACQ,MAAA,SAAe,qBAAA,IAAyB,MAAA,SAAe,qBAAA,gBAC3D,MAAA;EA0FqB,sEAvFlC,IAAA;EA6Fc;;;;;;;;EAnFd,OAAA;EA0G8D;;;;;EAnG9D,YAAA,GAAe,oBAAA;EAkLC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA3IhB,IAAA,YAAgB,oBAAA;EAqC8B;;;;;;;;;;;;;;;;;;;EAhB9C,OAAA,GAAU,OAAA;EAoGV;;;;;;;;EA1FA,MAAA,GAAS,aAAA,YAAyB,WAAA,CAAY,MAAA;EA2K5C;;;;EArKF,KAAA,IAAS,GAAA,EAAK,YAAA,CAAa,MAAA,MAAY,IAAA,GAAO,OAAA,CAAQ,IAAA;EAgMnB;;;;;;;;AAwBiC;;EA5MpE,OAAA,EAAS,QAAA;;;;;;;;;;EAWT,QAAA,IAAY,GAAA,EAAK,eAAA,CAAgB,MAAA,MAAY,cAAA,GAAiB,OAAA,CAAQ,cAAA;;;;;;;;;;;;;;;;EAiBtE,KAAA,GAAQ,MAAA;;;;;EAMR,aAAA;;;;;EAMA,YAAA;;;;;;;;;;;EAYA,MAAA,GAAS,gBAAA,CAAiB,OAAA;;;;;;;;;;;;EAa1B,aAAA,GAAgB,WAAA;;;;;;EAOhB,EAAA,GAAK,uBAAA;;;;;;;;;;;;;;;;;EAkBL,GAAA,GAAM,SAAA,CAAU,MAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwChB,UAAA,GAAa,gBAAA,CAAiB,MAAA;;;;;;;;;;;;;;;;;;;;;;EAsB9B,aAAA;IACE,MAAA;IACA,MAAA;IACA,GAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;EAyBF,eAAA,GAAkB,gBAAA,CAAiB,UAAA;;;;;;;;;;;;;;;;;;;;;;;EAwBnC,iBAAA,IAAqB,KAAA,EAAO,MAAA,EAAQ,SAAA,EAAW,UAAA,KAAe,MAAA;AAAA"}
+{"version":3,"file":"supervisor-config.type.d.mts","names":[],"sources":["../../../../../../../../@warlock.js/ai/src/contracts/supervisor/supervisor-config.type.ts"],"mappings":";;;;;;;;;;;;;;;;;;;AAoBA;;KAAY,sBAAA,iBAAuC,kBAAA,KACjD,OAAA,EAAS,kBAAA,CAAmB,CAAA;AAAA,KAGlB,uBAAA,GAA0B,OAAA,eACxB,kBAAA,GAAqB,sBAAA,CAAuB,CAAA;;;;;;;;;AAJ1B;AAGhC;;;;;;;;;;;;;;;AAC2D;AAyC3D;;;;;;;;;;;;;KAAY,gBAAA,6BAED,OAAA,mBACQ,MAAA,SAAe,qBAAA,IAAyB,MAAA,SAAe,qBAAA,gBAC3D,MAAA;EAuGJ,sEApGT,IAAA;EAoGkC;;;;;;;;EA1FlC,OAAA;EAuH6C;;;;;;;;;;;EA1G7C,WAAA,GAAc,gBAAA,CAAiB,eAAA;EAoRI;;;;;EA7QnC,YAAA,GAAe,oBAAA;EAiUqD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA1RpE,IAAA,YAAgB,oBAAA;EA4DiB;;;;;;;;;;;;;;;;;;;EAvCjC,OAAA,GAAU,OAAA;EA+JG;;;;;;;;EArJb,MAAA,GAAS,aAAA,YAAyB,WAAA,CAAY,MAAA;EAmO9C;;;;EA7NA,KAAA,IAAS,GAAA,EAAK,YAAA,CAAa,MAAA,MAAY,IAAA,GAAO,OAAA,CAAQ,IAAA;EAqPP;;;;AAAqB;;;;;;EAzOpE,OAAA,EAAS,QAAA;;;;;;;;;;EAWT,QAAA,IAAY,GAAA,EAAK,eAAA,CAAgB,MAAA,MAAY,cAAA,GAAiB,OAAA,CAAQ,cAAA;;;;;;;;;;;;;;;;EAiBtE,KAAA,GAAQ,MAAA;;;;;EAMR,aAAA;;;;;EAMA,YAAA;;;;;;;;;;;EAYA,MAAA,GAAS,gBAAA,CAAiB,OAAA;;;;;;;;;;;;;EAc1B,aAAA,GAAgB,aAAA;;;;;;EAOhB,EAAA,GAAK,uBAAA;;;;;;;;;;;;;;;;;EAkBL,GAAA,GAAM,SAAA,CAAU,MAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwChB,UAAA,GAAa,gBAAA,CAAiB,MAAA;;;;;;;;;;;;;;;;;;;;;;EAsB9B,aAAA;IACE,MAAA;IACA,MAAA;IACA,GAAA;EAAA;;;;;;;;;;;;;;;;;;;;;;;EAyBF,eAAA,GAAkB,gBAAA,CAAiB,UAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;EA4BnC,UAAA,GAAa,eAAA;;;;;;;;;;;;;;;;;;;;;;;EAwBb,iBAAA,IAAqB,KAAA,EAAO,MAAA,EAAQ,SAAA,EAAW,UAAA,KAAe,MAAA;AAAA"}

package/esm/contracts/supervisor/supervisor-snapshot.type.d.mts

@@ -1,5 +1,5 @@
-import { IterationSnapshot } from "./iteration-snapshot.type.mjs";
 import { SupervisorInput } from "./supervisor-input.type.mjs";
+import { IterationSnapshot } from "./iteration-snapshot.type.mjs";
 
 //#region ../@warlock.js/ai/src/contracts/supervisor/supervisor-snapshot.type.d.ts
 /**

package/esm/contracts/supervisor/supervisor.contract.d.mts

@@ -1,11 +1,11 @@
 import { ExecutableContract } from "../executable.contract.mjs";
 import { StreamContract } from "../stream/stream.contract.mjs";
+import { SupervisorResult } from "../result/supervisor-result.type.mjs";
 import { ToolContract } from "../../tool/tool.mjs";
 import { SupervisorInput } from "./supervisor-input.type.mjs";
-import { SupervisorEventHandler } from "./supervisor-config.type.mjs";
 import { SupervisorExecuteOptions, SupervisorResumeOptions } from "./supervisor-execute-options.type.mjs";
+import { SupervisorEventHandler } from "./supervisor-config.type.mjs";
 import { SupervisorStreamEvent } from "./supervisor-stream-event.type.mjs";
-import { SupervisorResult } from "../result/supervisor-result.type.mjs";
 import { SupervisorEventMap } from "../events/event-map.type.mjs";
 import { StandardSchemaV1 } from "@standard-schema/spec";
 
@@ -68,6 +68,13 @@ type SupervisorAsToolOptions<TToolInput> = {
 interface SupervisorContract<TOutput = unknown> extends ExecutableContract<SupervisorInput, SupervisorExecuteOptions, SupervisorResult<TOutput>> {
   /** Stable identifier — mirrors the config's `name`. */
   readonly name: string;
+  /**
+   * Mirrors {@link SupervisorConfig.inputSchema} when set — lets the
+   * agent tool-collection path auto-adapt this supervisor into a
+   * `ToolContract` (manifest derived from name + this schema) when it
+   * appears in `tools: []` without `.asTool()`.
+   */
+  readonly inputSchema?: StandardSchemaV1<SupervisorInput>;
   /**
    * Structural fingerprint of the supervisor definition — agent
    * keys + their resolved descriptions + router identity (if set) +

package/esm/contracts/supervisor/supervisor.contract.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"supervisor.contract.d.mts","names":[],"sources":["../../../../../../../../@warlock.js/ai/src/contracts/supervisor/supervisor.contract.ts"],"mappings":";;;;;;;;;;;;;;AAwBA;;;;;;;;KAAY,uBAAA;EACV,IAAA;EACA,WAAA;EACA,WAAA,EAAa,gBAAgB,CAAC,UAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA2Cf,kBAAA,4BAA8C,kBAAA,CAC7D,eAAA,EACA,wBAAA,EACA,gBAAA,CAAiB,OAAA;EAAjB;EAAA,SAGS,IAAA;EAAA;;;;;;EAAA,SAQA,SAAA;EAWN;;;;;;EAHH,OAAA,CACE,KAAA,EAAO,eAAA,EACP,OAAA,GAAU,wBAAA,GACT,OAAA,CAAQ,gBAAA,CAAiB,OAAA;EAW1B;;;;;;;EAFF,MAAA,CACE,KAAA,EAAO,eAAA,EACP,OAAA,GAAU,wBAAA,GACT,cAAA,CAAe,gBAAA,CAAiB,OAAA,GAAU,qBAAA;EAWvB;;;;;;;;;EAAtB,MAAA,CAAO,KAAA,UAAe,OAAA,GAAU,uBAAA,GAA0B,OAAA,CAAQ,gBAAA,CAAiB,OAAA;EAQF;;;;;;EAAjF,EAAA,iBAAmB,kBAAA,EAAoB,KAAA,EAAO,CAAA,EAAG,OAAA,EAAS,sBAAA,CAAuB,CAAA;EAMtB;;;;EAA3D,GAAA,iBAAoB,kBAAA,EAAoB,KAAA,EAAO,CAAA,EAAG,OAAA,EAAS,sBAAA,CAAuB,CAAA;EAUvE;;;;;;;EADX,MAAA,sBACE,OAAA,EAAS,uBAAA,CAAwB,UAAA,IAChC,YAAA,CAAa,UAAA,EAAY,OAAA;AAAA"}
+{"version":3,"file":"supervisor.contract.d.mts","names":[],"sources":["../../../../../../../../@warlock.js/ai/src/contracts/supervisor/supervisor.contract.ts"],"mappings":";;;;;;;;;;;;;;AAwBA;;;;;;;;KAAY,uBAAA;EACV,IAAA;EACA,WAAA;EACA,WAAA,EAAa,gBAAgB,CAAC,UAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA2Cf,kBAAA,4BAA8C,kBAAA,CAC7D,eAAA,EACA,wBAAA,EACA,gBAAA,CAAiB,OAAA;EAFjB;EAAA,SAKS,IAAA;EAHT;;;;;;EAAA,SAWS,WAAA,GAAc,gBAAA,CAAiB,eAAA;EAgBxC;;;;;;EAAA,SARS,SAAA;EAWmB;;;;;;EAH5B,OAAA,CACE,KAAA,EAAO,eAAA,EACP,OAAA,GAAU,wBAAA,GACT,OAAA,CAAQ,gBAAA,CAAiB,OAAA;EAYV;;;;;;;EAHlB,MAAA,CACE,KAAA,EAAO,eAAA,EACP,OAAA,GAAU,wBAAA,GACT,cAAA,CAAe,gBAAA,CAAiB,OAAA,GAAU,qBAAA;EAWqB;;;;;;;;;EAAlE,MAAA,CAAO,KAAA,UAAe,OAAA,GAAU,uBAAA,GAA0B,OAAA,CAAQ,gBAAA,CAAiB,OAAA;EAcnF;;;;;;EANA,EAAA,iBAAmB,kBAAA,EAAoB,KAAA,EAAO,CAAA,EAAG,OAAA,EAAS,sBAAA,CAAuB,CAAA;EAM/B;;;;EAAlD,GAAA,iBAAoB,kBAAA,EAAoB,KAAA,EAAO,CAAA,EAAG,OAAA,EAAS,sBAAA,CAAuB,CAAA;EAUhF;;;;;AACiC;;EAFnC,MAAA,sBACE,OAAA,EAAS,uBAAA,CAAwB,UAAA,IAChC,YAAA,CAAa,UAAA,EAAY,OAAA;AAAA"}

package/esm/contracts/workflow/index.d.mts

@@ -2,5 +2,5 @@ import { NextStepResult } from "./next-step-result.type.mjs";
 import { RetryBackoff, RetryConfig } from "./retry-config.type.mjs";
 import { WorkflowContext } from "./workflow-context.type.mjs";
 import { StepAgentInput, StepDefinition, StepLocalEvents, StepOutputSpec } from "./step.contract.mjs";
-import { WorkflowDefinition, WorkflowEventHandler, WorkflowEventHandlers, WorkflowExecuteOptions, WorkflowInstance, WorkflowResumeOptions, WorkflowRunOptions } from "./workflow.contract.mjs";
-import { WorkflowSnapshot } from "./workflow-snapshot.type.mjs";
+import { WorkflowSnapshot } from "./workflow-snapshot.type.mjs";
+import { WorkflowDefinition, WorkflowEventHandler, WorkflowEventHandlers, WorkflowExecuteOptions, WorkflowInstance, WorkflowResumeOptions, WorkflowRunOptions } from "./workflow.contract.mjs";

package/esm/contracts/workflow/workflow.contract.d.mts

@@ -1,13 +1,14 @@
 import { ExecutableContract } from "../executable.contract.mjs";
 import { WorkflowResult } from "../result/workflow-result.type.mjs";
 import { ToolContract } from "../../tool/tool.mjs";
+import { SnapshotStore } from "../orchestrator/snapshot-store.contract.mjs";
 import { NextStepResult } from "./next-step-result.type.mjs";
 import { RetryConfig } from "./retry-config.type.mjs";
 import { WorkflowContext } from "./workflow-context.type.mjs";
 import { StepDefinition, StepOutputSpec } from "./step.contract.mjs";
+import { WorkflowSnapshot } from "./workflow-snapshot.type.mjs";
 import { WorkflowEventMap } from "../events/event-map.type.mjs";
 import { StandardSchemaV1 } from "@standard-schema/spec";
-import { CacheDriver } from "@warlock.js/cache";
 
 //#region ../@warlock.js/ai/src/contracts/workflow/workflow.contract.d.ts
 type WorkflowEventHandler<K extends keyof WorkflowEventMap> = (payload: WorkflowEventMap[K]) => void;
@@ -58,18 +59,31 @@ type WorkflowDefinition<TInput = unknown, TOutput = unknown, TState = Record<str
    * the default tool description.
    */
   description?: string;
+  /**
+   * Opt-in Standard Schema describing this workflow's input. Purely
+   * additive — when set, the workflow can be dropped straight into an
+   * agent's `tools: []` array WITHOUT calling `.asTool()`: the runtime
+   * derives the LLM tool manifest from `name` + `description` + this
+   * schema and dispatches through `execute()`. Omit it and `.asTool()`
+   * (which takes its own `inputSchema`) remains the way to expose the
+   * workflow as a tool. Never validated by the workflow engine itself —
+   * step inputs are still each step's responsibility.
+   */
+  inputSchema?: StandardSchemaV1<TInput>;
   version?: string;
   steps: StepDefinition<TInput, TState, TContext>[];
   /**
-   * Optional durable store enabling `workflow.resume(runId)`. Accepts
-   * any `@warlock.js/cache` driver — `MemoryCacheDriver` for
-   * dev/tests, `RedisCacheDriver` / `PgCacheDriver` for production.
+   * Optional durable {@link SnapshotStore} enabling
+   * `workflow.resume(runId)`. Construct with
+   * `ai.snapshot.{memory,pg,redis}()` — `ai.snapshot.memory()` for
+   * dev/tests, `ai.snapshot.redis()` / `ai.snapshot.pg()` for
+   * production.
    *
-   * Falls back to `ai.config({ defaultStore })` when omitted. When
-   * neither is set, `resume()` throws and snapshot writes silently
+   * Falls back to `ai.config({ defaultSnapshotStore })` when omitted.
+   * When neither is set, `resume()` throws and snapshot writes silently
    * skip (current behavior preserved).
    */
-  snapshotStore?: CacheDriver<any, any>;
+  snapshotStore?: SnapshotStore<WorkflowSnapshot>;
   /**
    * Default retry applied to every step that doesn't supply its own
    * `retry`. `undefined` (omitted) means "no retry" — resolves to
@@ -95,6 +109,13 @@ type WorkflowDefinition<TInput = unknown, TOutput = unknown, TState = Record<str
 interface WorkflowInstance<TInput = unknown, TOutput = unknown, TState = Record<string, unknown>, TContext = unknown> extends ExecutableContract<TInput, WorkflowRunOptions<TContext>, WorkflowResult<TOutput>> {
   readonly name: string;
   readonly description?: string;
+  /**
+   * Mirrors {@link WorkflowDefinition.inputSchema} when set — lets the
+   * agent tool-collection path auto-adapt this workflow into a
+   * `ToolContract` (manifest derived from name + description + this
+   * schema) when it appears in `tools: []` without `.asTool()`.
+   */
+  readonly inputSchema?: StandardSchemaV1<TInput>;
   readonly signature: string;
   readonly version?: string;
   /**

package/esm/contracts/workflow/workflow.contract.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"workflow.contract.d.mts","names":[],"sources":["../../../../../../../../@warlock.js/ai/src/contracts/workflow/workflow.contract.ts"],"mappings":";;;;;;;;;;;;KAWY,oBAAA,iBAAqC,gBAAA,KAC/C,OAAA,EAAS,gBAAA,CAAiB,CAAA;AAAA,KAGhB,qBAAA,GAAwB,OAAA,eACtB,gBAAA,GAAmB,oBAAA,CAAqB,CAAA;;;;;KAO1C,kBAAA;EAXiB,sEAa3B,KAAA,WAd+C;EAgB/C,MAAA,GAAS,WAAA,EAfiB;EAiB1B,EAAA,GAAK,qBAAA;EAjBuB;AAAA;AAG9B;;;;;EAsBE,OAAA,GAAU,QAAA;EAtBwB;;;;;;;EA8BlC,SAAA;AAAA;AA7BqD;AAOvD;;;;AAPuD,KAqC3C,sBAAA,yCAGR,kBAAA,CAAmB,QAAA;EACrB,KAAA,EAAO,MAAA;AAAA;AAAA,KAGG,qBAAA,uBACV,kBAAkB,CAAC,QAAA;EAtCU;;EAyC3B,KAAA;AAAA;AAAA,KAGQ,kBAAA,+CAGD,MAAA;EAGT,IAAA;EApCA;;;;AAQS;EAkCT,WAAA;EACA,OAAA;EACA,KAAA,EAAO,cAAA,CAAe,MAAA,EAAQ,MAAA,EAAQ,QAAA;EAzBjB;;;;;;;;;EAmCrB,aAAA,GAAgB,WAAA;EAlCT;;AAAM;AAGf;;;;;;EAyCE,YAAA,GAAe,WAAA;EACf,QAAA;EACA,aAAA;EACA,QAAA,IACE,QAAA,UACA,GAAA,EAAK,eAAA,CAAgB,MAAA,EAAQ,MAAA,EAAQ,QAAA,MAClC,cAAA,GAAiB,OAAA,CAAQ,cAAA;EAC9B,MAAA,GAAS,cAAA,CAAe,OAAA,EAAS,MAAA,EAAQ,MAAA,EAAQ,QAAA;EACjD,EAAA,GAAK,qBAAA;AAAA;;;;;;;UASU,gBAAA,+CAGN,MAAA,+CAED,kBAAA,CACR,MAAA,EACA,kBAAA,CAAmB,QAAA,GACnB,cAAA,CAAe,OAAA;EAAA,SAEN,IAAA;EAAA,SACA,WAAA;EAAA,SACA,SAAA;EAAA,SACA,OAAA;EAxBJ;;;;;;;;;;;;;;EAwCL,OAAA,CACE,KAAA,EAAO,MAAA,EACP,OAAA,GAAU,kBAAA,CAAmB,QAAA,IAC5B,OAAA,CAAQ,cAAA,CAAe,OAAA;EAC1B,OAAA,CACE,OAAA,EAAS,sBAAA,CAAuB,MAAA,EAAQ,QAAA,IACvC,OAAA,CAAQ,cAAA,CAAe,OAAA;EAE1B,MAAA,CACE,KAAA,UACA,OAAA,GAAU,qBAAA,CAAsB,QAAA,IAC/B,OAAA,CAAQ,cAAA,CAAe,OAAA;EAE1B,EAAA,iBAAmB,gBAAA,EAAkB,KAAA,EAAO,CAAA,EAAG,OAAA,EAAS,oBAAA,CAAqB,CAAA;EAC7E,GAAA,iBAAoB,gBAAA,EAAkB,KAAA,EAAO,CAAA,EAAG,OAAA,EAAS,oBAAA,CAAqB,CAAA;EAhF9E;;;;;;;;;;;;;;;;EAkGA,MAAA,cAAoB,MAAA,EAAQ,OAAA;IAC1B,WAAA;IACA,WAAA,EAAa,gBAAA,CAAiB,UAAA;EAAA,IAC5B,YAAA,CAAa,UAAA,EAAY,OAAA;AAAA"}
+{"version":3,"file":"workflow.contract.d.mts","names":[],"sources":["../../../../../../../../@warlock.js/ai/src/contracts/workflow/workflow.contract.ts"],"mappings":";;;;;;;;;;;;;KAYY,oBAAA,iBAAqC,gBAAA,KAC/C,OAAA,EAAS,gBAAA,CAAiB,CAAA;AAAA,KAGhB,qBAAA,GAAwB,OAAA,eACtB,gBAAA,GAAmB,oBAAA,CAAqB,CAAA;;;;;KAO1C,kBAAA;EAXiB,sEAa3B,KAAA,WAd+C;EAgB/C,MAAA,GAAS,WAAA,EAfiB;EAiB1B,EAAA,GAAK,qBAAA;EAjBuB;AAAA;AAG9B;;;;;EAsBE,OAAA,GAAU,QAAA;EAtBwB;;;;;;;EA8BlC,SAAA;AAAA;AA7BqD;AAOvD;;;;AAPuD,KAqC3C,sBAAA,yCAGR,kBAAA,CAAmB,QAAA;EACrB,KAAA,EAAO,MAAA;AAAA;AAAA,KAGG,qBAAA,uBACV,kBAAkB,CAAC,QAAA;EAtCU;;EAyC3B,KAAA;AAAA;AAAA,KAGQ,kBAAA,+CAGD,MAAA;EAGT,IAAA;EApCA;;;;AAQS;EAkCT,WAAA;EA1BgC;;;;;;;;;;EAqChC,WAAA,GAAc,gBAAA,CAAiB,MAAA;EAC/B,OAAA;EACA,KAAA,EAAO,cAAA,CAAe,MAAA,EAAQ,MAAA,EAAQ,QAAA;EAnCzB;AAAA;AAGf;;;;;;;;;EA4CE,aAAA,GAAgB,aAAA,CAAc,gBAAA;EArCpB;;;;;;;;;EA+CV,YAAA,GAAe,WAAA;EACf,QAAA;EACA,aAAA;EACA,QAAA,IACE,QAAA,UACA,GAAA,EAAK,eAAA,CAAgB,MAAA,EAAQ,MAAA,EAAQ,QAAA,MAClC,cAAA,GAAiB,OAAA,CAAQ,cAAA;EAC9B,MAAA,GAAS,cAAA,CAAe,OAAA,EAAS,MAAA,EAAQ,MAAA,EAAQ,QAAA;EACjD,EAAA,GAAK,qBAAA;AAAA;;;;;;;UASU,gBAAA,+CAGN,MAAA,+CAED,kBAAA,CACR,MAAA,EACA,kBAAA,CAAmB,QAAA,GACnB,cAAA,CAAe,OAAA;EAAA,SAEN,IAAA;EAAA,SACA,WAAA;EApBJ;;;;;;EAAA,SA2BI,WAAA,GAAc,gBAAA,CAAiB,MAAA;EAAA,SAC/B,SAAA;EAAA,SACA,OAAA;EAxET;;;;;;;;;;;;;;EAwFA,OAAA,CACE,KAAA,EAAO,MAAA,EACP,OAAA,GAAU,kBAAA,CAAmB,QAAA,IAC5B,OAAA,CAAQ,cAAA,CAAe,OAAA;EAC1B,OAAA,CACE,OAAA,EAAS,sBAAA,CAAuB,MAAA,EAAQ,QAAA,IACvC,OAAA,CAAQ,cAAA,CAAe,OAAA;EAE1B,MAAA,CACE,KAAA,UACA,OAAA,GAAU,qBAAA,CAAsB,QAAA,IAC/B,OAAA,CAAQ,cAAA,CAAe,OAAA;EAE1B,EAAA,iBAAmB,gBAAA,EAAkB,KAAA,EAAO,CAAA,EAAG,OAAA,EAAS,oBAAA,CAAqB,CAAA;EAC7E,GAAA,iBAAoB,gBAAA,EAAkB,KAAA,EAAO,CAAA,EAAG,OAAA,EAAS,oBAAA,CAAqB,CAAA;EA9DvE;;;;;;;;;;;;;;;;EAgFP,MAAA,cAAoB,MAAA,EAAQ,OAAA;IAC1B,WAAA;IACA,WAAA,EAAa,gBAAA,CAAiB,UAAA;EAAA,IAC5B,YAAA,CAAa,UAAA,EAAY,OAAA;AAAA"}

package/esm/errors/error-code.type.d.mts

@@ -13,7 +13,7 @@
  *   return agent.execute(input);
  * }
  */
-type AIErrorCode = "AGENT_EXEC_FAILED" | "AGENT_CANCELLED" | "AGENT_MAX_TRIPS" | "SCHEMA_VALIDATION_FAILED" | "TOOL_EXEC_FAILED" | "PROVIDER_ERROR" | "PROVIDER_RATE_LIMIT" | "PROVIDER_QUOTA_EXCEEDED" | "PROVIDER_TIMEOUT" | "CONTEXT_LENGTH_EXCEEDED" | "CONTENT_FILTER" | "PROVIDER_INVALID_REQUEST" | "PROVIDER_AUTH" | "BUDGET_EXCEEDED" | "GUARDRAIL_VIOLATION" | "WORKFLOW_ERROR" | "STEP_FAILED" | "WORKFLOW_DRIFT" | "WORKFLOW_CANCELLED" | "WORKFLOW_MAX_STEPS" | "WORKFLOW_INVALID_GOTO" | "SUPERVISOR_FAILED" | "SUPERVISOR_MAX_ITERATIONS" | "SUPERVISOR_INVALID_ROUTE" | "SUPERVISOR_CANCELLED" | "SUPERVISOR_DRIFT" | "SUPERVISOR_INTENT_DESCRIPTION_REQUIRED" | "SUPERVISOR_INTENT_MIXED_DISPATCH" | "SUPERVISOR_INTENT_STREAM_AND_OUTPUT" | "SUPERVISOR_INTENT_STREAM_TO_REQUIRED" | "SUPERVISOR_INTENT_STREAM_ON_WORKFLOW" | "SUPERVISOR_DISPATCH_CYCLE";
+type AIErrorCode = "AGENT_EXEC_FAILED" | "AGENT_CANCELLED" | "AGENT_MAX_TRIPS" | "SCHEMA_VALIDATION_FAILED" | "TOOL_EXEC_FAILED" | "PROVIDER_ERROR" | "PROVIDER_RATE_LIMIT" | "PROVIDER_QUOTA_EXCEEDED" | "PROVIDER_TIMEOUT" | "CONTEXT_LENGTH_EXCEEDED" | "CONTENT_FILTER" | "PROVIDER_INVALID_REQUEST" | "PROVIDER_AUTH" | "BUDGET_EXCEEDED" | "GUARDRAIL_VIOLATION" | "WORKFLOW_ERROR" | "STEP_FAILED" | "WORKFLOW_DRIFT" | "WORKFLOW_CANCELLED" | "WORKFLOW_MAX_STEPS" | "WORKFLOW_INVALID_GOTO" | "SUPERVISOR_FAILED" | "SUPERVISOR_MAX_ITERATIONS" | "SUPERVISOR_INVALID_ROUTE" | "SUPERVISOR_CANCELLED" | "SUPERVISOR_DRIFT" | "SUPERVISOR_INTENT_DESCRIPTION_REQUIRED" | "SUPERVISOR_INTENT_MIXED_DISPATCH" | "SUPERVISOR_INTENT_STREAM_AND_OUTPUT" | "SUPERVISOR_INTENT_STREAM_TO_REQUIRED" | "SUPERVISOR_INTENT_STREAM_ON_WORKFLOW" | "SUPERVISOR_DISPATCH_CYCLE" | "ORCHESTRATOR_FAILED" | "ORCHESTRATOR_DRIFT" | "ORCHESTRATOR_CONFIG" | "ORCHESTRATOR_CANCELLED" | "PLANNER_FAILED" | "PLANNER_PLAN_INVALID" | "PLANNER_CANCELLED";
 //#endregion
 export { AIErrorCode };
 //# sourceMappingURL=error-code.type.d.mts.map

package/esm/errors/index.d.mts

@@ -14,6 +14,13 @@ import { SupervisorFailedError } from "./supervisor-failed-error.mjs";
 import { MaxIterationsError, MaxIterationsErrorOptions } from "./max-iterations-error.mjs";
 import { WorkflowError } from "./workflow-error.mjs";
 import { MaxStepsExceededError, MaxStepsExceededErrorOptions } from "./max-steps-exceeded-error.mjs";
+import { OrchestratorFailedError } from "./orchestrator-failed-error.mjs";
+import { OrchestratorCancelledError, OrchestratorCancelledErrorOptions } from "./orchestrator-cancelled-error.mjs";
+import { OrchestratorConfigError } from "./orchestrator-config-error.mjs";
+import { OrchestratorDriftError, OrchestratorDriftErrorOptions } from "./orchestrator-drift-error.mjs";
+import { PlannerFailedError } from "./planner-failed-error.mjs";
+import { PlannerCancelledError, PlannerCancelledErrorOptions } from "./planner-cancelled-error.mjs";
+import { PlannerPlanInvalidError } from "./planner-plan-invalid-error.mjs";
 import { ProviderAuthError } from "./provider-auth-error.mjs";
 import { ProviderRateLimitError, ProviderRateLimitErrorOptions } from "./provider-rate-limit-error.mjs";
 import { ProviderTimeoutError } from "./provider-timeout-error.mjs";

package/esm/errors/index.mjs

@@ -12,6 +12,13 @@ import { SupervisorFailedError } from "./supervisor-failed-error.mjs";
 import { MaxIterationsError } from "./max-iterations-error.mjs";
 import { WorkflowError } from "./workflow-error.mjs";
 import { MaxStepsExceededError } from "./max-steps-exceeded-error.mjs";
+import { OrchestratorFailedError } from "./orchestrator-failed-error.mjs";
+import { OrchestratorCancelledError } from "./orchestrator-cancelled-error.mjs";
+import { OrchestratorConfigError } from "./orchestrator-config-error.mjs";
+import { OrchestratorDriftError } from "./orchestrator-drift-error.mjs";
+import { PlannerFailedError } from "./planner-failed-error.mjs";
+import { PlannerCancelledError } from "./planner-cancelled-error.mjs";
+import { PlannerPlanInvalidError } from "./planner-plan-invalid-error.mjs";
 import { ProviderAuthError } from "./provider-auth-error.mjs";
 import { ProviderRateLimitError } from "./provider-rate-limit-error.mjs";
 import { ProviderTimeoutError } from "./provider-timeout-error.mjs";

package/esm/errors/orchestrator-cancelled-error.d.mts

@@ -0,0 +1,32 @@
+import { ErrorCategory } from "./error-category.type.mjs";
+import { AIErrorOptions } from "./ai-error.mjs";
+import { OrchestratorFailedError } from "./orchestrator-failed-error.mjs";
+
+//#region ../@warlock.js/ai/src/errors/orchestrator-cancelled-error.d.ts
+type OrchestratorCancelledErrorOptions = AIErrorOptions & {
+  /** ISO-8601 timestamp at which the abort was observed by the orchestrator. */cancelledAt: string; /** The session whose turn was cancelled. */
+  sessionId: string; /** `controller.abort(reason)` payload when the caller supplied one. */
+  reason?: string;
+};
+/**
+ * A turn was cancelled via `AbortSignal` before it could settle
+ * (orchestrator.md §17 — "mid-turn cancel"). The orchestrator returns
+ * normally with `report.status: "cancelled"` and the error placed on
+ * `result.error` rather than thrown; session state reverts to the
+ * pre-turn checkpoint (the orchestrator does not persist a fresh row
+ * for a cancelled turn — Q10).
+ *
+ * Mirrors `SupervisorCancelledError`, orchestrator scope. When an
+ * `iterate: true` turn is cancelled mid-iteration, the underlying
+ * `SupervisorCancelledError` rides on `cause`.
+ */
+declare class OrchestratorCancelledError extends OrchestratorFailedError {
+  static readonly defaultCategory: ErrorCategory;
+  readonly cancelledAt: string;
+  readonly sessionId: string;
+  readonly reason?: string;
+  constructor(message: string, options: OrchestratorCancelledErrorOptions);
+}
+//#endregion
+export { OrchestratorCancelledError, OrchestratorCancelledErrorOptions };
+//# sourceMappingURL=orchestrator-cancelled-error.d.mts.map

package/esm/errors/orchestrator-cancelled-error.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrator-cancelled-error.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai/src/errors/orchestrator-cancelled-error.ts"],"mappings":";;;;;KAIY,iCAAA,GAAoC,cAAc;gFAE5D,WAAA,UAF2C;EAI3C,SAAA,UAJ4D;EAM5D,MAAA;AAAA;;;;AAAM;AAeR;;;;;;;;cAAa,0BAAA,SAAmC,uBAAA;EAAA,gBACvB,eAAA,EAAiB,aAAA;EAAA,SAExB,WAAA;EAAA,SACA,SAAA;EAAA,SACA,MAAA;cAGd,OAAA,UACA,OAAA,EAAS,iCAAA;AAAA"}

package/esm/errors/orchestrator-cancelled-error.mjs

@@ -0,0 +1,31 @@
+import { OrchestratorFailedError } from "./orchestrator-failed-error.mjs";
+
+//#region ../@warlock.js/ai/src/errors/orchestrator-cancelled-error.ts
+/**
+* A turn was cancelled via `AbortSignal` before it could settle
+* (orchestrator.md §17 — "mid-turn cancel"). The orchestrator returns
+* normally with `report.status: "cancelled"` and the error placed on
+* `result.error` rather than thrown; session state reverts to the
+* pre-turn checkpoint (the orchestrator does not persist a fresh row
+* for a cancelled turn — Q10).
+*
+* Mirrors `SupervisorCancelledError`, orchestrator scope. When an
+* `iterate: true` turn is cancelled mid-iteration, the underlying
+* `SupervisorCancelledError` rides on `cause`.
+*/
+var OrchestratorCancelledError = class extends OrchestratorFailedError {
+	static {
+		this.defaultCategory = "cancelled";
+	}
+	constructor(message, options) {
+		super(message, options, "ORCHESTRATOR_CANCELLED");
+		this.name = "OrchestratorCancelledError";
+		this.cancelledAt = options.cancelledAt;
+		this.sessionId = options.sessionId;
+		this.reason = options.reason;
+	}
+};
+
+//#endregion
+export { OrchestratorCancelledError };
+//# sourceMappingURL=orchestrator-cancelled-error.mjs.map

package/esm/errors/orchestrator-cancelled-error.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrator-cancelled-error.mjs","names":[],"sources":["../../../../../../../@warlock.js/ai/src/errors/orchestrator-cancelled-error.ts"],"sourcesContent":["import type { AIErrorOptions } from \"./ai-error\";\nimport type { ErrorCategory } from \"./error-category.type\";\nimport { OrchestratorFailedError } from \"./orchestrator-failed-error\";\n\nexport type OrchestratorCancelledErrorOptions = AIErrorOptions & {\n  /** ISO-8601 timestamp at which the abort was observed by the orchestrator. */\n  cancelledAt: string;\n  /** The session whose turn was cancelled. */\n  sessionId: string;\n  /** `controller.abort(reason)` payload when the caller supplied one. */\n  reason?: string;\n};\n\n/**\n * A turn was cancelled via `AbortSignal` before it could settle\n * (orchestrator.md §17 — \"mid-turn cancel\"). The orchestrator returns\n * normally with `report.status: \"cancelled\"` and the error placed on\n * `result.error` rather than thrown; session state reverts to the\n * pre-turn checkpoint (the orchestrator does not persist a fresh row\n * for a cancelled turn — Q10).\n *\n * Mirrors `SupervisorCancelledError`, orchestrator scope. When an\n * `iterate: true` turn is cancelled mid-iteration, the underlying\n * `SupervisorCancelledError` rides on `cause`.\n */\nexport class OrchestratorCancelledError extends OrchestratorFailedError {\n  public static readonly defaultCategory: ErrorCategory = \"cancelled\";\n\n  public readonly cancelledAt: string;\n  public readonly sessionId: string;\n  public readonly reason?: string;\n\n  public constructor(\n    message: string,\n    options: OrchestratorCancelledErrorOptions,\n  ) {\n    super(message, options, \"ORCHESTRATOR_CANCELLED\");\n    this.name = \"OrchestratorCancelledError\";\n    this.cancelledAt = options.cancelledAt;\n    this.sessionId = options.sessionId;\n    this.reason = options.reason;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;AAyBA,IAAa,6BAAb,cAAgD,wBAAwB;;yBACd;;CAMxD,AAAO,YACL,SACA,SACA;EACA,MAAM,SAAS,SAAS,wBAAwB;EAChD,KAAK,OAAO;EACZ,KAAK,cAAc,QAAQ;EAC3B,KAAK,YAAY,QAAQ;EACzB,KAAK,SAAS,QAAQ;CACxB;AACF"}

package/esm/errors/orchestrator-config-error.d.mts

@@ -0,0 +1,26 @@
+import { ErrorCategory } from "./error-category.type.mjs";
+import { AIErrorOptions } from "./ai-error.mjs";
+import { OrchestratorFailedError } from "./orchestrator-failed-error.mjs";
+
+//#region ../@warlock.js/ai/src/errors/orchestrator-config-error.d.ts
+/**
+ * Authoring-time misconfiguration of `ai.orchestrator(config)`
+ * (orchestrator.md §17). Thrown synchronously at construction — never
+ * surfaced via `result.error` — so a bad definition fails fast at boot
+ * rather than on the first turn.
+ *
+ * Examples (§17): `iterate: true` with no `snapshotStore` (or
+ * `ai.config({ defaultSnapshotStore })`); no resolvable
+ * `checkpointStore`; both `route` and `router` configured;
+ * `initialAgent` that is not a key in `intents`.
+ *
+ * Mirrors the `authoring: true` context tag the supervisor factory
+ * stamps on its construction-time failures.
+ */
+declare class OrchestratorConfigError extends OrchestratorFailedError {
+  static readonly defaultCategory: ErrorCategory;
+  constructor(message: string, options?: AIErrorOptions);
+}
+//#endregion
+export { OrchestratorConfigError };
+//# sourceMappingURL=orchestrator-config-error.d.mts.map

package/esm/errors/orchestrator-config-error.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrator-config-error.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai/src/errors/orchestrator-config-error.ts"],"mappings":";;;;;;;AAkBA;;;;;;;;;;;;cAAa,uBAAA,SAAgC,uBAAA;EAAA,gBACpB,eAAA,EAAiB,aAAA;cAErB,OAAA,UAAiB,OAAA,GAAU,cAAA;AAAA"}

package/esm/errors/orchestrator-config-error.mjs

@@ -0,0 +1,30 @@
+import { OrchestratorFailedError } from "./orchestrator-failed-error.mjs";
+
+//#region ../@warlock.js/ai/src/errors/orchestrator-config-error.ts
+/**
+* Authoring-time misconfiguration of `ai.orchestrator(config)`
+* (orchestrator.md §17). Thrown synchronously at construction — never
+* surfaced via `result.error` — so a bad definition fails fast at boot
+* rather than on the first turn.
+*
+* Examples (§17): `iterate: true` with no `snapshotStore` (or
+* `ai.config({ defaultSnapshotStore })`); no resolvable
+* `checkpointStore`; both `route` and `router` configured;
+* `initialAgent` that is not a key in `intents`.
+*
+* Mirrors the `authoring: true` context tag the supervisor factory
+* stamps on its construction-time failures.
+*/
+var OrchestratorConfigError = class extends OrchestratorFailedError {
+	static {
+		this.defaultCategory = "validation";
+	}
+	constructor(message, options) {
+		super(message, options, "ORCHESTRATOR_CONFIG");
+		this.name = "OrchestratorConfigError";
+	}
+};
+
+//#endregion
+export { OrchestratorConfigError };
+//# sourceMappingURL=orchestrator-config-error.mjs.map

package/esm/errors/orchestrator-config-error.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrator-config-error.mjs","names":[],"sources":["../../../../../../../@warlock.js/ai/src/errors/orchestrator-config-error.ts"],"sourcesContent":["import type { AIErrorOptions } from \"./ai-error\";\nimport type { ErrorCategory } from \"./error-category.type\";\nimport { OrchestratorFailedError } from \"./orchestrator-failed-error\";\n\n/**\n * Authoring-time misconfiguration of `ai.orchestrator(config)`\n * (orchestrator.md §17). Thrown synchronously at construction — never\n * surfaced via `result.error` — so a bad definition fails fast at boot\n * rather than on the first turn.\n *\n * Examples (§17): `iterate: true` with no `snapshotStore` (or\n * `ai.config({ defaultSnapshotStore })`); no resolvable\n * `checkpointStore`; both `route` and `router` configured;\n * `initialAgent` that is not a key in `intents`.\n *\n * Mirrors the `authoring: true` context tag the supervisor factory\n * stamps on its construction-time failures.\n */\nexport class OrchestratorConfigError extends OrchestratorFailedError {\n  public static readonly defaultCategory: ErrorCategory = \"validation\";\n\n  public constructor(message: string, options?: AIErrorOptions) {\n    super(message, options, \"ORCHESTRATOR_CONFIG\");\n    this.name = \"OrchestratorConfigError\";\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAkBA,IAAa,0BAAb,cAA6C,wBAAwB;;yBACX;;CAExD,AAAO,YAAY,SAAiB,SAA0B;EAC5D,MAAM,SAAS,SAAS,qBAAqB;EAC7C,KAAK,OAAO;CACd;AACF"}

package/esm/errors/orchestrator-drift-error.d.mts

@@ -0,0 +1,38 @@
+import { ErrorCategory } from "./error-category.type.mjs";
+import { AIErrorOptions } from "./ai-error.mjs";
+import { OrchestratorFailedError } from "./orchestrator-failed-error.mjs";
+
+//#region ../@warlock.js/ai/src/errors/orchestrator-drift-error.d.ts
+type OrchestratorDriftErrorOptions = AIErrorOptions & {
+  /** Signature recorded on the loaded checkpoint. */savedSignature: string; /** Signature computed from the current orchestrator definition. */
+  currentSignature: string; /** The session whose checkpoint drifted. */
+  sessionId: string;
+};
+/**
+ * Phase 2 drift guard (orchestrator.md §3 / §10). `execute()` or
+ * `resume()` loaded a checkpoint whose structural fingerprint does not
+ * match the current orchestrator definition (name + intents map +
+ * route/router presence + evaluate presence + initialAgent +
+ * maxIterations + iterate flag + historyWindow shape — §10.1).
+ *
+ * The turn is refused synchronously — nothing dispatches — and the dev
+ * decides how to recover: discard the session, migrate the persisted
+ * state, or pass `{ force: true }` to accept the new signature on the
+ * next persisted checkpoint.
+ *
+ * Mirrors `SupervisorDriftError` / `WorkflowDriftError` — same
+ * rationale, orchestrator scope. The orchestrator signature does NOT
+ * aggregate the internal supervisor's signature (§10.1); internal-
+ * supervisor drift surfaces only on `iterate: true` resume via the
+ * supervisor's own drift check.
+ */
+declare class OrchestratorDriftError extends OrchestratorFailedError {
+  static readonly defaultCategory: ErrorCategory;
+  readonly savedSignature: string;
+  readonly currentSignature: string;
+  readonly sessionId: string;
+  constructor(message: string, options: OrchestratorDriftErrorOptions);
+}
+//#endregion
+export { OrchestratorDriftError, OrchestratorDriftErrorOptions };
+//# sourceMappingURL=orchestrator-drift-error.d.mts.map

package/esm/errors/orchestrator-drift-error.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrator-drift-error.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai/src/errors/orchestrator-drift-error.ts"],"mappings":";;;;;KAIY,6BAAA,GAAgC,cAAc;qDAExD,cAAA,UAFuC;EAIvC,gBAAA,UAJwD;EAMxD,SAAA;AAAA;;;;AAAS;AAqBX;;;;;;;;;;;;;;cAAa,sBAAA,SAA+B,uBAAA;EAAA,gBACnB,eAAA,EAAiB,aAAA;EAAA,SAExB,cAAA;EAAA,SACA,gBAAA;EAAA,SACA,SAAA;cAEG,OAAA,UAAiB,OAAA,EAAS,6BAAA;AAAA"}

package/esm/errors/orchestrator-drift-error.mjs

@@ -0,0 +1,37 @@
+import { OrchestratorFailedError } from "./orchestrator-failed-error.mjs";
+
+//#region ../@warlock.js/ai/src/errors/orchestrator-drift-error.ts
+/**
+* Phase 2 drift guard (orchestrator.md §3 / §10). `execute()` or
+* `resume()` loaded a checkpoint whose structural fingerprint does not
+* match the current orchestrator definition (name + intents map +
+* route/router presence + evaluate presence + initialAgent +
+* maxIterations + iterate flag + historyWindow shape — §10.1).
+*
+* The turn is refused synchronously — nothing dispatches — and the dev
+* decides how to recover: discard the session, migrate the persisted
+* state, or pass `{ force: true }` to accept the new signature on the
+* next persisted checkpoint.
+*
+* Mirrors `SupervisorDriftError` / `WorkflowDriftError` — same
+* rationale, orchestrator scope. The orchestrator signature does NOT
+* aggregate the internal supervisor's signature (§10.1); internal-
+* supervisor drift surfaces only on `iterate: true` resume via the
+* supervisor's own drift check.
+*/
+var OrchestratorDriftError = class extends OrchestratorFailedError {
+	static {
+		this.defaultCategory = "drift";
+	}
+	constructor(message, options) {
+		super(message, options, "ORCHESTRATOR_DRIFT");
+		this.name = "OrchestratorDriftError";
+		this.savedSignature = options.savedSignature;
+		this.currentSignature = options.currentSignature;
+		this.sessionId = options.sessionId;
+	}
+};
+
+//#endregion
+export { OrchestratorDriftError };
+//# sourceMappingURL=orchestrator-drift-error.mjs.map

package/esm/errors/orchestrator-drift-error.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrator-drift-error.mjs","names":[],"sources":["../../../../../../../@warlock.js/ai/src/errors/orchestrator-drift-error.ts"],"sourcesContent":["import type { AIErrorOptions } from \"./ai-error\";\nimport type { ErrorCategory } from \"./error-category.type\";\nimport { OrchestratorFailedError } from \"./orchestrator-failed-error\";\n\nexport type OrchestratorDriftErrorOptions = AIErrorOptions & {\n  /** Signature recorded on the loaded checkpoint. */\n  savedSignature: string;\n  /** Signature computed from the current orchestrator definition. */\n  currentSignature: string;\n  /** The session whose checkpoint drifted. */\n  sessionId: string;\n};\n\n/**\n * Phase 2 drift guard (orchestrator.md §3 / §10). `execute()` or\n * `resume()` loaded a checkpoint whose structural fingerprint does not\n * match the current orchestrator definition (name + intents map +\n * route/router presence + evaluate presence + initialAgent +\n * maxIterations + iterate flag + historyWindow shape — §10.1).\n *\n * The turn is refused synchronously — nothing dispatches — and the dev\n * decides how to recover: discard the session, migrate the persisted\n * state, or pass `{ force: true }` to accept the new signature on the\n * next persisted checkpoint.\n *\n * Mirrors `SupervisorDriftError` / `WorkflowDriftError` — same\n * rationale, orchestrator scope. The orchestrator signature does NOT\n * aggregate the internal supervisor's signature (§10.1); internal-\n * supervisor drift surfaces only on `iterate: true` resume via the\n * supervisor's own drift check.\n */\nexport class OrchestratorDriftError extends OrchestratorFailedError {\n  public static readonly defaultCategory: ErrorCategory = \"drift\";\n\n  public readonly savedSignature: string;\n  public readonly currentSignature: string;\n  public readonly sessionId: string;\n\n  public constructor(message: string, options: OrchestratorDriftErrorOptions) {\n    super(message, options, \"ORCHESTRATOR_DRIFT\");\n    this.name = \"OrchestratorDriftError\";\n    this.savedSignature = options.savedSignature;\n    this.currentSignature = options.currentSignature;\n    this.sessionId = options.sessionId;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AA+BA,IAAa,yBAAb,cAA4C,wBAAwB;;yBACV;;CAMxD,AAAO,YAAY,SAAiB,SAAwC;EAC1E,MAAM,SAAS,SAAS,oBAAoB;EAC5C,KAAK,OAAO;EACZ,KAAK,iBAAiB,QAAQ;EAC9B,KAAK,mBAAmB,QAAQ;EAChC,KAAK,YAAY,QAAQ;CAC3B;AACF"}

package/esm/errors/orchestrator-failed-error.d.mts

@@ -0,0 +1,33 @@
+import { AIErrorCode } from "./error-code.type.mjs";
+import { AIError, AIErrorOptions } from "./ai-error.mjs";
+
+//#region ../@warlock.js/ai/src/errors/orchestrator-failed-error.d.ts
+/**
+ * Base class for every orchestrator-specific failure surfaced from
+ * `orchestrator.execute()` / `orchestrator.resume()` /
+ * `orchestrator.command()` or thrown at authoring-time by
+ * `ai.orchestrator()` validation (orchestrator.md §17).
+ *
+ * **Role.** Anchor for the `ORCHESTRATOR_*` code family. Subclasses
+ * carry precise codes (`ORCHESTRATOR_DRIFT`, `ORCHESTRATOR_CONFIG`,
+ * `ORCHESTRATOR_CANCELLED`, …); this base catches everything a turn can
+ * produce that isn't already an agent / tool / provider / supervisor
+ * error bubbling up from the dispatched child.
+ *
+ * Child-execution errors (agent, tool, provider, supervisor) flow
+ * through the orchestrator unchanged — they are captured on the turn's
+ * `childReport` and surfaced on `result.error` directly, never
+ * re-wrapped.
+ *
+ * @example
+ * const result = await orchestrator.execute(message, { sessionId, history });
+ * if (result.error instanceof OrchestratorFailedError) {
+ *   console.error(result.error.code, result.error.message);
+ * }
+ */
+declare class OrchestratorFailedError extends AIError {
+  constructor(message: string, options?: AIErrorOptions, code?: AIErrorCode);
+}
+//#endregion
+export { OrchestratorFailedError };
+//# sourceMappingURL=orchestrator-failed-error.d.mts.map

package/esm/errors/orchestrator-failed-error.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrator-failed-error.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai/src/errors/orchestrator-failed-error.ts"],"mappings":";;;;;;AA0BA;;;;;;;;;;;;;;;;AAI6C;;;;;cAJhC,uBAAA,SAAgC,OAAA;cAEzC,OAAA,UACA,OAAA,GAAU,cAAA,EACV,IAAA,GAAM,WAAA;AAAA"}

package/esm/errors/orchestrator-failed-error.mjs

@@ -0,0 +1,36 @@
+import { AIError } from "./ai-error.mjs";
+
+//#region ../@warlock.js/ai/src/errors/orchestrator-failed-error.ts
+/**
+* Base class for every orchestrator-specific failure surfaced from
+* `orchestrator.execute()` / `orchestrator.resume()` /
+* `orchestrator.command()` or thrown at authoring-time by
+* `ai.orchestrator()` validation (orchestrator.md §17).
+*
+* **Role.** Anchor for the `ORCHESTRATOR_*` code family. Subclasses
+* carry precise codes (`ORCHESTRATOR_DRIFT`, `ORCHESTRATOR_CONFIG`,
+* `ORCHESTRATOR_CANCELLED`, …); this base catches everything a turn can
+* produce that isn't already an agent / tool / provider / supervisor
+* error bubbling up from the dispatched child.
+*
+* Child-execution errors (agent, tool, provider, supervisor) flow
+* through the orchestrator unchanged — they are captured on the turn's
+* `childReport` and surfaced on `result.error` directly, never
+* re-wrapped.
+*
+* @example
+* const result = await orchestrator.execute(message, { sessionId, history });
+* if (result.error instanceof OrchestratorFailedError) {
+*   console.error(result.error.code, result.error.message);
+* }
+*/
+var OrchestratorFailedError = class extends AIError {
+	constructor(message, options, code = "ORCHESTRATOR_FAILED") {
+		super(code, message, options);
+		this.name = "OrchestratorFailedError";
+	}
+};
+
+//#endregion
+export { OrchestratorFailedError };
+//# sourceMappingURL=orchestrator-failed-error.mjs.map

package/esm/errors/orchestrator-failed-error.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrator-failed-error.mjs","names":[],"sources":["../../../../../../../@warlock.js/ai/src/errors/orchestrator-failed-error.ts"],"sourcesContent":["import { AIError, type AIErrorOptions } from \"./ai-error\";\nimport type { AIErrorCode } from \"./error-code.type\";\n\n/**\n * Base class for every orchestrator-specific failure surfaced from\n * `orchestrator.execute()` / `orchestrator.resume()` /\n * `orchestrator.command()` or thrown at authoring-time by\n * `ai.orchestrator()` validation (orchestrator.md §17).\n *\n * **Role.** Anchor for the `ORCHESTRATOR_*` code family. Subclasses\n * carry precise codes (`ORCHESTRATOR_DRIFT`, `ORCHESTRATOR_CONFIG`,\n * `ORCHESTRATOR_CANCELLED`, …); this base catches everything a turn can\n * produce that isn't already an agent / tool / provider / supervisor\n * error bubbling up from the dispatched child.\n *\n * Child-execution errors (agent, tool, provider, supervisor) flow\n * through the orchestrator unchanged — they are captured on the turn's\n * `childReport` and surfaced on `result.error` directly, never\n * re-wrapped.\n *\n * @example\n * const result = await orchestrator.execute(message, { sessionId, history });\n * if (result.error instanceof OrchestratorFailedError) {\n *   console.error(result.error.code, result.error.message);\n * }\n */\nexport class OrchestratorFailedError extends AIError {\n  public constructor(\n    message: string,\n    options?: AIErrorOptions,\n    code: AIErrorCode = \"ORCHESTRATOR_FAILED\",\n  ) {\n    super(code, message, options);\n    this.name = \"OrchestratorFailedError\";\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,IAAa,0BAAb,cAA6C,QAAQ;CACnD,AAAO,YACL,SACA,SACA,OAAoB,uBACpB;EACA,MAAM,MAAM,SAAS,OAAO;EAC5B,KAAK,OAAO;CACd;AACF"}