@warlock.js/ai 4.2.10 → 4.3.0

package/esm/orchestrator/orchestrator.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrator.mjs","names":["orchestratorAsTool"],"sources":["../../../../../../../@warlock.js/ai/src/orchestrator/orchestrator.ts"],"sourcesContent":["import type { OrchestratorConfig } from \"../contracts/orchestrator/orchestrator-config.type\";\nimport type {\n  OrchestratorEventHandler,\n  OrchestratorEventName,\n} from \"../contracts/orchestrator/orchestrator-event.type\";\nimport type {\n  OrchestratorAsToolOptions,\n  OrchestratorContract,\n} from \"../contracts/orchestrator/orchestrator.contract\";\nimport type { OrchestratorCommands } from \"../contracts/orchestrator/orchestrator-commands.type\";\nimport type {\n  OrchestratorExecuteOptions,\n  OrchestratorResumeOptions,\n} from \"../contracts/orchestrator/orchestrator-execute-options.type\";\nimport type { OrchestratorEvent } from \"../contracts/orchestrator/orchestrator-event.type\";\nimport type { OrchestratorResult } from \"../contracts/result/orchestrator-result.type\";\nimport type { StreamContract } from \"../contracts/stream/stream.contract\";\nimport type { SupervisorIntentValue } from \"../contracts/supervisor/intent-entry.type\";\nimport type { SupervisorInput } from \"../contracts/supervisor/supervisor-input.type\";\nimport { resolveDefaultSnapshotStore } from \"../config\";\nimport { OrchestratorConfigError } from \"../errors/orchestrator-config-error\";\nimport { resolveIntentEntries, type ResolvedIntentEntry } from \"../supervisor/entries\";\nimport { SupervisorFailedError } from \"../errors\";\nimport type { ToolContract } from \"../tool/tool\";\nimport { asTool as orchestratorAsTool } from \"./as-tool\";\nimport { createCommandDispatcher } from \"./commands\";\nimport { OrchestratorEmitter } from \"./emitter\";\nimport { OrchestratorExecution } from \"./execution\";\nimport { createOrchestratorStream } from \"./orchestrator-stream\";\nimport { computeOrchestratorSignature } from \"./signature\";\n\n/**\n * `ai.orchestrator(config)` — construct an {@link OrchestratorContract}:\n * a session-state manager wrapped around a supervisor (orchestrator.md\n * §1, §15). Validates the config at author time (throws\n * {@link OrchestratorConfigError} on bad shape), resolves the intent\n * entries, computes a stable structural signature for drift detection\n * (§10.1), wires the three-tier event emitter, and returns a handle that\n * runs one durable session turn per `execute` / `stream` call, resumes\n * an interrupted `iterate: true` turn via `resume`, and exposes typed\n * built-in commands plus an `asTool` wrapper.\n *\n * The \"what runs\" fields (`intents`, `route` / `router`, `evaluate`,\n * `state`, `output`, `initialAgent`, `maxIterations`) are the\n * supervisor's surface spread directly — the lifecycle builds the\n * supervisor lazily per turn and delegates to it (§3 Phase 5). Users\n * never see the supervisor object.\n *\n * @example\n * const supportBot = ai.orchestrator<SessionState>({\n *   name: \"refund-support\",\n *   intents: { classify, lookup, process, compose },\n *   route: (ctx) => (ctx.iteration === 0 ? \"classify\" : END),\n *   iterate: true,\n *   checkpointStore: ai.checkpoint.pg({ client: pg }),\n *   snapshotStore: ai.snapshot.pg({ client: pg }),\n * });\n *\n * const result = await supportBot.execute(message, { sessionId, history });\n */\nexport function orchestrator<\n  TOutput = unknown,\n  TState = TOutput,\n  TIntents extends Record<string, SupervisorIntentValue> = Record<\n    string,\n    SupervisorIntentValue\n  >,\n>(\n  config: OrchestratorConfig<TOutput, TState, TIntents>,\n): OrchestratorContract<TOutput, TState> {\n  validateFactoryConfig(config as unknown as OrchestratorConfig<unknown>);\n\n  const entries = resolveEntries(config as unknown as OrchestratorConfig<unknown>);\n\n  assertInitialAgent(config as unknown as OrchestratorConfig<unknown>, entries);\n\n  const signature = computeOrchestratorSignature(\n    config as unknown as OrchestratorConfig<unknown>,\n    entries,\n  );\n  const emitter = new OrchestratorEmitter(config.on);\n\n  async function execute(\n    input: SupervisorInput,\n    options: OrchestratorExecuteOptions<TState>,\n  ): Promise<OrchestratorResult<TOutput>> {\n    const execution = new OrchestratorExecution<TOutput, TState>({\n      config: config as unknown as OrchestratorConfig<TOutput, TState>,\n      entries,\n      signature,\n      emitter,\n      input,\n      options,\n    });\n\n    return execution.run();\n  }\n\n  function stream(\n    input: SupervisorInput,\n    options: OrchestratorExecuteOptions<TState>,\n  ): StreamContract<OrchestratorResult<TOutput>, OrchestratorEvent> {\n    const { controller, stream: contract } = createOrchestratorStream<\n      OrchestratorResult<TOutput>\n    >();\n\n    const execution = new OrchestratorExecution<TOutput, TState>({\n      config: config as unknown as OrchestratorConfig<TOutput, TState>,\n      entries,\n      signature,\n      emitter,\n      input,\n      options,\n      streamController: controller,\n    });\n\n    void execution.run();\n\n    return contract;\n  }\n\n  async function resume(\n    sessionId: string,\n    options?: OrchestratorResumeOptions,\n  ): Promise<OrchestratorResult<TOutput> | null> {\n    const execution = new OrchestratorExecution<TOutput, TState>({\n      config: config as unknown as OrchestratorConfig<TOutput, TState>,\n      entries,\n      signature,\n      emitter,\n      resumeSessionId: sessionId,\n      resumeOptions: options,\n    });\n\n    return execution.resume();\n  }\n\n  // The dispatcher owns command ROUTING only; the `compact` handler\n  // delegates to the shared compaction code path on the lifecycle engine\n  // (§11 / §12.2 — manual compact reuses the post-turn compaction path).\n  const command = createCommandDispatcher({\n    compact: (args: OrchestratorCommands[\"compact\"][\"args\"]) => {\n      const execution = new OrchestratorExecution<TOutput, TState>({\n        config: config as unknown as OrchestratorConfig<TOutput, TState>,\n        entries,\n        signature,\n        emitter,\n      });\n\n      return execution.compact(args);\n    },\n  });\n\n  const instance: OrchestratorContract<TOutput, TState> = {\n    name: config.name,\n    signature,\n    version: config.version,\n    execute,\n    stream,\n    resume,\n    command,\n    asTool<TToolInput = string>(\n      options: OrchestratorAsToolOptions<TToolInput>,\n    ): ToolContract<TToolInput, TOutput> {\n      return orchestratorAsTool<TOutput, TState, TToolInput>(instance, options);\n    },\n    on<K extends OrchestratorEventName>(\n      event: K,\n      handler: OrchestratorEventHandler<K>,\n    ): () => void {\n      return emitter.on(event, handler);\n    },\n    off<K extends OrchestratorEventName>(\n      event: K,\n      handler: OrchestratorEventHandler<K>,\n    ): void {\n      emitter.off(event, handler);\n    },\n  };\n\n  return instance;\n}\n\n/**\n * Author-time validation (orchestrator.md §17). Enforces the rules that\n * must fail at construction rather than on the first turn:\n *\n * - `name` present and a string.\n * - `intents` present.\n * - `route` XOR `router` (mutually exclusive; at least one required) —\n *   the supervisor's dispatch-source rule, surfaced as an orchestrator\n *   config error.\n * - `router` is a valid agent contract or `{ agent, ... }` entry.\n * - `maxIterations >= 1` when set.\n * - `snapshotStore` resolvable when `iterate: true` — explicit field or\n *   the global `ai.config({ defaultSnapshotStore })` fallback.\n *\n * `initialAgent` membership is checked separately once the intent\n * entries are resolved.\n */\nfunction validateFactoryConfig(config: OrchestratorConfig<unknown>): void {\n  if (!config.name || typeof config.name !== \"string\") {\n    throw new OrchestratorConfigError(\n      \"ai.orchestrator: `name` is required and must be a string\",\n      { context: { authoring: true } },\n    );\n  }\n\n  if (!config.intents || typeof config.intents !== \"object\") {\n    throw new OrchestratorConfigError(\n      `ai.orchestrator(\"${config.name}\"): \\`intents\\` is required`,\n      { context: { authoring: true } },\n    );\n  }\n\n  const hasRoute = typeof config.route === \"function\";\n  const hasRouter = Boolean(config.router);\n\n  if (hasRouter) {\n    const router = config.router;\n    const isBareAgent = typeof (router as { execute?: unknown }).execute === \"function\";\n    const isEntryForm =\n      !isBareAgent &&\n      typeof (router as { agent?: { execute?: unknown } }).agent === \"object\" &&\n      typeof (router as { agent?: { execute?: unknown } }).agent?.execute === \"function\";\n\n    if (!isBareAgent && !isEntryForm) {\n      throw new OrchestratorConfigError(\n        `ai.orchestrator(\"${config.name}\"): \\`router\\` must be an agent contract or a \\`{ agent, placeholders?, input? }\\` entry`,\n        { context: { authoring: true } },\n      );\n    }\n  }\n\n  if (hasRoute && hasRouter) {\n    throw new OrchestratorConfigError(\n      `ai.orchestrator(\"${config.name}\"): \\`route\\` and \\`router\\` are mutually exclusive — configure exactly one`,\n      { context: { authoring: true } },\n    );\n  }\n\n  if (!hasRoute && !hasRouter) {\n    throw new OrchestratorConfigError(\n      `ai.orchestrator(\"${config.name}\"): one of \\`route\\` or \\`router\\` is required`,\n      { context: { authoring: true } },\n    );\n  }\n\n  if (config.maxIterations !== undefined && config.maxIterations < 1) {\n    throw new OrchestratorConfigError(\n      `ai.orchestrator(\"${config.name}\"): \\`maxIterations\\` must be >= 1`,\n      { context: { authoring: true, maxIterations: config.maxIterations } },\n    );\n  }\n\n  if (config.iterate && !config.snapshotStore && !resolveDefaultSnapshotStore()) {\n    throw new OrchestratorConfigError(\n      `ai.orchestrator(\"${config.name}\"): \\`iterate: true\\` requires a \\`snapshotStore\\` (or \\`ai.config({ defaultSnapshotStore })\\`) for mid-turn resume`,\n      { context: { authoring: true } },\n    );\n  }\n}\n\n/**\n * Resolve the `intents` map into the supervisor's internal entry shape,\n * re-wrapping the supervisor's authoring failure as an\n * {@link OrchestratorConfigError} so misuse surfaces under the\n * orchestrator's error family rather than the supervisor's.\n */\nfunction resolveEntries(\n  config: OrchestratorConfig<unknown>,\n): Map<string, ResolvedIntentEntry> {\n  try {\n    return resolveIntentEntries(config.intents, config.name);\n  } catch (error) {\n    if (error instanceof SupervisorFailedError) {\n      throw new OrchestratorConfigError(error.message, {\n        context: { authoring: true },\n        cause: error,\n      });\n    }\n\n    throw error;\n  }\n}\n\n/**\n * Enforce the `initialAgent` membership rule (§17) once entries are\n * resolved — `initialAgent`, when set, must name a key in `intents`.\n */\nfunction assertInitialAgent(\n  config: OrchestratorConfig<unknown>,\n  entries: Map<string, ResolvedIntentEntry>,\n): void {\n  if (config.initialAgent && !entries.has(config.initialAgent)) {\n    throw new OrchestratorConfigError(\n      `ai.orchestrator(\"${config.name}\"): \\`initialAgent\\` \"${config.initialAgent}\" is not a key in \\`intents\\``,\n      { context: { authoring: true } },\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4DA,SAAgB,aAQd,QACuC;CACvC,sBAAsB,MAAgD;CAEtE,MAAM,UAAU,eAAe,MAAgD;CAE/E,mBAAmB,QAAkD,OAAO;CAE5E,MAAM,YAAY,6BAChB,QACA,OACF;CACA,MAAM,UAAU,IAAI,oBAAoB,OAAO,EAAE;CAEjD,eAAe,QACb,OACA,SACsC;EAUtC,OAAO,IATe,sBAAuC;GACnD;GACR;GACA;GACA;GACA;GACA;EACF,CAEe,CAAC,CAAC,IAAI;CACvB;CAEA,SAAS,OACP,OACA,SACgE;EAChE,MAAM,EAAE,YAAY,QAAQ,aAAa,yBAEvC;EAYF,AAAK,IAViB,sBAAuC;GACnD;GACR;GACA;GACA;GACA;GACA;GACA,kBAAkB;EACpB,CAEa,CAAC,CAAC,IAAI;EAEnB,OAAO;CACT;CAEA,eAAe,OACb,WACA,SAC6C;EAU7C,OAAO,IATe,sBAAuC;GACnD;GACR;GACA;GACA;GACA,iBAAiB;GACjB,eAAe;EACjB,CAEe,CAAC,CAAC,OAAO;CAC1B;CAKA,MAAM,UAAU,wBAAwB,EACtC,UAAU,SAAkD;EAQ1D,OAAO,IAPe,sBAAuC;GACnD;GACR;GACA;GACA;EACF,CAEe,CAAC,CAAC,QAAQ,IAAI;CAC/B,EACF,CAAC;CAED,MAAM,WAAkD;EACtD,MAAM,OAAO;EACb;EACA,SAAS,OAAO;EAChB;EACA;EACA;EACA;EACA,OACE,SACmC;GACnC,OAAOA,OAAgD,UAAU,OAAO;EAC1E;EACA,GACE,OACA,SACY;GACZ,OAAO,QAAQ,GAAG,OAAO,OAAO;EAClC;EACA,IACE,OACA,SACM;GACN,QAAQ,IAAI,OAAO,OAAO;EAC5B;CACF;CAEA,OAAO;AACT;;;;;;;;;;;;;;;;;;AAmBA,SAAS,sBAAsB,QAA2C;CACxE,IAAI,CAAC,OAAO,QAAQ,OAAO,OAAO,SAAS,UACzC,MAAM,IAAI,wBACR,4DACA,EAAE,SAAS,EAAE,WAAW,KAAK,EAAE,CACjC;CAGF,IAAI,CAAC,OAAO,WAAW,OAAO,OAAO,YAAY,UAC/C,MAAM,IAAI,wBACR,oBAAoB,OAAO,KAAK,8BAChC,EAAE,SAAS,EAAE,WAAW,KAAK,EAAE,CACjC;CAGF,MAAM,WAAW,OAAO,OAAO,UAAU;CACzC,MAAM,YAAY,QAAQ,OAAO,MAAM;CAEvC,IAAI,WAAW;EACb,MAAM,SAAS,OAAO;EACtB,MAAM,cAAc,OAAQ,OAAiC,YAAY;EACzE,MAAM,cACJ,CAAC,eACD,OAAQ,OAA6C,UAAU,YAC/D,OAAQ,OAA6C,OAAO,YAAY;EAE1E,IAAI,CAAC,eAAe,CAAC,aACnB,MAAM,IAAI,wBACR,oBAAoB,OAAO,KAAK,2FAChC,EAAE,SAAS,EAAE,WAAW,KAAK,EAAE,CACjC;CAEJ;CAEA,IAAI,YAAY,WACd,MAAM,IAAI,wBACR,oBAAoB,OAAO,KAAK,8EAChC,EAAE,SAAS,EAAE,WAAW,KAAK,EAAE,CACjC;CAGF,IAAI,CAAC,YAAY,CAAC,WAChB,MAAM,IAAI,wBACR,oBAAoB,OAAO,KAAK,iDAChC,EAAE,SAAS,EAAE,WAAW,KAAK,EAAE,CACjC;CAGF,IAAI,OAAO,kBAAkB,UAAa,OAAO,gBAAgB,GAC/D,MAAM,IAAI,wBACR,oBAAoB,OAAO,KAAK,qCAChC,EAAE,SAAS;EAAE,WAAW;EAAM,eAAe,OAAO;CAAc,EAAE,CACtE;CAGF,IAAI,OAAO,WAAW,CAAC,OAAO,iBAAiB,CAAC,4BAA4B,GAC1E,MAAM,IAAI,wBACR,oBAAoB,OAAO,KAAK,sHAChC,EAAE,SAAS,EAAE,WAAW,KAAK,EAAE,CACjC;AAEJ;;;;;;;AAQA,SAAS,eACP,QACkC;CAClC,IAAI;EACF,OAAO,qBAAqB,OAAO,SAAS,OAAO,IAAI;CACzD,SAAS,OAAO;EACd,IAAI,iBAAiB,uBACnB,MAAM,IAAI,wBAAwB,MAAM,SAAS;GAC/C,SAAS,EAAE,WAAW,KAAK;GAC3B,OAAO;EACT,CAAC;EAGH,MAAM;CACR;AACF;;;;;AAMA,SAAS,mBACP,QACA,SACM;CACN,IAAI,OAAO,gBAAgB,CAAC,QAAQ,IAAI,OAAO,YAAY,GACzD,MAAM,IAAI,wBACR,oBAAoB,OAAO,KAAK,wBAAwB,OAAO,aAAa,gCAC5E,EAAE,SAAS,EAAE,WAAW,KAAK,EAAE,CACjC;AAEJ"}

package/esm/orchestrator/resume.mjs

@@ -0,0 +1,74 @@
+import { summarizeRoute } from "./checkpoint.mjs";
+import { deriveRunId, dispatchTurn } from "./dispatch.mjs";
+import { loadSession } from "./load.mjs";
+
+//#region ../@warlock.js/ai/src/orchestrator/resume.ts
+/**
+* §9 resume protocol. Detects and drains an interrupted `iterate: true`
+* turn:
+*
+* 1. Load the latest checkpoint (§9.1 step 1).
+* 2. Compute the candidate `runId` for the NEXT turn — the one that was
+*    in flight — `${sessionId}.${version}.${turn_index + 1}` (§9.1 step 2).
+* 3. Load the supervisor snapshot for that runId (§9.1 step 3).
+* 4. If a still-`running` snapshot exists, resume the supervisor, persist
+*    a fresh checkpoint for `turn_index + 1`, and return the result
+*    (§9.1 step 4).
+* 5. Otherwise return `null` — nothing in flight; the caller proceeds to
+*    `execute()` normally (§9.1 step 5, §9.3 drain idempotency).
+*
+* Runs the same Phase 2 drift check as `execute()` (§9.4). Resume is a
+* no-op for `iterate: false` orchestrators (no SnapshotStore, nothing to
+* resume) — it returns `null`.
+*/
+async function resolveResume(ctx, sessionId, options, hooks) {
+	if (!ctx.snapshotStore || ctx.config.iterate !== true) return null;
+	const loaded = await loadSession(ctx, sessionId);
+	hooks.assertNoDrift(loaded.record?.signature);
+	const resumedTurnIndex = (loaded.record?.turn_index ?? -1) + 1;
+	const runId = deriveRunId(sessionId, ctx.config.version, resumedTurnIndex);
+	const snapshot = await ctx.snapshotStore.load(runId);
+	if (!snapshot || snapshot.status !== "running") return null;
+	ctx.emitter.emit("orchestrator.turn.starting", {
+		sessionId,
+		turnIndex: resumedTurnIndex
+	});
+	const { result, state, turnSnapshot } = await dispatchTurn({
+		ctx,
+		sessionId,
+		input: snapshot.input,
+		seedState: loaded.state,
+		turnIndex: resumedTurnIndex,
+		history: [],
+		context: options?.context,
+		signal: options?.signal
+	});
+	const status = result.error ? hooks.deriveStatus(result.report.status) : "awaiting-input";
+	if (result.error) {
+		const report = hooks.buildReport(resumedTurnIndex, status, turnSnapshot, result.report);
+		hooks.emitTerminal(resumedTurnIndex, status);
+		return {
+			data: result.data,
+			error: result.error,
+			usage: result.usage,
+			report,
+			sessionId,
+			turnIndex: resumedTurnIndex
+		};
+	}
+	await hooks.persist(resumedTurnIndex, state, summarizeRoute(turnSnapshot.decision.raw), loaded.record?.summarized_through ?? null);
+	const report = hooks.buildReport(resumedTurnIndex, "awaiting-input", turnSnapshot, result.report);
+	hooks.emitTerminal(resumedTurnIndex, "awaiting-input");
+	return {
+		data: result.data,
+		error: void 0,
+		usage: result.usage,
+		report,
+		sessionId,
+		turnIndex: resumedTurnIndex
+	};
+}
+
+//#endregion
+export { resolveResume };
+//# sourceMappingURL=resume.mjs.map

package/esm/orchestrator/resume.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"resume.mjs","names":[],"sources":["../../../../../../../@warlock.js/ai/src/orchestrator/resume.ts"],"sourcesContent":["import type { OrchestratorResumeOptions } from \"../contracts/orchestrator/orchestrator-execute-options.type\";\nimport type {\n  OrchestratorReport,\n  OrchestratorReportStatus,\n  OrchestratorResult,\n  TurnSnapshot,\n} from \"../contracts/result/orchestrator-result.type\";\nimport type { BaseReport } from \"../contracts/result/base-report.type\";\nimport { summarizeRoute } from \"./checkpoint\";\nimport { deriveRunId, dispatchTurn } from \"./dispatch\";\nimport type { OrchestratorEngineContext } from \"./engine-context.type\";\nimport { loadSession } from \"./load\";\n\n/**\n * Hooks the resume protocol borrows from the execution module so it can\n * reuse the drift check, report assembly, status mapping, terminal\n * event emission, and checkpoint persistence without a circular import\n * (execution.ts owns those; resume.ts is called by it).\n */\nexport type ResumeHooks = {\n  assertNoDrift(loadedSignature: string | undefined): void;\n  buildReport(\n    turnIndex: number,\n    status: OrchestratorReportStatus,\n    turnSnapshot: TurnSnapshot | undefined,\n    childReport: BaseReport | undefined,\n  ): OrchestratorReport;\n  deriveStatus(childStatus: BaseReport[\"status\"]): OrchestratorReportStatus;\n  emitTerminal(turnIndex: number, status: OrchestratorReportStatus): void;\n  persist(\n    turnIndex: number,\n    state: unknown,\n    lastRoute: string | string[] | null,\n    summarizedThrough: number | null,\n  ): Promise<unknown>;\n};\n\n/**\n * §9 resume protocol. Detects and drains an interrupted `iterate: true`\n * turn:\n *\n * 1. Load the latest checkpoint (§9.1 step 1).\n * 2. Compute the candidate `runId` for the NEXT turn — the one that was\n *    in flight — `${sessionId}.${version}.${turn_index + 1}` (§9.1 step 2).\n * 3. Load the supervisor snapshot for that runId (§9.1 step 3).\n * 4. If a still-`running` snapshot exists, resume the supervisor, persist\n *    a fresh checkpoint for `turn_index + 1`, and return the result\n *    (§9.1 step 4).\n * 5. Otherwise return `null` — nothing in flight; the caller proceeds to\n *    `execute()` normally (§9.1 step 5, §9.3 drain idempotency).\n *\n * Runs the same Phase 2 drift check as `execute()` (§9.4). Resume is a\n * no-op for `iterate: false` orchestrators (no SnapshotStore, nothing to\n * resume) — it returns `null`.\n */\nexport async function resolveResume<TOutput, TState>(\n  ctx: OrchestratorEngineContext<TOutput, TState>,\n  sessionId: string,\n  options: OrchestratorResumeOptions | undefined,\n  hooks: ResumeHooks,\n): Promise<OrchestratorResult<TOutput> | null> {\n  if (!ctx.snapshotStore || ctx.config.iterate !== true) {\n    return null;\n  }\n\n  const loaded = await loadSession(ctx, sessionId);\n\n  // Drift guard — same as execute() (§9.4).\n  hooks.assertNoDrift(loaded.record?.signature);\n\n  // The in-flight turn is the one AFTER the last settled checkpoint.\n  const resumedTurnIndex = (loaded.record?.turn_index ?? -1) + 1;\n  const runId = deriveRunId(sessionId, ctx.config.version, resumedTurnIndex);\n\n  const snapshot = await ctx.snapshotStore.load(runId);\n\n  if (!snapshot || snapshot.status !== \"running\") {\n    return null;\n  }\n\n  ctx.emitter.emit(\"orchestrator.turn.starting\", {\n    sessionId,\n    turnIndex: resumedTurnIndex,\n  });\n\n  // Re-dispatch: dispatchTurn detects the in-flight snapshot for this\n  // runId and calls supervisor.resume() rather than execute() (§5 step 5).\n  const { result, state, turnSnapshot } = await dispatchTurn<TOutput, TState>({\n    ctx,\n    sessionId,\n    input: snapshot.input,\n    seedState: loaded.state,\n    turnIndex: resumedTurnIndex,\n    history: [],\n    context: options?.context,\n    signal: options?.signal,\n  });\n\n  const status = result.error\n    ? hooks.deriveStatus(result.report.status)\n    : \"awaiting-input\";\n\n  if (result.error) {\n    const report = hooks.buildReport(\n      resumedTurnIndex,\n      status,\n      turnSnapshot,\n      result.report,\n    );\n\n    hooks.emitTerminal(resumedTurnIndex, status);\n\n    return {\n      data: result.data,\n      error: result.error,\n      usage: result.usage,\n      report,\n      sessionId,\n      turnIndex: resumedTurnIndex,\n    };\n  }\n\n  // Finalize: persist a fresh checkpoint for the resumed turn (§9.1 step 4).\n  await hooks.persist(\n    resumedTurnIndex,\n    state,\n    summarizeRoute(turnSnapshot.decision.raw as never),\n    loaded.record?.summarized_through ?? null,\n  );\n\n  const report = hooks.buildReport(\n    resumedTurnIndex,\n    \"awaiting-input\",\n    turnSnapshot,\n    result.report,\n  );\n\n  hooks.emitTerminal(resumedTurnIndex, \"awaiting-input\");\n\n  return {\n    data: result.data,\n    error: undefined,\n    usage: result.usage,\n    report,\n    sessionId,\n    turnIndex: resumedTurnIndex,\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAuDA,eAAsB,cACpB,KACA,WACA,SACA,OAC6C;CAC7C,IAAI,CAAC,IAAI,iBAAiB,IAAI,OAAO,YAAY,MAC/C,OAAO;CAGT,MAAM,SAAS,MAAM,YAAY,KAAK,SAAS;CAG/C,MAAM,cAAc,OAAO,QAAQ,SAAS;CAG5C,MAAM,oBAAoB,OAAO,QAAQ,cAAc,MAAM;CAC7D,MAAM,QAAQ,YAAY,WAAW,IAAI,OAAO,SAAS,gBAAgB;CAEzE,MAAM,WAAW,MAAM,IAAI,cAAc,KAAK,KAAK;CAEnD,IAAI,CAAC,YAAY,SAAS,WAAW,WACnC,OAAO;CAGT,IAAI,QAAQ,KAAK,8BAA8B;EAC7C;EACA,WAAW;CACb,CAAC;CAID,MAAM,EAAE,QAAQ,OAAO,iBAAiB,MAAM,aAA8B;EAC1E;EACA;EACA,OAAO,SAAS;EAChB,WAAW,OAAO;EAClB,WAAW;EACX,SAAS,CAAC;EACV,SAAS,SAAS;EAClB,QAAQ,SAAS;CACnB,CAAC;CAED,MAAM,SAAS,OAAO,QAClB,MAAM,aAAa,OAAO,OAAO,MAAM,IACvC;CAEJ,IAAI,OAAO,OAAO;EAChB,MAAM,SAAS,MAAM,YACnB,kBACA,QACA,cACA,OAAO,MACT;EAEA,MAAM,aAAa,kBAAkB,MAAM;EAE3C,OAAO;GACL,MAAM,OAAO;GACb,OAAO,OAAO;GACd,OAAO,OAAO;GACd;GACA;GACA,WAAW;EACb;CACF;CAGA,MAAM,MAAM,QACV,kBACA,OACA,eAAe,aAAa,SAAS,GAAY,GACjD,OAAO,QAAQ,sBAAsB,IACvC;CAEA,MAAM,SAAS,MAAM,YACnB,kBACA,kBACA,cACA,OAAO,MACT;CAEA,MAAM,aAAa,kBAAkB,gBAAgB;CAErD,OAAO;EACL,MAAM,OAAO;EACb,OAAO;EACP,OAAO,OAAO;EACd;EACA;EACA,WAAW;CACb;AACF"}

package/esm/orchestrator/signature.d.mts

@@ -0,0 +1,40 @@
+import { OrchestratorConfig } from "../contracts/orchestrator/orchestrator-config.type.mjs";
+import { ResolvedIntentEntry } from "../supervisor/entries.mjs";
+
+//#region ../@warlock.js/ai/src/orchestrator/signature.d.ts
+/**
+ * Deterministic structural fingerprint of an orchestrator definition
+ * (orchestrator.md §10.1). Persisted on every checkpoint so Phase 2 can
+ * refuse a turn when the live definition no longer matches the saved
+ * session shape. Covers exactly the dispatch contract:
+ *
+ * - `name`.
+ * - The `intents` map — each intent key + its resolved description +
+ *   the underlying unit's stable identity (agent name, workflow name +
+ *   signature, or a `"callback"` marker for dev-callback intents).
+ *   Reuses the supervisor's resolved-entry fingerprinting verbatim.
+ * - `route` callback presence (its body is code, not data).
+ * - `router` agent identity when LLM routing is configured.
+ * - `evaluate` callback presence.
+ * - `initialAgent` when set.
+ * - `maxIterations`.
+ * - The `iterate` flag — flipping single-dispatch to delegated
+ *   iteration is a semantic shape change.
+ * - The `historyWindow` config SHAPE — which roles window and whether
+ *   each is a number or a callback (not the window value itself).
+ *
+ * Does NOT cover (§10.1): `version` (metadata only), `systemPrompt`
+ * text, logger config, store identities, event handlers, or callback
+ * function bodies (callbacks fingerprint as their presence/`"callback"`
+ * marker only). The orchestrator signature does NOT aggregate the
+ * internal supervisor's signature — that is a per-run concern delegated
+ * to `supervisor.resume()`'s own drift check on `iterate: true`.
+ *
+ * @example
+ * const signature = computeOrchestratorSignature(config, resolvedEntries);
+ * // "1a2b3c4d" — 8-char FNV-1a hex, stable across process restarts.
+ */
+declare function computeOrchestratorSignature(config: OrchestratorConfig<unknown>, entries: Map<string, ResolvedIntentEntry>): string;
+//#endregion
+export { computeOrchestratorSignature };
+//# sourceMappingURL=signature.d.mts.map

package/esm/orchestrator/signature.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signature.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai/src/orchestrator/signature.ts"],"mappings":";;;;;;AA4CA;;;;;;;;;;;;;;AAE2C;;;;;;;;;;;;;;;;iBAF3B,4BAAA,CACd,MAAA,EAAQ,kBAAA,WACR,OAAA,EAAS,GAAA,SAAY,mBAAA"}

package/esm/orchestrator/signature.mjs

@@ -0,0 +1,120 @@
+//#region ../@warlock.js/ai/src/orchestrator/signature.ts
+/**
+* Deterministic structural fingerprint of an orchestrator definition
+* (orchestrator.md §10.1). Persisted on every checkpoint so Phase 2 can
+* refuse a turn when the live definition no longer matches the saved
+* session shape. Covers exactly the dispatch contract:
+*
+* - `name`.
+* - The `intents` map — each intent key + its resolved description +
+*   the underlying unit's stable identity (agent name, workflow name +
+*   signature, or a `"callback"` marker for dev-callback intents).
+*   Reuses the supervisor's resolved-entry fingerprinting verbatim.
+* - `route` callback presence (its body is code, not data).
+* - `router` agent identity when LLM routing is configured.
+* - `evaluate` callback presence.
+* - `initialAgent` when set.
+* - `maxIterations`.
+* - The `iterate` flag — flipping single-dispatch to delegated
+*   iteration is a semantic shape change.
+* - The `historyWindow` config SHAPE — which roles window and whether
+*   each is a number or a callback (not the window value itself).
+*
+* Does NOT cover (§10.1): `version` (metadata only), `systemPrompt`
+* text, logger config, store identities, event handlers, or callback
+* function bodies (callbacks fingerprint as their presence/`"callback"`
+* marker only). The orchestrator signature does NOT aggregate the
+* internal supervisor's signature — that is a per-run concern delegated
+* to `supervisor.resume()`'s own drift check on `iterate: true`.
+*
+* @example
+* const signature = computeOrchestratorSignature(config, resolvedEntries);
+* // "1a2b3c4d" — 8-char FNV-1a hex, stable across process restarts.
+*/
+function computeOrchestratorSignature(config, entries) {
+	const intentsFingerprint = [...entries.entries()].sort(([first], [second]) => first.localeCompare(second)).map(([intent, entry]) => ({
+		k: intent,
+		d: entry.description,
+		u: fingerprintUnit(entry)
+	}));
+	const fingerprint = {
+		n: config.name,
+		a: intentsFingerprint,
+		r: resolveRouterName(config.router),
+		rc: config.route ? 1 : 0,
+		e: config.evaluate ? 1 : 0,
+		i: config.initialAgent ?? null,
+		m: config.maxIterations ?? null,
+		it: config.iterate ? 1 : 0,
+		hw: fingerprintHistoryWindow(config.historyWindow)
+	};
+	return hash(JSON.stringify(fingerprint));
+}
+/**
+* Router identity for the fingerprint. Accepts both the bare-agent
+* shorthand and the `{ agent, ... }` entry form, returning the agent's
+* name (or `null` when no router is configured). Mirrors the
+* supervisor's `resolveRouterName`.
+*/
+function resolveRouterName(router) {
+	if (!router) return null;
+	if (typeof router.execute === "function") return router.name ?? null;
+	return router.agent?.name ?? null;
+}
+/**
+* Structural fingerprint of the `historyWindow` config. Records the
+* windowing strategy per role (`"number"` / `"callback"` / `null`) so a
+* dev swapping a fixed-size window for a token-counting callback drifts
+* the signature, while tuning the window value (e.g. `5` → `8`) does
+* not. The window value is a runtime knob, not a shape change.
+*/
+function fingerprintHistoryWindow(historyWindow) {
+	return {
+		router: fingerprintHistoryWindowRole(historyWindow?.router),
+		agents: fingerprintHistoryWindowRole(historyWindow?.agents)
+	};
+}
+function fingerprintHistoryWindowRole(window) {
+	if (window === void 0) return null;
+	if (typeof window === "function") return "callback";
+	return "number";
+}
+/**
+* Stable identity of one resolved intent's underlying unit. Agents
+* fingerprint by name; workflows by name + their own signature;
+* callbacks by a type marker only (their closure can't be hashed
+* deterministically, so drift covers add/remove/rename, not body
+* edits). Identical to the supervisor's `fingerprintUnit`.
+*/
+function fingerprintUnit(entry) {
+	if (entry.type === "callback") return { t: "callback" };
+	if (entry.type === "workflow") {
+		const workflow = entry.unit;
+		return {
+			t: "workflow",
+			n: workflow.name,
+			s: workflow.signature
+		};
+	}
+	return {
+		t: "agent",
+		n: entry.unit.name
+	};
+}
+/**
+* FNV-1a 32-bit — the same hash `supervisor/signature.ts` and
+* `workflow/signature.ts` use. Deterministic, no crypto dependency,
+* cheap; signatures are 8-char hex.
+*/
+function hash(input) {
+	let h = 2166136261;
+	for (let i = 0; i < input.length; i++) {
+		h ^= input.charCodeAt(i);
+		h = h + ((h << 1) + (h << 4) + (h << 7) + (h << 8) + (h << 24)) >>> 0;
+	}
+	return h.toString(16).padStart(8, "0");
+}
+
+//#endregion
+export { computeOrchestratorSignature };
+//# sourceMappingURL=signature.mjs.map

package/esm/orchestrator/signature.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"signature.mjs","names":[],"sources":["../../../../../../../@warlock.js/ai/src/orchestrator/signature.ts"],"sourcesContent":["import type { OrchestratorConfig } from \"../contracts/orchestrator/orchestrator-config.type\";\nimport type { ResolvedIntentEntry } from \"../supervisor/entries\";\n\n/**\n * Shape of the `historyWindow` config a fingerprint records. A number\n * window is recorded as `\"number\"`; a callback window as `\"callback\"`;\n * an absent role as `null`. The window VALUE (the literal `5`, the\n * callback body) is deliberately excluded — only the structural choice\n * of windowing strategy per role drifts the signature (§10.1).\n */\ntype HistoryWindowRoleFingerprint = \"number\" | \"callback\" | null;\n\n/**\n * Deterministic structural fingerprint of an orchestrator definition\n * (orchestrator.md §10.1). Persisted on every checkpoint so Phase 2 can\n * refuse a turn when the live definition no longer matches the saved\n * session shape. Covers exactly the dispatch contract:\n *\n * - `name`.\n * - The `intents` map — each intent key + its resolved description +\n *   the underlying unit's stable identity (agent name, workflow name +\n *   signature, or a `\"callback\"` marker for dev-callback intents).\n *   Reuses the supervisor's resolved-entry fingerprinting verbatim.\n * - `route` callback presence (its body is code, not data).\n * - `router` agent identity when LLM routing is configured.\n * - `evaluate` callback presence.\n * - `initialAgent` when set.\n * - `maxIterations`.\n * - The `iterate` flag — flipping single-dispatch to delegated\n *   iteration is a semantic shape change.\n * - The `historyWindow` config SHAPE — which roles window and whether\n *   each is a number or a callback (not the window value itself).\n *\n * Does NOT cover (§10.1): `version` (metadata only), `systemPrompt`\n * text, logger config, store identities, event handlers, or callback\n * function bodies (callbacks fingerprint as their presence/`\"callback\"`\n * marker only). The orchestrator signature does NOT aggregate the\n * internal supervisor's signature — that is a per-run concern delegated\n * to `supervisor.resume()`'s own drift check on `iterate: true`.\n *\n * @example\n * const signature = computeOrchestratorSignature(config, resolvedEntries);\n * // \"1a2b3c4d\" — 8-char FNV-1a hex, stable across process restarts.\n */\nexport function computeOrchestratorSignature(\n  config: OrchestratorConfig<unknown>,\n  entries: Map<string, ResolvedIntentEntry>,\n): string {\n  const intentsFingerprint = [...entries.entries()]\n    .sort(([first], [second]) => first.localeCompare(second))\n    .map(([intent, entry]) => ({\n      k: intent,\n      d: entry.description,\n      u: fingerprintUnit(entry),\n    }));\n\n  const fingerprint = {\n    n: config.name,\n    a: intentsFingerprint,\n    r: resolveRouterName(config.router),\n    rc: config.route ? 1 : 0,\n    e: config.evaluate ? 1 : 0,\n    i: config.initialAgent ?? null,\n    m: config.maxIterations ?? null,\n    it: config.iterate ? 1 : 0,\n    hw: fingerprintHistoryWindow(config.historyWindow),\n  };\n\n  return hash(JSON.stringify(fingerprint));\n}\n\n/**\n * Router identity for the fingerprint. Accepts both the bare-agent\n * shorthand and the `{ agent, ... }` entry form, returning the agent's\n * name (or `null` when no router is configured). Mirrors the\n * supervisor's `resolveRouterName`.\n */\nfunction resolveRouterName(router: OrchestratorConfig<unknown>[\"router\"]): string | null {\n  if (!router) {\n    return null;\n  }\n\n  if (typeof (router as { execute?: unknown }).execute === \"function\") {\n    return (router as { name?: string }).name ?? null;\n  }\n\n  return (router as { agent?: { name?: string } }).agent?.name ?? null;\n}\n\n/**\n * Structural fingerprint of the `historyWindow` config. Records the\n * windowing strategy per role (`\"number\"` / `\"callback\"` / `null`) so a\n * dev swapping a fixed-size window for a token-counting callback drifts\n * the signature, while tuning the window value (e.g. `5` → `8`) does\n * not. The window value is a runtime knob, not a shape change.\n */\nfunction fingerprintHistoryWindow(\n  historyWindow: OrchestratorConfig<unknown>[\"historyWindow\"],\n): { router: HistoryWindowRoleFingerprint; agents: HistoryWindowRoleFingerprint } {\n  return {\n    router: fingerprintHistoryWindowRole(historyWindow?.router),\n    agents: fingerprintHistoryWindowRole(historyWindow?.agents),\n  };\n}\n\nfunction fingerprintHistoryWindowRole(\n  window: number | ((...args: never[]) => unknown) | undefined,\n): HistoryWindowRoleFingerprint {\n  if (window === undefined) {\n    return null;\n  }\n\n  if (typeof window === \"function\") {\n    return \"callback\";\n  }\n\n  return \"number\";\n}\n\n/**\n * Stable identity of one resolved intent's underlying unit. Agents\n * fingerprint by name; workflows by name + their own signature;\n * callbacks by a type marker only (their closure can't be hashed\n * deterministically, so drift covers add/remove/rename, not body\n * edits). Identical to the supervisor's `fingerprintUnit`.\n */\nfunction fingerprintUnit(entry: ResolvedIntentEntry): unknown {\n  if (entry.type === \"callback\") {\n    return { t: \"callback\" };\n  }\n\n  if (entry.type === \"workflow\") {\n    const workflow = entry.unit;\n    return { t: \"workflow\", n: workflow.name, s: workflow.signature };\n  }\n\n  return { t: \"agent\", n: entry.unit.name };\n}\n\n/**\n * FNV-1a 32-bit — the same hash `supervisor/signature.ts` and\n * `workflow/signature.ts` use. Deterministic, no crypto dependency,\n * cheap; signatures are 8-char hex.\n */\nfunction hash(input: string): string {\n  let h = 0x811c9dc5;\n\n  for (let i = 0; i < input.length; i++) {\n    h ^= input.charCodeAt(i);\n    h = (h + ((h << 1) + (h << 4) + (h << 7) + (h << 8) + (h << 24))) >>> 0;\n  }\n\n  return h.toString(16).padStart(8, \"0\");\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4CA,SAAgB,6BACd,QACA,SACQ;CACR,MAAM,qBAAqB,CAAC,GAAG,QAAQ,QAAQ,CAAC,CAAC,CAC9C,MAAM,CAAC,QAAQ,CAAC,YAAY,MAAM,cAAc,MAAM,CAAC,CAAC,CACxD,KAAK,CAAC,QAAQ,YAAY;EACzB,GAAG;EACH,GAAG,MAAM;EACT,GAAG,gBAAgB,KAAK;CAC1B,EAAE;CAEJ,MAAM,cAAc;EAClB,GAAG,OAAO;EACV,GAAG;EACH,GAAG,kBAAkB,OAAO,MAAM;EAClC,IAAI,OAAO,QAAQ,IAAI;EACvB,GAAG,OAAO,WAAW,IAAI;EACzB,GAAG,OAAO,gBAAgB;EAC1B,GAAG,OAAO,iBAAiB;EAC3B,IAAI,OAAO,UAAU,IAAI;EACzB,IAAI,yBAAyB,OAAO,aAAa;CACnD;CAEA,OAAO,KAAK,KAAK,UAAU,WAAW,CAAC;AACzC;;;;;;;AAQA,SAAS,kBAAkB,QAA8D;CACvF,IAAI,CAAC,QACH,OAAO;CAGT,IAAI,OAAQ,OAAiC,YAAY,YACvD,OAAQ,OAA6B,QAAQ;CAG/C,OAAQ,OAAyC,OAAO,QAAQ;AAClE;;;;;;;;AASA,SAAS,yBACP,eACgF;CAChF,OAAO;EACL,QAAQ,6BAA6B,eAAe,MAAM;EAC1D,QAAQ,6BAA6B,eAAe,MAAM;CAC5D;AACF;AAEA,SAAS,6BACP,QAC8B;CAC9B,IAAI,WAAW,QACb,OAAO;CAGT,IAAI,OAAO,WAAW,YACpB,OAAO;CAGT,OAAO;AACT;;;;;;;;AASA,SAAS,gBAAgB,OAAqC;CAC5D,IAAI,MAAM,SAAS,YACjB,OAAO,EAAE,GAAG,WAAW;CAGzB,IAAI,MAAM,SAAS,YAAY;EAC7B,MAAM,WAAW,MAAM;EACvB,OAAO;GAAE,GAAG;GAAY,GAAG,SAAS;GAAM,GAAG,SAAS;EAAU;CAClE;CAEA,OAAO;EAAE,GAAG;EAAS,GAAG,MAAM,KAAK;CAAK;AAC1C;;;;;;AAOA,SAAS,KAAK,OAAuB;CACnC,IAAI,IAAI;CAER,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;EACrC,KAAK,MAAM,WAAW,CAAC;EACvB,IAAK,MAAM,KAAK,MAAM,KAAK,MAAM,KAAK,MAAM,KAAK,MAAM,KAAK,SAAU;CACxE;CAEA,OAAO,EAAE,SAAS,EAAE,CAAC,CAAC,SAAS,GAAG,GAAG;AACvC"}

package/esm/orchestrator/window.mjs

@@ -0,0 +1,56 @@
+//#region ../@warlock.js/ai/src/orchestrator/window.ts
+/**
+* Framework-default history windows (orchestrator.md §4 Phase 4 — "5
+* for the router, 15 for intents"). Applied when neither a per-entity
+* override nor a tier default is configured.
+*/
+const DEFAULT_ROUTER_WINDOW = 5;
+const DEFAULT_AGENTS_WINDOW = 15;
+/**
+* Apply a single window to a history array. A number keeps the last N
+* messages (most recent, chronological order preserved); a callback
+* takes full control of the slice (the escape hatch for token-counting
+* or semantic windowing — §4 Phase 4). `N <= 0` keeps nothing.
+*/
+function applyWindow(messages, window) {
+	if (typeof window === "function") return window(messages);
+	if (window <= 0) return [];
+	if (messages.length <= window) return messages.slice();
+	return messages.slice(messages.length - window);
+}
+/**
+* Phase 4 — window history (orchestrator.md §3 / §4 Phase 4). Applies
+* the `historyWindow` cascade to the dev-supplied `history` before it
+* is bound into the router and the dispatched agents. Two tiers,
+* evaluated per-role:
+*
+* 1. Tier default — `historyWindow.router` / `historyWindow.agents`.
+* 2. Framework default — `5` for the router, `15` for agents.
+*
+* (The first cascade layer — per-entity overrides on individual
+* intents / the router entry — is the supervisor's concern: it lives
+* on the intent entries the orchestrator spreads into the supervisor,
+* and the supervisor applies it to the agent-windowed slice this phase
+* produces. The orchestrator owns only the two role-level tiers.)
+*
+* Emits `orchestrator.history.windowed` with the agent-slice message
+* count. Pure aside from the event — returns the per-role slices for
+* the dispatch phase to thread through.
+*/
+function windowHistory(ctx, sessionId, history) {
+	const config = ctx.config.historyWindow;
+	const router = applyWindow(history, config?.router ?? 5);
+	const agents = applyWindow(history, config?.agents ?? 15);
+	ctx.emitter.emit("orchestrator.history.windowed", {
+		sessionId,
+		messageCount: agents.length
+	});
+	return {
+		router,
+		agents
+	};
+}
+
+//#endregion
+export { windowHistory };
+//# sourceMappingURL=window.mjs.map

package/esm/orchestrator/window.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"window.mjs","names":[],"sources":["../../../../../../../@warlock.js/ai/src/orchestrator/window.ts"],"sourcesContent":["import type { Message } from \"../contracts/conversation-message.type\";\nimport type { OrchestratorEngineContext } from \"./engine-context.type\";\n\n/**\n * Framework-default history windows (orchestrator.md §4 Phase 4 — \"5\n * for the router, 15 for intents\"). Applied when neither a per-entity\n * override nor a tier default is configured.\n */\nexport const DEFAULT_ROUTER_WINDOW = 5;\nexport const DEFAULT_AGENTS_WINDOW = 15;\n\n/** A history window: keep the last N messages, or a custom slicer. */\nexport type HistoryWindowValue =\n  | number\n  | ((messages: Message[]) => Message[]);\n\n/**\n * The windowed history bound into each consumer for a turn (§4 Phase\n * 4). Applied per-dispatchable, independently: the router can see a\n * different slice than the dispatched agents.\n */\nexport type WindowedHistory = {\n  /** Slice bound into the router's context. */\n  router: Message[];\n  /** Slice forwarded to every dispatched intent/agent. */\n  agents: Message[];\n};\n\n/**\n * Apply a single window to a history array. A number keeps the last N\n * messages (most recent, chronological order preserved); a callback\n * takes full control of the slice (the escape hatch for token-counting\n * or semantic windowing — §4 Phase 4). `N <= 0` keeps nothing.\n */\nexport function applyWindow(\n  messages: Message[],\n  window: HistoryWindowValue,\n): Message[] {\n  if (typeof window === \"function\") {\n    return window(messages);\n  }\n\n  if (window <= 0) {\n    return [];\n  }\n\n  if (messages.length <= window) {\n    return messages.slice();\n  }\n\n  return messages.slice(messages.length - window);\n}\n\n/**\n * Phase 4 — window history (orchestrator.md §3 / §4 Phase 4). Applies\n * the `historyWindow` cascade to the dev-supplied `history` before it\n * is bound into the router and the dispatched agents. Two tiers,\n * evaluated per-role:\n *\n * 1. Tier default — `historyWindow.router` / `historyWindow.agents`.\n * 2. Framework default — `5` for the router, `15` for agents.\n *\n * (The first cascade layer — per-entity overrides on individual\n * intents / the router entry — is the supervisor's concern: it lives\n * on the intent entries the orchestrator spreads into the supervisor,\n * and the supervisor applies it to the agent-windowed slice this phase\n * produces. The orchestrator owns only the two role-level tiers.)\n *\n * Emits `orchestrator.history.windowed` with the agent-slice message\n * count. Pure aside from the event — returns the per-role slices for\n * the dispatch phase to thread through.\n */\nexport function windowHistory(\n  ctx: OrchestratorEngineContext,\n  sessionId: string,\n  history: Message[],\n): WindowedHistory {\n  const config = ctx.config.historyWindow;\n\n  const router = applyWindow(history, config?.router ?? DEFAULT_ROUTER_WINDOW);\n  const agents = applyWindow(history, config?.agents ?? DEFAULT_AGENTS_WINDOW);\n\n  ctx.emitter.emit(\"orchestrator.history.windowed\", {\n    sessionId,\n    messageCount: agents.length,\n  });\n\n  return { router, agents };\n}\n"],"mappings":";;;;;;AAQA,MAAa,wBAAwB;AACrC,MAAa,wBAAwB;;;;;;;AAyBrC,SAAgB,YACd,UACA,QACW;CACX,IAAI,OAAO,WAAW,YACpB,OAAO,OAAO,QAAQ;CAGxB,IAAI,UAAU,GACZ,OAAO,CAAC;CAGV,IAAI,SAAS,UAAU,QACrB,OAAO,SAAS,MAAM;CAGxB,OAAO,SAAS,MAAM,SAAS,SAAS,MAAM;AAChD;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,cACd,KACA,WACA,SACiB;CACjB,MAAM,SAAS,IAAI,OAAO;CAE1B,MAAM,SAAS,YAAY,SAAS,QAAQ,WAA+B;CAC3E,MAAM,SAAS,YAAY,SAAS,QAAQ,YAA+B;CAE3E,IAAI,QAAQ,KAAK,iCAAiC;EAChD;EACA,cAAc,OAAO;CACvB,CAAC;CAED,OAAO;EAAE;EAAQ;CAAO;AAC1B"}

package/esm/planner/index.d.mts

@@ -0,0 +1,5 @@
+import { planner } from "./planner.mjs";
+import { planSchema } from "./plan-schema.mjs";
+import { buildPlanSystemPrompt } from "./plan-prompt.mjs";
+import { computeSignature } from "./signature.mjs";
+import { PlannerRunArgs } from "./planner-run.mjs";

package/esm/planner/index.mjs

@@ -0,0 +1,6 @@
+import { buildPlanSystemPrompt } from "./plan-prompt.mjs";
+import { planSchema } from "./plan-schema.mjs";
+import { computeSignature } from "./signature.mjs";
+import { planner } from "./planner.mjs";
+
+export {  };

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

@@ -0,0 +1,17 @@
+import { SystemPromptContract } from "../contracts/system-prompt.contract.mjs";
+import { PlannerCapability } from "../contracts/planner/planner-capability.type.mjs";
+
+//#region ../@warlock.js/ai/src/planner/plan-prompt.d.ts
+/**
+ * Assemble the plan-generation system prompt: optional caller framing on
+ * top, then the mechanical block listing every capability + its
+ * description and the rules for emitting an ordered plan.
+ *
+ * Runs once at factory time (the capability set is fixed for the
+ * planner's lifetime) — the produced string is baked onto the internal
+ * planning agent.
+ */
+declare function buildPlanSystemPrompt(capabilities: PlannerCapability[], maxSteps: number, prefix: SystemPromptContract | string | undefined): string;
+//#endregion
+export { buildPlanSystemPrompt };
+//# sourceMappingURL=plan-prompt.d.mts.map

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

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

package/esm/planner/plan-prompt.mjs

@@ -0,0 +1,30 @@
+//#region ../@warlock.js/ai/src/planner/plan-prompt.ts
+/**
+* Assemble the plan-generation system prompt: optional caller framing on
+* top, then the mechanical block listing every capability + its
+* description and the rules for emitting an ordered plan.
+*
+* Runs once at factory time (the capability set is fixed for the
+* planner's lifetime) — the produced string is baked onto the internal
+* planning agent.
+*/
+function buildPlanSystemPrompt(capabilities, maxSteps, prefix) {
+	const capabilityLines = capabilities.map((capability) => `- ${capability.name}: ${capability.description}`);
+	const sections = [];
+	const resolvedPrefix = resolvePrefix(prefix);
+	if (resolvedPrefix && resolvedPrefix.trim().length > 0) sections.push(resolvedPrefix.trim(), "");
+	sections.push("You are a planner. Break the user's goal into an ordered sequence of steps,", "each one dispatching exactly one of the available capabilities below.", "", "Available capabilities:", ...capabilityLines, "", "Rules:", `- Produce at most ${maxSteps} steps.`, "- Each step's `capability` must be exactly one name from the list above.", "- Each step's `input` is the concrete instruction passed to that capability.", "- Order the steps so each builds on the outputs of the ones before it.", "- Never invent a capability name that is not listed.", "- Keep the plan minimal — only the steps actually needed to satisfy the goal.");
+	return sections.join("\n");
+}
+/**
+* Resolve a caller-supplied `systemPrompt` (string or contract) to plain
+* text. Returns `undefined` when none was supplied.
+*/
+function resolvePrefix(prompt) {
+	if (!prompt) return;
+	return typeof prompt === "string" ? prompt : prompt.resolve();
+}
+
+//#endregion
+export { buildPlanSystemPrompt };
+//# sourceMappingURL=plan-prompt.mjs.map

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

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

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

@@ -0,0 +1,27 @@
+import { PlannerPlan } from "../contracts/planner/planner-plan.type.mjs";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+
+//#region ../@warlock.js/ai/src/planner/plan-schema.d.ts
+/**
+ * Build the Standard Schema the planning agent emits — an ordered
+ * `{ steps: [...], summary? }` plan whose every step references one of
+ * `capabilityNames` via the `capability` field.
+ *
+ * Mirrors the router's hand-built schema approach
+ * (`supervisor/router-factory.ts`): the JSON Schema extension carries
+ * the capability names as an `enum` so capable providers enforce the
+ * choice natively, while `validate()` still accepts the shape softly so
+ * providers without native structured output can pass a parsed object
+ * through. Validation is intentionally lenient on `capability` — an
+ * unknown name is surfaced later by the planner as a typed
+ * `PlannerPlanInvalidError`, with the full forensic context, rather
+ * than as an opaque schema issue here.
+ *
+ * `maxSteps`, when provided, is emitted as the `steps` array's
+ * `maxItems` so capable providers refuse to over-produce up front
+ * (the planner still truncates the tail to `skipped` defensively).
+ */
+declare function planSchema(capabilityNames: string[], maxSteps?: number): StandardSchemaV1<PlannerPlan>;
+//#endregion
+export { planSchema };
+//# sourceMappingURL=plan-schema.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"plan-schema.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai/src/planner/plan-schema.ts"],"mappings":";;;;;;AAsBA;;;;;;;;;AAG+B;;;;;;;;iBAHf,UAAA,CACd,eAAA,YACA,QAAA,YACC,gBAAgB,CAAC,WAAA"}

package/esm/planner/plan-schema.mjs

@@ -0,0 +1,117 @@
+//#region ../@warlock.js/ai/src/planner/plan-schema.ts
+/**
+* Build the Standard Schema the planning agent emits — an ordered
+* `{ steps: [...], summary? }` plan whose every step references one of
+* `capabilityNames` via the `capability` field.
+*
+* Mirrors the router's hand-built schema approach
+* (`supervisor/router-factory.ts`): the JSON Schema extension carries
+* the capability names as an `enum` so capable providers enforce the
+* choice natively, while `validate()` still accepts the shape softly so
+* providers without native structured output can pass a parsed object
+* through. Validation is intentionally lenient on `capability` — an
+* unknown name is surfaced later by the planner as a typed
+* `PlannerPlanInvalidError`, with the full forensic context, rather
+* than as an opaque schema issue here.
+*
+* `maxSteps`, when provided, is emitted as the `steps` array's
+* `maxItems` so capable providers refuse to over-produce up front
+* (the planner still truncates the tail to `skipped` defensively).
+*/
+function planSchema(capabilityNames, maxSteps) {
+	const stepsSchema = {
+		type: "array",
+		minItems: 1,
+		description: "Ordered steps to execute, one capability dispatch each.",
+		items: stepItemsSchema(capabilityNames)
+	};
+	if (maxSteps !== void 0) stepsSchema.maxItems = maxSteps;
+	const jsonSchema = {
+		type: "object",
+		properties: {
+			summary: {
+				type: "string",
+				description: "One-line summary of the overall strategy."
+			},
+			steps: stepsSchema
+		},
+		required: ["steps"],
+		additionalProperties: false
+	};
+	return { "~standard": {
+		version: 1,
+		vendor: "warlock-planner",
+		jsonSchema: { input: () => jsonSchema },
+		validate(value) {
+			if (!value || typeof value !== "object") return { issues: [{ message: "plan must be an object" }] };
+			const record = value;
+			if (!Array.isArray(record.steps) || record.steps.length === 0) return { issues: [{ message: "plan `steps` must be a non-empty array" }] };
+			const steps = [];
+			for (const raw of record.steps) {
+				const normalized = normalizeStep(raw);
+				if (!normalized) return { issues: [{ message: "each plan step must carry a string `capability` and `input`" }] };
+				steps.push(normalized);
+			}
+			const summary = typeof record.summary === "string" ? record.summary : void 0;
+			return { value: summary !== void 0 ? {
+				steps,
+				summary
+			} : { steps } };
+		}
+	} };
+}
+/** Per-step JSON Schema object — one capability dispatch. */
+function stepItemsSchema(capabilityNames) {
+	return {
+		type: "object",
+		properties: {
+			id: {
+				type: "string",
+				description: "Stable step id, referenced by dependsOn."
+			},
+			capability: {
+				type: "string",
+				enum: capabilityNames,
+				description: "Name of the capability to dispatch for this step."
+			},
+			input: {
+				type: "string",
+				description: "Concrete input passed to the capability's execute()."
+			},
+			reason: {
+				type: "string",
+				description: "Why this step exists."
+			},
+			dependsOn: {
+				type: "array",
+				items: { type: "string" },
+				description: "Ids of steps this one conceptually follows."
+			}
+		},
+		required: ["capability", "input"],
+		additionalProperties: false
+	};
+}
+/**
+* Coerce one raw step object into a {@link PlannerStep}, returning
+* `undefined` when the mandatory `capability` / `input` strings are
+* missing. Optional fields are copied only when well-typed.
+*/
+function normalizeStep(raw) {
+	if (!raw || typeof raw !== "object") return;
+	const record = raw;
+	if (typeof record.capability !== "string" || record.capability.length === 0) return;
+	if (typeof record.input !== "string") return;
+	const step = {
+		capability: record.capability,
+		input: record.input
+	};
+	if (typeof record.id === "string") step.id = record.id;
+	if (typeof record.reason === "string") step.reason = record.reason;
+	if (Array.isArray(record.dependsOn) && record.dependsOn.every((entry) => typeof entry === "string")) step.dependsOn = record.dependsOn;
+	return step;
+}
+
+//#endregion
+export { planSchema };
+//# sourceMappingURL=plan-schema.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"plan-schema.mjs","names":[],"sources":["../../../../../../../@warlock.js/ai/src/planner/plan-schema.ts"],"sourcesContent":["import type { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport type { PlannerPlan, PlannerStep } from \"../contracts/planner/planner-plan.type\";\n\n/**\n * Build the Standard Schema the planning agent emits — an ordered\n * `{ steps: [...], summary? }` plan whose every step references one of\n * `capabilityNames` via the `capability` field.\n *\n * Mirrors the router's hand-built schema approach\n * (`supervisor/router-factory.ts`): the JSON Schema extension carries\n * the capability names as an `enum` so capable providers enforce the\n * choice natively, while `validate()` still accepts the shape softly so\n * providers without native structured output can pass a parsed object\n * through. Validation is intentionally lenient on `capability` — an\n * unknown name is surfaced later by the planner as a typed\n * `PlannerPlanInvalidError`, with the full forensic context, rather\n * than as an opaque schema issue here.\n *\n * `maxSteps`, when provided, is emitted as the `steps` array's\n * `maxItems` so capable providers refuse to over-produce up front\n * (the planner still truncates the tail to `skipped` defensively).\n */\nexport function planSchema(\n  capabilityNames: string[],\n  maxSteps?: number,\n): StandardSchemaV1<PlannerPlan> {\n  const stepsSchema: Record<string, unknown> = {\n    type: \"array\",\n    minItems: 1,\n    description: \"Ordered steps to execute, one capability dispatch each.\",\n    items: stepItemsSchema(capabilityNames),\n  };\n\n  if (maxSteps !== undefined) {\n    stepsSchema.maxItems = maxSteps;\n  }\n\n  const jsonSchema = {\n    type: \"object\",\n    properties: {\n      summary: {\n        type: \"string\",\n        description: \"One-line summary of the overall strategy.\",\n      },\n      steps: stepsSchema,\n    },\n    required: [\"steps\"],\n    additionalProperties: false,\n  };\n\n  return {\n    \"~standard\": {\n      version: 1,\n      vendor: \"warlock-planner\",\n      jsonSchema: {\n        input: () => jsonSchema,\n      },\n      validate(value: unknown): StandardSchemaV1.Result<PlannerPlan> {\n        if (!value || typeof value !== \"object\") {\n          return { issues: [{ message: \"plan must be an object\" }] };\n        }\n\n        const record = value as { steps?: unknown; summary?: unknown };\n\n        if (!Array.isArray(record.steps) || record.steps.length === 0) {\n          return { issues: [{ message: \"plan `steps` must be a non-empty array\" }] };\n        }\n\n        const steps: PlannerStep[] = [];\n\n        for (const raw of record.steps) {\n          const normalized = normalizeStep(raw);\n\n          if (!normalized) {\n            return {\n              issues: [{ message: \"each plan step must carry a string `capability` and `input`\" }],\n            };\n          }\n\n          steps.push(normalized);\n        }\n\n        const summary = typeof record.summary === \"string\" ? record.summary : undefined;\n\n        return { value: summary !== undefined ? { steps, summary } : { steps } };\n      },\n    } as StandardSchemaV1<PlannerPlan>[\"~standard\"] & {\n      jsonSchema: { input: () => Record<string, unknown> };\n    },\n  };\n}\n\n/** Per-step JSON Schema object — one capability dispatch. */\nfunction stepItemsSchema(capabilityNames: string[]): Record<string, unknown> {\n  return {\n    type: \"object\",\n    properties: {\n      id: { type: \"string\", description: \"Stable step id, referenced by dependsOn.\" },\n      capability: {\n        type: \"string\",\n        enum: capabilityNames,\n        description: \"Name of the capability to dispatch for this step.\",\n      },\n      input: {\n        type: \"string\",\n        description: \"Concrete input passed to the capability's execute().\",\n      },\n      reason: { type: \"string\", description: \"Why this step exists.\" },\n      dependsOn: {\n        type: \"array\",\n        items: { type: \"string\" },\n        description: \"Ids of steps this one conceptually follows.\",\n      },\n    },\n    required: [\"capability\", \"input\"],\n    additionalProperties: false,\n  };\n}\n\n/**\n * Coerce one raw step object into a {@link PlannerStep}, returning\n * `undefined` when the mandatory `capability` / `input` strings are\n * missing. Optional fields are copied only when well-typed.\n */\nfunction normalizeStep(raw: unknown): PlannerStep | undefined {\n  if (!raw || typeof raw !== \"object\") {\n    return undefined;\n  }\n\n  const record = raw as {\n    id?: unknown;\n    capability?: unknown;\n    input?: unknown;\n    reason?: unknown;\n    dependsOn?: unknown;\n  };\n\n  if (typeof record.capability !== \"string\" || record.capability.length === 0) {\n    return undefined;\n  }\n\n  if (typeof record.input !== \"string\") {\n    return undefined;\n  }\n\n  const step: PlannerStep = {\n    capability: record.capability,\n    input: record.input,\n  };\n\n  if (typeof record.id === \"string\") {\n    step.id = record.id;\n  }\n\n  if (typeof record.reason === \"string\") {\n    step.reason = record.reason;\n  }\n\n  if (Array.isArray(record.dependsOn) && record.dependsOn.every((entry) => typeof entry === \"string\")) {\n    step.dependsOn = record.dependsOn as string[];\n  }\n\n  return step;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAsBA,SAAgB,WACd,iBACA,UAC+B;CAC/B,MAAM,cAAuC;EAC3C,MAAM;EACN,UAAU;EACV,aAAa;EACb,OAAO,gBAAgB,eAAe;CACxC;CAEA,IAAI,aAAa,QACf,YAAY,WAAW;CAGzB,MAAM,aAAa;EACjB,MAAM;EACN,YAAY;GACV,SAAS;IACP,MAAM;IACN,aAAa;GACf;GACA,OAAO;EACT;EACA,UAAU,CAAC,OAAO;EAClB,sBAAsB;CACxB;CAEA,OAAO,EACL,aAAa;EACX,SAAS;EACT,QAAQ;EACR,YAAY,EACV,aAAa,WACf;EACA,SAAS,OAAsD;GAC7D,IAAI,CAAC,SAAS,OAAO,UAAU,UAC7B,OAAO,EAAE,QAAQ,CAAC,EAAE,SAAS,yBAAyB,CAAC,EAAE;GAG3D,MAAM,SAAS;GAEf,IAAI,CAAC,MAAM,QAAQ,OAAO,KAAK,KAAK,OAAO,MAAM,WAAW,GAC1D,OAAO,EAAE,QAAQ,CAAC,EAAE,SAAS,yCAAyC,CAAC,EAAE;GAG3E,MAAM,QAAuB,CAAC;GAE9B,KAAK,MAAM,OAAO,OAAO,OAAO;IAC9B,MAAM,aAAa,cAAc,GAAG;IAEpC,IAAI,CAAC,YACH,OAAO,EACL,QAAQ,CAAC,EAAE,SAAS,8DAA8D,CAAC,EACrF;IAGF,MAAM,KAAK,UAAU;GACvB;GAEA,MAAM,UAAU,OAAO,OAAO,YAAY,WAAW,OAAO,UAAU;GAEtE,OAAO,EAAE,OAAO,YAAY,SAAY;IAAE;IAAO;GAAQ,IAAI,EAAE,MAAM,EAAE;EACzE;CACF,EAGF;AACF;;AAGA,SAAS,gBAAgB,iBAAoD;CAC3E,OAAO;EACL,MAAM;EACN,YAAY;GACV,IAAI;IAAE,MAAM;IAAU,aAAa;GAA2C;GAC9E,YAAY;IACV,MAAM;IACN,MAAM;IACN,aAAa;GACf;GACA,OAAO;IACL,MAAM;IACN,aAAa;GACf;GACA,QAAQ;IAAE,MAAM;IAAU,aAAa;GAAwB;GAC/D,WAAW;IACT,MAAM;IACN,OAAO,EAAE,MAAM,SAAS;IACxB,aAAa;GACf;EACF;EACA,UAAU,CAAC,cAAc,OAAO;EAChC,sBAAsB;CACxB;AACF;;;;;;AAOA,SAAS,cAAc,KAAuC;CAC5D,IAAI,CAAC,OAAO,OAAO,QAAQ,UACzB;CAGF,MAAM,SAAS;CAQf,IAAI,OAAO,OAAO,eAAe,YAAY,OAAO,WAAW,WAAW,GACxE;CAGF,IAAI,OAAO,OAAO,UAAU,UAC1B;CAGF,MAAM,OAAoB;EACxB,YAAY,OAAO;EACnB,OAAO,OAAO;CAChB;CAEA,IAAI,OAAO,OAAO,OAAO,UACvB,KAAK,KAAK,OAAO;CAGnB,IAAI,OAAO,OAAO,WAAW,UAC3B,KAAK,SAAS,OAAO;CAGvB,IAAI,MAAM,QAAQ,OAAO,SAAS,KAAK,OAAO,UAAU,OAAO,UAAU,OAAO,UAAU,QAAQ,GAChG,KAAK,YAAY,OAAO;CAG1B,OAAO;AACT"}