@mindot/will 0.7.0 → 0.8.0

package/dist/{will-DAW0l-lY.d.ts → will-cS6k4uiJ.d.ts}

@@ -1586,32 +1586,60 @@ declare class GoalManager implements SimulationEngine, CognitiveEngine {
     private _persistGoals;
 }
 
-/**
- * TokenTracker — monitors LLM token consumption across all engines.
- *
- * Hooks into the LLM calls to record:
- *   - Prompt tokens (input)
- *   - Completion tokens (output)
- *   - Total tokens
- *   - Cost (based on model pricing)
- *   - Per-engine breakdowns
- *   - Per-agent breakdowns
- *
- * Exposes as metrics so the orchestrator and runner can log costs,
- * and the ParameterOptimizer can factor cost into optimization decisions.
- */
-
+/** Top-level cost bucket for an LLM call. */
+type LLMCallCategory = 'executive' | 'summarizer' | 'embedding' | 'identity-guard';
+/** The actor/subsystem doing the work. */
+type LLMCallAttribute = 'master' | 'facet' | 'memory' | 'guard';
+/** The specific cognitive function being paid for. */
+type LLMCallFunction = 'decision' | 'ideation' | 'deliberation' | 'conversation' | 'outreach' | 'planning' | 'supervision' | 'consolidation' | 'recall' | 'index' | 'identity-coherence';
 /** One attributed ledger record (5-axis attribution + tokens + cost). */
 type TokenLedgerRecord = Record<string, unknown>;
 type TokenRecordListener = (record: TokenLedgerRecord) => void;
-/** Resolve the pricing row for any model id (exact, normalized, then default). */
-declare function resolvePricing(model: string): {
+/** USD per 1M tokens for one model. */
+interface ModelPrice {
     input: number;
     output: number;
-};
+}
+/**
+ * Host-supplied prices, keyed by model id. Matching is exact first, then
+ * normalized (provider prefix, date stamp and context qualifier stripped), so
+ * `claude-sonnet-5` matches `claude-sonnet-5-20260114`.
+ *
+ * Prices belong to the host: they change on a vendor's schedule, differ per
+ * account, and are ~0 for a self-hosted model. The engine ships none.
+ */
+type PriceTable = Record<string, ModelPrice>;
+/**
+ * Resolve the price for a model id from the host's table.
+ *
+ * The engine ships no prices at all. A table baked into a release is wrong the
+ * week a vendor changes a rate, differs per account, and is meaningless for a
+ * self-hosted model — and a *partial* table is worse than none, because some
+ * models then report plausible-but-stale numbers while others honestly report
+ * nothing. Prices live with the host, next to the routing policy they inform.
+ *
+ * `null` does NOT mean free — it means *unknown*, and the caller reports zero
+ * cost with `priced: false` so the gap stays visible rather than confidently
+ * wrong. (The removed built-in default priced every unrecognised model at
+ * Sonnet's rate, overstating a budget model's output by ~54×.)
+ */
+declare function resolvePricing(model: string, hostPrices?: PriceTable): ModelPrice | null;
 interface TokenUsage {
     /** Model identifier (e.g., 'openai/gpt-4o') */
     model: string;
+    /**
+     * The provider that actually served this call.
+     *
+     * Not derivable from `model`: routing is what makes the same model id
+     * reachable from several places — `deepseek-v3` direct, through a gateway, or
+     * self-hosted — at prices that differ by orders of magnitude. Without this a
+     * host billing across a multi-vendor routing table can attribute spend to a
+     * model but never to the vendor it actually paid.
+     *
+     * Optional because a caller recording usage directly (outside the LLM
+     * director) may not know it; absent means unattributed, not "the default".
+     */
+    provider?: string;
     /** Input/prompt tokens consumed */
     promptTokens: number;
     /** Output/completion tokens consumed */
@@ -1622,14 +1650,18 @@ interface TokenUsage {
     cacheReadTokens?: number;
     /** Anthropic prompt-cache write tokens (billed at 1.25× input). Optional. */
     cacheWriteTokens?: number;
-    /** Estimated cost in USD */
+    /** Estimated cost in USD. Zero when `priced` is false — unknown, not free. */
     estimatedCostUsd: number;
-    /** Top-level cost bucket: 'executive' | 'summarizer' | 'embedding' | 'identity-guard' | … */
-    category: string;
-    /** Actor/subsystem doing the work: 'master' | 'facet' | 'memory' | 'guard' | … */
-    attribute: string;
-    /** Cognitive function: 'decision' | 'ideation' | 'conversation' | 'planning' | 'deliberation' | 'outreach' | 'consolidation' | 'recall' | 'index' | 'identity-coherence' | … */
-    function: string;
+    /**
+     * Whether a price was found for this model. False ⇒ `estimatedCostUsd` is 0
+     * because nothing priced it, NOT because the call was free. A consumer
+     * summing costs should surface unpriced calls rather than fold them in as
+     * zero.
+     */
+    priced: boolean;
+    category: LLMCallCategory;
+    attribute: LLMCallAttribute;
+    function: LLMCallFunction;
     /** Optional specific id or namespace: facet id, entity id, model name. */
     scope?: string;
     /** Human-readable label — auto-composed from the axes when the caller omits it. */
@@ -1642,10 +1674,16 @@ interface TokenUsage {
     latencyMs: number;
 }
 /** What callers pass to {@link TokenTracker.recordUsage} — cost and label are derived. */
-type RecordUsageInput = Omit<TokenUsage, 'estimatedCostUsd' | 'label'> & {
+type RecordUsageInput = Omit<TokenUsage, 'estimatedCostUsd' | 'label' | 'priced'> & {
     label?: string;
 };
 interface TokenTrackerConfig {
+    /**
+     * Host-supplied model prices (USD per 1M tokens), merged from the per-provider
+     * `prices` maps in `WillLLMConfig.providers`. These win over the built-in
+     * fallback table. Omitted ⇒ fallback only.
+     */
+    prices?: PriceTable;
     /** Whether to emit cost events */
     emitCostEvents?: boolean;
     /** Cost threshold for warning events */
@@ -1664,6 +1702,7 @@ declare class TokenTracker implements SimulationEngine {
     readonly name = "token-tracker";
     private _emitCostEvents;
     private _costWarningThreshold;
+    private _prices;
     private _usageLog;
     private _totalPromptTokens;
     private _totalCompletionTokens;
@@ -1672,6 +1711,8 @@ declare class TokenTracker implements SimulationEngine {
     private _categoryTokens;
     private _functionCosts;
     private _functionTokens;
+    private _providerCosts;
+    private _providerTokens;
     private _tickCosts;
     private _maxTickCostSamples;
     private _lastCostWarningTick;
@@ -1716,6 +1757,21 @@ declare class TokenTracker implements SimulationEngine {
         prompt: number;
         completion: number;
     }>;
+    /**
+     * Cost broken down by provider ('anthropic' | 'glm' | 'moonshot' | …), plus
+     * an `unattributed` bucket for usage recorded without one.
+     *
+     * This is the axis a host reconciles against vendor invoices. Calls whose
+     * model went unpriced contribute 0 here, so compare against
+     * `getUsageLog()`'s `priced` flag before treating a small number as a small
+     * bill.
+     */
+    get providerBreakdown(): ReadonlyMap<string, number>;
+    /** Token counts (prompt + completion) broken down by provider. */
+    get providerTokenBreakdown(): ReadonlyMap<string, {
+        prompt: number;
+        completion: number;
+    }>;
     /** Cost per call average */
     get averageCostPerCall(): number;
     /** Cost per tick average */
@@ -1739,6 +1795,8 @@ declare class TokenTracker implements SimulationEngine {
  *   - Mock embedder for testing/deterministic replay
  */
 
+/** Embedding is only ever a read or a write. */
+type EmbedFunction = Extract<LLMCallFunction, 'recall' | 'index'>;
 interface EmbeddingProvider {
     readonly modelName: string;
     readonly dimensions: number;
@@ -1775,12 +1833,12 @@ declare class OpenAICompatibleEmbedder implements EmbeddingProvider {
         /**
          * Per-Will token tracker. When provided, each embedding call records its
          * input-token usage under the 'embedding' category so memory-vector spend is
-         * visible alongside LLM spend instead of being a silent COGS leak.
+         * visible alongside LLM spend instead of being a silent cost leak.
          */
         tokenTracker?: TokenTracker | null;
     });
-    embed(content: unknown, fn?: string): Promise<number[]>;
-    embedBatch(contents: unknown[], fn?: string): Promise<number[][]>;
+    embed(content: unknown, fn?: EmbedFunction): Promise<number[]>;
+    embedBatch(contents: unknown[], fn?: EmbedFunction): Promise<number[][]>;
     areEquivalent(embedding1: number[], embedding2: number[], tolerance?: number): boolean;
 }
 /**
@@ -1792,8 +1850,8 @@ declare class MockEmbedder implements EmbeddingProvider {
     readonly dimensions = 128;
     private _seed;
     constructor(seed?: number);
-    embed(content: unknown, _fn?: string): Promise<number[]>;
-    embedBatch(contents: unknown[], fn?: string): Promise<number[][]>;
+    embed(content: unknown, _fn?: EmbedFunction): Promise<number[]>;
+    embedBatch(contents: unknown[], fn?: EmbedFunction): Promise<number[][]>;
     areEquivalent(embedding1: number[], embedding2: number[], tolerance?: number): boolean;
     private _hashString;
     private _next;
@@ -2567,7 +2625,150 @@ declare class CompletionInbox {
     clear(): number;
 }
 
-type LLMProvider = 'anthropic' | 'glm' | 'deepseek' | 'openai' | 'google';
+/**
+ * Where a single call should go. Every field except `model` falls back to the
+ * Will's default when omitted.
+ */
+interface ModelRoute {
+    /**
+     * Omit to keep the Will's default provider and change only the model — the
+     * common "same vendor, different model for this kind of work" route, and what
+     * the per-role model map compiles to (a role has never had a provider of its
+     * own). Name a provider to cross vendors; it must appear in `llm.providers`
+     * or the route falls back to the default.
+     */
+    provider?: LLMProvider;
+    model: string;
+    /** Override the provider's API base (self-hosted / OpenAI-compatible servers). */
+    baseUrl?: string;
+    /** Override the output-token ceiling for this call. */
+    maxOutputTokens?: number;
+}
+/**
+ * Chooses a model for a call.
+ *
+ * Returning `null` means "no opinion" — the Will's default model is used. A
+ * router should return `null` rather than guess when it does not recognise a
+ * call: falling back is always safe, and a wrong route is not.
+ */
+interface ModelRouter {
+    /** Stable identifier, recorded alongside routing telemetry. */
+    readonly name: string;
+    route(meta: LLMCallMeta): ModelRoute | null;
+}
+/**
+ * The default. Has no opinion about anything, allocates nothing.
+ *
+ * A Will running this must be byte-identical to one built before the routing
+ * seam existed — that property is asserted by test, and it is what lets this
+ * ship dark.
+ */
+declare const NULL_ROUTER: ModelRouter;
+/** True when the router is the no-op default (used to skip the seam entirely). */
+declare function isNullRouter(router: ModelRouter | null | undefined): boolean;
+/**
+ * One entry in a {@link TableRouter}'s table. All present conditions must match
+ * (logical AND); an absent condition matches anything.
+ */
+interface RoutingRule {
+    /**
+     * Match `LLMCallMeta.category` exactly (e.g. 'executive', 'summarizer').
+     *
+     * The axes are typed rather than free strings so a rule that names a bucket
+     * the engine never emits fails to compile instead of silently never matching
+     * — a routing table's worst failure is the rule that looks right and is dead.
+     */
+    category?: LLMCallMeta['category'];
+    /** Match `LLMCallMeta.attribute` exactly (e.g. 'master', 'facet', 'guard'). */
+    attribute?: LLMCallMeta['attribute'];
+    /** Match `LLMCallMeta.function` exactly (e.g. 'decision', 'consolidation'). */
+    function?: LLMCallMeta['function'];
+    /**
+     * Inclusive lower bound on `LLMCallMeta.demand`. A call with no demand
+     * reported never matches a rule that sets this — absent means unknown, and
+     * unknown must not be treated as zero.
+     */
+    minDemand?: number;
+    /** Exclusive upper bound on `LLMCallMeta.demand`. Same absence rule. */
+    maxDemand?: number;
+    /** Where a matching call goes. */
+    route: ModelRoute;
+}
+/**
+ * A worked example of the seam: first matching rule wins, otherwise no opinion.
+ *
+ * This ships so that the interface has a reference implementation and so that
+ * hosts have something to copy — it is deliberately dumb. It is not a routing
+ * strategy, and the engine ships no table of its own: what belongs where is the
+ * host's decision, expressed as configuration.
+ *
+ * Rules are evaluated in order, so put specific rules before general ones.
+ */
+declare class TableRouter implements ModelRouter {
+    readonly name: string;
+    private readonly _rules;
+    constructor(rules: readonly RoutingRule[], name?: string);
+    route(meta: LLMCallMeta): ModelRoute | null;
+}
+/**
+ * Ask each router in turn; the first with an opinion wins.
+ *
+ * This exists because a Will can have two sources of routing at once: the
+ * host's own router, and the one compiled from its per-role model map. Order
+ * expresses precedence — an explicit router is consulted before the role map,
+ * which is the precedence those two mechanisms already had when roles were
+ * served by separate directors.
+ *
+ * A throwing link is skipped, not propagated. The links are independent
+ * decisions, and one broken router must not take a working one down with it —
+ * that would silently demote every role-mapped call to the default model.
+ */
+declare function chainRouters(...routers: (ModelRouter | null | undefined)[]): ModelRouter;
+
+/**
+ * The request/response dialect an endpoint speaks. This — not the provider's
+ * name — is what the transport actually branches on.
+ */
+type LLMWire = 'anthropic' | 'openai' | 'google';
+/** Providers with built-in defaults. Any other string is equally valid. */
+type KnownProvider = 'anthropic' | 'glm' | 'openai' | 'google' | 'deepseek' | 'moonshot' | 'qwen' | 'xai' | 'minimax' | 'mistral' | 'ollama' | 'vllm';
+/**
+ * A provider name. Deliberately open: the field of providers changes monthly,
+ * and a closed union meant a host reaching Kimi or Qwen had to masquerade as
+ * `openai`, which then lied on the completion tape and in cost attribution.
+ *
+ * `(string & {})` keeps editor autocomplete for the known names while accepting
+ * anything. A provider outside {@link KNOWN_PROVIDERS} simply has to declare its
+ * `wire` and `baseUrl` — see `WillLLMConfig.providers`.
+ */
+type LLMProvider = KnownProvider | (string & {});
+/**
+ * Built-in wire + base URL per provider. This is *data*, not support: it saves
+ * a host from looking up an endpoint, and nothing more. Any provider absent
+ * from this table works identically once the host declares `wire` + `baseUrl`
+ * on its `llm.providers` entry.
+ *
+ * WHY THIS TABLE SURVIVES WHEN THE PRICE TABLE DID NOT. A stale price is
+ * invisible: it produces a confident wrong number nobody doubts. A stale base
+ * URL fails on the first call, loudly, with the endpoint in the message. They
+ * also move on completely different clocks — vendors reprice quarterly, and
+ * change an API host about once a decade. Convenience is worth it when being
+ * wrong is self-announcing.
+ *
+ * REGIONAL ENDPOINTS. `moonshot`, `qwen` and `minimax` all run separate
+ * mainland-China hosts (`api.moonshot.cn`, `dashscope.aliyuncs.com`,
+ * `api.minimaxi.com`). The international host is the default here; a key issued
+ * on the other one authenticates nowhere, so a host on a China account must set
+ * `baseUrl` explicitly.
+ */
+declare const KNOWN_PROVIDERS: Record<string, {
+    wire: LLMWire;
+    baseUrl: string;
+}>;
+/** Built-in wire for a known provider, or undefined — the host must declare it. */
+declare function knownWireFor(provider: LLMProvider): LLMWire | undefined;
+/** Built-in base URL for a known provider, or undefined — the host must declare it. */
+declare function defaultBaseFor(provider: LLMProvider): string | undefined;
 interface LLMDirectorConfig {
     willId: string;
     model: string;
@@ -2597,6 +2798,38 @@ interface LLMDirectorConfig {
      * replay runs). This replaces the former process-global getTokenTracker().
      */
     tokenTracker?: TokenTracker | null;
+    /**
+     * MODEL_ROUTING W3 — per-call model selection. Absent (or NULL_ROUTER) means
+     * every call uses the default model below, exactly as before the seam existed.
+     * A router that throws, or names a provider with no usable credential, falls
+     * back to the default: a routing problem must never kill a running mind.
+     */
+    router?: ModelRouter | null;
+    /**
+     * Per-provider credentials for routed calls. The top-level `apiKey`/`baseUrl`
+     * remain the default entry; a route to a provider absent from this map falls
+     * back to the default endpoint.
+     */
+    credentials?: Partial<Record<string, ProviderCredential>>;
+    /**
+     * Dialect for the default provider. Required when the provider is not one of
+     * {@link KNOWN_PROVIDERS} — the engine will not guess how to talk to an
+     * endpoint it has never heard of.
+     */
+    wire?: LLMWire;
+}
+/**
+ * Everything a single call needs to reach a model. Resolved once per call and
+ * threaded through the provider methods — never stored on the instance, because
+ * the concurrency gate lets several calls be in flight on one director at once
+ * and per-call state on `this` would race between them.
+ */
+/** What a host supplies so a routed provider can be reached. */
+interface ProviderCredential {
+    apiKey: string;
+    baseUrl?: string;
+    /** Required for providers outside {@link KNOWN_PROVIDERS}. */
+    wire?: LLMWire;
 }
 interface LLMCallResult {
     text: string;
@@ -2614,17 +2847,44 @@ interface LLMCallResult {
  * here, letting the TokenTracker break spend down per category for transparency.
  */
 interface LLMCallMeta {
-    /** Top-level cost bucket: 'executive' | 'summarizer' | 'embedding' | 'identity-guard' | … */
-    category: string;
-    /** The actor/subsystem doing the work: 'master' | 'facet' | 'memory' | 'guard' | … */
-    attribute: string;
-    /** The specific cognitive function: 'decision' | 'ideation' | 'conversation' | 'planning' | 'deliberation' | 'outreach' | 'consolidation' | 'recall' | 'index' | 'identity-coherence' | … */
-    function: string;
+    /** Top-level cost bucket. */
+    category: LLMCallCategory;
+    /** The actor/subsystem doing the work. */
+    attribute: LLMCallAttribute;
+    /** The specific cognitive function. */
+    function: LLMCallFunction;
     /** Optional specific id or namespace: facet id, entity id, model name. */
     scope?: string;
     /** Free-form human-readable label. Auto-composed from the axes when omitted. */
     label?: string;
+    /**
+     * How much this call demands, 0..1 — MODEL_ROUTING W0.
+     *
+     * A *cognitive* measure, never a commercial one: it says how consequential or
+     * uncertain this moment is, never who is paying for it. Two faculties already
+     * compute it and simply forward what they have — the master and its facets
+     * pass `effortScore` (the a-priori effort gate: uncertainty, prior
+     * confidence, novelty, a pending reply, stress load), and deliberation passes
+     * the agency stakes of the choice under consideration. Structurally
+     * background work (summarising, guarding, embedding, delivery) reports a low
+     * constant, because it is background whether the mind is calm or in crisis.
+     *
+     * Absent means UNKNOWN, not zero: a consumer must fall back to its default
+     * rather than treat a missing value as "cheapest possible".
+     *
+     * This field is inert with respect to cognition. It rides along to whoever
+     * resolves the model for a call; no engine may read it back and behave
+     * differently, or the routing layer becomes a hidden input to the mind.
+     */
+    demand?: number;
 }
+/** Structurally background work — see `LLMCallMeta.demand`. */
+declare const BACKGROUND_DEMAND = 0.1;
+/**
+ * Escalation is elevated by construction: the buffer only fires once something
+ * has already failed to resolve on its own.
+ */
+declare const ESCALATION_DEMAND = 0.7;
 declare class LLMDirector {
     private _willId;
     private _model;
@@ -2636,7 +2896,20 @@ declare class LLMDirector {
     private _baseUrl;
     private _timeoutMs;
     private _tokenTracker;
+    private _router;
+    private _credentials;
+    /** Default endpoint — what every call used before the routing seam existed. */
+    private _defaultEndpoint;
+    /** Routes already warned about (missing credential / bad provider) — log once. */
+    private _routeWarned;
     constructor(config: LLMDirectorConfig);
+    /**
+     * Resolve which model serves this call. Falls back to the default endpoint
+     * whenever the router has no opinion, throws, or names a provider we hold no
+     * credential for — degrade, never crash.
+     */
+    private _resolveEndpoint;
+    private _warnRouteOnce;
     /**
      * Returns a structurally valid executive output with zero API cost.
      * Used when `mock: true` — e.g. for `bw_test_` key holders and the Playground.
@@ -2705,8 +2978,6 @@ declare class LLMDirector {
     /** Cost-attribution tag for this call. Defaults to the master executive. */
     meta?: LLMCallMeta): Promise<LLMCallResult>;
     private _callProvider;
-    /** Default API base URL (including version segment) for a provider. */
-    private _baseFor;
     /** Resolved API base: explicit override wins, else the provider default. */
     private _resolvedBase;
     /**
@@ -2996,7 +3267,7 @@ interface FocusSection {
      * into the facet's LLM calls as `LLMCallMeta.function` so the TokenTracker can
      * break spend down per facet type. Defaults to 'facet' when unset.
      */
-    function?: string;
+    function?: LLMCallFunction;
     /**
      * Optional: Custom output format to append instead of the standard executive format.
      * Pass via PromptBuildOptions.outputFormat when building the user message.
@@ -3115,13 +3386,14 @@ declare class ExecutiveEngine extends AsyncEngine implements CognitiveEngine {
     private _lastExecutiveOutput;
     private _lastExecutiveTick;
     private _willId;
-    /** Per-Will, per-role model ids (config.model, resolved in mind.ts). */
-    private _models;
+    /**
+     * The Will's default model (config.model's `executive` role, resolved in
+     * mind.ts). Every other role reaches its model through the router — see
+     * `compileRoleRouter`.
+     */
+    private _modelId;
     /** Per-Will LLM transport overrides (config.llm) — env fallbacks apply per field. */
     private _llm;
-    /** One director per distinct model — same config, different model. Shared
-     *  tracker/recorder/willId, so ledger attribution and replay hold per role. */
-    private _directorCache;
     private _workingMemory;
     private _goalManager;
     private _episodicConsolidator;
@@ -3164,19 +3436,15 @@ declare class ExecutiveEngine extends AsyncEngine implements CognitiveEngine {
      */
     attachCompletionInbox(inbox: CompletionInbox): void;
     set willId(willId: string);
-    /** Per-Will role models (config.model, resolved). Set before the first tick. */
-    set models(m: {
-        executive: string | null;
-        summarizer: string | null;
-        deliberation: string | null;
-        conversation: string | null;
-    });
-    get models(): {
-        executive: string | null;
-        summarizer: string | null;
-        deliberation: string | null;
-        conversation: string | null;
-    };
+    /**
+     * The Will's default model. Set before the first tick.
+     *
+     * This replaced a four-role map (W7): the other roles are routing rules now,
+     * compiled in mind.ts, so the engine holds one model and one router rather
+     * than a model per role plus a router.
+     */
+    set modelId(id: string | null);
+    get modelId(): string | null;
     /** Per-Will LLM transport overrides (config.llm). Set before the first tick. */
     set llm(c: {
         provider?: string;
@@ -3184,9 +3452,10 @@ declare class ExecutiveEngine extends AsyncEngine implements CognitiveEngine {
         baseUrl?: string;
         maxOutputTokens?: number;
         timeoutMs?: number;
+        credentials?: Partial<Record<string, ProviderCredential>>;
+        router?: ModelRouter | null;
+        wire?: LLMWire;
     } | null);
-    /** The executive-role model id (back-compat read). */
-    get modelId(): string | null;
     get latestOutput(): ExecutiveOutputFull | null;
     isFresh(currentTick: Tick): boolean;
     /**
@@ -3202,7 +3471,40 @@ declare class ExecutiveEngine extends AsyncEngine implements CognitiveEngine {
      * and subscribe() to receive facet decisions.
      */
     /** Get-or-create the director for a model id (shared config, per-Will). */
-    private _directorFor;
+    /**
+     * The provider, from config or environment — never guessed.
+     *
+     * This used to default to 'anthropic', which is how a Will configured for one
+     * vendor could quietly talk to another. An unset provider is a configuration
+     * error, and saying so at construction is far cheaper than a 401 mid-tick.
+     */
+    private _requireProvider;
+    /**
+     * True when this Will cannot make a live call, so provider/model are not
+     * required: mock mode, or a replay re-feeding recorded completions.
+     */
+    private _noLiveCalls;
+    /**
+     * Build this Will's one and only director.
+     *
+     * There used to be a cache of them, keyed by model, because the per-role
+     * model map had no other way to make a role use a different model. Routing
+     * gave it one — the role map now compiles to rules (see `compileRoleRouter`)
+     * and a single director resolves every call's endpoint per call. That is also
+     * strictly more faithful: a facet follows the work it is doing rather than
+     * whatever role it happened to be spawned under.
+     */
+    private _buildDirector;
+    /**
+     * Spawn a facet.
+     *
+     * `role` declares the facet's intent at the call site. It no longer selects a
+     * model: that used to happen here, pinning a facet for life to whatever role
+     * it was spawned under, and it now happens per call from the focus function
+     * the caller sets immediately afterwards (W7). The two always agreed — every
+     * spawn site sets a focus whose `function` matches its role — so the routed
+     * answer is the same one, decided later and from the work itself.
+     */
     spawnFacet(role?: 'deliberation' | 'conversation' | 'outreach' | 'supervision'): {
         attention: 'available' | 'full';
         handle?: ExecutiveFacetHandle;
@@ -6012,6 +6314,30 @@ interface LearnedSkill {
     lastEnactedTick: number;
 }
 
+/**
+ * WHY this denial is final — the distinction that makes a refusal learnable
+ * rather than a wall to re-probe forever. Each value selects a different
+ * cognitive fate; they are not degrees of one severity.
+ *
+ *   • 'class'     — the ACTION ITSELF is never permitted. Suppress the
+ *                   affordance hard, erase any learned envelope, and let go of
+ *                   a commitment currently deliberating toward it.
+ *   • 'parameter' — the action is fine; THESE ARGUMENTS were not (bound
+ *                   exceeded, wrong target). Narrow the envelope the Will
+ *                   reaches for; the ability stays.
+ *   • 'context'   — the refusal was NOT ABOUT THE ACTION at all (tainted
+ *                   context, unavailable dependency). Touch nothing: no
+ *                   availability delta, no envelope, no competence.
+ *
+ * POLICY_REAFFERENCE P5 widened this from 'class' | 'instance' after the HELM
+ * joint RFC ("Denials That Teach") identified that an instance-scoped refusal
+ * splits in two, and that the two halves demand opposite responses. These are
+ * OUR names for the distinctions, deliberately not HELM's wire spellings — see
+ * the naming-boundary note in .TODO/POLICY_REAFFERENCE.md. A provider adapter
+ * translates; this interface stays vendor-neutral.
+ */
+type DenialFinality = 'class' | 'parameter' | 'context';
+
 interface OutcomeObservation {
     schema: string;
     success: boolean;
@@ -6055,11 +6381,17 @@ declare class SchemaRepertoire {
     availabilityOf(schema: string): number;
     /**
      * Fold a policy refusal into the availability layer (NOT competence). A
-     * `class` refusal cuts availability hard; an `instance` refusal dents it
+     * `class` refusal cuts availability hard; a `parameter` refusal dents it
      * lightly. Multiplicative so repeated refusals compound toward — but never
      * reach — zero, keeping re-probe alive.
+     *
+     * `context` is EXCLUDED FROM THE SIGNATURE, not handled inside: a refusal
+     * that was not about the action must never reach the availability layer at
+     * all, and making that a type error rather than a convention means a future
+     * caller cannot quietly re-introduce the dent. The routing decision lives in
+     * the ReafferenceEngine's refused branch (P5).
      */
-    recordRefusal(schema: string, finality: 'class' | 'instance', tick: number): number;
+    recordRefusal(schema: string, finality: Exclude<DenialFinality, 'context'>, tick: number): number;
     /**
      * Fold one outcome into the schema's learned skill. Returns the updated skill
      * and whether it just crossed the proceduralization threshold this update.
@@ -6645,12 +6977,53 @@ interface WillModelConfig {
  * `apiKey` is held in memory only — it is never mirrored into state entities,
  * session logs, or the PMA.
  */
+interface WillProviderConfig {
+    /** Credential for this provider. Held in memory only — never state/logs/PMA. */
+    apiKey?: string;
+    /** Base URL override — self-hosted or OpenAI-compatible endpoints. */
+    baseUrl?: string;
+    /**
+     * USD per 1M tokens, keyed by model id. Host-owned on purpose: prices change
+     * on a vendor's schedule, differ per account, and are ~0 self-hosted, so they
+     * cannot be tracked from inside an npm release. These win over the engine's
+     * built-in fallback table.
+     *
+     * Cost is telemetry only — it never enters simulation state — so changing a
+     * price can never change what a mind does or break a replay.
+     */
+    prices?: PriceTable;
+}
 interface WillLLMConfig {
     provider?: LLMProvider;
     apiKey?: string;
     baseUrl?: string;
     maxOutputTokens?: number;
     timeoutMs?: number;
+    /**
+     * Everything the host knows about each provider — credential, endpoint, and
+     * prices — declared once per provider. The single-provider fields above stay
+     * the simple path; this map is for hosts reaching more than one.
+     */
+    providers?: Partial<Record<LLMProvider, WillProviderConfig>>;
+    /**
+     * Per-call model selection. Omitted (or NULL_ROUTER) means every call uses
+     * `model` above, exactly as before the seam existed.
+     *
+     * The router sees only the call's attribution — what kind of work it is and
+     * how much the moment demands — never who is paying or what anything costs.
+     * Routes name providers from the `providers` map above; a route to a provider
+     * with no credential falls back to the default rather than failing the call.
+     */
+    router?: ModelRouter | null;
+    /**
+     * Concrete LLM model id(s) for this Will — a single id for every role, or a
+     * per-role map. An explicit WILL_LLM_MODEL env pins the thinking roles
+     * (operator single-model deployments); unset roles fall back to `executive`,
+     * then the LLMDirector's built-in default. Product-level labels (pricing
+     * tiers, model families) live host-side and resolve to concrete ids BEFORE
+     * reaching the engine.
+     */
+    model?: string | WillModelConfig;
 }
 interface WillIdentity {
     /**
@@ -6693,15 +7066,6 @@ interface WillConfig {
     identity: WillIdentity;
     /** Anatomy — 'mind' (default) or the no-LLM 'reflex' shell. */
     anatomy?: Anatomy;
-    /**
-     * Concrete LLM model id(s) for this Will — a single id for every role, or a
-     * per-role map. An explicit WILL_LLM_MODEL env pins the thinking roles
-     * (operator single-model deployments); unset roles fall back to `executive`,
-     * then the LLMDirector's built-in default. Product-level labels (pricing
-     * tiers, model families) live host-side and resolve to concrete ids BEFORE
-     * reaching the engine.
-     */
-    model?: string | WillModelConfig;
     /**
      * Per-Will LLM transport overrides (provider, BYO apiKey, baseUrl, output
      * cap, timeout). Unset fields fall back to WILL_LLM_* envs. The apiKey never
@@ -7465,7 +7829,7 @@ interface WillSummary {
     createdAt: Date;
     lastTickAt: Date | null;
     anatomy: WillConfig['anatomy'];
-    model: WillConfig['model'];
+    model: NonNullable<WillConfig['llm']>['model'];
 }
 
 interface WillInstance {
@@ -7941,20 +8305,42 @@ interface CreateWillOptions {
     anatomy?: Anatomy;
     /** Concrete LLM model id, or a per-role map ({ executive, summarizer?,
      *  deliberation?, embedding? } — unset thinking roles fall back to executive).
-     *  Unset → env / provider default. */
+     *  Unset → env / provider default.
+     *  @deprecated Pass `llmConfig: { model }` instead — model and transport are
+     *  one concern. Still honoured; an explicit `llmConfig.model` wins. */
     model?: string | WillModelConfig;
-    /** Per-Will LLM transport overrides (provider, BYO apiKey, baseUrl, caps).
+    /** Per-Will LLM config: provider, model(s), BYO apiKey, baseUrl, caps.
      *  Unset fields fall back to WILL_LLM_* envs. apiKey stays in memory only.
-     *  (Named llmConfig because `llm` is the mock/anthropic MODE switch.) */
+     *  (Named llmConfig because `llm` is the provider MODE switch.) */
     llmConfig?: WillLLMConfig;
     /**
-    * LLM mode. 'mock' (default when no key is present) runs a deterministic
-    * canned executive — zero keys, zero cost. 'anthropic' calls Claude (needs
-    * ANTHROPIC_API_KEY / WILL_LLM_* env); 'glm' calls Z.ai's GLM over its
-    * Anthropic-compatible endpoint (needs ZAI_API_KEY / WILL_LLM_*). Omit to
-    * auto-detect from whichever key is set.
+    * LLM mode — which provider the executive speaks to.
+    *
+    * 'mock' (the default when no key is present) runs a deterministic canned
+    * executive: zero keys, zero cost. Every other value names a provider and
+    * needs its key, either the provider's own env below or the
+    * provider-agnostic WILL_LLM_API_KEY:
+    *
+    *   anthropic  ANTHROPIC_API_KEY   Claude, native Messages wire
+    *   glm        ZAI_API_KEY         Z.ai GLM, Anthropic-compatible wire
+    *   openai     OPENAI_API_KEY      OpenAI wire
+    *   google     GOOGLE_API_KEY | GEMINI_API_KEY   native Gemini wire
+    *   deepseek   DEEPSEEK_API_KEY    OpenAI wire
+    *   moonshot   MOONSHOT_API_KEY    Kimi — OpenAI wire
+    *   qwen       DASHSCOPE_API_KEY   Alibaba Model Studio — OpenAI wire
+    *   xai        XAI_API_KEY         Grok — OpenAI wire
+    *   minimax    MINIMAX_API_KEY     OpenAI wire
+    *   mistral    MISTRAL_API_KEY     OpenAI wire
+    *   ollama · vllm                  local; no key, set `llm` explicitly
+    *
+    * Any other string works too — it just has to declare its `wire` and
+    * `baseUrl` on `llmConfig.providers`. Naming the vendor rather than
+    * borrowing `openai` because it speaks that wire is what keeps the
+    * completion tape and the cost breakdown honest.
+    *
+    * Omit to auto-detect from whichever key is set.
     */
-    llm?: 'mock' | 'anthropic' | 'glm';
+    llm?: 'mock' | LLMProvider;
     /**
      * Abilities the Will can choose to enact. `name → handler`, or
      * `name → { handler, description?, cost?, valence?, preconditions? }` to seed
@@ -8077,4 +8463,4 @@ declare class Will {
     private _emitError;
 }
 
-export { ConfidenceCalibrator as $, type AckResult as A, type AsyncEngineConfig as B, type ConflictReport as C, AttachmentEvaluator as D, type EffectorHandler as E, type AttachmentEvaluatorConfig as F, AttentionAllocator as G, type AttentionAllocatorConfig as H, type InboundEnvelope as I, AuditionEngine as J, AutobiographicalNarrator as K, type AutobiographicalNarratorConfig as L, type BehavioralProbeResult as M, BiasDetector as N, type OutboundEnvelope as O, type BiasDetectorConfig as P, BunStorageAdapter as Q, type RestoreOptions as R, type SimulationContext as S, type TransportStatus as T, type ChunkEnvelope as U, type CircadianConfig as V, Will as W, CircadianOscillator as X, type ClockConfig as Y, type Cognition as Z, type CognitiveHealth as _, type ExternalTransport as a, type LossEvaluatorConfig as a$, type ConfidenceCalibratorConfig as a0, type Coordinates as a1, type CreateWillOptions as a2, DefaultEventBus as a3, DefaultMetricCollector as a4, DefaultOrchestrator as a5, DefaultReplayRecorder as a6, DefaultReplaySession as a7, DefaultScenario as a8, DefaultSerializer as a9, type EventFilter as aA, type EventHandler as aB, type EventPayload as aC, ExecutiveEngine as aD, type ExecutiveEngineConfig$1 as aE, Exteroception as aF, type ExteroceptionConfig as aG, ForgettingCurve as aH, type ForgettingCurveConfig as aI, FrustrationEvaluator as aJ, type FrustrationEvaluatorConfig as aK, GoalManager as aL, type GoalManagerConfig as aM, GustationEngine as aN, type InboundMessageEnvelope as aO, type InboundPerceptEnvelope as aP, InhibitionController as aQ, type InhibitionControllerConfig as aR, Interoception as aS, type InteroceptionConfig as aT, IntrospectionEngine as aU, type IntrospectionEngineConfig as aV, KnownEntityTracker as aW, type KnownEntityTrackerConfig as aX, type LLMCompletionRecord as aY, type LLMCompletionSink as aZ, LossEvaluator as a_, DefaultSimulation as aa, DefaultSimulationClock as ab, DefaultStateManager as ac, DefaultVectorMemoryAdapter as ad, DeliberationEngine as ae, DeltaEncoder as af, type DeltaSnapshot as ag, DreamSimulator as ah, type DreamSimulatorConfig as ai, type Duration as aj, type EffectorDeclaration as ak, type EffectorEntry as al, type EffectorResult as am, type EffectorSpec as an, type EmbeddingProvider as ao, EmpathySimulator as ap, type EmpathySimulatorConfig as aq, EnergyRegulator as ar, type EnergyRegulatorConfig as as, type EngineRegistry as at, type EngineResult as au, type Envelope as av, EpisodicConsolidator as aw, type EpisodicConsolidatorConfig as ax, type EventBus as ay, type EventBusConfig as az, type SeededPRNG as b, type SimulationEngine as b$, type MessageEnvelope as b0, type MetricCollector as b1, type MetricPoint as b2, type MinimalContext as b3, MockEmbedder as b4, MoralEvaluator as b5, type MoralEvaluatorConfig as b6, MotorSchemaExecutor as b7, NoveltyDetector as b8, type NoveltyDetectorConfig as b9, type ReplayMetadata as bA, type ReplayRecord as bB, type ReplayRecorder as bC, type ReplaySession as bD, type ReplyEnvelope as bE, ReputationTracker as bF, type ReputationTrackerConfig as bG, RewardEvaluator as bH, type RewardEvaluatorConfig as bI, type Scenario as bJ, type ScenarioConfig as bK, type ScenarioValidationResult as bL, type SchemaPrecondition as bM, SelfModelUpdater as bN, type SelfModelUpdaterConfig as bO, SemanticIntegrator as bP, type SemanticIntegratorConfig as bQ, type SensoryInput as bR, type SerializationConfig as bS, type SerializationFormat as bT, type SerializedEntity as bU, type SerializedState as bV, type Serializer as bW, type SessionLogEnvelope as bX, type Simulation as bY, type SimulationClock as bZ, type SimulationConfig as b_, OlfactionEngine as ba, OpenAICompatibleEmbedder as bb, type Orchestrator as bc, type OrchestratorConfig as bd, type OutboxMessage as be, type PMABehavioral as bf, type PMABelief as bg, type PMAEmotionalBaseline as bh, PMAEvalHarness as bi, type PMAGoal as bj, type PMAIdentity as bk, type PMAProbe as bl, type PMASnapshot as bm, type PerceptEnvelope as bn, PersonaConsolidator as bo, type PersonaConsolidatorConfig as bp, PlanningEngine as bq, type PlanningEngineConfig as br, ReafferenceEngine as bs, type ReconstructionFidelityReport as bt, type ReconstructionFidelityScores as bu, type RecordUsageInput as bv, type ReplayComparison as bw, type ReplayConfig as bx, type ReplayDifference as by, ReplayManager as bz, type SimulationEntity as c, type SimulationEventBase as c0, type SimulationEventListener as c1, type SleepPressureConfig as c2, SleepPressureRegulator as c3, SocialPerception as c4, type SocialPerceptionConfig as c5, SomatosensationEngine as c6, SpacedRepetition as c7, type SpacedRepetitionConfig as c8, type StateSnapshot as c9, type WillConfig as cA, type WillEffectorAct as cB, type WillInstance as cC, type WillMessage as cD, type WillStateSummary as cE, type WillStatus as cF, WillStem as cG, type WillSummary as cH, WorkingMemory as cI, type WorkingMemoryConfig as cJ, type WorldEntity as cK, type WorldInterface as cL, assembleMind as cM, clearCompletionRecorder as cN, type effectorInvocation as cO, type effectorInvocationEnvelope as cP, getCompletionRecorder as cQ, resolvePricing as cR, setCompletionRecorder as cS, type Stimulus as ca, type StorageAdapter as cb, StressRegulator as cc, type StressRegulatorConfig as cd, TaskSwitcher as ce, type TaskSwitcherConfig as cf, type TextMessage as cg, TheoryOfMind as ch, type TheoryOfMindConfig as ci, ThreatEvaluator as cj, type ThreatEvaluatorConfig as ck, type TickListener as cl, type TokenLedgerRecord as cm, type TokenReportEnvelope as cn, TokenTracker as co, type TokenTrackerConfig as cp, type TokenUsage as cq, type VectorIndex as cr, type VectorMemoryAdapter as cs, type VectorMemoryConfig as ct, type VectorQueryFilter as cu, type VectorQueryResult as cv, type VectorRecord as cw, VisionEngine as cx, type VoiceChunk as cy, type WillAffect as cz, type Timestamp as d, type SimulationEvent as e, type StateManager as f, type Tick as g, type SimulationState as h, type StateCommands as i, type ReasoningFootprint as j, type ReadonlySimulationState as k, type ConflictStrategy as l, type ConflictResolution as m, type AckEnvelope as n, type ActionRequest as o, type ActionResult as p, ActionSelector as q, type ActivityEnvelope as r, type ActivityEvent as s, type ActivityEventHandler as t, AestheticEvaluator as u, type AestheticEvaluatorConfig as v, AffectiveBlender as w, type AffectiveBlenderConfig as x, AffordanceSynthesizer as y, AsyncEngine as z };
+export { type CognitiveHealth as $, type AckResult as A, type AsyncEngineConfig as B, type ConflictReport as C, AttachmentEvaluator as D, type EffectorHandler as E, type AttachmentEvaluatorConfig as F, AttentionAllocator as G, type AttentionAllocatorConfig as H, type InboundEnvelope as I, AuditionEngine as J, AutobiographicalNarrator as K, type AutobiographicalNarratorConfig as L, BACKGROUND_DEMAND as M, type BehavioralProbeResult as N, type OutboundEnvelope as O, BiasDetector as P, type BiasDetectorConfig as Q, type RestoreOptions as R, type SimulationContext as S, type TransportStatus as T, BunStorageAdapter as U, type ChunkEnvelope as V, Will as W, type CircadianConfig as X, CircadianOscillator as Y, type ClockConfig as Z, type Cognition as _, type ExternalTransport as a, type KnownProvider as a$, ConfidenceCalibrator as a0, type ConfidenceCalibratorConfig as a1, type Coordinates as a2, type CreateWillOptions as a3, DefaultEventBus as a4, DefaultMetricCollector as a5, DefaultOrchestrator as a6, DefaultReplayRecorder as a7, DefaultReplaySession as a8, DefaultScenario as a9, type EventBus as aA, type EventBusConfig as aB, type EventFilter as aC, type EventHandler as aD, type EventPayload as aE, ExecutiveEngine as aF, type ExecutiveEngineConfig$1 as aG, Exteroception as aH, type ExteroceptionConfig as aI, ForgettingCurve as aJ, type ForgettingCurveConfig as aK, FrustrationEvaluator as aL, type FrustrationEvaluatorConfig as aM, GoalManager as aN, type GoalManagerConfig as aO, GustationEngine as aP, type InboundMessageEnvelope as aQ, type InboundPerceptEnvelope as aR, InhibitionController as aS, type InhibitionControllerConfig as aT, Interoception as aU, type InteroceptionConfig as aV, IntrospectionEngine as aW, type IntrospectionEngineConfig as aX, KNOWN_PROVIDERS as aY, KnownEntityTracker as aZ, type KnownEntityTrackerConfig as a_, DefaultSerializer as aa, DefaultSimulation as ab, DefaultSimulationClock as ac, DefaultStateManager as ad, DefaultVectorMemoryAdapter as ae, DeliberationEngine as af, DeltaEncoder as ag, type DeltaSnapshot as ah, DreamSimulator as ai, type DreamSimulatorConfig as aj, type Duration as ak, ESCALATION_DEMAND as al, type EffectorDeclaration as am, type EffectorEntry as an, type EffectorResult as ao, type EffectorSpec as ap, type EmbeddingProvider as aq, EmpathySimulator as ar, type EmpathySimulatorConfig as as, EnergyRegulator as at, type EnergyRegulatorConfig as au, type EngineRegistry as av, type EngineResult as aw, type Envelope as ax, EpisodicConsolidator as ay, type EpisodicConsolidatorConfig as az, type SeededPRNG as b, SelfModelUpdater as b$, type LLMCallMeta as b0, type LLMCompletionRecord as b1, type LLMCompletionSink as b2, type LLMProvider as b3, type LLMWire as b4, LossEvaluator as b5, type LossEvaluatorConfig as b6, type MessageEnvelope as b7, type MetricCollector as b8, type MetricPoint as b9, type PersonaConsolidatorConfig as bA, PlanningEngine as bB, type PlanningEngineConfig as bC, type PriceTable as bD, type ProviderCredential as bE, ReafferenceEngine as bF, type ReconstructionFidelityReport as bG, type ReconstructionFidelityScores as bH, type RecordUsageInput as bI, type ReplayComparison as bJ, type ReplayConfig as bK, type ReplayDifference as bL, ReplayManager as bM, type ReplayMetadata as bN, type ReplayRecord as bO, type ReplayRecorder as bP, type ReplaySession as bQ, type ReplyEnvelope as bR, ReputationTracker as bS, type ReputationTrackerConfig as bT, RewardEvaluator as bU, type RewardEvaluatorConfig as bV, type RoutingRule as bW, type Scenario as bX, type ScenarioConfig as bY, type ScenarioValidationResult as bZ, type SchemaPrecondition as b_, type MinimalContext as ba, MockEmbedder as bb, type ModelPrice as bc, type ModelRoute as bd, type ModelRouter as be, MoralEvaluator as bf, type MoralEvaluatorConfig as bg, MotorSchemaExecutor as bh, NULL_ROUTER as bi, NoveltyDetector as bj, type NoveltyDetectorConfig as bk, OlfactionEngine as bl, OpenAICompatibleEmbedder as bm, type Orchestrator as bn, type OrchestratorConfig as bo, type OutboxMessage as bp, type PMABehavioral as bq, type PMABelief as br, type PMAEmotionalBaseline as bs, PMAEvalHarness as bt, type PMAGoal as bu, type PMAIdentity as bv, type PMAProbe as bw, type PMASnapshot as bx, type PerceptEnvelope as by, PersonaConsolidator as bz, type SimulationEntity as c, assembleMind as c$, type SelfModelUpdaterConfig as c0, SemanticIntegrator as c1, type SemanticIntegratorConfig as c2, type SensoryInput as c3, type SerializationConfig as c4, type SerializationFormat as c5, type SerializedEntity as c6, type SerializedState as c7, type Serializer as c8, type SessionLogEnvelope as c9, type TickListener as cA, type TokenLedgerRecord as cB, type TokenReportEnvelope as cC, TokenTracker as cD, type TokenTrackerConfig as cE, type TokenUsage as cF, type VectorIndex as cG, type VectorMemoryAdapter as cH, type VectorMemoryConfig as cI, type VectorQueryFilter as cJ, type VectorQueryResult as cK, type VectorRecord as cL, VisionEngine as cM, type VoiceChunk as cN, type WillAffect as cO, type WillConfig as cP, type WillEffectorAct as cQ, type WillInstance as cR, type WillMessage as cS, type WillStateSummary as cT, type WillStatus as cU, WillStem as cV, type WillSummary as cW, WorkingMemory as cX, type WorkingMemoryConfig as cY, type WorldEntity as cZ, type WorldInterface as c_, type Simulation as ca, type SimulationClock as cb, type SimulationConfig as cc, type SimulationEngine as cd, type SimulationEventBase as ce, type SimulationEventListener as cf, type SleepPressureConfig as cg, SleepPressureRegulator as ch, SocialPerception as ci, type SocialPerceptionConfig as cj, SomatosensationEngine as ck, SpacedRepetition as cl, type SpacedRepetitionConfig as cm, type StateSnapshot as cn, type Stimulus as co, type StorageAdapter as cp, StressRegulator as cq, type StressRegulatorConfig as cr, TableRouter as cs, TaskSwitcher as ct, type TaskSwitcherConfig as cu, type TextMessage as cv, TheoryOfMind as cw, type TheoryOfMindConfig as cx, ThreatEvaluator as cy, type ThreatEvaluatorConfig as cz, type Timestamp as d, chainRouters as d0, clearCompletionRecorder as d1, defaultBaseFor as d2, type effectorInvocation as d3, type effectorInvocationEnvelope as d4, getCompletionRecorder as d5, isNullRouter as d6, knownWireFor as d7, resolvePricing as d8, setCompletionRecorder as d9, type SimulationEvent as e, type StateManager as f, type Tick as g, type SimulationState as h, type StateCommands as i, type ReasoningFootprint as j, type ReadonlySimulationState as k, type ConflictStrategy as l, type ConflictResolution as m, type AckEnvelope as n, type ActionRequest as o, type ActionResult as p, ActionSelector as q, type ActivityEnvelope as r, type ActivityEvent as s, type ActivityEventHandler as t, AestheticEvaluator as u, type AestheticEvaluatorConfig as v, AffectiveBlender as w, type AffectiveBlenderConfig as x, AffordanceSynthesizer as y, AsyncEngine as z };