@mindot/will 0.7.0 → 0.9.0

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

@@ -928,6 +928,22 @@ declare class DefaultOrchestrator implements Orchestrator {
      * calls _executeTick() which handles pause/stop checks internally.
      * The orchestrator is the sole driver of ticks.
      */
+    /**
+     * A plain SimulationEngine's `react()` is implicitly "finish inside the tick" —
+     * only an AsyncEngine is allowed to span ticks, and it does so by LAUNCHING work
+     * and landing it later (see async.engine.ts: "react() never awaits LLM calls").
+     * Nothing enforces that on everyone else, and the failure is silent and severe:
+     * every agency deadline is denominated in TICKS, so an engine that awaits network
+     * I/O does not merely run slowly, it rescales time for the whole mind.
+     *
+     * Measured: one rate-limited embedding call awaited inside EpisodicConsolidator
+     * made two consecutive ticks take 64.9s and 63.5s. `AWAIT_TIMEOUT` — 15 ticks,
+     * normally ~15s — silently became 15 minutes, so a communicate intent sat
+     * 'awaiting' forever and the serial selector never chose anything again. 45
+     * executive decisions produced one intent and zero delivered messages, with no
+     * error anywhere. This turns that into a line in the log the first time it happens.
+     */
+    private _warnIfSlow;
     private _runLoop;
     private _shutdown;
     stop(): void;
@@ -1332,7 +1348,6 @@ declare class WorkingMemory implements SimulationEngine, CognitiveEngine {
     private _emitEvents;
     private _items;
     private _modulatedCapacity;
-    private _currentFocusId;
     private _activeGoalCount;
     /**
      * Monotonic suffix counter for injected WM item ids. Replaces Math.random()
@@ -1373,8 +1388,10 @@ declare class WorkingMemory implements SimulationEngine, CognitiveEngine {
      */
     private _ingestGoals;
     /**
-     * Mark the currently focused entity's WM item as attended this tick.
-     * Also checks for attention.focus entities in state as a fallback.
+     * Mark the currently focused entity's WM item as attended this tick, from the
+     * `attention.focus` entities AttentionAllocator writes. (A second, bus-driven
+     * branch used to sit above this one, labelled "preferred"; the event behind it was
+     * never published, so this loop has always been the only path — see #114.)
      */
     private _applyAttention;
     /**
@@ -1446,6 +1463,10 @@ interface GoalState {
     activatedAt: Tick;
     deadline?: Tick;
     tags: string[];
+    /** Why this goal was abandoned, when it was. Set only on status 'abandoned'.
+     *  The reason used to be pushed onto `tags`, which threw once the goal had
+     *  been rehydrated from a deep-frozen state entity. */
+    abandonedReason?: string;
     /** Snapshot of memory.beliefs_total when this goal was activated.
      *  Used to compute epistemic progress: (currentBeliefs - baseline) / threshold. */
     beliefsAtActivation: number;
@@ -1573,6 +1594,19 @@ declare class GoalManager implements SimulationEngine, CognitiveEngine {
      * "learn" ↔ "learning").
      */
     private _nudgeActionGoals;
+    /**
+     * Somebody answered. Advance the action goals that were about reaching them.
+     *
+     * Linked the way every other goal→person link in the system is linked: the
+     * `keid:<id>` tag (selection.scoring's `collectGoalTargets` reads the same one
+     * to lift a reach-out's goal relevance) or `requestingEntityId`, set when a
+     * conversation escalation created the goal. Nothing here guesses from wording.
+     *
+     * Unmatched by design: a goal with no link to this person gets nothing, even if
+     * it is tagged 'communication'. Being answered by one person is not progress on
+     * wanting to talk to another.
+     */
+    private _nudgeAnsweredGoals;
     /** True when a metric completionCondition (e.g. "emotion.boredom < 40") is already met. */
     private _isConditionMet;
     private _evaluateMetricProgress;
@@ -1586,32 +1620,62 @@ 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 process being paid for. */
+type LLMCallProcess = 'cog' | 'decision' | 'ideation';
+/** The specific cognitive function being paid for. */
+type LLMCallFunction = '-' | '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 +1686,33 @@ 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;
+    /**
+     * How much this call demanded, 0..1 — the cognitive measure the router saw.
+     *
+     * Recorded so routing can be ANSWERED rather than argued. Every call computes
+     * this, routes on it, and until now threw it away — which left questions like
+     * "is deliberation being rated by the tick's mood rather than the stakes of
+     * its own choice?" with no dataset at all.
+     *
+     * Absent means UNMEASURED, never zero. It must stay nullable all the way to
+     * storage: a call that never reported demand and a call that reported 0.0 are
+     * different facts, and collapsing them would put a floor of invented
+     * confidence under exactly the analysis this exists to enable.
+     */
+    demand?: number;
+    category: LLMCallCategory;
+    attribute: LLMCallAttribute;
+    process: LLMCallProcess;
+    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 +1725,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 +1753,7 @@ declare class TokenTracker implements SimulationEngine {
     readonly name = "token-tracker";
     private _emitCostEvents;
     private _costWarningThreshold;
+    private _prices;
     private _usageLog;
     private _totalPromptTokens;
     private _totalCompletionTokens;
@@ -1672,6 +1762,10 @@ declare class TokenTracker implements SimulationEngine {
     private _categoryTokens;
     private _functionCosts;
     private _functionTokens;
+    private _processCosts;
+    private _processTokens;
+    private _providerCosts;
+    private _providerTokens;
     private _tickCosts;
     private _maxTickCostSamples;
     private _lastCostWarningTick;
@@ -1716,6 +1810,28 @@ declare class TokenTracker implements SimulationEngine {
         prompt: number;
         completion: number;
     }>;
+    /** Cost broken down by process ('decision' | 'ideation' | 'cog'). */
+    get processBreakdown(): ReadonlyMap<string, number>;
+    /** Token counts (prompt + completion) broken down by process. */
+    get processTokenBreakdown(): ReadonlyMap<string, {
+        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 +1855,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;
@@ -1761,12 +1879,26 @@ declare class OpenAICompatibleEmbedder implements EmbeddingProvider {
     private _maxConcurrency;
     private _timeoutMs;
     private _tokenTracker;
+    /**
+     * Own gate — the same LLMSemaphore the LLM calls use, on a separate instance so
+     * embeddings and reasoning do not compete for one another's slots. It bounds the
+     * fan-out that produced the 10.7s tail, and `withGate` additionally retries a 429
+     * with backoff, which a bare `embed()` previously surfaced as a hard failure.
+     */
+    private _gate;
     constructor(config: {
         modelName: string;
         dimensions: number;
         apiUrl: string;
         apiKey?: string | null;
-        /** Max embedding requests in flight at once for embedBatch(). Default 8. */
+        /**
+         * Max embedding requests in flight at once — across ALL callers, not just one
+         * embedBatch(). Default 4, chosen from measured provider behaviour rather than
+         * taste: gemini-embedding-001 answers a lone request in ~1.1s, but queues hard
+         * under fan-out — at 8 in flight the slowest three took 10.7s (all HTTP 200, no
+         * 429, simply serialized). That tail is what made recall exceed its 5s budget
+         * and return "no recall" while a mind with six live facets was asking.
+         */
         maxConcurrency?: number;
         /** @deprecated use maxConcurrency — kept as its fallback for back-compat. */
         batchSize?: number;
@@ -1775,12 +1907,20 @@ 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 one item, gated. Every caller funnels through here — a facet building a
+     * prompt, the master recalling, the consolidator indexing — so the gate is the
+     * only place total in-flight fan-out is bounded. Waiting for a slot is strictly
+     * better than the alternative it replaces: an ungated request that returns after
+     * the recall budget has already expired is a request whose answer is thrown away.
+     */
+    embed(content: unknown, fn?: EmbedFunction): Promise<number[]>;
+    private _embedOnce;
+    embedBatch(contents: unknown[], fn?: EmbedFunction): Promise<number[][]>;
     areEquivalent(embedding1: number[], embedding2: number[], tolerance?: number): boolean;
 }
 /**
@@ -1792,8 +1932,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;
@@ -1945,6 +2085,16 @@ declare class DefaultVectorMemoryAdapter implements VectorMemoryAdapter {
     persist(): Promise<void>;
     load(): Promise<void>;
     private _evictColdest;
+    /**
+     * Throttle, NOT a debounce. The previous version cleared and re-armed the timer on
+     * every index(), so it only ever fired after 5s of complete inactivity — and a mind
+     * consolidating steadily indexes far more often than that, so the write was pushed
+     * back indefinitely and the index never reached disk while it was awake.
+     *
+     * A pending timer is now left alone: the first write after a quiet period sets the
+     * deadline, and everything indexed within the window rides along on it. Persist is
+     * bounded at 5s from the FIRST pending change rather than the last.
+     */
     private _schedulePersist;
 }
 
@@ -2007,6 +2157,13 @@ declare class EpisodicConsolidator implements SimulationEngine, CognitiveEngine
     private _affectDominance;
     private _bus;
     private _vectorMemory;
+    /**
+     * In-flight background indexing. Indexing is deliberately not awaited inside
+     * react() (a rate-limit retry chain would stall the whole tick loop), so this is
+     * the handle for the two callers that genuinely must wait for it: shutdown,
+     * before persisting the index, and tests asserting on it.
+     */
+    private _indexing;
     private _embedder;
     private _autoIndex;
     private readonly _model;
@@ -2044,6 +2201,8 @@ declare class EpisodicConsolidator implements SimulationEngine, CognitiveEngine
      * Other metadata narrowing (sourceType / tags) remains the caller's job on the
      * returned episodes (which carry all metadata).
      */
+    /** Await any background indexing still in flight. Shutdown and tests only. */
+    flushIndexing(): Promise<void>;
     semanticQuery(query: unknown, filters?: {
         minSimilarity?: number;
         limit?: number;
@@ -2567,7 +2726,152 @@ 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.process` exactly (e.g. 'decision', 'ideation'). */
+    process?: LLMCallMeta['process'];
+    /** 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 +2901,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 +2950,56 @@ 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. */
+    process: LLMCallProcess;
+    /** 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.
+     *
+     * What actually reports it today:
+     *   · the master and every facet — including the deliberation facet — forward
+     *     `effortScore`, the a-priori effort gate (uncertainty, prior confidence,
+     *     novelty, a pending reply, stress load);
+     *   · structurally background work (summarising, the identity guard) reports a
+     *     low constant, because it is background whether the mind is calm or in
+     *     crisis.
+     *
+     * Note what is NOT here: agency's `stakes( winner, bias )` — the consequence
+     * of the specific choice under contest — is computed in
+     * `agency/selection.scoring.ts` and never reaches a call. So a deliberation
+     * facet currently reports the tick's general effort, not the stakes of the
+     * choice it is deliberating. Carrying it is MODEL_ROUTING W1, still open.
+     * This comment previously claimed deliberation passed those stakes; it does
+     * not, and a doc comment that ships to npm is a bad place to be aspirational.
+     *
+     * 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 +3011,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 +3093,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;
     /**
@@ -2866,6 +3252,18 @@ interface ExecutiveOutputFull {
         name?: string;
         learned?: string[];
         feeling?: number;
+        /**
+         * "This is the same someone as that" — another keid I now believe is this
+         * same referent, fusing two of my records into one.
+         *
+         * The mind's own verdict on an identity, and it may do what the recognition
+         * heuristic will not: absorb an ESTABLISHED relationship. The heuristic is
+         * right to refuse — fusing two real people who share a name would take one of
+         * them's whole history — but the mind has evidence a name-match does not,
+         * usually because somebody just told it. Without this, the same human
+         * well-established on two channels stayed two people permanently.
+         */
+        sameAs?: string;
     }>;
     newGoals?: Array<{
         description: string;
@@ -2884,6 +3282,8 @@ interface ExecutiveOutputFull {
         reason: string;
     }>;
     selfObservations?: string[];
+    /** Compound actions the mind is naming as single skills (see ProposedSkill). */
+    newSkills?: ProposedSkill[];
     /**
      * Plain-text reply from a conversation facet — populated by parseResponse()
      * from the [REPLY_TEXT]...[/REPLY_TEXT] block.
@@ -2891,6 +3291,11 @@ interface ExecutiveOutputFull {
      * Paragraphs (double-newline separated) map to separate reply bubbles.
      */
     replyText?: string;
+    /**
+     * Set when the facet declared it is NOT speaking this cycle, carrying why.
+     * Present ⇒ nothing is sent, whatever else the response contains.
+     */
+    noMessage?: string;
     /**
      * @deprecated Legacy JSON reply format — no longer emitted by conversation facets.
      * Kept for backward compatibility with any tests/tooling that inspect parsed output.
@@ -2940,6 +3345,24 @@ interface ExecutiveEngineConfig$1 {
     cooldownTicks?: number;
     bus?: CognitiveBus;
 }
+/**
+ * A compound action the mind names as one thing it does — "when I do A then B,
+ * that is <name>". Registered into the SchemaRepertoire as a composite, after
+ * which it competes as a single affordance and can proceduralize into a habit.
+ *
+ * This is the creation seam for the instrumental→habitual gradient. Before it,
+ * `agency.composite.proposed` was subscribed by ReafferenceEngine — whose handler
+ * is the only caller of `registerComposite()` anywhere — and published by nothing,
+ * so no Will could ever hold a skill beyond the innate floor (#114).
+ */
+interface ProposedSkill {
+    /** What the mind calls it. Becomes the schema id. */
+    id: string;
+    /** The sub-schemas it is made of, in order. Two or more, or it is not compound. */
+    composedOf: string[];
+    tags?: string[];
+    cost?: number;
+}
 
 /**
  * PromptFactory — single source of truth for all executive prompts
@@ -2996,7 +3419,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.
@@ -3027,6 +3450,18 @@ interface FocusSection {
      * only sees that person's plans. When unset, those sections show all.
      */
     awarenessEntityId?: string;
+    /**
+     * Optional: WHO this facet is engaged with — the keid and the name the mind has
+     * learned for them. Reported back to the master on every `executive.facet.sync`.
+     *
+     * Without it the master was told, in its own system prompt, that "focused facets
+     * may run simultaneously… their reasoning syncs back to me" while the sync payload
+     * carried only a facetId and a confidence number — so a mind holding two live
+     * conversations could not tell you whose they were. The master is the singular
+     * seat: it has to know who is at the table to reason about them together.
+     */
+    subjectEntityId?: string;
+    subjectName?: string;
     /**
      * Optional: Provided by the creating engine to convert the LLM's parsed output
      * into a domain-specific decision payload.
@@ -3053,6 +3488,18 @@ interface FacetReport {
     contextId?: string;
     /** Optional dynamic instructions to append to the user message */
     instructions?: string;
+    /**
+     * Attend to something else for THIS report only, leaving the facet's standing
+     * focus untouched.
+     *
+     * A facet's focus was a single mutable field, so anything that wanted a live
+     * facet to consider one different thing had to `setFocus()` first — clobbering
+     * whatever the facet was already set up for, and racing with any report already
+     * queued behind it. That is why a self-initiated message to someone the mind was
+     * ALREADY talking to had to be composed by a separate, transient facet that could
+     * not see the live conversation at all.
+     */
+    focus?: FocusSection;
 }
 interface FacetDecision {
     facetId: string;
@@ -3062,6 +3509,16 @@ interface FacetDecision {
     decision: unknown;
     reasoning: string;
     confidence: number;
+    /**
+     * Sim tick this decision was reasoned at.
+     *
+     * The facet has always known it and never passed it on, so a subscriber writing
+     * state in response had no deterministic clock and reached for a process-local
+     * counter instead — which resets on restart and collides. Never wall-clock: this
+     * reaches ids that live in state, and a wall-clock id makes recorded and replayed
+     * runs diverge (R2).
+     */
+    tick: number;
 }
 type FacetEventListener = (decision: FacetDecision) => void;
 interface ExecutiveFacetHandle {
@@ -3095,6 +3552,44 @@ interface ExecutiveFacetHandle {
     onReaped: (handler: () => void) => void;
 }
 
+/**
+ * DeliberationCache — types and contracts.
+ *
+ * The cache stores past executive outputs keyed by a deterministic
+ * cognitive fingerprint. It is pure, deterministic, and R2-safe:
+ * the same state + same history ⇒ same retrieval + same composition.
+ *
+ * Scope note: Phase 1 caches the ACTIONS block only. The composed output
+ * is a valid `ExecutiveOutputFull` carrying the three required fields
+ * (actions, reasoning, confidence) plus whatever optional blocks the
+ * enabled scopes cover. Everything else stays undefined and the existing
+ * downstream (`buildStateCommands`) treats it as "nothing to do", which is
+ * exactly the intended Phase-1 behaviour.
+ */
+
+/** Which blocks of the executive output the cache may synthesise. */
+type CacheScope = 'actions' | 'goals' | 'beliefs';
+interface DeliberationCacheConfig {
+    /** Maximum patterns to retain. Lowest (competence × recency) evicted when full. */
+    maxPatterns?: number;
+    /** Neighbors retrieved for composition. */
+    k?: number;
+    /** Minimum similarity for a stored pattern to count as a neighbor. */
+    minSimilarity?: number;
+    /** Confidence threshold θ — cache hit requires ρ ≥ θ. Start conservative. */
+    theta?: number;
+    /** Temperature for softmax weights over neighbors. */
+    tau?: number;
+    /** Learning rate (EMA) for competence updates. */
+    eta?: number;
+    /** Competence decay per executive cycle (applied via decay()). */
+    decayPerCycle?: number;
+    /** Verify 1-in-N cache hits against the LLM (0 = never). */
+    verifyEveryNHits?: number;
+    /** Which output blocks to synthesise. Phase 1 default: ['actions']. */
+    scopes?: CacheScope[];
+}
+
 interface ExecutiveEngineConfig {
     executiveInterval?: number;
     cooldownTicks?: number;
@@ -3108,20 +3603,26 @@ declare class ExecutiveEngine extends AsyncEngine implements CognitiveEngine {
     private _consumedBufferEntries;
     private _llmDirector;
     private _testMode;
-    private _messageQueue;
     private _recentActionTypes;
     private _coherenceVersion;
     private _lastEpistemicUncertainty;
     private _lastExecutiveOutput;
     private _lastExecutiveTick;
+    private _cache;
+    private _cacheRestored;
+    private _pendingVerify;
+    private _lastCacheHit;
+    private _lastCacheConfidence;
+    private _lastCacheNeighborCount;
     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;
@@ -3134,11 +3635,28 @@ declare class ExecutiveEngine extends AsyncEngine implements CognitiveEngine {
     private _inbox;
     private _tokenTracker;
     private readonly _facetSupervisor;
-    private _facetSyncSubscribed;
+    /**
+     * Who each live facet is engaged with, learned from `executive.facet.sync`.
+     * Keyed by facetId; the last sync wins. Rendered into the master's own prompt so
+     * the singular seat can reason across its conversations "as if they were sitting
+     * at the same table" — which it cannot do while it only knows facet numbers.
+     * Stale entries age out on read (see _activeConversations).
+     */
+    private _facetSubjects;
     private readonly _model;
     private readonly _generativeModel;
     private _summarizerRestored;
     private _lastStateRef;
+    /**
+     * The tick currently being processed, refreshed every react() — distinct from
+     * `_lastStateRef` (which tracks the REASONING tick and must not move under
+     * onReasoningComplete) and from `_lastExecutiveTick` (the last cycle that ran).
+     *
+     * Off-tick arrivals — a facet handoff, in particular — need to be stamped with
+     * when they actually happened. Using `_lastExecutiveTick` for that dated them to
+     * the last master cycle, which can be hundreds of ticks behind.
+     */
+    private _currentTick;
     private readonly _deferred;
     private _chunkBroadcaster;
     private readonly _escalations;
@@ -3164,19 +3682,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 +3698,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,11 +3717,56 @@ 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;
-    spawnFacet(role?: 'deliberation' | 'conversation' | 'outreach' | 'supervision'): {
+    /**
+     * 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', 
+    /**
+     * What this facet is FOR — see `FacetSpawnDeps.key`. Two spawns with the same
+     * key get the same facet, so callers no longer each invent their own dedup
+     * (and `authorOutreach`, which had none, no longer opens a rival facet on a
+     * person the mind is already talking to).
+     */
+    key?: string): {
         attention: 'available' | 'full';
         handle?: ExecutiveFacetHandle;
     };
+    /**
+     * The facet already attending to `key`, if one is open — without spawning.
+     * See FacetSupervisor.handleFor.
+     */
+    facetFor(key: string): ExecutiveFacetHandle | undefined;
     subscribes(): string[];
     publishes(): CognitiveEventSchema[];
     snapshot(): Record<string, unknown>;
@@ -3218,12 +3778,119 @@ declare class ExecutiveEngine extends AsyncEngine implements CognitiveEngine {
      * its `executive.last_tick` metric reflects whether our prior commands landed.
      */
     react(delta: Duration, tick: Tick, state: ReadonlySimulationState, context: SimulationContext): Promise<EngineResult>;
+    /**
+     * What the mind is attending to because a facet is reasoning about it, as
+     * `attention.demand` entities the AttentionAllocator allocates real capacity
+     * against (`_extractSalienceSignals` reads this type; `costPerFocus` is then
+     * charged against the same 100-unit budget as perceptual foci).
+     *
+     * This closes a loop that was open in one direction only: the allocator's
+     * `freeFraction` scaled the facet budget, but facets never appeared in
+     * `_activeFocus`, so holding three conversations reported exactly as much spare
+     * attention as holding none. The budget was being scaled by a signal blind to the
+     * thing it was bounding.
+     *
+     * `urgency` sits below 1 on purpose: a live conversation is a genuine claim on
+     * attention but must not automatically outrank every percept — the allocator sorts
+     * candidates by salience into `maxFoci` slots, and a facet that always won would
+     * starve perception. Only BUSY facets are charged; an open-but-quiet thread is one
+     * the mind is in, not one it is attending to.
+     */
+    private _facetAttentionDemands;
     protected shouldAct(state: ReadonlySimulationState, tick: Tick, _context: SimulationContext): boolean;
     protected readState(state: ReadonlySimulationState, tick: Tick): ReasoningFootprint;
     protected reasonAsync(footprint: ReasoningFootprint, state: ReadonlySimulationState, context: SimulationContext, stream: IntermediateStream): Promise<unknown>;
     protected onIntermediateResult(step: string, result: unknown, _footprint: ReasoningFootprint, _context: SimulationContext): StateCommands | null;
     protected onReasoningComplete(output: unknown, footprint: ReasoningFootprint, _context: SimulationContext): StateCommands;
-    private _ensureFacetSyncSubscription;
+    /**
+     * The people the mind is in conversation with right now, newest first.
+     *
+     * Pruned against the supervisor's live facets on every read: a reaped facet is a
+     * conversation that has ended, and a master that still believes it is mid-thread
+     * with someone reasons about a table that is no longer there.
+     */
+    private _activeConversations;
+    /**
+     * Facet sync — remember WHO each facet is with, and wake the master.
+     *
+     * Reached from `onCognitiveEvent`, NOT from its own `bus.subscribe`. The bus
+     * stores one subscription per engineId (`_subscriptions.set( engineId, … )`),
+     * so a second `subscribe(this.name, …)` silently REPLACES the first — and the
+     * orchestrator registers `subscribe( engine.name, engine.subscribes(), … )`
+     * after `attachBus`, which replaced everything registered here. Two dedicated
+     * handlers used to be installed at this point; the second overwrote the first
+     * and the orchestrator then overwrote that, so neither ever ran. The escalation
+     * leg had been dead in production for its whole life: a facet could escalate,
+     * the audition engine published, and nothing was listening.
+     */
+    /**
+     * Retire undertakings the mind has already honoured, and refuse to restate one
+     * it is already carrying.
+     *
+     * An undertaking percept says, in the first person, "I said I would reach X and
+     * nothing has gone to them yet". That sentence has to stop being true at some
+     * point, and nothing made it stop. Measured on a live Will: SEVEN of them
+     * accumulated in state, every one still asserting nothing had been sent, while
+     * a `conversation.sent` to that person sat right beside them. She read seven
+     * standing unfulfilled promises every cycle and dutifully sent the same message
+     * again, five times in five minutes and once more in the next session — the
+     * percept meant to stop her forgetting a promise was making her unable to
+     * believe she had kept it.
+     *
+     * Discharged by EVIDENCE, not by a timer: a `conversation.sent` to that target,
+     * written no earlier than the undertaking, means the contact happened. That
+     * record is durable and snapshots with the state, so the discharge survives a
+     * restart exactly as the promise does — which the tick-scoped satiation in
+     * `enactionFootprint` deliberately cannot.
+     *
+     * It stays a decision, not an erasure. Retiring the percept removes the standing
+     * claim that the words are unsent; whether to say more to that person is then an
+     * ordinary competition like any other.
+     */
+    private _reconcileUndertakings;
+    private _onFacetSync;
+    /**
+     * A focused part of me surfaced something the singular seat owns — work to plan
+     * (`escalation`) or an intention toward a third party (`undertaking`).
+     *
+     * ONE handler for every facet type. This was `_onAuditionTaskSignal`, listening
+     * on a topic named for one sense engine and typed with one sense engine's nouns
+     * (`entityId`, `threadId`), which meant a planning, supervision or deliberation
+     * facet had no way to hand anything up at all. See EscalationBuffer for the full
+     * rationale; new kinds go in `HandoffBody`, not in a new topic and a new handler
+     * beside this one.
+     *
+     * Master stays out of the reply path entirely:
+     *   • The facet has already said (or will say) whatever the person in front of
+     *     it needed to hear.
+     *   • The master's job is purely cognitive: create a [PLANS] block, update
+     *     goals, reflect, or decide whether it still means to make that contact.
+     *     Any follow-up communication flows through the agency competition —
+     *     NEVER via [REPLY].
+     *
+     * Buffered rather than written directly: state is read-only here, so
+     * `EscalationBuffer.drainToPercepts()` emits it as a StateCommand on the next
+     * master cycle, where Exteroception surfaces it under "## Percepts (What I Notice)".
+     */
+    private _onFacetHandoff;
+    /** Enable the deliberation cache (off by default). Call during mind assembly. */
+    enableCache(config?: DeliberationCacheConfig): void;
+    /** True when the cache is active. */
+    get cacheEnabled(): boolean;
+    /** Telemetry snapshot for harnesses / eval. Null when disabled. */
+    cacheStats(): {
+        size: number;
+        hits: number;
+        misses: number;
+    } | null;
+    /**
+     * Reafference hook — update cache competence from a confirmed action outcome.
+     * Optional, layered on top of the inline verify loop. Reward follows the
+     * research sketch: mean of (action succeeded, stress relief, goal progress).
+     */
+    onActionOutcome(state: ReadonlySimulationState, tick: Tick, success: boolean, stressDelta: number, goalProgressDelta: number): void;
+    private _actionTypesMatch;
+    private _restoreDeliberationCache;
     private _restoreSummarizer;
 }
 
@@ -3837,6 +4504,13 @@ declare class ThreatEvaluator implements SimulationEngine, CognitiveEngine {
      * metadata.hostile === true). Updates _threatFromHostile and re-emits
      * the full threat/emotion metrics so that downstream engines always see
      * a current picture even when no bus event arrives.
+     *
+     * `threat` is a HOST SEAM, not a starved input (#114). No core engine writes
+     * one — appraisal runs entirely off this engine's six bus inputs (energy,
+     * sleep, stress, novelty, metacognition, prediction), all of which are live.
+     * A host embedding a Will in a world with actual hostile agents writes `threat`
+     * entities to make them felt. Empty here means nothing is hostile, not that
+     * nothing is wired.
      */
     react(_delta: Duration, _tick: Tick, state: ReadonlySimulationState, _context: SimulationContext): Promise<EngineResult>;
     private _computeScarcityThreat;
@@ -4696,6 +5370,8 @@ declare class SelfModelUpdater extends AsyncEngine implements CognitiveEngine {
     private _affectObservations;
     private _bus;
     private _semanticIntegrator;
+    /** The reasoning tick's state — onReasoningComplete needs it to merge identity. */
+    private _lastStateRef;
     private readonly _model;
     constructor(config?: SelfModelUpdaterConfig);
     attachBus(bus: CognitiveBus): void;
@@ -5275,6 +5951,19 @@ interface Reputation {
     negativeInteractions: number;
     lastInteractionTick: Tick;
     confidence: number;
+    /**
+     * Everything the mind has OBSERVED about this person, acts and silences alike.
+     *
+     * `interactionCount` counts acts, and only acts — a silence must never inflate
+     * it or the mind remembers conversations that never happened. But confidence is
+     * about how much evidence a read rests on, and a silence is evidence. Counting
+     * only acts meant someone who never answers could never be confidently known as
+     * someone who never answers, which is precisely the read worth holding.
+     *
+     * Rises in lockstep with `interactionCount` on the interaction path, so a mind
+     * that has only ever been spoken to behaves exactly as it did before.
+     */
+    observations: number;
 }
 declare class ReputationTracker implements SimulationEngine, CognitiveEngine {
     readonly name = "reputation-tracker";
@@ -5286,6 +5975,8 @@ declare class ReputationTracker implements SimulationEngine, CognitiveEngine {
     /** True after reputations have been rehydrated from persisted state on first tick. */
     private _restored;
     private _pendingInteractions;
+    /** Whether someone answered when the mind spoke to them (ReafferenceEngine). */
+    private _pendingResponsiveness;
     private _bus;
     private readonly _model;
     constructor(config?: ReputationTrackerConfig);
@@ -5307,6 +5998,36 @@ declare class ReputationTracker implements SimulationEngine, CognitiveEngine {
     private _prune;
 }
 
+/**
+ * A way this referent has been reachable, and what happened there.
+ *
+ * `kind` is the one fact that decides whether a room is the right place for a
+ * given utterance, and it was being computed at the Discord edge (`isDM`) and
+ * discarded before the mind could see it.
+ *
+ * `lastAnsweredTick` is evidence, not configuration — it arrives free from the
+ * `social.responsiveness` signal. It is what lets the mind prefer the DM because
+ * that is where this person actually answers, rather than because a constant in
+ * the code says DMs rank higher.
+ */
+interface Handle {
+    /** The transport address — what a channel bridge can actually deliver to. */
+    keid: string;
+    /**
+     * 'dm' — a private thread. 'room' — somewhere others are listening. Left open
+     * for a non-social referent, where the meaningful distinction is a different one.
+     */
+    kind: 'dm' | 'room' | 'unknown';
+    /** The place this handle lives in, once places are dossiers of their own. */
+    place?: string;
+    /** When the mind last SAID something here. */
+    lastUsedTick?: Tick;
+    /** When someone last answered it here — the only evidence that this route works. */
+    lastAnsweredTick?: Tick;
+    /** Free-form, so a host can mark what its own vocabulary cares about. */
+    tags?: string[];
+}
+
 /**
  * KnownEntityTracker — the cross-modal binder, and owner of the known-entity dossier.
  *
@@ -5361,6 +6082,31 @@ interface KnownEntity {
     lastSeenTick: Tick;
     /** 0–1: how identified/coherent this referent is (a name + repeated encounters raise it). */
     resolutionConfidence: number;
+    /**
+     * The ways this referent has been reachable, with the circumstances.
+     *
+     * Distinct from an ALIAS, and the distinction is load-bearing: an alias is
+     * another NAME for the same referent (a transport user id), a handle is a
+     * PLACE it can be reached (a thread, a room). One person has one identity and
+     * several rooms, and conflating them is what made "which room should I say
+     * this in?" unaskable.
+     */
+    handles: Handle[];
+    /**
+     * Referents this one MIGHT be the same someone as, unresolved.
+     *
+     * A blocked merge used to vanish. `_recognise` will only absorb a THIN handle
+     * into an established relationship — rightly, because fusing two real people
+     * who share a name is the dangerous direction — so once the same human was
+     * well-established on two channels they stayed two people permanently, and
+     * nothing anywhere recorded the near-miss.
+     *
+     * A person does not silently fail here. They NOTICE — "hang on, is this the
+     * same Mara?" — and then resolve it by asking. So the doubt is kept, shown, and
+     * left for the mind to settle. Deliberately not a merge: this is a question,
+     * and the answer is the mind's to give.
+     */
+    suspectedSameAs?: string[];
 }
 declare class KnownEntityTracker implements SimulationEngine, CognitiveEngine {
     readonly name = "known-entity-tracker";
@@ -5376,6 +6122,13 @@ declare class KnownEntityTracker implements SimulationEngine, CognitiveEngine {
     private _pendingEncounters;
     private _pendingConscious;
     private _pendingOutcomes;
+    /**
+     * Aliases minted this tick, awaiting persistence. `_getOrCreate` runs deep inside
+     * the drain loops with no access to the command list, and an alias that lives
+     * only in memory is one the mind forgets on restart — every transport address
+     * would mint a SECOND anchor next boot and the person would fork in two.
+     */
+    private _mintedAliases;
     private _bus;
     private readonly _model;
     constructor(config?: KnownEntityTrackerConfig);
@@ -5392,7 +6145,31 @@ declare class KnownEntityTracker implements SimulationEngine, CognitiveEngine {
     snapshot(): Record<string, unknown>;
     react(_delta: Duration, tick: Tick, state: ReadonlySimulationState, _ctx: SimulationContext): Promise<EngineResult>;
     /** The dossier for a referent, if the Will has one. */
+    /**
+     * The dossier for anything that names this referent — its anchor, or any address
+     * it has been met at.
+     *
+     * Alias-aware because a caller has no business knowing the anchor. This read
+     * `_dossiers.get(keid)` raw, so the moment addresses became aliases of a minted
+     * anchor, every caller holding a transport id got `undefined` — the mind would
+     * have looked up someone it knows perfectly well and found a stranger. The
+     * existing Phase-4 tests caught it, which is exactly what they are for.
+     */
     getDossier(keid: string): KnownEntity | undefined;
+    /**
+     * Absorb `alias` into `canon` — one someone where there were two.
+     *
+     * Shared by the recognition heuristic and by the mind's own `sameAs` verdict,
+     * because "these are the same person" must mean the same thing whichever
+     * concluded it. The only difference is who is ENTITLED to conclude it: the
+     * heuristic will not absorb an established relationship, the mind may, because
+     * it has reasons a name-match does not — usually that somebody just told it.
+     *
+     * Routes MOVE. This used to delete the absorbed dossier and keep only a
+     * redirect, so the mind concluded "same person" and in the same breath threw
+     * away the second way to reach them.
+     */
+    private _fuse;
     /** Resolution confidence: a learned name plus repeated encounters identify a referent. */
     private _resolution;
     /**
@@ -5400,12 +6177,51 @@ declare class KnownEntityTracker implements SimulationEngine, CognitiveEngine {
      * true if any merge happened. Pure + deterministic.
      */
     private _recognise;
+    /**
+     * The dossier for a referent, minting its anchor the first time it is met.
+     *
+     * A transport address arriving here (`discord:1019…`) is not an identity, it is
+     * a way the world happened to name someone. So it becomes an ALIAS of a fresh
+     * `ke:` anchor, and the dossier lives under the anchor. Everything downstream —
+     * reputation, theory-of-mind, attachment, goals, the PMA — keeps working
+     * untouched: it still sees one opaque string per referent, which is simply no
+     * longer a route. The same human met later on another channel resolves to this
+     * same anchor instead of becoming a second person nobody could connect.
+     */
     private _getOrCreate;
     /** Keep the most-familiar dossiers; absence-faded acquaintances fall away (forgetting). */
+    /**
+     * Forget the least-held referents when over capacity.
+     *
+     * Ranked by more than exposure, deliberately. This sorted on `familiarity`
+     * alone, which is MERE EXPOSURE — and now that a referent need not be a person
+     * (a document, a repo, a room), things get far more exposure than people do. A
+     * mind that touched sixty files would have evicted a colleague it speaks to
+     * weekly in favour of a config file it opened a lot, silently, taking that
+     * person's reputation, theory-of-mind model and attachment bond with it.
+     *
+     * So a referent the mind has actually got to know is stickier than one it has
+     * merely seen often: knowing their NAME is the single strongest signal (it is
+     * what distinguishes a someone from a blip), then how resolved the referent is,
+     * then exposure. Nothing here is about being a person — a named, well-resolved
+     * document outranks a glimpsed stranger, which is correct.
+     */
     private _prune;
     private _restoreFromState;
 }
 
+/**
+ * Referent → a deliverable address, and the room to use when none was chosen.
+ *
+ * Returns null when the referent is already an address (nothing to translate) or
+ * when the mind holds no route at all — in which case the row goes out as-is and
+ * the bridge's own roster fallback still applies, so a message is never silently
+ * dropped for want of a handle.
+ */
+type OutboxRouting = (targetEntityId: string, chosenThread: string | undefined) => {
+    targetEntityId: string;
+    threadId?: string;
+} | null;
 /** The caller-supplied fields of an outbox row; the writer stamps id + defaults. */
 interface OutboxRow {
     targetEntityId: string;
@@ -5427,11 +6243,24 @@ declare class OutboxWriter {
      * which made the embedded ids in `conversation.sent` diverge every run).
      */
     private _seq;
+    private _routing;
     constructor(opts?: {
         outbox?: OutboxMessage[];
         willId?: string;
     });
     attachSessionLogger(logger: SessionLogger | null): void;
+    /**
+     * Turn a referent into somewhere the world can actually be spoken to.
+     *
+     * Injected rather than read here, because this writer is deliberately dumb —
+     * it holds no state and must stay replay-safe. Assembly closes over the state
+     * manager (the same shape as `attachMemorySink`).
+     *
+     * This is the ONE seam both send paths cross: ProactiveCommunicator's
+     * `enqueue()` and AuditionEngine's `enqueueReply()`. Translating anywhere else
+     * would mean doing it twice and getting it wrong once.
+     */
+    attachRouting(resolve: OutboxRouting | null): void;
     private _genId;
     /**
      * Push one canonical outbox row and return its generated id. The single point
@@ -5533,6 +6362,18 @@ interface TextMessage {
     content: string;
     /** Display name — used in the facet focus content. */
     speakerName?: string;
+    /**
+     * True when `threadId` is a PRIVATE thread — this someone and the mind, nobody
+     * else listening. The single fact that decides whether a room is the right
+     * place for a given utterance, and the Discord edge has always computed it
+     * (`isDM`) and discarded it before the mind could see it: a follow-up promised
+     * in a DM went out to a public channel, because the roster's "where did I last
+     * see them" is a different question from "where did I promise this".
+     *
+     * Undefined means the channel did not say, which is honestly different from
+     * false — an unknown room is not known to be public.
+     */
+    direct?: boolean;
 }
 interface VoiceChunk {
     kind: 'voice';
@@ -5716,6 +6557,12 @@ declare class AuditionEngine extends BaseSenseEngine {
      * other percept uses. Wired to `stateManager.setEntity` in assembleMind().
      */
     private _memorySink;
+    /**
+     * Sim tick of the most recent facet decision — the only deterministic clock this
+     * off-tick engine has. Stamped from `FacetDecision.tick`, and used to key the
+     * conversation records it writes into state.
+     */
+    private _lastDecisionTick;
     /** Speaker attachment strength accessor (0–1) — weights salience by relationship. */
     private _getAttachmentScore;
     /** Active-goal topic text accessor — for salience topic-overlap. */
@@ -5724,6 +6571,8 @@ declare class AuditionEngine extends BaseSenseEngine {
     private _inflightInbound;
     /** In-flight thread per entity — stamps chunk envelopes with the current threadId. */
     private _inflightThread;
+    /** Targets with an outreach being composed right now — see authorOutreach. */
+    private _outreachInFlight;
     attachExecutiveEngine(exec: ExecutiveEngine): void;
     /**
      * Inject the OutboxWriter so reply bubbles are delivered through the canonical
@@ -5767,7 +6616,7 @@ declare class AuditionEngine extends BaseSenseEngine {
     attachAttachmentScore(fn: (entityId: string) => number): void;
     /** Inject an active-goal topic-text accessor (reads GoalManager) for salience overlap. */
     attachActiveGoalText(fn: () => string[]): void;
-    /** Override: audition adds the master-escalation signal to the base percept schema. */
+    /** Override: audition adds the facet→master handoff to the base percept schema. */
     publishes(): CognitiveEventSchema[];
     snapshot(): Record<string, unknown>;
     /**
@@ -5836,6 +6685,52 @@ declare class AuditionEngine extends BaseSenseEngine {
      * (Section 1.2) routes ingest through the tick loop. The entity carries no
      * wall-clock timestamp — `setEntity` stamps createdAt/tick from the sim clock.
      */
+    /**
+     * The inbound as a social signal in state — mirror of `conversation.sent`.
+     *
+     * Shaped for `SocialPerception._scanSocialSignals`, which reads `sourceKeid` for
+     * who acted and `directedAtSelf` for whether it was aimed at us. Valence is left
+     * UNSET on purpose: the words have not been appraised yet, and guessing a number
+     * here would feed reputation and affect a sentiment nobody measured. Absent, the
+     * scanner falls back to its neutral default, so the Will learns *that* someone
+     * engaged (familiarity, recency, reliability) without inventing how it felt.
+     */
+    /**
+     * A durable, deterministic id for a conversation record.
+     *
+     * `<prefix>-<entity>-<tick>-<hash of the words>`. Every part earns its place:
+     *   • entity — whose conversation this is;
+     *   • tick   — WHEN, from the sim clock, which resumes from the snapshot and so
+     *              keeps rising across restarts;
+     *   • hash   — which utterance, so two things said to one person on one tick stay
+     *              two records.
+     *
+     * What it replaces was `<prefix>-<entity>-<N>` with N a process-local counter.
+     * It restarted at 1 on every boot, so each session OVERWROTE the previous
+     * session's records of the same person — a mind that had spoken with someone
+     * across four restarts held one session's worth of evidence that it ever had.
+     * Found by diffing a live snapshot against the Discord transcript it came from:
+     * `conv-sent-reply-discord:1019…-1` held that morning's greeting, and every
+     * earlier conversation keyed to the same id was simply gone.
+     *
+     * No wallClock: these ids live in state, and a wall-clock id makes the recorded
+     * and replayed runs diverge (R2).
+     */
+    private _sentKey;
+    private _writeReceived;
+    /**
+     * Record that the mind SPOKE to someone, mirroring `_writeReceived`.
+     *
+     * Only ProactiveCommunicator wrote `conversation.sent`, so a reply — which is
+     * most of what a Will says — left no durable trace of having spoken. Everything
+     * that asks "have I already said something to them?" was therefore blind to
+     * conversation: satiation could not damp repeating a relay delivered as a reply,
+     * and an undertaking discharged inside a conversation stayed forever unkept,
+     * which is exactly how the same message went out again and again.
+     *
+     * Speaking is speaking, whichever path carried it.
+     */
+    private _writeSent;
     private _persistExchangeMemory;
     private _onFacetDecision;
     /**
@@ -6012,6 +6907,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 +6974,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.
@@ -6112,6 +7037,16 @@ declare class AffordanceSynthesizer implements CognitiveEngine {
     private _schemas;
     private _skills;
     private _repertoire;
+    /**
+     * This tick's live consequence descriptors — the acts the mind has performed
+     * whose outcome has not yet come back. Refreshed once at the top of react()
+     * because `_build` runs per candidate and reading them is a full-entity scan.
+     */
+    private _inFlight;
+    /** Ticks an act stays satiating (engine-config-action-selector.repeatWindowTicks). */
+    private _satiationWindow;
+    /** Tick of the last thing said to each entity — outlives the descriptor sweep. */
+    private _spokenAt;
     private _bus;
     private _defaultCap;
     private _lastFieldSize;
@@ -6245,6 +7180,21 @@ declare class MotorSchemaExecutor implements CognitiveEngine {
     private _author;
     private _grants;
     private _bus;
+    /**
+     * Two-phase outreach authoring. A facet cannot be awaited from inside a tick:
+     * `ExecutiveFacet.report()` only QUEUES in tick-discipline mode and the reasoning
+     * launches from `pump()`, which the ExecutiveEngine calls once per tick — so an
+     * in-tick `await` blocks the very loop that would produce the answer. Observed
+     * live: a 61s freeze of the whole mind inside one tick, then an empty result.
+     * (It passes unit tests because bare facets have no inbox and author inline.)
+     *
+     * So `_deliver` REQUESTS words and returns false (the intent holds 'awaiting'),
+     * the facet answers off-tick, and a later tick delivers. Process-local by design:
+     * an authoring call in flight cannot survive a restart, and the intent would
+     * simply re-request.
+     */
+    private _authoring;
+    private _authored;
     constructor(schemas?: MotorSchema[]);
     attachBus(bus: CognitiveBus): void;
     /** Resolve schemas (incl. learned composites) from the live repertoire first. */
@@ -6284,6 +7234,13 @@ declare class MotorSchemaExecutor implements CognitiveEngine {
      * conversation facet); this is the single enaction → delivery path.
      */
     private _deliver;
+    /**
+     * Ask a facet for the words, off-tick. Fire-and-forget on purpose: awaiting this
+     * from inside `react()` deadlocks the tick loop against the facet pump. Idempotent
+     * per intent — a request already in flight is not duplicated, so the intent may sit
+     * 'awaiting' across many ticks with exactly one LLM call behind it.
+     */
+    private _requestAuthoring;
     private _emitEnacted;
     /**
      * Publish `action.outcome` for EVERY enaction — the shared metacognitive/affective
@@ -6292,6 +7249,32 @@ declare class MotorSchemaExecutor implements CognitiveEngine {
      * RewardEvaluator reads it as a reward signal. `confidence` carries the agency's
      * own forward-model prior so calibration has a real prediction to score.
      */
+    /**
+     * Retire the `ideomotor.intent` that produced this act.
+     *
+     * Nothing deleted these. They were cleared only when the executive next ran and
+     * declined to name the same action again — and the executive runs on an interval,
+     * so between cycles a willed reach-out STOOD in state, was rebuilt into an
+     * affordance every single tick, and competed every single tick. Observed as
+     * dozens of identical lines:
+     *
+     *   [selector] willed reach-out → … NOT selected: 0.297 < inspect… 0.340
+     *
+     * losing by four thousandths, over and over, until it won — twice. Fabrice got
+     * the same message byte-for-byte 25 ticks apart, two outbox ids.
+     *
+     * `justEnacted` was built to hold this line and cannot: it is a DECAYING
+     * quantity, capped at `repeatDamping` (0.30), and a standing intent outlasts it
+     * by construction. Damping a permanent pull only ever delays it. So the intention
+     * is discharged by being acted on, which is what an intention is — you meant to
+     * tell someone something, you told them, and it is finished. If the mind still
+     * wants to say more, the next executive cycle forms a new one, now seeing "I said
+     * this 25 ticks ago and have had no answer" in front of it.
+     *
+     * Satiation stays exactly as it was, and still earns its keep: it damps saying
+     * the same thing again for reasons that did NOT come from a standing will.
+     */
+    private _dischargeWill;
     private _emitActionOutcome;
     private _emitDispatch;
 }
@@ -6308,6 +7291,35 @@ declare class ReafferenceEngine implements CognitiveEngine {
     onCognitiveEvent(e: CognitiveEvent): void;
     snapshot(): Record<string, unknown>;
     react(_delta: Duration, tick: Tick, state: ReadonlySimulationState, _context: SimulationContext): Promise<EngineResult>;
+    /**
+     * Latch each open turn's fate onto its own record and announce it once.
+     *
+     * Two rules earn their keep here:
+     *
+     *  • MERGE, never replace. `StateManager.setEntity` overwrites the whole entity,
+     *    and a `conversation.sent` carries `outboxMessageIds` — the sole key by which
+     *    a later delivery ack can find it. Rewriting the record with only the fields
+     *    this method cares about would sever that, silently, for every turn that got
+     *    an answer.
+     *
+     *  • Latch, don't recompute. `answeredAt`/`unansweredAt` persist, so the event
+     *    fires on the one tick the fact changed rather than every tick for the rest
+     *    of the session — which for an unanswered turn would be thousands of
+     *    identical reputation hits against one person for one silence.
+     */
+    private _resolveReplies;
+    /**
+     * Publish how a person responded to being spoken to.
+     *
+     * Deliberately NOT an `interaction.occurred`: that event means "someone did
+     * something toward us" and carries a valence for what they did. A silence is
+     * nobody doing anything, and forcing it through that channel would have the
+     * ReputationTracker book a hostile *act* where there was only an absence — the
+     * mind would come to think it was being rebuffed rather than simply not
+     * answered yet. Separate signal, separate meaning, one consumer decides what
+     * either is worth.
+     */
+    private _emitResponsiveness;
     private _emitProceduralized;
     /**
      * Emit the `action.outcome{planId,stepId}` for an async (host-acked) plan-step
@@ -6339,6 +7351,12 @@ type EngineRegistry = {
     affectiveBlender: AffectiveBlender;
     workingMemory: WorkingMemory;
     episodicConsolidator: EpisodicConsolidator;
+    /**
+     * The vector index, when semantic recall is configured. Exposed so shutdown can
+     * FLUSH it: it lives outside the state snapshot and previously persisted only from
+     * a debounce timer no shutdown path awaited, so it died with the process.
+     */
+    vectorMemory: VectorMemoryAdapter | null;
     semanticIntegrator: SemanticIntegrator;
     spacedRepetition: SpacedRepetition;
     forgettingCurve: ForgettingCurve;
@@ -6645,12 +7663,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 {
     /**
@@ -6691,17 +7750,26 @@ interface WillConfig {
     profile?: string | null;
     /** Persona definition seeded into the will.identity entity. */
     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.
+     * This config's `identity` is a PLACEHOLDER — the real one arrives from a PMA
+     * artifact moments later, on the same boot.
+     *
+     * Set by `Will.wake`, which passes `{ prompt: '' }` because a woken mind's
+     * persona belongs to its artifact, not to the caller. Without this flag the
+     * creation-time identity guard inspected that placeholder and warned, on every
+     * single wake, that "identity.values is empty", "identity.style is generic" and
+     * "identity is shallow (strength 0)" — three alarms about a config nobody
+     * intended to use, fired before the real identity had loaded.
+     *
+     * It suppresses only the WARNINGS. Errors still throw (an over-long or
+     * malformed prompt is a hard failure whenever it appears), and the artifact's
+     * OWN identity is fully guarded at the load boundary by PMAController.load,
+     * which is the honest place to ask whether this mind's persona is thin — it is
+     * the only point where the answer is knowable.
      */
-    model?: string | WillModelConfig;
+    identityFromArtifact?: boolean;
+    /** Anatomy — 'mind' (default) or the no-LLM 'reflex' shell. */
+    anatomy?: Anatomy;
     /**
      * Per-Will LLM transport overrides (provider, BYO apiKey, baseUrl, output
      * cap, timeout). Unset fields fall back to WILL_LLM_* envs. The apiKey never
@@ -6735,6 +7803,21 @@ interface WillConfig {
      * Plan-enforced floor for executiveInterval — the customer cannot go faster.
      */
     minExecutiveInterval?: number;
+    /**
+     * Enable the DeliberationCache — a learned fast path that composes an executive
+     * output from highly-similar, highly-competent precedent instead of calling the
+     * LLM. Off unless asked for.
+     *
+     * OFF BY DEFAULT ON PURPOSE, and the default is the interesting part: this
+     * changes how a mind THINKS, not how fast it runs. A cache hit means the mind
+     * acted from precedent without deliberating, which is a real thing minds do and
+     * a real thing an operator must opt into for a specific Will — not something a
+     * dependency bump should switch on underneath one that is already living.
+     *
+     * Pass `true` for the built-in conservative settings, or a config object to tune
+     * the retrieval/competence parameters (see cognition/cache/types).
+     */
+    deliberationCache?: boolean | DeliberationCacheConfig;
     /**
      * Goals seeded before the first tick. If omitted or empty, the Will starts
      * goalless — the executive engine will generate context-appropriate goals on its
@@ -7465,7 +8548,7 @@ interface WillSummary {
     createdAt: Date;
     lastTickAt: Date | null;
     anatomy: WillConfig['anatomy'];
-    model: WillConfig['model'];
+    model: NonNullable<WillConfig['llm']>['model'];
 }
 
 interface WillInstance {
@@ -7828,6 +8911,8 @@ interface Stimulus {
     speaker?: string;
     /** Conversation/thread id (default = `from`). */
     thread?: string;
+    /** True when `thread` is private — just this someone and the Will. See TextMessage.direct. */
+    direct?: boolean;
 }
 /** A message the Will emitted to someone. */
 interface WillMessage {
@@ -7837,6 +8922,20 @@ interface WillMessage {
     content: string;
     /** Entity id the Will addressed (the speaker you used in say()/tell(), or a bond). */
     to: string;
+    /**
+     * The conversation this belongs to — the `thread` from the `perceive()` that
+     * prompted it. Absent when the Will spoke unprompted, which genuinely has no
+     * thread.
+     *
+     * WHERE, not just to whom. The engine knew this the whole way down —
+     * `OutboxMessage.threadId` carries it — and the projection dropped it here, so
+     * a channel adapter had nothing to answer INTO and had to guess from a roster.
+     * Observed live: a DM arrived on `discord:1532693…`, she answered it correctly
+     * and in seconds, and the reply went to the shared server channel because that
+     * was the last room the roster had seen this person in. From the operator's
+     * side she had simply ignored him.
+     */
+    thread?: string;
 }
 /**
  * A motor act the Will *chose* to enact — a projection of its agency, surfaced
@@ -7941,20 +9040,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 +9198,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 };