@animalabs/connectome-host 0.7.2 → 0.7.4

package/src/modules/settings-module.ts

@@ -33,6 +33,14 @@ import type {
 export interface ReasoningSettings {
   enabled: boolean;
   budgetTokens: number;
+  /**
+   * How thinking content comes back from the API: 'summarized' returns a
+   * readable reasoning summary in the `thinking` field; 'omitted' returns an
+   * empty `thinking` field with only the encrypted signature. Models 4.7+
+   * default to 'omitted' server-side — we default to 'summarized' to restore
+   * the pre-4.7 behavior (visible reasoning in stores, webui, estimators).
+   */
+  display: 'summarized' | 'omitted';
 }
 
 export interface SettingsState {
@@ -40,7 +48,7 @@ export interface SettingsState {
 }
 
 const DEFAULTS: SettingsState = {
-  reasoning: { enabled: false, budgetTokens: 8192 },
+  reasoning: { enabled: false, budgetTokens: 8192, display: 'summarized' },
 };
 
 export class SettingsModule implements Module {
@@ -112,8 +120,16 @@ export class SettingsModule implements Module {
           type: 'number',
           description: 'Token budget for thinking blocks (min 1024).',
         },
+        reasoning_display: {
+          type: 'string',
+          enum: ['summarized', 'omitted'],
+          description:
+            "How your thinking is returned: 'summarized' (a readable summary of your reasoning " +
+            "is recorded alongside the signature) or 'omitted' (signature only, slightly faster " +
+            'first token; your reasoning is not visible to anyone, including you on replay).',
+        },
       },
-      keys: ['reasoning_enabled', 'reasoning_budget_tokens'],
+      keys: ['reasoning_enabled', 'reasoning_budget_tokens', 'reasoning_display'],
       get: () => this.reasoningSettingsView(),
       update: (_agentName, patch) => {
         const next = { ...this.state.reasoning };
@@ -130,6 +146,12 @@ export class SettingsModule implements Module {
           }
           next.budgetTokens = Math.max(1024, Math.round(budget));
         }
+        if (patch.reasoning_display !== undefined) {
+          if (patch.reasoning_display !== 'summarized' && patch.reasoning_display !== 'omitted') {
+            throw new Error("reasoning_display must be 'summarized' or 'omitted'");
+          }
+          next.display = patch.reasoning_display;
+        }
         this.state.reasoning = next;
         this.ctx?.setState(this.state);
         return this.reasoningSettingsView();
@@ -142,6 +164,9 @@ export class SettingsModule implements Module {
         if (all || keys?.includes('reasoning_budget_tokens')) {
           this.state.reasoning.budgetTokens = DEFAULTS.reasoning.budgetTokens;
         }
+        if (all || keys?.includes('reasoning_display')) {
+          this.state.reasoning.display = DEFAULTS.reasoning.display;
+        }
         this.ctx?.setState(this.state);
         return this.reasoningSettingsView();
       },
@@ -153,6 +178,7 @@ export class SettingsModule implements Module {
     return {
       reasoning_enabled: this.state.reasoning.enabled,
       reasoning_budget_tokens: this.state.reasoning.budgetTokens,
+      reasoning_display: this.state.reasoning.display,
     };
   }
 

package/src/modules/subscription-gc-module.ts

@@ -336,11 +336,25 @@ export class SubscriptionGcModule implements Module {
       // Cross the threshold → close and clear the counter.
       delete this.state.counters[channelId];
       this.persistNow();
+      // A CONFIGURED numeric budget for this channel is an explicit idle
+      // lease: someone chose a close-at-N budget for this specific channel,
+      // so the registry may close even an explicitly-opened one. The state
+      // does not record WHO configured it (agent via agent_settings,
+      // operator, or imported before these semantics existed), so nothing
+      // downstream may claim "agent-set" — receipts say 'configured-budget',
+      // actor unknown. The global default is not consent of any kind; the
+      // registry refuses machine closes of explicit opens under it (#5).
+      const hasConfiguredLease = typeof this.state.overrides[channelId] === 'number';
       const result = await this.ctx
         ?.callTool({
           id: `gc-unsub-${this.callSeq++}`,
           name: 'channel_close',
-          input: { channelId, serverId: this.serverId },
+          input: {
+            channelId,
+            serverId: this.serverId,
+            source: 'subscription-gc',
+            overrideExplicitOpen: hasConfiguredLease,
+          },
         })
         .catch((err: unknown) => ({
           success: false,
@@ -349,6 +363,34 @@ export class SubscriptionGcModule implements Module {
         }));
 
       if (result && result.success) {
+        // Operator-side receipt (privacy-minimal: ids and thresholds, no
+        // content) — a GC close changes durable listening state and must
+        // not look spontaneous from outside the transcript. Duck-typed
+        // against a framework that may not have ModuleContext.notifyOps yet
+        // (skipped there), and invoked THROUGH the context object: the real
+        // ModuleContextImpl.notifyOps reads `this`, so a detached
+        // `const f = ctx.notifyOps; f(...)` throws in production while
+        // passing against arrow-function mocks.
+        const opsCtx = this.ctx as unknown as {
+          notifyOps?: (kind: string, agent: string, message: string, data?: Record<string, unknown>) => void;
+        } | null;
+        opsCtx?.notifyOps?.(
+          'subscription-gc-close',
+          this.ctx?.getAgents()[0]?.name ?? 'unknown',
+          `subscription-gc auto-closed channel ${channelId} (over ${limit} ambient chars ` +
+          `since last activation${hasConfiguredLease ? ', configured per-channel budget' : ', default budget'}). ` +
+          `Restore: channel_open ${channelId}, or agent_settings channel_idle_limits.`,
+          {
+            channelId,
+            limitChars: limit,
+            decisionSource: 'subscription-gc',
+            // 'configured-budget' deliberately does NOT claim an actor: the
+            // override state records no provenance (agent, operator, or
+            // imported are all possible).
+            lease: hasConfiguredLease ? 'configured-budget' : 'default',
+            restore: `channel_open ${channelId}`,
+          },
+        );
         return {
           addMessages: [
             {
@@ -367,6 +409,17 @@ export class SubscriptionGcModule implements Module {
           ],
         };
       }
+
+      // The registry refused because the channel was explicitly opened and
+      // we hold no lease: stand down quietly — the janitor doesn't argue
+      // with stated intent. The counter stays cleared, so the next refusal
+      // is at least a full budget away; if the channel's provenance later
+      // changes (reopened by policy), GC self-heals.
+      const refusal = (result as { data?: { refusal?: string } } | undefined)?.data?.refusal;
+      if (refusal === 'explicit-open') {
+        return {};
+      }
+
       // Close failed — keep the channel counted so we retry on the next
       // ambient message rather than silently giving up.
       this.state.counters[channelId] = next;

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;