@mindot/will 0.9.0 → 0.10.0

package/src/llm/index.ts

@@ -13,7 +13,7 @@ import type {
 import { type ModelRouter, isNullRouter } from '#llm/routing'
 import { getCompletionRecorder, getCompletionSource } from '#core/completion.recorder'
 import type { LLMCompletionRecord } from '#core/completion.recorder'
-import { withGate } from '#llm/gate'
+import { withGate, gateFor } from '#llm/gate'
 import { matchConversationFocus, wrapReplyText } from '#llm/wire.contracts'
 
 /**
@@ -264,6 +264,48 @@ export interface LLMCallResult {
   cacheWriteTok?: number
 }
 
+/**
+ * The usage block on an Anthropic-wire SSE event. Every field is optional
+ * because which of them a host populates — and on which event — varies: see
+ * `takeUsage` in `_callAnthropicStream`.
+ */
+export interface StreamUsage {
+  input_tokens?:                 number
+  output_tokens?:                number
+  cache_read_input_tokens?:      number
+  cache_creation_input_tokens?:  number
+}
+
+/** Running token totals accumulated across a stream's usage events. */
+export interface StreamTokens {
+  inputTok:      number
+  outputTok:     number
+  cacheReadTok:  number
+  cacheWriteTok: number
+}
+
+/**
+ * Fold one SSE usage block into the running totals.
+ *
+ * Which event carries the real numbers is host-specific. Real Anthropic puts
+ * the input side on `message_start` and only `output_tokens` on `message_delta`.
+ * Z.ai (glm) sends `message_start` with every field zeroed and reports input,
+ * output and cache together on the final `message_delta`. Reading input from
+ * `message_start` alone recorded 0 input and 0 cache for every GLM call ever
+ * made — 441,896 output tokens against 0 input across one 7-hour COO run.
+ *
+ * So: fold from wherever it arrives, and let a later non-zero reading win. A
+ * zero never overwrites a figure already in hand, and a real figure always
+ * replaces a placeholder — which makes the fold correct under either ordering.
+ */
+export function foldStreamUsage( acc: StreamTokens, u: StreamUsage ): StreamTokens {
+  if( u.input_tokens )                 acc.inputTok      = u.input_tokens
+  if( u.output_tokens )                acc.outputTok     = u.output_tokens
+  if( u.cache_read_input_tokens )      acc.cacheReadTok  = u.cache_read_input_tokens
+  if( u.cache_creation_input_tokens )  acc.cacheWriteTok = u.cache_creation_input_tokens
+  return acc
+}
+
 /**
  * Cost-attribution metadata for a single LLM call. The same director instance is
  * shared by the master executive, every facet (conversation/planning/outreach),
@@ -703,11 +745,24 @@ export class LLMDirector {
     onChunk:      ( chunk: string ) => void,
     temperature?: number,
   ): Promise<LLMCallResult> {
-    // First-byte deadline only: a hard timeout on the whole stream would
-    // truncate a healthy but long generation, so the timer is cleared once
-    // the response headers arrive.
+    // IDLE deadline, not a whole-response one. A hard cap on the total stream
+    // would truncate a healthy long generation; no cap at all lets a stalled
+    // socket hang forever. A live generation keeps emitting and a dead one goes
+    // quiet, so the clock is restarted by every chunk that arrives and fires
+    // only after `_timeoutMs` of silence — the first byte included.
+    //
+    // It used to be cleared the moment the response headers arrived, which left
+    // the read loop with no deadline at all. A mid-stream stall then never
+    // settled, and the reasoning promise it belonged to stayed in the executive's
+    // `_pending` map forever: `hasPendingWork` gated every cycle and the master
+    // seat went silent for the full 600-tick prune horizon. Observed live as ten
+    // minutes of a mind not deliberating, announced by nothing.
     const controller = new AbortController()
-    const timer = setTimeout( () => controller.abort(), this._timeoutMs )
+    let   timer = setTimeout( () => controller.abort(), this._timeoutMs )
+    const restartDeadline = (): void => {
+      clearTimeout( timer )
+      timer = setTimeout( () => controller.abort(), this._timeoutMs )
+    }
 
     let res: Response
     try {
@@ -732,24 +787,23 @@ export class LLMDirector {
       throw err
     }
 
-    clearTimeout( timer )
-
-    if( !res.ok )
+    if( !res.ok ){
+      clearTimeout( timer )
       throw new Error(`Anthropic stream ${res.status}: ${( await res.text() ).slice(0, 300)}`)
+    }
 
     const reader  = res.body!.getReader()
     const decoder = new TextDecoder()
     let   buffer  = ''
-    let   fullText    = ''
-    let   inputTok    = 0
-    let   outputTok   = 0
-    let   cacheReadTok  = 0
-    let   cacheWriteTok = 0
+    let   fullText  = ''
+    const tokens: StreamTokens = {
+      inputTok: 0, outputTok: 0, cacheReadTok: 0, cacheWriteTok: 0 }
 
     try {
       while( true ){
         const { done, value } = await reader.read()
         if( done ) break
+        restartDeadline()
         buffer += decoder.decode( value, { stream: true })
 
         const lines = buffer.split('\n')
@@ -764,32 +818,52 @@ export class LLMDirector {
             const ev = JSON.parse( raw ) as {
               type: string
               delta?: { type: string; text?: string; stop_reason?: string }
-              message?: { usage?: { input_tokens: number; cache_read_input_tokens?: number; cache_creation_input_tokens?: number } }
-              usage?:   { output_tokens: number }
+              message?: { usage?: StreamUsage }
+              usage?:   StreamUsage
             }
 
-            if( ev.type === 'message_start' && ev.message?.usage ){
-              inputTok      = ev.message.usage.input_tokens
-              cacheReadTok  = ev.message.usage.cache_read_input_tokens     ?? 0
-              cacheWriteTok = ev.message.usage.cache_creation_input_tokens ?? 0
-            }
+            // Usage arrives in different events depending on the host. Real
+            // Anthropic reports the input side up front on `message_start` and
+            // only `output_tokens` on `message_delta`. Anthropic-WIRE hosts do
+            // not all follow that: Z.ai (glm) sends `message_start` with zeroed
+            // placeholders and puts the true figures — input, output AND cache —
+            // on the final `message_delta`. Reading the input side from
+            // `message_start` alone therefore recorded 0 input and 0 cache for
+            // every GLM call ever made, while output logged correctly: 441,896
+            // output tokens against 0 input across one 7-hour COO run, which is
+            // not a possible shape for a conversation.
+            //
+            // So take usage wherever it appears and let a later non-zero reading
+            // win — a zero never overwrites a figure already in hand, and a real
+            // figure always replaces a placeholder.
+            if( ev.type === 'message_start' && ev.message?.usage )
+              foldStreamUsage( tokens, ev.message.usage )
             else if( ev.type === 'content_block_delta' && ev.delta?.text ){
               fullText += ev.delta.text
               onChunk( ev.delta.text )
             }
-            else if( ev.type === 'message_delta' && ev.usage?.output_tokens ){
-              outputTok = ev.usage.output_tokens
-            }
+            else if( ev.type === 'message_delta' && ev.usage )
+              foldStreamUsage( tokens, ev.usage )
           }
           catch { /* ignore malformed events */ }
         }
       }
     }
+    catch( err ){
+      // An abort here is the idle deadline, not a caller cancelling: nothing
+      // arrived for `_timeoutMs` while the stream was still open. Naming it is
+      // the whole point — a stall that throws is a pass that failed, and a pass
+      // that failed settles its promise and frees the seat.
+      if( controller.signal.aborted )
+        throw new Error(`LLM stream to ${ep.provider} stalled — no data for ${this._timeoutMs}ms`)
+      throw err
+    }
     finally {
+      clearTimeout( timer )
       reader.releaseLock()
     }
 
-    return { text: fullText, inputTok, outputTok, cacheReadTok, cacheWriteTok }
+    return { text: fullText, ...tokens }
   }
 
   /**
@@ -831,7 +905,10 @@ export class LLMDirector {
       () => ep.wire === 'anthropic'
         ? this._callAnthropicStream( ep, systemPrompt, userMessage, () => {}, temperature )
         : this._callProvider( ep, systemPrompt, userMessage, temperature ),
-      'executive/direct',
+      `executive/direct:${ meta.function }`,
+      // A reply to a waiting person takes the reserved lane; everything the
+      // mind is doing for itself shares the general one. See `gateFor`.
+      gateFor( meta.function ),
     )
 
     // Record token usage + cost into this Will's injected tracker (R4), tagged

package/src/llm/wire.contracts.ts

@@ -58,6 +58,44 @@ export function wrapReplyText( body: string ): string {
   return [ REPLY_TEXT_OPEN, body, REPLY_TEXT_CLOSE ].join('\n')
 }
 
+/**
+ * Every marker that is PROTOCOL rather than content.
+ *
+ * Named explicitly rather than matched as `[ANYTHING]`, because bracketed text is
+ * ordinary in real messages — "[1]", "[see §4.4]", "[REDACTED]" are things a mind
+ * may legitimately say, and a greedy strip would eat them.
+ */
+export const PROTOCOL_TAGS: readonly string[] = [
+  REPLY_TEXT_TAG, NO_MESSAGE_TAG, 'INTROSPECTION', 'NARRATIVE', 'SELF_OBS',
+]
+
+/**
+ * Remove any protocol marker that survived inside extracted content.
+ *
+ * `extractTextBlock` slices from the first `[TAG]` to the first `[/TAG]` after
+ * it, so a STRAY second opener inside the body is carried out as content — and
+ * the bubble splitter, seeing a line of its own, delivers it as a message.
+ *
+ * Live: a COO's reply to a technical document went out as four substantive
+ * bubbles followed by a fifth reading exactly `[REPLY_TEXT]`. The person got a
+ * message whose entire content was the name of the slot it should have filled.
+ *
+ * These tokens can never be legitimate content — they are the wire, not the
+ * words — so stripping them is not censorship of anything the mind meant. A line
+ * left empty by the removal is dropped so it cannot become an empty bubble.
+ */
+export function stripProtocolMarkers( text: string ): string {
+  let out = text
+  for( const tag of PROTOCOL_TAGS )
+    out = out.split(`[${ tag }]`).join('').split(`[/${ tag }]`).join('')
+
+  return out
+    .split('\n')
+    .filter( ( line, i, all ) => line.trim() !== '' || ( i > 0 && i < all.length - 1 && all[ i - 1 ]?.trim() !== '') )
+    .join('\n')
+    .trim()
+}
+
 // ── Conversation-facet focus — render ↔ match pair ────────────
 // The AuditionEngine RENDERS these lines into the facet focus; the mock LLM
 // MATCHES them to detect "this call is a conversation turn" and synthesize a

package/src/pma/index.ts

@@ -282,7 +282,7 @@ export class PMADistiller {
    * @param willId     The Will's ID
    * @param willName   The Will's display name
    * @param state      Current simulation state (from stateManager.snapshot())
-   * @param sessionId  Active session ID — recorded as provenance
+   * @param sessionId  Active session ID — recorded on the snapshot as its origin
    * @param dataDir    Root data dir (defaults to WILL_DATA_DIR env or './data')
    * @param repertoire The agency competence layer (in-memory manager). When
    *                   provided, the Will's learned skills + composite schemas are

package/src/stem/index.ts

@@ -38,6 +38,8 @@ import { TransportController } from '#stem/tracts/transport.controller'
 import { InboundQueue } from '#stem/tracts/inbound.queue'
 import type { ExternalTransport } from '#stem/tracts/transport'
 import { effectorController } from '#stem/tracts/effector.controller'
+import type { EffectorAck } from '#stem/tracts/effector/types'
+import type { PolicyArbiter } from '#stem/policy/arbiter'
 import { externalSchemas } from '#agency/schemas/external'
 import { inFlightOnRestore } from '#agency/restart'
 import { buildEngineConfigEntities } from '#cognition/config.mirror.entities'
@@ -575,16 +577,30 @@ export class WillStem {
           ? `${offlineMins} minutes`
           : `${Math.round( offlineMins / 60 )} hours`
 
-      instance.simulation.stateManager.setEntity({
-        id:        'percept-wake-event',
-        type:      'percept',
-        createdAt: Date.now(),
-        updatedAt: Date.now(),
-        metadata: {
-          category:  'system',
-          summary:   `I was offline for ${duration}. I am now online again.`,
-          salience:  0.75,
-          source:    'system',
+      // Through the SENSE DOOR, not a hand-written percept (SIGNAL_BOUNDARY P1).
+      //
+      // This used to build a `percept` entity here, by hand, and every bug it
+      // had came from that: no tick (so it never expired, and told the executive
+      // "I was offline for 3 hours" for the rest of the mind's life), and no
+      // provenance (so `action.selector`'s rupture gate excluded it exactly as
+      // it excludes the mind's own echo — a mind returning after hours away
+      // could not be ruptured by noticing).
+      //
+      // Both were fixed by hand in P0 step 2. This removes the hand: waking is
+      // the world touching the mind, so it arrives as a `SystemSignal` through
+      // somatosensation like any other touch, and the sense supplies the tick,
+      // the trace, and the stamp because that is what a sense does. The wake
+      // event stops being special.
+      //
+      // Fire-and-forget: `ingest` is async and the resume path is not. The
+      // signal reaches state on the sense's own timing, exactly as an inbound
+      // message does.
+      void instance.cognition.somatosensationEngine.sense({
+        kind:       'system',
+        signal:     'WAKE',
+        provenance: 'exafferent',   // time passed; nothing I did caused it
+        data: {
+          summary:  `I was offline for ${duration}. I am now online again.`,
           offlineMs,
         },
       })
@@ -731,7 +747,35 @@ export class WillStem {
    * Resume the Will after loading to start ticking with the seeded state.
    */
   loadPMA( id: string, pma: PMASnapshot ): void {
-    this._pma.load( id, this._get( id ), pma )
+    const instance = this._get( id )
+    this._pma.load( id, instance, pma )
+
+    // A MIND THAT WAKES SHOULD KNOW IT WAS AWAY (SIGNAL_BOUNDARY P1, follow-up).
+    //
+    // `resumeWill` has always raised a wake event, gated on `instance.pausedAt`
+    // — and `pausedAt` is set ONLY by `pauseWill()`, an in-session pause. The
+    // hibernate→wake lifecycle never touches it: `Will.wake` calls
+    // `createWill( config, startPaused: true )`, which sets `status = 'paused'`
+    // but leaves `pausedAt` null, and `resumeWill` then skips the whole block.
+    //
+    // So the one lifecycle every deployed Will actually uses was the one that
+    // never fired. Found by running a live Will after P1 routed the wake through
+    // the sense door: the door was correct and nothing walked through it. The
+    // unit test passed because it set `pausedAt` by hand — which is precisely
+    // the kind of test that agrees with you instead of checking.
+    //
+    // The PMA has carried the answer all along: `distilledAt` is when this mind
+    // was distilled, i.e. when it stopped. Loading a PMA IS the statement "this
+    // mind existed before and has been away since then", so this is where the
+    // fact belongs. A Will born fresh never calls this and is never told it
+    // woke, which is right — it was not away, it did not exist.
+    //
+    // Guarded: a clock skew or a hand-edited artifact must not tell a mind it
+    // has been away for negative time, or since 1970.
+    const distilled = pma.distilledAt
+    if( typeof distilled === 'number' && Number.isFinite( distilled )
+        && distilled > 0 && distilled <= Date.now() )
+      instance.pausedAt = new Date( distilled )
   }
 
   // ── Replay ─────────────────────────────────────────────────
@@ -871,15 +915,20 @@ export class WillStem {
    * `agency.intent` id). Reconciles it into an `agency.outcome` the ReafferenceEngine
    * consumes — learning the result, freeing the intent, and advancing the plan it
    * served (if any). See effectorController.confirmExecution.
+   *
+   * Takes the full `EffectorAck`. It used to declare its own narrower shape —
+   * `{ success, description, metrics? }` — which P2 left behind: the controller
+   * has routed `observation` into a reafferent percept since #150, but a host
+   * driving the stem DIRECTLY could not typecheck one, so the facts half of the
+   * ack was reachable only through the SDK facade. A type that silently withholds
+   * half a boundary from the hosts most likely to need it — a robot control
+   * layer, a game loop, anything not using the facade — is the same defect class
+   * as a comment that outlives its claim, with a compiler enforcing it.
    */
   confirmEffectorExecution(
     id:           string,
     invocationId: string,
-    result: {
-      success:     boolean
-      description: string
-      metrics?:    Record<string, number>
-    },
+    result:       EffectorAck,
   ): void {
     this._effector.confirmExecution( this._get( id ), invocationId, result )
   }
@@ -894,6 +943,28 @@ export class WillStem {
     this._effector.resolveEscalation( this._get( id ), invocationId, approved )
   }
 
+
+  /**
+   * Install the Policy Decision Point consulted before every host-owned
+   * effector invocation is handed to the world (POLICY_REAFFERENCE P0).
+   * Passing `null` restores the no-op default — a stem with no arbiter
+   * installed runs byte-identical to one built before the policy seam existed.
+   *
+   * SCOPE: one arbiter per `WillStem`, not per Will — `effectorController` is a
+   * single instance shared by every Will this stem hosts (`setAllowed`,
+   * `resolveEscalation` etc. take a resolved instance; this does not, because
+   * there is only one). `Will.create()` / `Will.wake()` each allocate a fresh
+   * `WillStem`, so on that (recommended) path this is per-Will in practice. A
+   * host running several Wills on ONE shared `WillStem` — e.g. a multi-tenant
+   * service holding many users' Wills in one process — installs ONE arbiter
+   * for all of them; branch on `invocation.willId` inside `evaluate()` if
+   * that's your host, the same way `PolicyVerdictRecord`/`PolicyVerdictSource`
+   * are already keyed per-Will for recording and replay.
+   */
+  setArbiter( arbiter: PolicyArbiter | null ): void {
+    this._effector.setArbiter( arbiter )
+  }
+
   // ── Messaging / outbox (11.1) ────────────────────────────────────────────
   // Delegates to OutboxController (R5-c). `_get(id)` validates the Will exists
   // and supplies the WillInstance; the outbox ops touch only instance fields.
@@ -952,8 +1023,8 @@ export class WillStem {
    * @param id     Will ID
    * @param input  TextMessage — `{ kind: 'text', entityId, threadId, content, speakerName? }`
    */
-  async ingestText( id: string, input: TextMessage ): Promise<void> {
-    await this._sensory.ingestText( this._get( id ), input )
+  async senseText( id: string, input: TextMessage ): Promise<void> {
+    await this._sensory.senseText( this._get( id ), input )
   }
 
   /**
@@ -1005,10 +1076,10 @@ export class WillStem {
   /**
    * Route a raw SensoryInput to the appropriate sense engine by domain.
    * Used by the debug `POST /senses/:domain/ingest` route.
-   * Audition inputs are gated by the 'listen' effector like ingestText().
+   * Audition inputs are gated by the 'listen' effector like senseText().
    */
-  async ingestSensory( id: string, domain: string, input: SensoryInput ): Promise<void> {
-    await this._sensory.ingestSensory( this._get( id ), domain, input )
+  async senseSignal( id: string, domain: string, input: SensoryInput ): Promise<void> {
+    await this._sensory.senseSignal( this._get( id ), domain, input )
   }
 
   listWills(): WillSummary[] {

package/src/stem/mind.ts

@@ -26,14 +26,14 @@ import { OutboxWriter } from '#stem/tracts/outbox.writer'
 import { ExecutiveSummarizer } from '#llm/summarizer'
 import type { LLMProvider } from '#llm/index'
 import { TableRouter, chainRouters, type ModelRouter, type RoutingRule } from '#llm/routing'
-import { resolveProfile } from '#profiles/index'
+import { resolveProfile } from '#stem/profiles/index'
 import { DefaultVectorMemoryAdapter } from '#memory/vector.adapter'
 import { OpenAICompatibleEmbedder, MockEmbedder } from '#memory/vector.embedder'
 import type { VectorMemoryAdapter } from '#memory/vector.adapter'
 import type { ExternalTransport } from '#stem/tracts/transport'
 import type { Cognition, OutboxMessage } from '#types'
 import type { StorageAdapter } from '#core/abstracts'
-import '#profiles/built-in'
+import '#stem/profiles/built-in'
 
 // ── Agency pipeline (new action system) ──────────────────────
 import { ProactiveCommunicator } from '#agency/proactive.communicator'
@@ -100,6 +100,7 @@ import {
   GustationEngine
 } from '#cognition/index'
 import { buildEngineConfigEntities, mergeEngineConfig, EngineConfigEntity } from '#cognition/config.mirror.entities'
+import { endogenousTypes } from '#cognition/sense.boundary'
 import { mergeIdentity, composeIdentityPrompt, WILL_CORE_PREAMBLE } from '#cognition/identity.entity'
 import {
   isReferentId, readAliases, handlesOf, defaultHandle,
@@ -1064,6 +1065,23 @@ function _constructCognition(
   // buildExecutiveContext (already vector-backed via the consolidator).
   auditionEngine.attachMemorySink( entity => simulation.stateManager.setEntity( entity ) )
 
+  // Every sense lays down a percept trace (SIGNAL_BOUNDARY P0). Wired for all
+  // five, not just the implemented one, because that is the contract a host is
+  // owed: implement a sense and what it senses reaches the faculties that read
+  // percepts, rather than a bus event three subscribers glance at for one tick.
+  //
+  // The tick is a getter, not a value — a sense is ingest-driven and off-tick,
+  // so it has no `react()` to be handed one in, and a captured number would
+  // stamp every percept with whenever assembly ran.
+  //
+  // AuditionEngine opts out (`tracesPercepts = false`); it still gets the wiring
+  // so turning it on is a one-word change when the measurement is done.
+  for( const sense of [ auditionEngine, visionEngine, somatosensationEngine, olfactionEngine, gustationEngine ] )
+    sense.attachPerceptTrace(
+      entity => simulation.stateManager.setEntity( entity ),
+      () => simulation.clock.currentTick,
+    )
+
   // Referent → address + room. Closes over the state manager because the writer
   // is deliberately stateless; this is the one seam both send paths cross, so the
   // translation happens once rather than in each of them.
@@ -1307,6 +1325,12 @@ function _registerEngines( simulation: DefaultSimulation, cognition: Cognition,
   activeEngines
     .sort( ( a: any, b: any ) => a.priority - b.priority )
     .forEach( e => simulation.addEngine( e ) )
+
+  // Where this mind ends. Read from the LIVE engine list, not a copy, so an
+  // engine a host registers after assembly is inside the boundary too — its
+  // declared `writes` are machinery, and machinery is not perceived.
+  cognition.exteroception.attachBoundary(
+    () => endogenousTypes( simulation.orchestrator.engines ) )
 }
 
 /**

package/src/stem/policy/arbiter.ts

@@ -98,6 +98,16 @@ export interface PolicyInvocation {
   schema:          string
   parameters:      Record<string, unknown>
   targetEntityId?: string
+  /**
+   * The addresses this host knows `targetEntityId` by (e.g. `discord:123…`) —
+   * the same enrichment a host effector handler already receives on `ctx`
+   * (`EffectorHandler`'s `ctx.targetAddresses`, `surface/sdk/will.ts`). The
+   * arbiter sits at the identical boundary, one step earlier in the same flow,
+   * so withholding it here bought no extra privacy — a handler downstream of an
+   * ALLOW already sees it. Absent when the invocation binds no target or the
+   * entity has no known address.
+   */
+  targetAddresses?: readonly string[]
   /** The ability's declared meaning, as given by the host at wiring time. */
   description?:    string
   tick:            number

package/src/stem/profiles/built-in.ts

@@ -0,0 +1,7 @@
+// Side-effect import — registers all built-in world profiles.
+// Import this once at application entry (mind.ts) before resolveProfile is called.
+import '#stem/profiles/customer-service'
+import '#stem/profiles/companion'
+import '#stem/profiles/smart-home'
+import '#stem/profiles/game-npc'
+import '#stem/profiles/company-brain'

package/src/{profiles → stem/profiles}/companion.ts

@@ -1,4 +1,4 @@
-import { registerProfile } from '#profiles/index'
+import { registerProfile } from '#stem/profiles/index'
 
 registerProfile({
   id: 'companion',

package/src/{profiles → stem/profiles}/company-brain.ts

@@ -1,4 +1,4 @@
-import { registerProfile } from '#profiles/index'
+import { registerProfile } from '#stem/profiles/index'
 
 registerProfile({
   id: 'company-brain',

package/src/{profiles → stem/profiles}/customer-service.ts

@@ -1,4 +1,4 @@
-import { registerProfile } from '#profiles/index'
+import { registerProfile } from '#stem/profiles/index'
 
 registerProfile({
   id: 'customer-service',

package/src/{profiles → stem/profiles}/game-npc.ts

@@ -1,4 +1,4 @@
-import { registerProfile } from '#profiles/index'
+import { registerProfile } from '#stem/profiles/index'
 
 registerProfile({
   id: 'game-npc',

package/src/{profiles → stem/profiles}/index.ts

@@ -1,5 +1,5 @@
 // ─────────────────────────────────────────────────────────────
-// src/profiles/index.ts — World profile registry
+// src/stem/profiles/index.ts — World profile registry
 // ─────────────────────────────────────────────────────────────
 //
 // A world profile is a named configuration preset that:

package/src/{profiles → stem/profiles}/smart-home.ts

@@ -1,4 +1,4 @@
-import { registerProfile } from '#profiles/index'
+import { registerProfile } from '#stem/profiles/index'
 
 registerProfile({
   id: 'smart-home',