@warlock.js/ai 4.2.11 → 4.3.0

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"}

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

@@ -0,0 +1,33 @@
+import { ErrorCategory } from "./error-category.type.mjs";
+import { AIErrorOptions } from "./ai-error.mjs";
+import { PlannerFailedError } from "./planner-failed-error.mjs";
+
+//#region ../@warlock.js/ai/src/errors/planner-cancelled-error.d.ts
+/**
+ * Options for {@link PlannerCancelledError}. Carries the observation
+ * timestamp and the optional `controller.abort(reason)` payload.
+ */
+type PlannerCancelledErrorOptions = AIErrorOptions & {
+  /** ISO-8601 timestamp at which the abort was observed by the planner. */cancelledAt: string; /** `controller.abort(reason)` payload when the caller supplied one. */
+  reason?: string;
+};
+/**
+ * Planner run was cancelled via `AbortSignal` before it could finish.
+ * Between-step cancellation is guaranteed; mid-step cancellation is
+ * best-effort (the signal is threaded into every in-flight capability
+ * `execute()` call, but effectiveness depends on the child primitive
+ * respecting it).
+ *
+ * On cancellation the planner returns normally with
+ * `report.status === "cancelled"` and the partial step snapshots — the
+ * error is placed on `result.error` rather than thrown.
+ */
+declare class PlannerCancelledError extends PlannerFailedError {
+  static readonly defaultCategory: ErrorCategory;
+  readonly cancelledAt: string;
+  readonly reason?: string;
+  constructor(message: string, options: PlannerCancelledErrorOptions);
+}
+//#endregion
+export { PlannerCancelledError, PlannerCancelledErrorOptions };
+//# sourceMappingURL=planner-cancelled-error.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"planner-cancelled-error.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai/src/errors/planner-cancelled-error.ts"],"mappings":";;;;;;;AAQA;;KAAY,4BAAA,GAA+B,cAAc;EAAA,yEAEvD,WAAA;EAEA,MAAA;AAAA;AAAM;AAcR;;;;;;;;;;AAdQ,cAcK,qBAAA,SAA8B,kBAAA;EAAA,gBAClB,eAAA,EAAiB,aAAA;EAAA,SAExB,WAAA;EAAA,SACA,MAAA;cAEG,OAAA,UAAiB,OAAA,EAAS,4BAAA;AAAA"}

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

@@ -0,0 +1,29 @@
+import { PlannerFailedError } from "./planner-failed-error.mjs";
+
+//#region ../@warlock.js/ai/src/errors/planner-cancelled-error.ts
+/**
+* Planner run was cancelled via `AbortSignal` before it could finish.
+* Between-step cancellation is guaranteed; mid-step cancellation is
+* best-effort (the signal is threaded into every in-flight capability
+* `execute()` call, but effectiveness depends on the child primitive
+* respecting it).
+*
+* On cancellation the planner returns normally with
+* `report.status === "cancelled"` and the partial step snapshots — the
+* error is placed on `result.error` rather than thrown.
+*/
+var PlannerCancelledError = class extends PlannerFailedError {
+	static {
+		this.defaultCategory = "cancelled";
+	}
+	constructor(message, options) {
+		super(message, options, "PLANNER_CANCELLED");
+		this.name = "PlannerCancelledError";
+		this.cancelledAt = options.cancelledAt;
+		this.reason = options.reason;
+	}
+};
+
+//#endregion
+export { PlannerCancelledError };
+//# sourceMappingURL=planner-cancelled-error.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"planner-cancelled-error.mjs","names":[],"sources":["../../../../../../../@warlock.js/ai/src/errors/planner-cancelled-error.ts"],"sourcesContent":["import type { AIErrorOptions } from \"./ai-error\";\nimport type { ErrorCategory } from \"./error-category.type\";\nimport { PlannerFailedError } from \"./planner-failed-error\";\n\n/**\n * Options for {@link PlannerCancelledError}. Carries the observation\n * timestamp and the optional `controller.abort(reason)` payload.\n */\nexport type PlannerCancelledErrorOptions = AIErrorOptions & {\n  /** ISO-8601 timestamp at which the abort was observed by the planner. */\n  cancelledAt: string;\n  /** `controller.abort(reason)` payload when the caller supplied one. */\n  reason?: string;\n};\n\n/**\n * Planner run was cancelled via `AbortSignal` before it could finish.\n * Between-step cancellation is guaranteed; mid-step cancellation is\n * best-effort (the signal is threaded into every in-flight capability\n * `execute()` call, but effectiveness depends on the child primitive\n * respecting it).\n *\n * On cancellation the planner returns normally with\n * `report.status === \"cancelled\"` and the partial step snapshots — the\n * error is placed on `result.error` rather than thrown.\n */\nexport class PlannerCancelledError extends PlannerFailedError {\n  public static readonly defaultCategory: ErrorCategory = \"cancelled\";\n\n  public readonly cancelledAt: string;\n  public readonly reason?: string;\n\n  public constructor(message: string, options: PlannerCancelledErrorOptions) {\n    super(message, options, \"PLANNER_CANCELLED\");\n    this.name = \"PlannerCancelledError\";\n    this.cancelledAt = options.cancelledAt;\n    this.reason = options.reason;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;AA0BA,IAAa,wBAAb,cAA2C,mBAAmB;;yBACJ;;CAKxD,AAAO,YAAY,SAAiB,SAAuC;EACzE,MAAM,SAAS,SAAS,mBAAmB;EAC3C,KAAK,OAAO;EACZ,KAAK,cAAc,QAAQ;EAC3B,KAAK,SAAS,QAAQ;CACxB;AACF"}

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

@@ -0,0 +1,40 @@
+import { ErrorCategory } from "./error-category.type.mjs";
+import { AIErrorCode } from "./error-code.type.mjs";
+import { AIError, AIErrorOptions } from "./ai-error.mjs";
+
+//#region ../@warlock.js/ai/src/errors/planner-failed-error.d.ts
+/**
+ * Base class for every planner-specific failure surfaced from
+ * `planner.execute()` or thrown at authoring-time by `ai.planner()`
+ * validation.
+ *
+ * **Role.** Anchor for the `PLANNER_*` code family. Subclasses carry
+ * precise codes (`PLANNER_PLAN_INVALID`, `PLANNER_CANCELLED`); this base
+ * catches everything a planning run can produce that isn't already an
+ * agent / tool / workflow / supervisor error bubbling up from a
+ * dispatched capability.
+ *
+ * Child-execution errors (agent, tool, provider, workflow) flow through
+ * the planner unchanged — they are captured on the relevant step
+ * snapshot and surfaced on `result.error` directly, never re-wrapped.
+ *
+ * @example
+ * const result = await planner.execute("Research and summarize X");
+ * if (result.error instanceof PlannerFailedError) {
+ *   console.error(result.error.code, result.error.message);
+ * }
+ */
+declare class PlannerFailedError extends AIError {
+  /**
+   * Generic planner failures (authoring-time config violations, the
+   * `toAIError` catch-all for unexpected runtime crashes during a run)
+   * are orchestration-level provider failures. Subclasses with a more
+   * precise meaning redeclare their own — `PlannerPlanInvalidError` is
+   * `"schema"`, `PlannerCancelledError` is `"cancelled"`.
+   */
+  static readonly defaultCategory: ErrorCategory;
+  constructor(message: string, options?: AIErrorOptions, code?: AIErrorCode);
+}
+//#endregion
+export { PlannerFailedError };
+//# sourceMappingURL=planner-failed-error.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"planner-failed-error.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai/src/errors/planner-failed-error.ts"],"mappings":";;;;;;;AAyBA;;;;;;;;;;;;;;;;;;;cAAa,kBAAA,SAA2B,OAAA;;;;;;;;kBAQf,eAAA,EAAiB,aAAA;cAGtC,OAAA,UACA,OAAA,GAAU,cAAA,EACV,IAAA,GAAM,WAAA;AAAA"}

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

@@ -0,0 +1,37 @@
+import { AIError } from "./ai-error.mjs";
+
+//#region ../@warlock.js/ai/src/errors/planner-failed-error.ts
+/**
+* Base class for every planner-specific failure surfaced from
+* `planner.execute()` or thrown at authoring-time by `ai.planner()`
+* validation.
+*
+* **Role.** Anchor for the `PLANNER_*` code family. Subclasses carry
+* precise codes (`PLANNER_PLAN_INVALID`, `PLANNER_CANCELLED`); this base
+* catches everything a planning run can produce that isn't already an
+* agent / tool / workflow / supervisor error bubbling up from a
+* dispatched capability.
+*
+* Child-execution errors (agent, tool, provider, workflow) flow through
+* the planner unchanged — they are captured on the relevant step
+* snapshot and surfaced on `result.error` directly, never re-wrapped.
+*
+* @example
+* const result = await planner.execute("Research and summarize X");
+* if (result.error instanceof PlannerFailedError) {
+*   console.error(result.error.code, result.error.message);
+* }
+*/
+var PlannerFailedError = class extends AIError {
+	static {
+		this.defaultCategory = "provider";
+	}
+	constructor(message, options, code = "PLANNER_FAILED") {
+		super(code, message, options);
+		this.name = "PlannerFailedError";
+	}
+};
+
+//#endregion
+export { PlannerFailedError };
+//# sourceMappingURL=planner-failed-error.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"planner-failed-error.mjs","names":[],"sources":["../../../../../../../@warlock.js/ai/src/errors/planner-failed-error.ts"],"sourcesContent":["import { AIError, type AIErrorOptions } from \"./ai-error\";\nimport type { AIErrorCode } from \"./error-code.type\";\nimport type { ErrorCategory } from \"./error-category.type\";\n\n/**\n * Base class for every planner-specific failure surfaced from\n * `planner.execute()` or thrown at authoring-time by `ai.planner()`\n * validation.\n *\n * **Role.** Anchor for the `PLANNER_*` code family. Subclasses carry\n * precise codes (`PLANNER_PLAN_INVALID`, `PLANNER_CANCELLED`); this base\n * catches everything a planning run can produce that isn't already an\n * agent / tool / workflow / supervisor error bubbling up from a\n * dispatched capability.\n *\n * Child-execution errors (agent, tool, provider, workflow) flow through\n * the planner unchanged — they are captured on the relevant step\n * snapshot and surfaced on `result.error` directly, never re-wrapped.\n *\n * @example\n * const result = await planner.execute(\"Research and summarize X\");\n * if (result.error instanceof PlannerFailedError) {\n *   console.error(result.error.code, result.error.message);\n * }\n */\nexport class PlannerFailedError extends AIError {\n  /**\n   * Generic planner failures (authoring-time config violations, the\n   * `toAIError` catch-all for unexpected runtime crashes during a run)\n   * are orchestration-level provider failures. Subclasses with a more\n   * precise meaning redeclare their own — `PlannerPlanInvalidError` is\n   * `\"schema\"`, `PlannerCancelledError` is `\"cancelled\"`.\n   */\n  public static readonly defaultCategory: ErrorCategory = \"provider\";\n\n  public constructor(\n    message: string,\n    options?: AIErrorOptions,\n    code: AIErrorCode = \"PLANNER_FAILED\",\n  ) {\n    super(code, message, options);\n    this.name = \"PlannerFailedError\";\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAyBA,IAAa,qBAAb,cAAwC,QAAQ;;yBAQU;;CAExD,AAAO,YACL,SACA,SACA,OAAoB,kBACpB;EACA,MAAM,MAAM,SAAS,OAAO;EAC5B,KAAK,OAAO;CACd;AACF"}