@mindot/will 0.9.0 → 0.10.0

package/src/cognition/senses/audition.engine/engine.ts

@@ -11,7 +11,7 @@
  * ExecutiveFacet — one facet per entityId, kept alive for the session duration.
  *
  * Architecture:
- *   - External call: WillManager.ingestText() → audition.ingest(TextMessage)
+ *   - External call: WillManager.senseText() → audition.sense(TextMessage)
  *   - Percept published on bus:  senses.audition.percept
  *   - Facet handoffs to the seat: executive.facet.handoff  (escalation | undertaking)
  *   - GoalManager integration:   automatic via executive.facet.progress (bus)
@@ -73,10 +73,13 @@ import type {
   SensoryInput,
   LanguagePercept,
   TextMessage,
+  Transduced,
   VoiceChunk
 } from '#senses/index'
+import { PERCEPT_SUMMARY_CAP } from '#cognition/percept.entity'
 import { validateFacetHandoff, type HandoffBody } from '#faculties/executive.engine/escalation.buffer'
 import { fnv1a } from '#agency/consequence'
+import type { OutreachResult } from '#agency/engines/motor.schema.executor'
 
 // ── Internal types ─────────────────────────────────────────────
 
@@ -85,6 +88,15 @@ interface ConversationDecision {
   reply:                  string
   /** Individual reply bubbles for display (separate SSE chunks). */
   replyBubbles:           string[]
+  /**
+   * The mind DECLARED silence — it considered speaking and chose not to.
+   *
+   * Distinct from empty bubbles, which also happens when authoring timed out, the
+   * facet budget was full, or a second pass deferred to one already in flight.
+   * Only this one is an answer; the others are the absence of one, and the
+   * executor must keep holding those.
+   */
+  withheld?:              boolean
   targetEntityId:         string
   /**
    * Actions this facet aimed at someone OTHER than the person it is talking to.
@@ -178,7 +190,7 @@ export function partitionOutwardIntents(
 // [REPLY_TEXT] is plain prose — no JSON wrapper, no targetEntityId needed.
 // The facet is entity-scoped so the recipient is always the speakerEntityId.
 
-const CONVERSATION_OUTPUT_FORMAT = `\
+export const CONVERSATION_OUTPUT_FORMAT = `\
 ## Response Format (REQUIRED)
 
 Step 1 — JSON object (my private reasoning, optionally in a \`\`\`json code block):
@@ -217,6 +229,24 @@ That is recorded and NEVER sent. Anything between the [REPLY_TEXT] markers IS SE
 like "[no message this cycle — waiting for their reply]" does not describe my silence to
 myself, it delivers that sentence to them. If I write both blocks, the silence wins.
 
+## Reaching someone who is not in this conversation
+[REPLY_TEXT] is delivered TO THE PERSON I AM TALKING TO, and to nobody else. It has an
+audience, not just a reader. So words meant for a third party do not become a message to
+that third party by being about them — they are handed to the speaker, who reads something
+addressed to someone else, while the person it was actually for never hears it.
+
+To reach someone else I name them in an action:
+
+{"type": "reach-out", "target": "<their name or id as it appears under '## People I Know'>",
+ "args": {"content": "what I want to say to them"}}
+
+I am one conversation of a mind that is having several. Opening a channel is not mine to
+do — that action hands the intention to the part of me that owns whom I contact. It is a
+decision, not a delivery: at the moment I write it nothing has reached anyone, and it may
+yet come to nothing. So I never tell the person in front of me that I have contacted
+someone, or that a message is on its way. The most I can truthfully say is that I mean to.
+I keep [REPLY_TEXT] for the person in front of me.
+
 ## When to use GOALS_NEW (almost always)
 If the speaker requests, mentions, or implies something I should follow through on — embed [GOALS_NEW] in my reasoning.
 This tracks intent across future cycles on its own.
@@ -347,6 +377,27 @@ export class AuditionEngine extends BaseSenseEngine {
    * off-tick engine has. Stamped from `FacetDecision.tick`, and used to key the
    * conversation records it writes into state.
    */
+  /**
+   * Audition does NOT lay down a percept trace (SIGNAL_BOUNDARY P0, step 3).
+   *
+   * Every other sense does, and a host implementing a new one gets it by
+   * default. This is the grandfathered exception, and the reason is measurement
+   * rather than principle: audition is the only live sense, and switching it on
+   * routes every inbound message to five consumers it has never reached —
+   * `action.selector`'s rupture gate (where a fresh high-salience exafferent
+   * percept can preempt an awaiting intent), working memory, the executive
+   * prompt, novelty, and reafference credit. On a deployed Will that is not a
+   * tweak; it is a different mind, and it deserves a measured rollout rather
+   * than a line in a refactor.
+   *
+   * Audition is not trace-less meanwhile: it writes `conversation.received`
+   * through its own sink, which is what SocialPerception reads. That record is
+   * social — sourceKeid, directedAtSelf, action:'communication' — and is NOT
+   * the generic percept the other senses now write. Two different traces for
+   * two different readers; this flag turns off only the second.
+   */
+  protected readonly tracesPercepts = false
+
   private _lastDecisionTick = 0
   /** Speaker attachment strength accessor (0–1) — weights salience by relationship. */
   private _getAttachmentScore: (( entityId: string ) => number) | null = null
@@ -557,7 +608,7 @@ export class AuditionEngine extends BaseSenseEngine {
     const salience = this._model.observe(`audition.${entityId}`, langEnergy ).salience
 
     // ── Percept ────────────────────────────────────────────────
-    const percept: LanguagePercept = {
+    const transduced: Transduced<LanguagePercept> = {
       domain: 'audition',
       channel: msg.kind,
       content,
@@ -565,6 +616,10 @@ export class AuditionEngine extends BaseSenseEngine {
       speakerEntityId: entityId,
       threadId,
       digest: this._digests.getDigest( threadId ),
+      // What a heard turn amounts to, for readers that do not know this is
+      // audition. Bounded, because `summary` renders into the executive prompt
+      // and a pasted essay would take the whole percept budget.
+      summary: `${ speakerName } said: ${ content }`.slice( 0, PERCEPT_SUMMARY_CAP ),
       salience,
       // Arrival metadata for an EXTERNAL inbound message (network/RPC boundary):
       // no sim clock in scope here and the value is not replayed — wallClock() is
@@ -575,7 +630,7 @@ export class AuditionEngine extends BaseSenseEngine {
 
     // Publish to CognitiveBus — AttentionAllocator et al. can react.
     // publishPercept() (base) is the single emit chokepoint on senses.<domain>.percept.
-    this.publishPercept( percept )
+    const percept = this.publishPercept<LanguagePercept>( transduced, msg )
 
     // ── Update digest with inbound turn ───────────────────────
     this._digests.append( threadId, 'user', content )
@@ -640,6 +695,16 @@ export class AuditionEngine extends BaseSenseEngine {
     this._turnDone.get( entityId )?.()
   }
 
+  /**
+   * True while a turn with this person is still resolving — they spoke and the
+   * reply has not landed yet. The agency asks before delivering a self-initiated
+   * message (see OutreachAuthor.isSpeakingTo), so one mind does not reach one
+   * person down two paths in the same tick.
+   */
+  isSpeakingTo( entityId: string ): boolean {
+    return this._turnDone.has( entityId )
+  }
+
   // ── Facet lifecycle ─────────────────────────────────────────
 
   private async _routeToFacet( percept: LanguagePercept, speakerName: string ): Promise<boolean> {
@@ -845,8 +910,8 @@ export class AuditionEngine extends BaseSenseEngine {
    * (MotorSchemaExecutor) to deliver through the proactive communicate path; empty
    * when no executive is attached or the facet budget is full (caller then awaits).
    */
-  async authorOutreach( entityId: string, entityName: string, gist?: string ): Promise<string[]> {
-    if( !this._executiveEngine ) return []
+  async authorOutreach( entityId: string, entityName: string, gist?: string ): Promise<OutreachResult> {
+    if( !this._executiveEngine ) return { bubbles: [] }
 
     // One authoring pass per person at a time.
     //
@@ -862,7 +927,7 @@ export class AuditionEngine extends BaseSenseEngine {
     // had a chance to read it, which is the outcome we want anyway.
     if( this._outreachInFlight.has( entityId ) ){
       logger.info(`[audition-engine] already composing an outreach to ${ entityId } — not opening a second`)
-      return []
+      return { bubbles: [] }
     }
 
     // Already talking to them? Then this is not a second thread — it is a thing to
@@ -889,7 +954,7 @@ export class AuditionEngine extends BaseSenseEngine {
       return spawned.handle
     } )()
 
-    if( !handle ) return []
+    if( !handle ) return { bubbles: [] }
 
     if( openThread )
       logger.info(`[audition-engine] composing outreach to ${ entityId } inside the open conversation (${ openThread.facetId })`)
@@ -934,7 +999,7 @@ export class AuditionEngine extends BaseSenseEngine {
         // saying something — nobody is waiting on this.
         if( output.noMessage !== undefined ){
           logger.info(`[audition-engine] chose not to reach out to ${ entityName }: ${ output.noMessage.slice( 0, 120 ) }`)
-          return { reply: '', replyBubbles: [], targetEntityId: entityId, requiresMasterAttention: false }
+          return { reply: '', replyBubbles: [], withheld: true, targetEntityId: entityId, requiresMasterAttention: false }
         }
         const rawReply = output.replyText?.trim() ?? ''
         const bubbles  = rawReply.split( /\n{2,}/ ).map( b => b.trim() ).filter( Boolean )
@@ -947,13 +1012,13 @@ export class AuditionEngine extends BaseSenseEngine {
     // a safety timeout, then tear the transient facet down.
     this._outreachInFlight.add( entityId )
     try {
-      const bubbles = await new Promise<string[]>( resolve => {
+      const authored = await new Promise<OutreachResult>( resolve => {
         let settled = false
         let unsub:  () => void = () => {}
         let timer:  ReturnType<typeof setTimeout>
-        const done = ( b: string[] ): void => { if( settled ) return; settled = true; clearTimeout( timer ); unsub(); resolve( b ) }
+        const done = ( r: OutreachResult ): void => { if( settled ) return; settled = true; clearTimeout( timer ); unsub(); resolve( r ) }
         timer = setTimeout(
-          () => { logger.warn(`[audition-engine] outreach authoring timed out for ${ entityId }`); done( [] ) },
+          () => { logger.warn(`[audition-engine] outreach authoring timed out for ${ entityId }`); done( { bubbles: [] } ) },
           60_000,   // generous: the facet LLM authors in ~8–18s
         )
         // ONLY this report's decision. Sharing a live conversation facet means its
@@ -962,20 +1027,29 @@ export class AuditionEngine extends BaseSenseEngine {
         // composed it unprompted — and deliver it twice.
         unsub = handle.subscribe( d => {
           if( d.respondingToType !== 'outreach') return
-          done( ( d.decision as ConversationDecision ).replyBubbles ?? [] )
+          const decision = d.decision as ConversationDecision
+          // A facet reasoned and its decision arrived — `answered`, whatever it
+          // holds. That is what separates an empty ANSWER from the empty every
+          // other exit on this method returns, and it is the only place on the
+          // method that can honestly say so.
+          done( {
+            bubbles:  decision.replyBubbles ?? [],
+            withheld: decision.withheld === true,
+            answered: true,
+          } )
         } )
         // The focus rides the REPORT, so a shared conversation facet keeps its own
         // standing focus and its next inbound turn resumes untouched.
         Promise.resolve( handle.report({ type: 'outreach', payload: { entityId, gist }, focus: outreachFocus }) ).catch( err => {
           logger.warn(`[audition-engine] outreach report failed for ${ entityId }: ${ ( err as Error ).message }`)
-          done( [] )
+          done( { bubbles: [] } )
         } )
       } )
 
       // Only tear down what we opened. Destroying a borrowed conversation facet
       // would end the conversation as a side effect of speaking in it.
       if( !openThread ) handle.destroy()
-      return bubbles
+      return authored
     }
     catch( err ){
       // A facet that throws is a pass that produced no words — the same outcome as
@@ -983,7 +1057,7 @@ export class AuditionEngine extends BaseSenseEngine {
       // author". Letting it escape would reject inside MotorSchemaExecutor's
       // fire-and-forget authoring chain instead.
       logger.warn(`[audition-engine] outreach authoring failed for ${ entityId }: ${ ( err as Error ).message }`)
-      return []
+      return { bubbles: [] }
     }
     // finally{} on every path — the timeout resolves empty rather than throwing, but
     // a destroy() or report() that throws must not leave this person permanently
@@ -1256,6 +1330,13 @@ export class AuditionEngine extends BaseSenseEngine {
           )
           handoff({
             kind:      'undertaking',
+            // The commitment in the mind's own words. A contact is one KIND of
+            // promise, not the only kind the tract can carry — see
+            // UndertakingHandoff. This producer only makes contact-shaped ones,
+            // because a facet declares an outward intent by naming a
+            // communicate action; anything else it means to follow through on
+            // goes through [GOALS_NEW], which the format already asks for.
+            what:      `reach ${ intent.target }`,
             target:    intent.target,
             reasoning: intent.reasoning ?? '',
             ...( intent.gist ? { gist: intent.gist } : {} ),

package/src/cognition/senses/base.sense.engine.ts

@@ -29,7 +29,10 @@ import type { CognitiveEvent, CognitiveBus } from '#cognition/bus'
 import type { CognitiveEventSchema } from '#cognition/schema.registry'
 import type { StateCommands } from '#core/types'
 import type { AccessGrants } from '#agency/access.grants'
-import type { SenseEngine, SensoryInput, SenseDomain, Percept } from '#senses/index'
+import type { SensorySignal } from '#senses/provenance'
+import { perceptEntity, type PerceptEntity } from '#cognition/percept.entity'
+import { fnv1a } from '#agency/consequence'
+import type { SenseEngine, SensoryInput, SenseDomain, Percept, Transduced } from '#senses/index'
 
 export abstract class BaseSenseEngine implements SenseEngine {
   abstract readonly name:   string
@@ -38,7 +41,7 @@ export abstract class BaseSenseEngine implements SenseEngine {
   /**
    * The `SensoryInput.kind` values this engine consumes. Inputs of any other
    * kind are ignored silently by `ingest()` (no warning, no work) — this is how
-   * a single `ingestSensory(domain, input)` call can be routed leniently.
+   * a single `senseSignal(domain, input)` call can be routed leniently.
    */
   protected abstract readonly acceptedKinds: ReadonlySet<SensoryInput['kind']>
 
@@ -51,12 +54,45 @@ export abstract class BaseSenseEngine implements SenseEngine {
 
   protected _bus:    CognitiveBus | null = null
   protected _grants: AccessGrants | null = null
+  protected _trace:  (( e: PerceptEntity ) => void) | null = null
+  protected _now:    (() => number) | null = null
+
+  /**
+   * Whether this sense lays down a `percept` trace in state (SIGNAL_BOUNDARY P0).
+   *
+   * ON by default, because that is the contract a host is owed: implement a
+   * sense, and what it senses reaches the five things that read percepts — the
+   * rupture gate, reafference credit, working memory, the executive prompt, and
+   * novelty. Before this, `publishPercept()` emitted a bus event three
+   * subscribers glanced at for one tick and nothing else, so a robot host
+   * ingesting frames could never remember having SEEN anything.
+   *
+   * `AuditionEngine` overrides it to `false` — see the comment there. It is the
+   * documented exception, not the template.
+   */
+  protected readonly tracesPercepts: boolean = true
 
   // ── Wiring ───────────────────────────────────────────────
   attachBus( bus: CognitiveBus ): void { this._bus = bus }
   /** Inject the AccessGrants so `ingest()` honours `gateEffector` (the permission gate). */
   attachGrants( g: AccessGrants ): void { this._grants = g }
 
+  /**
+   * Wire the sense to state: where a percept goes, and what tick it is now.
+   *
+   * Both together, never one: a percept without a tick is uncollectable — the
+   * sweeper reads `metadata.tick` and nothing else — which is the leak P0 step 2
+   * closed in two other writers. And the tick has to be injected rather than
+   * remembered, because a sense is INGEST-DRIVEN and off-tick: it has no `react()`
+   * to be handed one in. Audition's own `_lastDecisionTick` is the cautionary
+   * case — it lags to whenever the executive last decided, so a message arriving
+   * forty ticks later would be stamped forty ticks stale and swept on arrival.
+   */
+  attachPerceptTrace( write: ( e: PerceptEntity ) => void, currentTick: () => number ): void {
+    this._trace = write
+    this._now   = currentTick
+  }
+
   // ── CognitiveEngine defaults ─────────────────────────────
   publishes(): CognitiveEventSchema[] {
     return [ { type: `senses.${this.domain}.percept`, version: 1, validate: () => null } ]
@@ -71,7 +107,7 @@ export abstract class BaseSenseEngine implements SenseEngine {
    * the domain-specific work to `_perceive()`. Subclasses never re-handle gating
    * or filtering — they only implement `_perceive()`.
    */
-  async ingest( input: SensoryInput ): Promise<void> {
+  async sense( input: SensoryInput ): Promise<void> {
     // Permission gate — AccessGrants decides whether this sense may ingest.
     if( this.gateEffector && this._grants && !this._grants.isAllowed( this.gateEffector ) ) return
     if( !this.acceptedKinds.has( input.kind ) ) return
@@ -86,15 +122,77 @@ export abstract class BaseSenseEngine implements SenseEngine {
    * Publish a percept on this engine's `senses.<domain>.percept` topic. The
    * single emit chokepoint — the AttentionAllocator (and, in future, a
    * cross-modal binder) observes percepts here.
+   *
+   * `from` is the signal this percept was transduced FROM, and it is required
+   * rather than optional on purpose: every percept has a cause, and the one
+   * fact transduction must not lose is whose doing that cause was. Taking it
+   * here — instead of stashing the in-flight input on a field — is what keeps
+   * the stamp correct while `_perceive()` is async and two ingests overlap.
+   *
+   * The percept arrives as `Transduced`, i.e. WITHOUT the two fields, so a
+   * sense engine cannot supply them at all. An earlier cut let one through: the
+   * stamp overwrote `provenance` unconditionally but `sourceIntentId` only when
+   * the host supplied one, so an engine could fabricate an intent id and it
+   * survived — provenance the mind would later trust, laundered by the very
+   * step that exists to establish it. The type now refuses it outright; the
+   * host's assertion is the only authority.
+   *
+   * Returns the stamped percept so a sense engine that needs it downstream (as
+   * audition does, to route the turn) uses the SAME object the bus saw, rather
+   * than a second one that could drift from it.
    */
-  protected publishPercept( percept: Percept ): void {
+  protected publishPercept<P extends Percept>( percept: Transduced<P>, from: SensorySignal ): P {
+    // Stripped, then re-applied — belt AND braces. `Transduced` makes forging a
+    // compile error, but a type is only as strong as the compiler that saw it:
+    // a JS host, or a consumer built against an older .d.ts, hands over whatever
+    // it likes. The strip is what holds at runtime.
+    const { provenance: _stale, sourceIntentId: _staleIntent, ...rest } =
+      percept as Transduced<P> & Partial<SensorySignal>
+
+    const stamped = {
+      ...rest,
+      provenance: from.provenance,
+      ...( from.sourceIntentId ? { sourceIntentId: from.sourceIntentId } : {} ),
+    } as P
+
     this._bus?.publish({
       type:         `senses.${this.domain}.percept`,
       version:      1,
       sourceEngine: this.name,
-      salience:     percept.salience,
-      payload:      percept,
+      salience:     stamped.salience,
+      payload:      stamped,
     })
+
+    this._writeTrace( stamped )
+    return stamped
+  }
+
+  /**
+   * Lay the percept down in state, so it reaches the faculties that read
+   * percepts rather than only the three that were listening on the bus this
+   * tick. Silent when the sense opts out or the host wired no sink.
+   *
+   * The id is content-derived and tick-stamped — never `wallClock()` — because
+   * this entity lives in state, and a wall-clock id makes a recorded and a
+   * replayed run diverge (R2). Two identical signals from one entity on one
+   * tick collapse to one percept, which is the same coalescing audition already
+   * applies to a burst of identical messages.
+   */
+  private _writeTrace( p: Percept ): void {
+    if( !this.tracesPercepts || !this._trace || !this._now ) return
+
+    const tick = this._now()
+    this._trace( perceptEntity( {
+      id:         `sense-${ this.domain }-${ tick }-${ fnv1a( `${ p.sourceEntityId }\u0000${ p.summary }` ) }`,
+      tick,
+      salience:   p.salience,
+      category:   this.domain,
+      summary:    p.summary,
+      provenance: p.provenance,
+      entityId:   p.sourceEntityId,
+      ...( p.sourceIntentId !== undefined ? { sourceIntentId: p.sourceIntentId } : {} ),
+      ...( p.data           !== undefined ? { data:           p.data           } : {} ),
+    } ) )
   }
 }
 

package/src/cognition/senses/index.ts

@@ -21,6 +21,7 @@
 
 import type { CognitiveEngine } from '#cognition/types'
 import type { CognitiveBus }    from '#cognition/bus'
+import type { SensorySignal }   from './provenance'
 
 // ── Domain ────────────────────────────────────────────────────
 
@@ -31,15 +32,57 @@ export type SenseDomain =
   | 'olfaction'       // ambient signals  — OlfactionEngine (shell)
   | 'gustation'       // self-evaluation  — GustationEngine (shell)
 
+// ── Provenance (re-exported from ./provenance) ────────────────
+
+export type { SignalProvenance, SensorySignal, Transduced } from './provenance'
+export { asProvenance } from './provenance'
+
 // ── Percept types ─────────────────────────────────────────────
 
-/** Base percept published on the CognitiveBus. */
-export interface Percept {
+/**
+ * Base percept published on the CognitiveBus.
+ *
+ * It extends `SensorySignal` because transduction does not change whose doing a
+ * signal was: what the host stamped on the input is what the percept carries.
+ * `BaseSenseEngine.publishPercept()` applies both from the input, so a percept
+ * ALWAYS carries provenance — no consumer downstream ever writes a fallback.
+ */
+export interface Percept extends SensorySignal {
   domain:         SenseDomain
   sourceEntityId: string
   timestamp:      number
   salience:       number   // 0–1, computed by the sense engine
   raw:            unknown  // original input object
+  /**
+   * A LABEL for what was sensed. Required, so a percept is never invisible —
+   * `extractPercepts` skips one without it.
+   *
+   * A label, not the payload, and not a meaning. The engine composes it from
+   * what it has (the signal's name, a compact rendering) — A HOST IS NEVER
+   * ASKED TO WRITE ONE. Demanding prose from an integration puts the mind's own
+   * work on the wrong side of the boundary: a robot's vision system reports
+   * `object_detected, confidence 0.9, bbox […]`, and making it also write
+   * "I see a red ball on the table" is asking the arm to do the thinking.
+   *
+   * Because the ENGINE composes this, `PERCEPT_SUMMARY_CAP` may bound it —
+   * bounding its own words destroys nobody's only copy. `data` beside it is the
+   * host's, and is never bounded.
+   */
+  summary:        string
+  /**
+   * What the host actually sent, in the shape it had it — whole, unreshaped,
+   * uncapped.
+   *
+   * The mind's job is to make meaning by connecting pieces of information, and
+   * it cannot do that from a sentence somebody else wrote about the pieces. A
+   * host reporting `memberCount: 47` under a summary saying "a few people"
+   * leaves a mind that can never recover 47.
+   *
+   * Distinct from `raw`, which is the whole `SensoryInput` envelope and is
+   * engine-internal — never persisted. This is, and it reaches state, working
+   * memory and the prompt.
+   */
+  data?:          unknown
 }
 
 /** Audition-specific percept — carries language content and thread context. */
@@ -56,7 +99,7 @@ export interface LanguagePercept extends Percept {
 // ── Sensory input types (discriminated union) ─────────────────
 
 // Audition
-export interface TextMessage {
+export interface TextMessage extends SensorySignal {
   kind:     'text'
   entityId: string
   threadId: string
@@ -75,9 +118,24 @@ export interface TextMessage {
    * false — an unknown room is not known to be public.
    */
   direct?: boolean
+  /**
+   * What this room is CALLED, where the channel knows.
+   *
+   * A room has had a dossier of its own since 0.9.0 and no way to be named, so
+   * every place the mind knew was the id it was reached at —
+   * `discord:1531261362838441996`. It rendered to the mind as "something", which
+   * is what the prompt says for a `thing` with no name, and left a mind deciding
+   * *where* to say something choosing between two opaque numbers.
+   *
+   * A display label, not an address: `#general` is what a person calls the room,
+   * `discord:1531…` is how a message gets there, and 0.9.0 established that those
+   * are different facts. The bridge composes it, because what a room is called is
+   * a platform's business and the mind should not learn Discord's spelling.
+   */
+  threadName?: string
 }
 
-export interface VoiceChunk {
+export interface VoiceChunk extends SensorySignal {
   kind:           'voice'
   entityId:       string
   threadId:       string
@@ -86,14 +144,14 @@ export interface VoiceChunk {
 }
 
 // Vision (stub)
-export interface ImageFrame {
+export interface ImageFrame extends SensorySignal {
   kind:     'image'
   entityId: string
   data:     Buffer
   mimeType: string
 }
 
-export interface VideoSegment {
+export interface VideoSegment extends SensorySignal {
   kind:      'video'
   entityId:  string
   frames:    ImageFrame[]
@@ -101,41 +159,41 @@ export interface VideoSegment {
 }
 
 // Somatosensation (stub)
-export interface WebhookEvent {
+export interface WebhookEvent extends SensorySignal {
   kind:    'webhook'
   source:  string
   payload: unknown
   headers: Record<string, string>
 }
 
-export interface SystemSignal {
+export interface SystemSignal extends SensorySignal {
   kind:   'system'
   signal: string
   data:   unknown
 }
 
 // Olfaction (stub)
-export interface AmbientMetric {
+export interface AmbientMetric extends SensorySignal {
   kind:      'ambient'
   metricKey: string
   value:     number
   trend:     'rising' | 'falling' | 'stable'
 }
 
-export interface BackgroundSignal {
+export interface BackgroundSignal extends SensorySignal {
   kind:     'background'
   category: string
   data:     unknown
 }
 
 // Gustation (stub)
-export interface InternalEvaluation {
+export interface InternalEvaluation extends SensorySignal {
   kind:    'self-eval'
   context: string
   trigger: string
 }
 
-export interface SelfAssessmentTrigger {
+export interface SelfAssessmentTrigger extends SensorySignal {
   kind:      'assessment'
   goalId?:   string
   checkType: string
@@ -171,7 +229,7 @@ export type SensoryInput =
 export interface SenseEngine extends CognitiveEngine {
   readonly domain: SenseDomain
   attachBus( bus: CognitiveBus ): void
-  ingest( input: SensoryInput ): Promise<void>
+  sense( input: SensoryInput ): Promise<void>
 }
 
 // ── Re-exports ────────────────────────────────────────────────