@mindot/will 0.8.0 → 0.10.0

package/src/{sdk → surface/sdk}/will.ts

@@ -1,5 +1,5 @@
 // ─────────────────────────────────────────────────────────────
-// src/sdk/will.ts — the ergonomic facade
+// src/surface/sdk/will.ts — the ergonomic facade
 // ─────────────────────────────────────────────────────────────
 //
 // `WillStem` is the full, powerful contract (tick listeners, the outbox drain,
@@ -9,11 +9,11 @@
 //   const will = await Will.create({ name: 'Aria', identity: {...} })
 //   will.on('message', m => console.log(m.content))
 //   will.effector('search_docs', async a => await myDb.search(a.query))
-//   await will.perceive({ from: 'ada', text: 'What should we work on?' })
+//   await will.sense({ from: 'ada', text: 'What should we work on?', provenance: 'exafferent' })
 //   const reply = await will.nextUtterance({ to: 'ada' })   // WillMessage | null
 //   const pma = await will.save()               // non-destructive; keeps ticking
 //
-// A Will is a *subject*, not a function: you `perceive` stimuli to it and observe
+// A Will is a *subject*, not a function: you `sense` stimuli to it and observe
 // its *projections* (message / effector / emotion / state) — you never `await`
 // a computed return. `nextUtterance` is a thin, honest adapter for callers that
 // want a reply-shaped await; `null` means the Will chose silence, not an error.
@@ -33,12 +33,14 @@ import { PROVIDER_KEY_ENV, providerKeyFromEnv, type LLMProvider } from '#llm/ind
 import type { PMASnapshot } from '#pma/index'
 import type { effectorInvocation } from '#types'
 import type { EffectorDeclaration, SchemaPrecondition } from '#agency/types'
+import type { PolicyArbiter } from '#stem/policy/arbiter'
+import type { SignalProvenance } from '#senses/provenance'
 
 // ── Public surface ────────────────────────────────────────────
 
 /**
  * A stimulus entering the Will's sensory field. A Will is a subject, not a
- * function: you don't *call* it with input and await a return — you `perceive`
+ * function: you don't *call* it with input and await a return — you `sense`
  * something to it, and it *may* project a response later (see `nextUtterance`),
  * coloured by its current state. Silence is a valid, meaningful outcome.
  */
@@ -54,8 +56,39 @@ export interface Stimulus {
    * name, the Will knows the person as "someone" until it learns one.
    */
   speaker?: string
+  /**
+   * Whose doing this was: `'exafferent'` (the world), `'reafferent'` (the Will's
+   * own act, coming back), or `'unknown'` (you cannot tell).
+   *
+   * REQUIRED, as of P3. Only you can answer it — nothing inside the mind can
+   * tell the echo of its own utterance from a stranger saying the same words,
+   * which is why this is asserted at the boundary and never inferred behind it.
+   * Most inbound traffic is `'exafferent'`; use `say()`/`tell()`, whose verbs
+   * already make that claim, when that is all you mean. Reach for `'reafferent'`
+   * when you are feeding back the result of something the Will did — an
+   * ability's output, a webhook fired by its own write, a platform echo of a
+   * message it sent — and pass `sourceIntentId` if you have it.
+   *
+   * It was optional for exactly one epoch, defaulting to `'exafferent'`, so that
+   * a host migrated ONCE — at P3, alongside the `perceive()` → `sense()` rename
+   * — rather than twice. That default was the last surviving instance of the
+   * four-state hole the internal types exist to forbid: an omission silently
+   * became a claim nobody made. It is gone.
+   *
+   * If you genuinely cannot tell, say `'unknown'`. That is a different statement
+   * from `'exafferent'` and the mind treats it as one: the rupture gate in
+   * `action.selector` counts only `'exafferent'` percepts, so a mislabelled echo
+   * can interrupt a mind's train of thought with its own words.
+   */
+  provenance: SignalProvenance
+  /** The intent whose enaction caused this, when `provenance` is `'reafferent'`. */
+  sourceIntentId?: string
   /** Conversation/thread id (default = `from`). */
   thread?: string
+  /** True when `thread` is private — just this someone and the Will. See TextMessage.direct. */
+  direct?: boolean
+  /** What the room is called, e.g. `#general`. A label, not an address. See TextMessage.threadName. */
+  threadName?: string
 }
 
 /** A message the Will emitted to someone. */
@@ -66,6 +99,20 @@ export 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 `sense()` 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
 }
 
 /**
@@ -97,14 +144,75 @@ export interface WillAffect {
  */
 export type EffectorResult = string | {
   success: boolean
+  /** How the act WENT — its fate. What the Will learns competence from. */
   description: string
+  /**
+   * What the act REVEALED — new information about the world (SIGNAL_BOUNDARY P2).
+   *
+   * Return it and the Will *perceives* it: it arrives as a reafferent percept
+   * tied to the act by `sourceIntentId`, so it is remembered and recallable,
+   * not merely learned from. A lookup, a listing, a snapshot has one; a kick or
+   * a warning does not — those only have a fate.
+   *
+   *     return { success: true,
+   *              description: 'Looked up Ada.',              // how it went
+   *              observation: 'Ada joined 3 months ago, …' } // what I found
+   *
+   * Any shape — a string, a record, a list — and carried WHOLE.
+   *
+   * SEND WHAT YOU HAVE, NOT WHAT IT MEANS. You are not asked to summarise, and
+   * you should not: making meaning by connecting pieces of information is the
+   * mind's entire job, and a host that hands over a conclusion has done that
+   * work on the wrong side of the boundary. A robot's vision layer reports
+   * `{ object: 'ball', confidence: 0.9, bbox: […] }`; it has no business
+   * deciding whether that is worth reacting to.
+   *
+   * The mind labels it with the ability's own name, and sees the data itself in
+   * its percepts — state, working memory and the prompt all carry it. If you
+   * happen to have a one-line `summary` on your object it is used as the label,
+   * but that is a convenience and never a requirement.
+   *
+   * SIZE IS YOURS TO JUDGE, AND NOTHING TRUNCATES IT. What you send lands in
+   * the mind's percepts and, briefly, its prompt — so a very large payload
+   * costs tokens on the ticks it is alive. The engine will not second-guess you
+   * by cutting it: a cap here decides for a mind how much of an answer it may
+   * have, and that decision is not the engine's to make. Send the record; send
+   * the field you would want it to notice.
+   *
+   * Before this, a host with facts to hand back had to return the ack AND call
+   * `sense()` separately — two calls for one act, and the second one had to
+   * pretend somebody had spoken.
+   */
+  observation?: unknown
   metrics?: Record<string, number>
 }
 
 /** Your implementation of an ability the Will can choose to use. */
 export type EffectorHandler = (
   args: Record<string, unknown>,
-  ctx: { reasoning: string; targetEntityId?: string; description?: string },
+  ctx: {
+    reasoning: string
+    /**
+     * The `agency.intent` this handler is running under — the correlation handle
+     * the Will will match an ack to (SIGNAL_BOUNDARY P1).
+     *
+     * Pass it as `sourceIntentId` on any `sense()` you make from inside a
+     * handler, and the resulting percept is a *reafference* the mind can tie back
+     * to the act that caused it, rather than an unexplained arrival. Before this
+     * existed, `discord_inspect_channel` had to say so in English — a bracketed
+     * `[I looked into #general: …]` that only the LLM could read — because the
+     * fact had nowhere structural to live.
+     */
+    intentId: string
+    targetEntityId?: string
+    /**
+     * The addresses this host knows `targetEntityId` by — a channel id, a user id.
+     * `targetEntityId` itself is an opaque anchor (who something IS); these are
+     * where to find it. Resolved inside the Will, where the alias table lives.
+     */
+    targetAddresses?: readonly string[]
+    description?: string
+  },
 ) => EffectorResult | Promise<EffectorResult>
 
 /**
@@ -164,12 +272,6 @@ export interface CreateWillOptions {
   identity: Partial<WillIdentity> & { prompt: string }
   /** 'mind' (default: the whole architecture) | 'reflex' (no-LLM shell). */
   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.
-   *  @deprecated Pass `llmConfig: { model }` instead — model and transport are
-   *  one concern. Still honoured; an explicit `llmConfig.model` wins. */
-  model?: string | WillModelConfig
   /** 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 provider MODE switch.) */
@@ -319,17 +421,29 @@ export class Will {
     pma: PMASnapshot,
     opts: Omit<CreateWillOptions, 'identity'> & { identity?: Partial<WillIdentity> },
   ): Promise<Will> {
-    const id = opts.id ?? `${slug( opts.name )}-${Math.random().toString( 36 ).slice( 2, 8 )}`
+    // Waking IS being the same mind, so the id continues from the artifact unless the
+    // caller overrides it. The id is the path key for everything durable that lives
+    // OUTSIDE the artifact — `data/wills/<id>/vector_index`, snapshots, session logs.
+    // Minting a fresh `name-<random>` here gave a woken mind a brand-new, empty vector
+    // store every boot: identity/beliefs/goals returned (those are in the artifact) while
+    // episodic recall came back permanently empty, and the orphaned index was left behind
+    // on disk. Observed: four boots, four `lora-*` directories, four 4KB indexes, and a
+    // mind that concluded at 100% confidence that its own channel might not be viable
+    // because it could not recall a conversation it had just had.
+    const id = opts.id ?? pma.willId ?? `${slug( opts.name )}-${Math.random().toString( 36 ).slice( 2, 8 )}`
     const stem = new WillStem()
     const will = new Will( stem, id, opts.name )
 
     for( const [ name, entry ] of Object.entries( opts.effectors ?? {} ) )
       will._register( name, entry )
 
-    await stem.createWill(
-      will._buildConfig( id, { ...opts, identity: { prompt: '', ...opts.identity } } ),
-      true /* startPaused — load the artifact before the first tick */,
-    )
+    const config = will._buildConfig( id, { ...opts, identity: { prompt: '', ...opts.identity } } )
+    // Say out loud that this identity is a placeholder. Otherwise the creation
+    // guard warns about the empty persona we just constructed on purpose — three
+    // alarms per wake, drowning the real check that runs when the artifact loads.
+    config.identityFromArtifact = true
+
+    await stem.createWill( config, true /* startPaused — load the artifact before the first tick */ )
     stem.loadPMA( id, pma )
     stem.resumeWill( id )
     will._attach()
@@ -344,10 +458,18 @@ export class Will {
    * *delivered*, NOT once the Will has responded: a response (if any) is a
    * projection that arrives later on the `message` event, or via
    * `nextUtterance()`. The Will may also stay silent — that is not an error.
+   *
+   * NAMED `sense`, NOT `perceive` (SIGNAL_BOUNDARY P3). What happens here is
+   * *transduction*: a signal crosses into the mind. PERCEPTION is what a sense
+   * engine does afterwards — audition runs, judges salience, and produces a
+   * `Percept`, which may not resemble what arrived and may not happen at all
+   * (a gated sense drops it). Calling the door `perceive` said the caller had
+   * already done the mind's work, and it misled every reader of this flow,
+   * including the first draft of the epoch that renamed it.
    */
-  async perceive( stimulus: Stimulus ): Promise<void> {
+  async sense( stimulus: Stimulus ): Promise<void> {
     const from = stimulus.from ?? 'user'
-    await this.stem.ingestText( this.id, {
+    await this.stem.senseText( this.id, {
       kind:        'text',
       entityId:    from,
       threadId:    stimulus.thread ?? from,
@@ -358,17 +480,34 @@ export class Will {
       // the Will knows the person as "someone" until a real one is learned. (The live
       // conversation focus still falls back to the entity id for its Speaker line.)
       ...( stimulus.speaker ? { speakerName: stimulus.speaker } : {} ),
+      // Omitted rather than defaulted: an unknown room is not known to be public.
+      ...( stimulus.direct !== undefined ? { direct: stimulus.direct } : {} ),
+      // Omitted when the channel does not know — a room with no name stays
+      // unnamed, the same way a person does, rather than being labelled with its id.
+      ...( stimulus.threadName ? { threadName: stimulus.threadName } : {} ),
+      // No default. `Stimulus.provenance` is required now, so there is nothing
+      // left to fall back to — the four-state hole is closed at every door into
+      // this mind, which was the point of the epoch.
+      provenance: stimulus.provenance,
+      ...( stimulus.sourceIntentId ? { sourceIntentId: stimulus.sourceIntentId } : {} ),
     } )
   }
 
-  /** Perceive from the default user. Sugar over `perceive`. */
+  /**
+   * Sense from the default user. Sugar over `sense`.
+   *
+   * Supplies `provenance: 'exafferent'` — that is not a default sneaking back
+   * in, it is what the verb MEANS. "Say" is somebody speaking to the Will; a
+   * caller who wants to feed back the Will's own act reaches for `sense` and
+   * says so. The assertion lives in the function name.
+   */
   async say( text: string ): Promise<void> {
-    return this.perceive( { text, from: 'user' } )
+    return this.sense( { text, from: 'user', provenance: 'exafferent' } )
   }
 
-  /** Perceive from a specific interlocutor (multi-party). Sugar over `perceive`. */
+  /** Sense from a specific interlocutor (multi-party). Sugar over `sense` — see `say` on provenance. */
   async tell( entityId: string, speakerName: string, text: string ): Promise<void> {
-    return this.perceive( { text, from: entityId, speaker: speakerName } )
+    return this.sense( { text, from: entityId, speaker: speakerName, provenance: 'exafferent' } )
   }
 
   /**
@@ -378,7 +517,7 @@ export class Will {
    * 5000). `null` is a real outcome — the Will chose not to speak — not a
    * failure. Pass `to` to only accept an utterance addressed to that entity.
    *
-   *   await will.perceive( { from: 'ada', text: 'Hi!' } )
+   *   await will.sense( { from: 'ada', text: 'Hi!', provenance: 'exafferent' } )
    *   const reply = await will.nextUtterance( { to: 'ada', within: 3000 } )
    *   // reply is a WillMessage, or null if Ada got the silent treatment.
    */
@@ -485,6 +624,19 @@ export class Will {
   pause():  void { this.stem.pauseWill( this.id ) }
   resume(): void { this.stem.resumeWill( this.id ) }
 
+
+  /**
+   * Install the Policy Decision Point consulted before every effector
+   * invocation this Will hands to the host (POLICY_REAFFERENCE P0). `null`
+   * restores the no-op default. See `WillStem.setArbiter` for the one scoping
+   * caveat (per-stem, not per-Will id) — irrelevant here since `Will.create()`
+   * gives this instance its own dedicated stem.
+   */
+  setArbiter( arbiter: PolicyArbiter | null ): this {
+    this.stem.setArbiter( arbiter )
+    return this
+  }
+
   /**
    * Checkpoint the living mind into a portable PMA artifact — NON-destructive.
    * The Will keeps ticking; the snapshot is a point-in-time copy you can archive
@@ -525,16 +677,14 @@ export class Will {
     const mode = opts.llm ?? detectProvider()
     const useMock = mode === 'mock'
     // `llm` selects the provider; an explicit llmConfig.provider still wins.
-    // Model rides with the transport: `llmConfig.model` is canonical, the
-    // top-level `opts.model` is the deprecated spelling of the same thing.
-    const llmConfig: WillLLMConfig | undefined = useMock && !opts.llmConfig && opts.model === undefined
+    // Model rides with the transport — `llmConfig.model`, and only that. The
+    // top-level `model` spelling is gone: two ways to say one thing is how a
+    // config grows a precedence rule nobody can remember.
+    const llmConfig: WillLLMConfig | undefined = useMock && !opts.llmConfig
       ? undefined
       : {
           ...( mode !== 'mock' ? { provider: mode } : {} ),
           ...opts.llmConfig,
-          ...( opts.llmConfig?.model !== undefined ? { model: opts.llmConfig.model }
-             : opts.model        !== undefined ? { model: opts.model }
-             : {} ),
         }
     return {
       id, name: opts.name,
@@ -561,7 +711,10 @@ export class Will {
     this._unsub = this.stem.addTickListener( this.id, ( _snapshot, _tick, outbox, invocations ) => {
       // Outbound messages → event + auto delivery-ack.
       for( const msg of outbox ){
-        this._emitMessage( { id: msg.id, content: msg.content, to: msg.targetEntityId } )
+        this._emitMessage( {
+          id: msg.id, content: msg.content, to: msg.targetEntityId,
+          ...( msg.threadId ? { thread: msg.threadId } : {} ),
+        } )
         try { this.stem.confirmMessageDelivery( this.id, msg.id, true ) } catch { /* best-effort */ }
       }
       // Effector invocations → project the motor act, then run the handler → ack.
@@ -589,7 +742,7 @@ export class Will {
     if( !handler ){
       // The Will chose an effector we have no handler for — report it as failed so
       // the reafference loop learns it doesn't work, rather than hanging on the await.
-      this.stem.confirmEffectorExecution( this.id, inv.decisionRecordId, {
+      this.stem.confirmEffectorExecution( this.id, inv.intentId, {
         success: false, description: `No handler registered for effector "${inv.effectorName}"`,
       } )
       return
@@ -598,15 +751,23 @@ export class Will {
     try {
       const raw = await handler( inv.parameters, {
         reasoning: inv.reasoning,
+        // The correlation handle, so a handler that feeds its own result back in
+        // can say WHICH act caused it. This line used to read
+        // `intentId: inv.decisionRecordId` — the translation that proved the
+        // wire name was already wrong.
+        intentId: inv.intentId,
         targetEntityId: inv.targetEntityId,
+        // Which of the host's own ids that referent is — without it a handler
+        // gets an opaque anchor and nothing it can look up.
+        ...( inv.targetAddresses?.length ? { targetAddresses: inv.targetAddresses } : {} ),
         ...( inv.description ? { description: inv.description } : {} ),
       } )
       const result = typeof raw === 'string' ? { success: true, description: raw } : raw
-      this.stem.confirmEffectorExecution( this.id, inv.decisionRecordId, result )
+      this.stem.confirmEffectorExecution( this.id, inv.intentId, result )
     }
     catch( err ){
       this._emitError( err instanceof Error ? err : new Error( String( err ) ) )
-      this.stem.confirmEffectorExecution( this.id, inv.decisionRecordId, {
+      this.stem.confirmEffectorExecution( this.id, inv.intentId, {
         success: false, description: `Effector "${inv.effectorName}" threw: ${( err as Error ).message}`,
       } )
     }

package/src/{serve → surface/serve}/server.ts

@@ -1,5 +1,5 @@
 // ─────────────────────────────────────────────────────────────
-// src/serve/server.ts — a Will, exposed over plain HTTP (the sidecar)
+// src/surface/serve/server.ts — a Will, exposed over plain HTTP (the sidecar)
 // ─────────────────────────────────────────────────────────────
 //
 // `will serve` for hosts that aren't Node and aren't MCP clients — a Python
@@ -23,8 +23,9 @@
 import { createServer, type Server, type IncomingMessage, type ServerResponse } from 'node:http'
 import { mkdirSync, writeFileSync } from 'node:fs'
 import { dirname } from 'node:path'
-import type { Will } from '#sdk/will'
-import { UtteranceTap } from '#root/host/utterances'
+import type { Will } from '#surface/sdk/will'
+import { asProvenance } from '#senses/provenance'
+import { UtteranceTap } from '#surface/host/utterances'
 
 export interface WillHttpOptions {
   /** Where POST /save writes the PMA artifact. */
@@ -98,10 +99,16 @@ export function buildWillHttpServer( will: Will, opts: WillHttpOptions = {} ): S
         const body = await readJsonBody( req )
         const text = typeof body.text === 'string' ? body.text : ''
         if( !text ) return json( res, 400, { error: 'text is required' } )
-        await will.perceive( {
+        await will.sense( {
           text,
+          // Untyped ingress — a JSON body cannot be type-checked, and a client
+          // that predates the field has not claimed anything. asProvenance()
+          // owns the direction; see its comment for why 'exafferent' and not
+          // the tidier-looking 'unknown'.
+          provenance: asProvenance( body.provenance ),
           ...( typeof body.from    === 'string' ? { from:    body.from }    : {} ),
           ...( typeof body.speaker === 'string' ? { speaker: body.speaker } : {} ),
+          ...( typeof body.sourceIntentId === 'string' ? { sourceIntentId: body.sourceIntentId } : {} ),
         } )
         // 202: delivered into the sensory field — NOT answered. A response, if
         // any, arrives on /utterances or /next-utterance; silence is valid.

package/src/types.ts

@@ -22,12 +22,33 @@ export interface effectorInvocation {
   id:               string
   /** Correlation handle — the awaiting `agency.intent` id. Echo it when POSTing to
    *  `POST /v1/wills/:id/effectors/invoked/ack`; the Will reconciles the result onto
-   *  that intent. (Field name kept for wire-contract stability; no longer a
-   *  `decision.record` id since the agency cutover.) */
-  decisionRecordId: string
+   *  that intent.
+   *
+   *  Called `decisionRecordId` until the aliases came out. It stopped being a
+   *  `decision.record` id at the agency cutover and was kept anyway "for
+   *  wire-contract stability" — so the wire was stable and wrong, naming a
+   *  record type that no longer exists, while the SDK translated it to
+   *  `intentId` one hop later for the handler. Stability that preserves a false
+   *  name is preserving the wrong thing. */
+  intentId:         string
   effectorName:      string
   parameters:       Record<string, unknown>
   targetEntityId:   string | undefined
+  /**
+   * The addresses the world knows `targetEntityId` by.
+   *
+   * `targetEntityId` is an ANCHOR (`ke:1sqlkux`) — since 0.9.0 identity is opaque
+   * and deliberately not an address, because who someone is and where to find them
+   * are different facts. A host holds channel ids and knows nothing of anchors, so
+   * an invocation naming only the referent is one no surface can act on. Resolved
+   * inside, where the alias table lives, exactly as the outbox resolves a message
+   * addressed to a referent.
+   *
+   * Outbound only: this is the mind saying which of its own handles it means.
+   * Nothing here lets a surface name someone TO the mind — that is what perception
+   * is for.
+   */
+  targetAddresses?: readonly string[]
   reasoning:        string
   /** The ability's declared meaning (from its EffectorDeclaration), when present. */
   description?:     string

package/dist/channels/discord.d.ts

@@ -1,69 +0,0 @@
-import { W as Will } from '../will-cS6k4uiJ.js';
-import { C as ChannelBridge } from '../types-E9-HV-SW.js';
-
-interface DiscordLikeChannel {
-    send(content: string): Promise<unknown>;
-    sendTyping?(): Promise<unknown>;
-}
-interface DiscordLikeMessage {
-    content: string;
-    cleanContent?: string;
-    channelId: string;
-    guildId?: string | null;
-    author: {
-        id: string;
-        bot?: boolean;
-        username?: string;
-        displayName?: string;
-    };
-    member?: {
-        displayName?: string;
-    } | null;
-    mentions?: {
-        has(userId: string): boolean;
-    };
-    channel: DiscordLikeChannel;
-}
-interface DiscordLikeClient {
-    user: {
-        id: string;
-        setPresence?(p: unknown): void;
-    } | null;
-    /** discord.js ≥14.22; polled so we needn't subscribe to the deprecated `ready`. */
-    isReady?(): boolean;
-    on(event: 'messageCreate', fn: (m: DiscordLikeMessage) => void): unknown;
-    once(event: string, fn: () => void): unknown;
-    login(token: string): Promise<unknown>;
-    destroy(): Promise<unknown> | void;
-    channels: {
-        fetch(id: string): Promise<unknown>;
-    };
-    users: {
-        fetch(id: string): Promise<{
-            send(content: string): Promise<unknown>;
-        }>;
-    };
-}
-interface DiscordBridgeOptions {
-    /** Bot token (Discord developer portal). Unused when `client` is injected pre-logged-in. */
-    token?: string;
-    /** Channel ids the Will inhabits. Unset = every channel it can see. */
-    channels?: string[];
-    /** Perceive guild messages only when the Will is @mentioned (DMs always perceived). */
-    mentionOnly?: boolean;
-    /** Fallback channel for utterances with no reachable addressee. */
-    homeChannelId?: string;
-    /** Roster path (default: ./.will/<willId>.discord.json). */
-    rosterPath?: string;
-    /** Test / power-user seam: bring your own client; discord.js is never imported. */
-    client?: DiscordLikeClient;
-    log?: (msg: string) => void;
-}
-/**
- * Connect a Will to Discord. Resolves once the bridge is live (logged in and
- * relaying). Close it via the returned `ChannelBridge.close()` — the Will
- * itself is not stopped; it simply loses this surface.
- */
-declare function connectDiscord(will: Will, opts: DiscordBridgeOptions): Promise<ChannelBridge>;
-
-export { type DiscordBridgeOptions, type DiscordLikeChannel, type DiscordLikeClient, type DiscordLikeMessage, connectDiscord };