@animalabs/connectome-host 0.7.3 → 0.8.0

package/src/modules/subagent-module.ts

@@ -1376,6 +1376,18 @@ export class SubagentModule implements Module {
    *   3. parent agent's `maxTokens` (by default, subagents inherit their caller's budget)
    *   4. last-resort framework fallback (4096) — only reached if there's no parent at all
    */
+  /** Ephemeral agents inherit the caller's prose-routing mode. AF's Agent
+   *  defaults to 'locus' (ambient locus capture publishes plain prose to the
+   *  open channel), so a resident running proseRouting 'disabled' would still
+   *  spawn divers whose between-tool-calls prose leaks into its live channel
+   *  as parent speech — field-confirmed 2026-08-26. Falls back to the
+   *  configured parent agent, then to AF's own default. */
+  private resolveProseRouting(callerAgentName?: string): 'locus' | 'explicit' | 'hybrid' | 'disabled' | undefined {
+    const parentName = callerAgentName ?? this.config.parentAgentName;
+    if (!parentName) return undefined;
+    return this.framework?.getAgent(parentName)?.proseRouting;
+  }
+
   private resolveMaxTokens(callMaxTokens: number | undefined, parentAgentName?: string): number {
     if (callMaxTokens !== undefined) return callMaxTokens;
     if (this.config.defaultMaxTokens !== undefined) return this.config.defaultMaxTokens;
@@ -1703,6 +1715,9 @@ export class SubagentModule implements Module {
           model,
           systemPrompt: input.systemPrompt,
           maxTokens: this.resolveMaxTokens(input.maxTokens, _callerAgentName),
+          ...(this.resolveProseRouting(_callerAgentName) !== undefined
+            ? { proseRouting: this.resolveProseRouting(_callerAgentName) }
+            : {}),
           maxStreamTokens: 500_000,
           strategy: new KnowledgeStrategy({
             headWindowTokens: 2_000,
@@ -1855,6 +1870,9 @@ export class SubagentModule implements Module {
           model,
           systemPrompt,
           maxTokens: this.resolveMaxTokens(input.maxTokens, callerAgentName),
+          ...(this.resolveProseRouting(callerAgentName) !== undefined
+            ? { proseRouting: this.resolveProseRouting(callerAgentName) }
+            : {}),
           maxStreamTokens: 500_000,
           strategy: new KnowledgeStrategy({
             headWindowTokens: 2_000,

package/src/modules/tts-relay-module.ts

@@ -232,6 +232,13 @@ function rawChannelId(mcplId: string): string {
   return ix === -1 ? mcplId : mcplId.slice(ix + 1);
 }
 
+/** Channel-bound inference traces carry `channelId` at runtime, but the
+ *  framework's TraceEvent union doesn't declare it — read it through a cast. */
+function traceChannelId(event: unknown): string | undefined {
+  const v = (event as { channelId?: unknown }).channelId;
+  return typeof v === 'string' ? v : undefined;
+}
+
 const collapseWs = (s: string): string => s.replace(/\s+/g, ' ').trim();
 
 export class TtsRelayModule implements Module {
@@ -338,18 +345,41 @@ export class TtsRelayModule implements Module {
   }
 
   private onTraceEvent(event: TraceEvent): void {
+    // `mcpl:speech-routed` is a custom trace type emitted by the speech
+    // router, not part of the framework's TraceEvent union — the typed
+    // switch below could never narrow to it. Handle it up front via the
+    // standard custom-trace cast.
+    if ((event as { type: string }).type === 'mcpl:speech-routed') {
+      // Remember what landed where, so an interruption can find its edit
+      // target: (channelId, messageId, text) per posted segment.
+      const e = event as unknown as {
+        channelId: string; messageId?: string; text: string; timestamp: number;
+      };
+      this.routed.push({
+        rawChannelId: rawChannelId(e.channelId),
+        mcplChannelId: e.channelId,
+        messageId: e.messageId,
+        text: e.text,
+        at: e.timestamp,
+      });
+      if (this.routed.length > ROUTED_RING_MAX) {
+        this.routed.splice(0, this.routed.length - ROUTED_RING_MAX);
+      }
+      return;
+    }
+
     switch (event.type) {
       case 'inference:started': {
         // A context-budget restart re-emits inference:started mid-turn; the
         // existing activation (announced or not) simply carries on.
         const st = this.activation(event.agentName);
-        this.adoptChannel(st, event.agentName, event.channelId);
+        this.adoptChannel(st, event.agentName, traceChannelId(event));
         break;
       }
 
       case 'inference:tokens': {
         const st = this.activation(event.agentName);
-        this.adoptChannel(st, event.agentName, event.channelId);
+        this.adoptChannel(st, event.agentName, traceChannelId(event));
         if (!st.rawChannelId) break; // no locus — nothing to voice into
         st.blocks.set(event.blockIndex, (st.blocks.get(event.blockIndex) ?? '') + event.content);
         this.client?.emit('chunk', {
@@ -367,7 +397,7 @@ export class TtsRelayModule implements Module {
 
       case 'inference:content_block': {
         const st = this.activation(event.agentName);
-        this.adoptChannel(st, event.agentName, event.channelId);
+        this.adoptChannel(st, event.agentName, traceChannelId(event));
         if (!st.rawChannelId) break;
         const base = {
           channelId: st.rawChannelId,
@@ -398,21 +428,6 @@ export class TtsRelayModule implements Module {
         this.endActivation(event.agentName, 'error');
         break;
 
-      case 'mcpl:speech-routed': {
-        // Remember what landed where, so an interruption can find its edit
-        // target: (channelId, messageId, text) per posted segment.
-        this.routed.push({
-          rawChannelId: rawChannelId(event.channelId),
-          mcplChannelId: event.channelId,
-          messageId: event.messageId,
-          text: event.text,
-          at: event.timestamp,
-        });
-        if (this.routed.length > ROUTED_RING_MAX) {
-          this.routed.splice(0, this.routed.length - ROUTED_RING_MAX);
-        }
-        break;
-      }
 
       default:
         break;