@mindot/will 0.8.0 → 0.10.0

package/README.md

@@ -36,7 +36,7 @@ Embed it six ways — [**SDK facade**](#the-will-sdk-facade--recommended) (Node/
 | Personality: a prompt string | Five-factor trait model that *develops* — traits self-tune from experience and carry a learned baseline across restarts |
 | No self-improvement | A closing metacognition loop — introspection writes back into the engine apparatus (accommodation), bounded and surprise-gated |
 | Token blowout at tick 600 | Context windowing — rolling summariser + isolated conversation threads |
-| Fire-and-forget actions | Bidirectional effector ack loop — the host confirms execution; the result feeds back as a percept |
+| Fire-and-forget actions | Bidirectional effector ack loop — the host confirms execution; the result feeds back through reafference |
 | Fixed effector catalog | Learning agency pipeline — actions are *found in the situation*, enacted, and proceduralised into composite skills via reafference |
 | No identity across restarts | A portable, eval-verified mind artifact (PMA) — psychology **and** learned competence, with a measured reconstruction-fidelity score |
 
@@ -141,9 +141,11 @@ WILL_IDENTITY="I am Aria — curious, dry-witted, fond of this server's people."
 ANTHROPIC_API_KEY=sk-ant-… npx -y @mindot/will discord
 ```
 
-No command prefix, no forced replies. It perceives the rooms it can see (salience-scored — perceiving costs no LLM call), **decides for itself when to speak** (silence is a valid outcome), learns people's names as *learned* knowledge (`discord:<userId>` is one entity across servers), keeps each channel as its own conversation thread, and **can message first** — proactive utterances route to the addressee's last shared channel, then their DM, then `WILL_DISCORD_HOME_CHANNEL`. On shutdown it hibernates to its PMA and returns as the same self, still knowing everyone.
+No command prefix, no forced replies. It perceives the rooms it can see (salience-scored — perceiving costs no LLM call), **decides for itself when to speak** (silence is a valid outcome, written as `[NO_MESSAGE]` and recorded rather than sent), learns people's names as *learned* knowledge, keeps each channel as its own conversation thread, and **can message first**. On shutdown it hibernates to its PMA and returns as the same self, still knowing everyone.
 
-Scope it with `WILL_DISCORD_CHANNELS` (id allowlist) and `WILL_DISCORD_MENTION_ONLY` for busy servers. The bridge grants no tools — it is a mouth and ears, not hands; abilities stay explicit (effectors / MCP). Setup + SDK embedding (`import { connectDiscord } from '@mindot/will/discord'`): [docs/channels/discord.md](docs/channels/discord.md) · runnable: [`examples/discord.ts`](examples/discord.ts).
+Someone the Will meets is a **referent**, not an address: `discord:<userId>` becomes an alias onto an anchor, so the same person met in a server, a DM, and on WhatsApp is one entity rather than three. The rooms they are reachable in hang off that anchor as handles carrying the circumstances — private or shared, and when they last *answered* there — so the mind picks where to say something from evidence about where this person actually replies. `WILL_DISCORD_HOME_CHANNEL` and the roster chain (last shared channel → DM → home) remain the bridge's fallback for when it has nothing to go on.
+
+Scope it with `WILL_DISCORD_CHANNELS` (id allowlist) and `WILL_DISCORD_MENTION_ONLY` for busy servers. The bridge answers one innate act and grants nothing else: when the Will **inspects** a room it is already in, Discord replies with what that room is for, what it sits under, and how many are in it — a count, never a roster, because people are met rather than listed. The answer arrives as a *percept* it perceives and judges, not as a value written into it. Everything beyond that stays explicit (effectors / MCP). Setup + SDK embedding (`import { connectDiscord } from '@mindot/will/discord'`): [docs/channels/discord.md](docs/channels/discord.md) · runnable: [`examples/discord.ts`](examples/discord.ts).
 
 ### The MCP server — a persistent mind in Claude Desktop / Claude Code
 
@@ -246,7 +248,7 @@ manager.addTickListener(willId, (snapshot, tick, outbox, invocations) => {
 })
 
 // Speak to the Will. The reply arrives on a later tick via the listener above.
-await manager.ingestText(willId, {
+await manager.senseText(willId, {
   kind:        'text',
   entityId:    'alice',
   content:     'How are you feeling about the night shift?',
@@ -254,13 +256,13 @@ await manager.ingestText(willId, {
 })
 ```
 
-There is **no synchronous reply** — `ingestText` returns immediately; the Will answers when it has reasoned. Subscribe to the tick listener *before* (or right after) sending, and treat the outbox as the single source of outbound messages and effector calls.
+There is **no synchronous reply** — `senseText` returns immediately; the Will answers when it has reasoned. Subscribe to the tick listener *before* (or right after) sending, and treat the outbox as the single source of outbound messages and effector calls.
 
 ---
 
 ## Architecture
 
-> **Visual map:** [`docs/graphs/`](docs/graphs/) holds twenty-one architecture graphs — the cognitive stories (memory, executive & facets, agency, audition, body & affect, meta-cognition, the executive ⇄ agency seam, planning & goals, social cognition, proactive communication, competence, the two persona channels), the machinery (the deterministic tick, the simulation core, the cognitive bus & wiring, one LLM call end-to-end, transports, the stem's tracts), the edges (host surfaces, the PMA lifecycle), and the [whole composition](docs/graphs/composition.svg). One palette across all of them: violet is always memory, amber executive, green agency. Regenerate with `bun docs/graphs/generate.ts`.
+> **Visual map:** [`docs/graphs/`](docs/graphs/) holds twenty-eight architecture graphs — the cognitive stories (memory, executive & facets, agency, audition, body & affect, meta-cognition, the executive ⇄ agency seam, planning & goals, social cognition, proactive communication, competence, the two persona channels), the loops that close on the world (exafference, policy reafference and its joint RFC, the answered loop, identity vs route, the signal boundary), the machinery (the deterministic tick, the simulation core, the cognitive bus & wiring, one LLM call end-to-end, model routing, transports, the stem's tracts), the edges (host surfaces, the PMA lifecycle), and the [whole composition](docs/graphs/composition.svg). One palette across all of them: violet is always memory, amber executive, green agency. Regenerate with `bun docs/graphs/generate.ts`.
 
 ![Will — the whole composition](docs/graphs/composition.svg)
 
@@ -329,6 +331,8 @@ A plan does **not** dispatch steps to an executor down a parallel channel. It pr
 
 A Will does not own a catalog of effectors it looks up. Capability is a **relation between a body-in-a-state and a world-as-perceived**, not a row in a table. So the Will **finds actions in the situation**: perception synthesises a field of *affordances*, a biased competition selects one, the executor enacts it, and the outcome (reafference) updates competence.
 
+Which is why there is a **sense boundary**. Cognition and world share one entity map, so the outward senses have to be told where the mind ends — otherwise it perceives its own bookkeeping as world events and the situation it finds actions in is made of itself. The mind's own types are enumerable (it knows its anatomy); the world's are not, so everything undeclared is world by default and a host can introduce anything. An engine that writes about the mind says so with `writes`; see [`src/cognition/sense.boundary.ts`](src/cognition/sense.boundary.ts).
+
 ```
 senses → percepts
   → AffordanceSynthesizer        affordance field            (no LLM · attention-gated)
@@ -362,14 +366,14 @@ registerProfile({
 manager.addTickListener(willId, (snap, tick, outbox, invocations) => {
   for (const inv of invocations) {
     const result = world.execute(inv)              // YOUR world runs the action
-    manager.confirmEffectorExecution(willId, inv.decisionRecordId, {
+    manager.confirmEffectorExecution(willId, inv.intentId, {
       success: result.ok, description: result.summary, metrics: result.metrics,
     })
   }
 })
 ```
 
-The acked outcome returns as an `effector.result` percept and feeds the agency learning loop — so the Will gets *better* at your effectors over time, and that learned competence travels in the PMA. (Today external effectors are objectless: the host resolves the target. Per-effector cost/preconditions and entity-targeting are on the roadmap.)
+The acked outcome returns as an `action.outcome` the ReafferenceEngine reconciles against what the Will expected, and feeds the agency learning loop — so the Will gets *better* at your effectors over time, and that learned competence travels in the PMA. (Today external effectors are objectless: the host resolves the target. Per-effector cost/preconditions and entity-targeting are on the roadmap.)
 
 ### Senses
 
@@ -398,7 +402,7 @@ When a Will decides to communicate or invoke an external effector, the result go
 - **`outbox`** — `OutboxMessage[]` — text/speech bubbles to deliver. Each has `deliveryStatus: 'pending' | 'delivered' | 'failed'`.
 - **`pendingEffectorInvocations`** — `EffectorInvocation[]` — structured action requests, each carrying a correlation handle.
 
-The host closes the reafference loop by confirming back — which writes an `effector.result` percept into Exteroception, so the Will *learns what happened*:
+The host closes the reafference loop by confirming back — which writes an `action.outcome` the ReafferenceEngine reconciles, so the Will *learns what happened*:
 
 ```typescript
 manager.confirmMessageDelivery(willId, messageId, true)
@@ -641,7 +645,7 @@ await manager.archiveWill(willId)   // stops tick loop, persists final snapshot
 // Every tick — drain outbox + effector invocations, push to SSE/WS clients
 const unsub = manager.addTickListener(willId, (snapshot, tick, outbox, invocations) => {
   for (const msg of outbox)        pushToClient(msg)      // .id .content .effectorName .targetEntityId .deliveryStatus
-  for (const inv of invocations)   dispatchToWorld(inv)   // .decisionRecordId ← correlation handle
+  for (const inv of invocations)   dispatchToWorld(inv)   // .intentId ← correlation handle
 })
 
 // Fine-grained simulation events (goal.formed, belief.updated, emotion.spike, …)
@@ -696,7 +700,7 @@ manager.loadPMA(willId, pma)
 const report = await manager.runPMAEval(willId, { behavioral: true })
 
 // Senses — route external input through the sense engines
-await manager.ingestText(willId, { kind: 'text', entityId, content, speakerName })
+await manager.senseText(willId, { kind: 'text', entityId, content, speakerName })
 manager.getSenseEngineStatus(willId)          // five domains; audition active
 
 // Health & recovery

package/dist/index.d.ts

@@ -1,143 +1,5 @@
-import { O as OutboundEnvelope, A as AckResult, a as ExternalTransport, I as InboundEnvelope, T as TransportStatus, S as SimulationContext, b as SeededPRNG, c as SimulationEntity, d as Timestamp, e as SimulationEvent, f as StateManager, g as Tick, h as SimulationState, R as RestoreOptions, i as StateCommands, j as ReasoningFootprint, k as ReadonlySimulationState, C as ConflictReport, l as ConflictStrategy, m as ConflictResolution } from './will-cS6k4uiJ.js';
-export { n as AckEnvelope, o as ActionRequest, p as ActionResult, q as ActionSelector, r as ActivityEnvelope, s as ActivityEvent, t as ActivityEventHandler, u as AestheticEvaluator, v as AestheticEvaluatorConfig, w as AffectiveBlender, x as AffectiveBlenderConfig, y as AffordanceSynthesizer, z as AsyncEngine, B as AsyncEngineConfig, D as AttachmentEvaluator, F as AttachmentEvaluatorConfig, G as AttentionAllocator, H as AttentionAllocatorConfig, J as AuditionEngine, K as AutobiographicalNarrator, L as AutobiographicalNarratorConfig, M as BACKGROUND_DEMAND, N as BehavioralProbeResult, P as BiasDetector, Q as BiasDetectorConfig, U as BunStorageAdapter, V as ChunkEnvelope, X as CircadianConfig, Y as CircadianOscillator, Z as ClockConfig, _ as Cognition, $ as CognitiveHealth, a0 as ConfidenceCalibrator, a1 as ConfidenceCalibratorConfig, a2 as Coordinates, a3 as CreateWillOptions, a4 as DefaultEventBus, a5 as DefaultMetricCollector, a6 as DefaultOrchestrator, a7 as DefaultReplayRecorder, a8 as DefaultReplaySession, a9 as DefaultScenario, aa as DefaultSerializer, ab as DefaultSimulation, ac as DefaultSimulationClock, ad as DefaultStateManager, ae as DefaultVectorMemoryAdapter, af as DeliberationEngine, ag as DeltaEncoder, ah as DeltaSnapshot, ai as DreamSimulator, aj as DreamSimulatorConfig, ak as Duration, al as ESCALATION_DEMAND, am as EffectorDeclaration, an as EffectorEntry, E as EffectorHandler, ao as EffectorResult, ap as EffectorSpec, aq as EmbeddingProvider, ar as EmpathySimulator, as as EmpathySimulatorConfig, at as EnergyRegulator, au as EnergyRegulatorConfig, av as EngineRegistry, aw as EngineResult, ax as Envelope, ay as EpisodicConsolidator, az as EpisodicConsolidatorConfig, aA as EventBus, aB as EventBusConfig, aC as EventFilter, aD as EventHandler, aE as EventPayload, aF as ExecutiveEngine, aG as ExecutiveEngineConfig, aH as Exteroception, aI as ExteroceptionConfig, aJ as ForgettingCurve, aK as ForgettingCurveConfig, aL as FrustrationEvaluator, aM as FrustrationEvaluatorConfig, aN as GoalManager, aO as GoalManagerConfig, aP as GustationEngine, aQ as InboundMessageEnvelope, aR as InboundPerceptEnvelope, aS as InhibitionController, aT as InhibitionControllerConfig, aU as Interoception, aV as InteroceptionConfig, aW as IntrospectionEngine, aX as IntrospectionEngineConfig, aY as KNOWN_PROVIDERS, aZ as KnownEntityTracker, a_ as KnownEntityTrackerConfig, a$ as KnownProvider, b0 as LLMCallMeta, b1 as LLMCompletionRecord, b2 as LLMCompletionSink, b3 as LLMProvider, b4 as LLMWire, b5 as LossEvaluator, b6 as LossEvaluatorConfig, b7 as MessageEnvelope, b8 as MetricCollector, b9 as MetricPoint, ba as MinimalContext, bb as MockEmbedder, bc as ModelPrice, bd as ModelRoute, be as ModelRouter, bf as MoralEvaluator, bg as MoralEvaluatorConfig, bh as MotorSchemaExecutor, bi as NULL_ROUTER, bj as NoveltyDetector, bk as NoveltyDetectorConfig, bl as OlfactionEngine, bm as OpenAICompatibleEmbedder, bn as Orchestrator, bo as OrchestratorConfig, bp as OutboxMessage, bq as PMABehavioral, br as PMABelief, bs as PMAEmotionalBaseline, bt as PMAEvalHarness, bu as PMAGoal, bv as PMAIdentity, bw as PMAProbe, bx as PMASnapshot, by as PerceptEnvelope, bz as PersonaConsolidator, bA as PersonaConsolidatorConfig, bB as PlanningEngine, bC as PlanningEngineConfig, bD as PriceTable, bE as ProviderCredential, bF as ReafferenceEngine, bG as ReconstructionFidelityReport, bH as ReconstructionFidelityScores, bI as RecordUsageInput, bJ as ReplayComparison, bK as ReplayConfig, bL as ReplayDifference, bM as ReplayManager, bN as ReplayMetadata, bO as ReplayRecord, bP as ReplayRecorder, bQ as ReplaySession, bR as ReplyEnvelope, bS as ReputationTracker, bT as ReputationTrackerConfig, bU as RewardEvaluator, bV as RewardEvaluatorConfig, bW as RoutingRule, bX as Scenario, bY as ScenarioConfig, bZ as ScenarioValidationResult, b_ as SchemaPrecondition, b$ as SelfModelUpdater, c0 as SelfModelUpdaterConfig, c1 as SemanticIntegrator, c2 as SemanticIntegratorConfig, c3 as SensoryInput, c4 as SerializationConfig, c5 as SerializationFormat, c6 as SerializedEntity, c7 as SerializedState, c8 as Serializer, c9 as SessionLogEnvelope, ca as Simulation, cb as SimulationClock, cc as SimulationConfig, cd as SimulationEngine, ce as SimulationEventBase, cf as SimulationEventListener, cg as SleepPressureConfig, ch as SleepPressureRegulator, ci as SocialPerception, cj as SocialPerceptionConfig, ck as SomatosensationEngine, cl as SpacedRepetition, cm as SpacedRepetitionConfig, cn as StateSnapshot, co as Stimulus, cp as StorageAdapter, cq as StressRegulator, cr as StressRegulatorConfig, cs as TableRouter, ct as TaskSwitcher, cu as TaskSwitcherConfig, cv as TextMessage, cw as TheoryOfMind, cx as TheoryOfMindConfig, cy as ThreatEvaluator, cz as ThreatEvaluatorConfig, cA as TickListener, cB as TokenLedgerRecord, cC as TokenReportEnvelope, cD as TokenTracker, cE as TokenTrackerConfig, cF as TokenUsage, cG as VectorIndex, cH as VectorMemoryAdapter, cI as VectorMemoryConfig, cJ as VectorQueryFilter, cK as VectorQueryResult, cL as VectorRecord, cM as VisionEngine, cN as VoiceChunk, W as Will, cO as WillAffect, cP as WillConfig, cQ as WillEffectorAct, cR as WillInstance, cS as WillMessage, cT as WillStateSummary, cU as WillStatus, cV as WillStem, cW as WillSummary, cX as WorkingMemory, cY as WorkingMemoryConfig, cZ as WorldEntity, c_ as WorldInterface, c$ as assembleMind, d0 as chainRouters, d1 as clearCompletionRecorder, d2 as defaultBaseFor, d3 as effectorInvocation, d4 as effectorInvocationEnvelope, d5 as getCompletionRecorder, d6 as isNullRouter, d7 as knownWireFor, d8 as resolvePricing, d9 as setCompletionRecorder } from './will-cS6k4uiJ.js';
-
-/** Decides how emit() resolves an ack for a given envelope. Default: acked via callback. */
-type AckPolicy = (env: OutboundEnvelope) => AckResult;
-declare class LoopbackTransport implements ExternalTransport {
-    /** Every envelope passed to emit(), in order — inspect in tests. */
-    readonly sent: OutboundEnvelope[];
-    private _connected;
-    private _ackPolicy;
-    private readonly _inboundHandlers;
-    private readonly _statusHandlers;
-    constructor(ackPolicy?: AckPolicy);
-    get connected(): boolean;
-    emit(env: OutboundEnvelope): Promise<AckResult>;
-    onInbound(handler: (env: InboundEnvelope) => void): () => void;
-    onStatus(handler: (s: TransportStatus) => void): () => void;
-    close(): void;
-    /** Simulate the peer sending an inbound envelope to the Will. */
-    injectInbound(env: InboundEnvelope): void;
-    /** Flip connection state and notify status handlers. */
-    setConnected(connected: boolean): void;
-    /** Swap the ack policy mid-test (e.g. to simulate timeouts then recovery). */
-    setAckPolicy(policy: AckPolicy): void;
-    /** Convenience: only the envelopes on a given channel. */
-    sentOn<T extends OutboundEnvelope['channel']>(channel: T): Extract<OutboundEnvelope, {
-        channel: T;
-    }>[];
-}
-
-/** Minimal surface of a socket.io client we depend on — keeps us decoupled from the dep's types. */
-interface SocketLike {
-    connected: boolean;
-    on(event: string, handler: (...args: any[]) => void): void;
-    emit(event: string, payload: unknown, ack?: (response: unknown) => void): void;
-    disconnect(): void;
-}
-interface SocketIoTransportOptions {
-    /** socket.io server URL (e.g. wss://host or http://host:port). */
-    url: string;
-    /** This Will's id — sent as auth + routing key. */
-    willId: string;
-    /** Optional auth token sent in the socket.io handshake. */
-    token?: string;
-    /** Default ack timeout for emit() in ms. Default 5000. */
-    ackTimeoutMs?: number;
-    /**
-     * Override the socket factory — inject a fake in tests, or customize the
-     * socket.io connection. When omitted, `socket.io-client` is dynamically
-     * imported and `io(url, { auth })` is called.
-     */
-    socketFactory?: (url: string, opts: {
-        auth: {
-            willId: string;
-            token?: string;
-        };
-    }) => SocketLike | Promise<SocketLike>;
-}
-declare class SocketIoTransport implements ExternalTransport {
-    private readonly _opts;
-    private _socket;
-    private _connecting;
-    private _seq;
-    private readonly _inboundHandlers;
-    private readonly _statusHandlers;
-    constructor(_opts: SocketIoTransportOptions);
-    get connected(): boolean;
-    emit(env: OutboundEnvelope, opts?: {
-        ackTimeoutMs?: number;
-    }): Promise<AckResult>;
-    onInbound(handler: (env: InboundEnvelope) => void): () => void;
-    onStatus(handler: (s: TransportStatus) => void): () => void;
-    close(): void;
-    private _ensureSocket;
-    private _connect;
-    private _defaultFactory;
-    /** Attach socket.io event handlers that feed the inbound + status streams. */
-    private _wire;
-    private _emitInbound;
-    private _notifyStatus;
-    private _deliveryAck;
-    private _resultAck;
-}
-
-/** Channels a consumer can filter on (any OutboundEnvelope channel, or '*'). */
-type StreamChannel = OutboundEnvelope['channel'] | '*';
-type OutboundListener = (env: OutboundEnvelope) => void;
-declare class StreamTransport implements ExternalTransport {
-    readonly willId: string;
-    private _connected;
-    private readonly _outbound;
-    private readonly _outboundByCh;
-    private readonly _inboundHandlers;
-    private readonly _statusHandlers;
-    constructor(willId?: string);
-    get connected(): boolean;
-    /**
-     * Deliver an outbound envelope to subscribers. In-process and synchronous, so
-     * it resolves immediately (`via: 'event'`) — there is no remote peer to ack.
-     * A listener that throws is isolated; it can never break the tick loop.
-     */
-    emit(env: OutboundEnvelope): Promise<AckResult>;
-    /** Subscribe to every outbound envelope. Returns an unsubscribe function. */
-    subscribe(listener: OutboundListener): () => void;
-    /**
-     * Subscribe to a single channel (e.g. `'token_report'`, `'session_log'`,
-     * `'reply'`) or `'*'` for all. Returns an unsubscribe function.
-     */
-    on(channel: StreamChannel, listener: OutboundListener): () => void;
-    /**
-     * Inject an inbound envelope (message, percept, ack) into the Will. The stem
-     * enqueues it onto the tick-stamped InboundQueue and applies it deterministically
-     * on tick — this method itself never touches simulation state.
-     */
-    injectInbound(env: InboundEnvelope): void;
-    onInbound(handler: (env: InboundEnvelope) => void): () => void;
-    onStatus(handler: (s: TransportStatus) => void): () => void;
-    /** Notify status subscribers (e.g. flip to 'disconnected' in a test). */
-    setStatus(status: TransportStatus): void;
-    close(): void;
-    /** Total active outbound listeners (diagnostics/tests). */
-    get listenerCount(): number;
-    private _dispatch;
-}
-/**
- * Whether producers should ALSO write their telemetry to local files.
- *
- * Files are a development convenience only. In production the stream/transport is
- * the single source of truth and the consumer owns persistence.
- *
- * - `WILL_FILE_LOGS=true|1|false|0` — explicit override (wins).
- * - otherwise: on when `NODE_ENV` is neither `production` nor `test`.
- */
-declare function fileLoggingEnabled(): boolean;
-
-/**
- * Number of ticks an undelivered outbox message survives before it is
- * expired. Override via WILL_OUTBOX_TTL_TICKS. Default: 100 ticks.
- */
-declare const OUTBOX_TTL_TICKS: number;
+import { S as SimulationContext, a as SeededPRNG, b as SimulationEntity, T as Timestamp, c as SimulationEvent, d as StateManager, e as Tick, f as SimulationState, R as RestoreOptions, g as StateCommands, h as ReasoningFootprint, i as ReadonlySimulationState, C as ConflictReport, j as ConflictStrategy, k as ConflictResolution, O as OutboundEnvelope, A as AckResult, l as ExternalTransport, I as InboundEnvelope, m as TransportStatus, P as PolicyDecision, D as DenialFinality, n as PolicyArbiter, o as PolicyInvocation, V as Verdict } from './will-evj9_vrd.js';
+export { p as AckEnvelope, q as ActionRequest, r as ActionResult, s as ActionSelector, t as ActivityEnvelope, u as ActivityEvent, v as ActivityEventHandler, w as AestheticEvaluator, x as AestheticEvaluatorConfig, y as AffectiveBlender, z as AffectiveBlenderConfig, B as AffordanceSynthesizer, F as AsyncEngine, G as AsyncEngineConfig, H as AttachmentEvaluator, J as AttachmentEvaluatorConfig, K as AttentionAllocator, L as AttentionAllocatorConfig, M as AuditionEngine, N as AutobiographicalNarrator, Q as AutobiographicalNarratorConfig, U as BACKGROUND_DEMAND, X as BehavioralProbeResult, Y as BiasDetector, Z as BiasDetectorConfig, _ as BunStorageAdapter, $ as ChunkEnvelope, a0 as CircadianConfig, a1 as CircadianOscillator, a2 as ClockConfig, a3 as Cognition, a4 as CognitiveHealth, a5 as ConfidenceCalibrator, a6 as ConfidenceCalibratorConfig, a7 as Coordinates, a8 as CreateWillOptions, a9 as DefaultEventBus, aa as DefaultMetricCollector, ab as DefaultOrchestrator, ac as DefaultReplayRecorder, ad as DefaultReplaySession, ae as DefaultScenario, af as DefaultSerializer, ag as DefaultSimulation, ah as DefaultSimulationClock, ai as DefaultStateManager, aj as DefaultVectorMemoryAdapter, ak as DeliberationEngine, al as DeltaEncoder, am as DeltaSnapshot, an as DreamSimulator, ao as DreamSimulatorConfig, ap as Duration, aq as ESCALATION_DEMAND, ar as EffectorDeclaration, as as EffectorEntry, E as EffectorHandler, at as EffectorResult, au as EffectorSpec, av as EmbeddingProvider, aw as EmpathySimulator, ax as EmpathySimulatorConfig, ay as EnergyRegulator, az as EnergyRegulatorConfig, aA as EngineRegistry, aB as EngineResult, aC as Envelope, aD as EpisodicConsolidator, aE as EpisodicConsolidatorConfig, aF as EventBus, aG as EventBusConfig, aH as EventFilter, aI as EventHandler, aJ as EventPayload, aK as ExecutiveEngine, aL as ExecutiveEngineConfig, aM as Exteroception, aN as ExteroceptionConfig, aO as ForgettingCurve, aP as ForgettingCurveConfig, aQ as FrustrationEvaluator, aR as FrustrationEvaluatorConfig, aS as GoalManager, aT as GoalManagerConfig, aU as GustationEngine, aV as InboundMessageEnvelope, aW as InboundPerceptEnvelope, aX as InhibitionController, aY as InhibitionControllerConfig, aZ as Interoception, a_ as InteroceptionConfig, a$ as IntrospectionEngine, b0 as IntrospectionEngineConfig, b1 as KNOWN_PROVIDERS, b2 as KnownEntityTracker, b3 as KnownEntityTrackerConfig, b4 as KnownProvider, b5 as LLMCallMeta, b6 as LLMCompletionRecord, b7 as LLMCompletionSink, b8 as LLMProvider, b9 as LLMWire, ba as LossEvaluator, bb as LossEvaluatorConfig, bc as MessageEnvelope, bd as MetricCollector, be as MetricPoint, bf as MinimalContext, bg as MockEmbedder, bh as ModelPrice, bi as ModelRoute, bj as ModelRouter, bk as MoralEvaluator, bl as MoralEvaluatorConfig, bm as MotorSchemaExecutor, bn as NULL_ARBITER, bo as NULL_ROUTER, bp as NoveltyDetector, bq as NoveltyDetectorConfig, br as OlfactionEngine, bs as OpenAICompatibleEmbedder, bt as Orchestrator, bu as OrchestratorConfig, bv as OutboxMessage, bw as PMABehavioral, bx as PMABelief, by as PMAEmotionalBaseline, bz as PMAEvalHarness, bA as PMAGoal, bB as PMAIdentity, bC as PMAProbe, bD as PMASnapshot, bE as PerceptEnvelope, bF as PersonaConsolidator, bG as PersonaConsolidatorConfig, bH as PlanningEngine, bI as PlanningEngineConfig, bJ as PolicyCounterfactual, bK as PriceTable, bL as ProviderCredential, bM as ReafferenceEngine, bN as ReconstructionFidelityReport, bO as ReconstructionFidelityScores, bP as RecordUsageInput, bQ as ReplayComparison, bR as ReplayConfig, bS as ReplayDifference, bT as ReplayManager, bU as ReplayMetadata, bV as ReplayRecord, bW as ReplayRecorder, bX as ReplaySession, bY as ReplyEnvelope, bZ as ReputationTracker, b_ as ReputationTrackerConfig, b$ as RewardEvaluator, c0 as RewardEvaluatorConfig, c1 as RoutingRule, c2 as Scenario, c3 as ScenarioConfig, c4 as ScenarioValidationResult, c5 as SchemaPrecondition, c6 as SelfModelUpdater, c7 as SelfModelUpdaterConfig, c8 as SemanticIntegrator, c9 as SemanticIntegratorConfig, ca as SensoryInput, cb as SensorySignal, cc as SerializationConfig, cd as SerializationFormat, ce as SerializedEntity, cf as SerializedState, cg as Serializer, ch as SessionLogEnvelope, ci as SignalProvenance, cj as Simulation, ck as SimulationClock, cl as SimulationConfig, cm as SimulationEngine, cn as SimulationEventBase, co as SimulationEventListener, cp as SleepPressureConfig, cq as SleepPressureRegulator, cr as SocialPerception, cs as SocialPerceptionConfig, ct as SomatosensationEngine, cu as SpacedRepetition, cv as SpacedRepetitionConfig, cw as StateSnapshot, cx as Stimulus, cy as StorageAdapter, cz as StressRegulator, cA as StressRegulatorConfig, cB as TableRouter, cC as TaskSwitcher, cD as TaskSwitcherConfig, cE as TextMessage, cF as TheoryOfMind, cG as TheoryOfMindConfig, cH as ThreatEvaluator, cI as ThreatEvaluatorConfig, cJ as TickListener, cK as TokenLedgerRecord, cL as TokenReportEnvelope, cM as TokenTracker, cN as TokenTrackerConfig, cO as TokenUsage, cP as Transduced, cQ as VectorIndex, cR as VectorMemoryAdapter, cS as VectorMemoryConfig, cT as VectorQueryFilter, cU as VectorQueryResult, cV as VectorRecord, cW as VisionEngine, cX as VoiceChunk, W as Will, cY as WillAffect, cZ as WillConfig, c_ as WillEffectorAct, c$ as WillInstance, d0 as WillMessage, d1 as WillStateSummary, d2 as WillStatus, d3 as WillStem, d4 as WillSummary, d5 as WorkingMemory, d6 as WorkingMemoryConfig, d7 as WorldEntity, d8 as WorldInterface, d9 as asFinality, da as asProvenance, db as assembleMind, dc as chainRouters, dd as clearCompletionRecorder, de as defaultBaseFor, df as effectorInvocation, dg as effectorInvocationEnvelope, dh as finalityOf, di as getCompletionRecorder, dj as isNullArbiter, dk as isNullRouter, dl as knownWireFor, dm as resolvePricing, dn as setCompletionRecorder } from './will-evj9_vrd.js';
 
 /**
  * Creates a Mulberry32 PRNG from the given seed.
@@ -416,6 +278,144 @@ declare class ConflictDetector {
     private _merge;
 }
 
+/** Decides how emit() resolves an ack for a given envelope. Default: acked via callback. */
+type AckPolicy = (env: OutboundEnvelope) => AckResult;
+declare class LoopbackTransport implements ExternalTransport {
+    /** Every envelope passed to emit(), in order — inspect in tests. */
+    readonly sent: OutboundEnvelope[];
+    private _connected;
+    private _ackPolicy;
+    private readonly _inboundHandlers;
+    private readonly _statusHandlers;
+    constructor(ackPolicy?: AckPolicy);
+    get connected(): boolean;
+    emit(env: OutboundEnvelope): Promise<AckResult>;
+    onInbound(handler: (env: InboundEnvelope) => void): () => void;
+    onStatus(handler: (s: TransportStatus) => void): () => void;
+    close(): void;
+    /** Simulate the peer sending an inbound envelope to the Will. */
+    injectInbound(env: InboundEnvelope): void;
+    /** Flip connection state and notify status handlers. */
+    setConnected(connected: boolean): void;
+    /** Swap the ack policy mid-test (e.g. to simulate timeouts then recovery). */
+    setAckPolicy(policy: AckPolicy): void;
+    /** Convenience: only the envelopes on a given channel. */
+    sentOn<T extends OutboundEnvelope['channel']>(channel: T): Extract<OutboundEnvelope, {
+        channel: T;
+    }>[];
+}
+
+/** Minimal surface of a socket.io client we depend on — keeps us decoupled from the dep's types. */
+interface SocketLike {
+    connected: boolean;
+    on(event: string, handler: (...args: any[]) => void): void;
+    emit(event: string, payload: unknown, ack?: (response: unknown) => void): void;
+    disconnect(): void;
+}
+interface SocketIoTransportOptions {
+    /** socket.io server URL (e.g. wss://host or http://host:port). */
+    url: string;
+    /** This Will's id — sent as auth + routing key. */
+    willId: string;
+    /** Optional auth token sent in the socket.io handshake. */
+    token?: string;
+    /** Default ack timeout for emit() in ms. Default 5000. */
+    ackTimeoutMs?: number;
+    /**
+     * Override the socket factory — inject a fake in tests, or customize the
+     * socket.io connection. When omitted, `socket.io-client` is dynamically
+     * imported and `io(url, { auth })` is called.
+     */
+    socketFactory?: (url: string, opts: {
+        auth: {
+            willId: string;
+            token?: string;
+        };
+    }) => SocketLike | Promise<SocketLike>;
+}
+declare class SocketIoTransport implements ExternalTransport {
+    private readonly _opts;
+    private _socket;
+    private _connecting;
+    private _seq;
+    private readonly _inboundHandlers;
+    private readonly _statusHandlers;
+    constructor(_opts: SocketIoTransportOptions);
+    get connected(): boolean;
+    emit(env: OutboundEnvelope, opts?: {
+        ackTimeoutMs?: number;
+    }): Promise<AckResult>;
+    onInbound(handler: (env: InboundEnvelope) => void): () => void;
+    onStatus(handler: (s: TransportStatus) => void): () => void;
+    close(): void;
+    private _ensureSocket;
+    private _connect;
+    private _defaultFactory;
+    /** Attach socket.io event handlers that feed the inbound + status streams. */
+    private _wire;
+    private _emitInbound;
+    private _notifyStatus;
+    private _deliveryAck;
+    private _resultAck;
+}
+
+/** Channels a consumer can filter on (any OutboundEnvelope channel, or '*'). */
+type StreamChannel = OutboundEnvelope['channel'] | '*';
+type OutboundListener = (env: OutboundEnvelope) => void;
+declare class StreamTransport implements ExternalTransport {
+    readonly willId: string;
+    private _connected;
+    private readonly _outbound;
+    private readonly _outboundByCh;
+    private readonly _inboundHandlers;
+    private readonly _statusHandlers;
+    constructor(willId?: string);
+    get connected(): boolean;
+    /**
+     * Deliver an outbound envelope to subscribers. In-process and synchronous, so
+     * it resolves immediately (`via: 'event'`) — there is no remote peer to ack.
+     * A listener that throws is isolated; it can never break the tick loop.
+     */
+    emit(env: OutboundEnvelope): Promise<AckResult>;
+    /** Subscribe to every outbound envelope. Returns an unsubscribe function. */
+    subscribe(listener: OutboundListener): () => void;
+    /**
+     * Subscribe to a single channel (e.g. `'token_report'`, `'session_log'`,
+     * `'reply'`) or `'*'` for all. Returns an unsubscribe function.
+     */
+    on(channel: StreamChannel, listener: OutboundListener): () => void;
+    /**
+     * Inject an inbound envelope (message, percept, ack) into the Will. The stem
+     * enqueues it onto the tick-stamped InboundQueue and applies it deterministically
+     * on tick — this method itself never touches simulation state.
+     */
+    injectInbound(env: InboundEnvelope): void;
+    onInbound(handler: (env: InboundEnvelope) => void): () => void;
+    onStatus(handler: (s: TransportStatus) => void): () => void;
+    /** Notify status subscribers (e.g. flip to 'disconnected' in a test). */
+    setStatus(status: TransportStatus): void;
+    close(): void;
+    /** Total active outbound listeners (diagnostics/tests). */
+    get listenerCount(): number;
+    private _dispatch;
+}
+/**
+ * Whether producers should ALSO write their telemetry to local files.
+ *
+ * Files are a development convenience only. In production the stream/transport is
+ * the single source of truth and the consumer owns persistence.
+ *
+ * - `WILL_FILE_LOGS=true|1|false|0` — explicit override (wins).
+ * - otherwise: on when `NODE_ENV` is neither `production` nor `test`.
+ */
+declare function fileLoggingEnabled(): boolean;
+
+/**
+ * Number of ticks an undelivered outbox message survives before it is
+ * expired. Override via WILL_OUTBOX_TTL_TICKS. Default: 100 ticks.
+ */
+declare const OUTBOX_TTL_TICKS: number;
+
 interface WorldProfile {
     id: string;
     name: string;
@@ -433,4 +433,51 @@ declare function resolveProfile(id: string): WorldProfile | undefined;
 /** List all registered profile ids. */
 declare function listProfiles(): string[];
 
-export { type AckPolicy, AckResult, ConflictDetector, ConflictReport, ConflictResolution, ConflictStrategy, ConsistentHashRouter, ConsoleLogger, type CrossShardQuery, type CrossShardResult, type CrossShardTransport, DefaultPartitionRouter, type DeliveryGuarantee, type DistributedEvent, type DistributedNode, type DistributedNodeConfig, DistributedOrchestrator, DistributedStateManager, ExternalTransport, InboundEnvelope, LocalTransport, type Logger, LoopbackTransport, OUTBOX_TTL_TICKS, OutboundEnvelope, type OutboundListener, type PartitionRouter, ReasoningFootprint, RestoreOptions, type ShardConfig, type ShardStrategy, SilentLogger, SimulationContext, SimulationEntity, SimulationEvent, SimulationState, SocketIoTransport, type SocketIoTransportOptions, type SocketLike, StateManager, type StreamChannel, StreamTransport, Tick, Timestamp, TransportStatus, type WorldProfile, createContext, createPRNG, fileLoggingEnabled, getLogger, listProfiles, logger, resetLogger, resolveProfile, setLogger };
+/** A bound on one parameter. Checked in declaration order: max, min, equals, oneOf. */
+interface ParamConstraint {
+    max?: number;
+    min?: number;
+    equals?: unknown;
+    oneOf?: readonly unknown[];
+}
+/**
+ * One rule. `schema`/`target` scope it (omitted ⇒ matches any); the FIRST rule
+ * whose scope matches decides, so order is policy.
+ *
+ * `require` is meaningful with `decision: 'allow'` only: the scope matched, and
+ * these constraints must hold for the allow to stand. A violation flips the
+ * verdict to deny — carrying the counterfactual — with finality 'parameter',
+ * because the ability itself was permitted and only these arguments were not.
+ *
+ * A rule with `decision: 'deny'` and no `require` is a flat class-level ban;
+ * it reports finality 'class' unless told otherwise.
+ */
+interface PolicyRule {
+    schema?: string;
+    target?: string;
+    decision: PolicyDecision;
+    require?: Record<string, ParamConstraint>;
+    reasonCode?: string;
+    finality?: DenialFinality;
+}
+interface RuleTableOptions {
+    rules: readonly PolicyRule[];
+    /**
+     * The verdict when NO rule matches. Required — deliberately not defaulted.
+     * A policy component that silently defaults open is a trap; make the posture
+     * an explicit decision at the call site. 'deny' is fail-closed and is the
+     * right choice once a rule set is complete.
+     */
+    fallthrough: PolicyDecision;
+    /** Recorded with every verdict for audit. Defaults to 'rule-table'. */
+    name?: string;
+}
+declare class RuleTableArbiter implements PolicyArbiter {
+    readonly name: string;
+    private readonly _rules;
+    private readonly _fallthrough;
+    constructor(opts: RuleTableOptions);
+    evaluate(invocation: PolicyInvocation): Verdict;
+}
+
+export { type AckPolicy, AckResult, ConflictDetector, ConflictReport, ConflictResolution, ConflictStrategy, ConsistentHashRouter, ConsoleLogger, type CrossShardQuery, type CrossShardResult, type CrossShardTransport, DefaultPartitionRouter, type DeliveryGuarantee, DenialFinality, type DistributedEvent, type DistributedNode, type DistributedNodeConfig, DistributedOrchestrator, DistributedStateManager, ExternalTransport, InboundEnvelope, LocalTransport, type Logger, LoopbackTransport, OUTBOX_TTL_TICKS, OutboundEnvelope, type OutboundListener, type ParamConstraint, type PartitionRouter, PolicyArbiter, PolicyDecision, PolicyInvocation, type PolicyRule, ReasoningFootprint, RestoreOptions, RuleTableArbiter, type RuleTableOptions, type ShardConfig, type ShardStrategy, SilentLogger, SimulationContext, SimulationEntity, SimulationEvent, SimulationState, SocketIoTransport, type SocketIoTransportOptions, type SocketLike, StateManager, type StreamChannel, StreamTransport, Tick, Timestamp, TransportStatus, Verdict, type WorldProfile, createContext, createPRNG, fileLoggingEnabled, getLogger, listProfiles, logger, resetLogger, resolveProfile, setLogger };