@animalabs/connectome-host 0.3.7 → 0.3.9

package/.github/workflows/ci.yml

@@ -0,0 +1,52 @@
+name: CI
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+
+permissions:
+  contents: read
+
+jobs:
+  build-and-test:
+    name: Build & Test (${{ matrix.os }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      # Both platforms on purpose: a package-lock.json regenerated over an
+      # existing node_modules tree records only that machine's native binaries
+      # (esbuild/rollup/tailwind-oxide), so a lock made on macOS breaks Linux
+      # installs and vice versa. Each runner catches the lock the other's
+      # platform produced. macOS runs the install+build lock guard only;
+      # the full test suite runs on ubuntu.
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v6
+        with:
+          node-version: 24
+
+      - name: Setup Bun
+        uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: 1.3.14
+
+      - name: Install dependencies
+        run: npm install
+
+      # npm ci is the actual lockfile guard: `npm install` (npm >= 11)
+      # silently re-resolves platform packages missing from the lock, so a
+      # broken lock sails through it. npm ci installs the lock verbatim and
+      # the vite build then fails loudly on the missing rollup binary.
+      - name: Build web assets (strict lockfile)
+        run: npm run build:web:ci
+
+      - name: Test
+        if: matrix.os == 'ubuntu-latest'
+        run: npm test

package/.github/workflows/publish.yml

@@ -31,7 +31,7 @@ jobs:
         run: npm install
 
       - name: Build web assets
-        run: npm run build:web
+        run: npm run build:web:ci
 
       - name: Test
         run: npm test
@@ -64,7 +64,7 @@ jobs:
         run: npm install
 
       - name: Build web assets
-        run: npm run build:web
+        run: npm run build:web:ci
 
       - name: Publish
         run: npm publish --access public --provenance

package/bun.lock

@@ -5,10 +5,10 @@
     "": {
       "name": "connectome-host",
       "dependencies": {
-        "@animalabs/agent-framework": "^0.6.4",
+        "@animalabs/agent-framework": "^0.6.8",
         "@animalabs/chronicle": "^0.2.0",
-        "@animalabs/context-manager": "^0.5.5",
-        "@animalabs/membrane": "^0.5.71",
+        "@animalabs/context-manager": "^0.5.13",
+        "@animalabs/membrane": "^0.5.73",
         "@opentui/core": "^0.1.82",
       },
       "devDependencies": {
@@ -19,13 +19,13 @@
     },
   },
   "packages": {
-    "@animalabs/agent-framework": ["@animalabs/agent-framework@0.6.4", "", { "dependencies": { "@animalabs/chronicle": "^0.2.2", "@animalabs/context-manager": "^0.5.5", "@animalabs/membrane": "^0.5.64", "chokidar": "^4.0.3", "discord.js": "^14.25.1", "ws": "^8.18.0" }, "bin": { "agent-framework-mcp": "dist/src/api/mcp-server.js" } }, "sha512-jLDNNrE7rEI017loFwIx2zTxTBQDwXgo5taqGBrG84Ve0Kaiykj5Cm8pnGm8Mlidl2FtXp5v1NqpRntwZT2idA=="],
+    "@animalabs/agent-framework": ["@animalabs/agent-framework@0.6.8", "", { "dependencies": { "@animalabs/chronicle": "^0.2.2", "@animalabs/context-manager": "^0.5.13", "@animalabs/membrane": "^0.5.73", "chokidar": "^4.0.3", "discord.js": "^14.25.1", "ws": "^8.18.0" }, "bin": { "agent-framework-mcp": "dist/src/api/mcp-server.js", "agent-framework-recover": "dist/src/recovery/recover-cli.js" } }, "sha512-hLu+DI0Xj40zSRm+KmjEZO/uzizd2Gbaiih4IGNXJJZf0mcIxYDbOynEMpaLHtXGYMS8eYFmQK02ytdL9thtoA=="],
 
     "@animalabs/chronicle": ["@animalabs/chronicle@0.2.1", "", { "optionalDependencies": { "@animalabs/chronicle-darwin-arm64": "0.2.1", "@animalabs/chronicle-darwin-x64": "0.2.1", "@animalabs/chronicle-linux-arm64-gnu": "0.2.1", "@animalabs/chronicle-linux-x64-gnu": "0.2.1", "@animalabs/chronicle-win32-x64-msvc": "0.2.1" } }, "sha512-rDFc069yfi7BQUusgsXBwBdqljUWLByXSYaTF40AP+tonBh0No3eF9VzKTSy1I8DYg/jAUHIKtVdKDGsVMVubw=="],
 
-    "@animalabs/context-manager": ["@animalabs/context-manager@0.5.5", "", { "dependencies": { "@animalabs/chronicle": "^0.2.0", "@animalabs/membrane": "^0.5.64" } }, "sha512-KWTluwU5VIZKIPF/IdfUbkvPNZ5zMxSfZjaxZb81IXe+DBPmjHuUVNIqgXIQ2Mv1pCn1vCNqieZ/iSrc6dFH8w=="],
+    "@animalabs/context-manager": ["@animalabs/context-manager@0.5.13", "", { "dependencies": { "@animalabs/chronicle": "^0.2.6", "@animalabs/membrane": "^0.5.69" } }, "sha512-1NOsyCeiJoAa4MrBSGw1zbbs2XfvhRbkMfkFNCNFH9gSFTq/4tMwMu6lmZ082oNeB9FvptGrjCuZdVP8B9/UdA=="],
 
-    "@animalabs/membrane": ["@animalabs/membrane@0.5.71", "", { "dependencies": { "@anthropic-ai/sdk": "^0.52.0" } }, "sha512-Jos4Fh/kIbpOiJ43LKIFpmaCmWIzE6ly1x/4c5iHaMw8n6D8OJ2f4va7xo3vNdvfKWBbln4QghmNg4NWo3oFGA=="],
+    "@animalabs/membrane": ["@animalabs/membrane@0.5.73", "", { "dependencies": { "@anthropic-ai/sdk": "^0.52.0" } }, "sha512-w1rt/JVOD6dWwEO54tfR0yrLzwwD45cpYJ9hWJhHxs8k9FvW1PgIIV1KmNFNbpY8MR9HC5g7Lqgvhzs3pDst+g=="],
 
     "@anthropic-ai/sdk": ["@anthropic-ai/sdk@0.52.0", "", { "bin": { "anthropic-ai-sdk": "bin/cli" } }, "sha512-d4c+fg+xy9e46c8+YnrrgIQR45CZlAi7PwdzIfDXDM6ACxEZli1/fxhURsq30ZpMZy6LvSkr41jGq5aF5TD7rQ=="],
 
@@ -277,7 +277,7 @@
 
     "@animalabs/agent-framework/@animalabs/chronicle": ["@animalabs/chronicle@0.2.6", "", { "optionalDependencies": { "@animalabs/chronicle-darwin-arm64": "0.2.6", "@animalabs/chronicle-darwin-x64": "0.2.6", "@animalabs/chronicle-linux-arm64-gnu": "0.2.6", "@animalabs/chronicle-linux-x64-gnu": "0.2.6", "@animalabs/chronicle-win32-x64-msvc": "0.2.6" } }, "sha512-+gbt2GR4SP8MnKxeqkJZf6oZn339fLiBtk6GHyBD/gHQ4e4eFqBpTaTd5eKycKBws0xWGcOqyiJFH4IdBkweUA=="],
 
-    "@animalabs/context-manager/@animalabs/membrane": ["@animalabs/membrane@0.5.68", "", { "dependencies": { "@anthropic-ai/sdk": "^0.52.0" } }, "sha512-MfSERy0ECxdBZ4NelHdZbqsP/ORWJsfeAI6vuyy6gP77aGcdJL8qf4XrUkOox5yZa5MqB50y0K58Ffv79jCnbg=="],
+    "@animalabs/context-manager/@animalabs/chronicle": ["@animalabs/chronicle@0.2.6", "", { "optionalDependencies": { "@animalabs/chronicle-darwin-arm64": "0.2.6", "@animalabs/chronicle-darwin-x64": "0.2.6", "@animalabs/chronicle-linux-arm64-gnu": "0.2.6", "@animalabs/chronicle-linux-x64-gnu": "0.2.6", "@animalabs/chronicle-win32-x64-msvc": "0.2.6" } }, "sha512-+gbt2GR4SP8MnKxeqkJZf6oZn339fLiBtk6GHyBD/gHQ4e4eFqBpTaTd5eKycKBws0xWGcOqyiJFH4IdBkweUA=="],
 
     "@discordjs/rest/@discordjs/collection": ["@discordjs/collection@2.1.1", "", {}, "sha512-LiSusze9Tc7qF03sLCujF5iZp7K+vRNEDBZ86FT9aQAv3vxMLihUvKvpsCWiQ2DJq1tVckopKm1rxomgNUc9hg=="],
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@animalabs/connectome-host",
-  "version": "0.3.7",
+  "version": "0.3.9",
   "description": "General-purpose agent TUI host with recipe-based configuration",
   "type": "module",
   "scripts": {
@@ -8,13 +8,15 @@
     "dev": "bun --watch src/index.ts",
     "test": "bun test",
     "build:web": "npm --prefix web install && npm --prefix web run build",
+    "build:web:ci": "npm ci --prefix web && npm --prefix web run build",
+    "relock:web": "rm -rf web/node_modules web/package-lock.json && npm --prefix web install",
     "postinstall": "test -d web && npm --prefix web install && npm --prefix web run build || true"
   },
   "dependencies": {
-    "@animalabs/agent-framework": "^0.6.4",
+    "@animalabs/agent-framework": "^0.6.8",
     "@animalabs/chronicle": "^0.2.0",
-    "@animalabs/context-manager": "^0.5.5",
-    "@animalabs/membrane": "^0.5.71",
+    "@animalabs/context-manager": "^0.5.13",
+    "@animalabs/membrane": "^0.5.73",
     "@opentui/core": "^0.1.82"
   },
   "devDependencies": {

package/src/framework-agent-config.ts

@@ -0,0 +1,51 @@
+import { AgentFramework } from '@animalabs/agent-framework';
+import type { Recipe } from './recipe.js';
+
+type AgentConfig = Parameters<typeof AgentFramework.create>[0]['agents'][number];
+
+export type FrameworkAgentConfig = AgentConfig & {
+  // Forward recipe fields that newer Agent Framework releases understand
+  // while remaining structurally compatible with older installs.
+  refusalHandling?: Recipe['agent']['refusalHandling'];
+  sameRoundThinkTextPolicy?: 'public' | 'private';
+};
+
+export function buildFrameworkAgentConfig(
+  recipe: Recipe,
+  agentName: string,
+  model: string,
+  strategy: FrameworkAgentConfig['strategy'],
+): FrameworkAgentConfig {
+  return {
+    name: agentName,
+    model,
+    systemPrompt: recipe.agent.systemPrompt,
+    maxTokens: recipe.agent.maxTokens ?? 16384,
+    maxStreamTokens: recipe.agent.maxStreamTokens ?? 150000,
+    contextBudgetTokens: recipe.agent.contextBudgetTokens,
+    ...(recipe.agent.cacheTtl && { cacheTtl: recipe.agent.cacheTtl }),
+    ...(recipe.agent.provider === 'openai-responses' && {
+      providerParams: {
+        reasoning: {
+          effort: recipe.agent.responses?.reasoningEffort ?? 'high',
+          context: recipe.agent.responses?.reasoningContext ?? 'all_turns',
+        },
+        ...(recipe.agent.responses?.serviceTier ? {
+          service_tier: recipe.agent.responses.serviceTier,
+        } : {}),
+        ...(recipe.agent.responses?.compactThreshold ? {
+          context_management: [{
+            type: 'compaction',
+            compact_threshold: recipe.agent.responses.compactThreshold,
+          }],
+        } : {}),
+      },
+    }),
+    strategy,
+    ...(recipe.agent.thinking && { thinking: recipe.agent.thinking }),
+    ...(recipe.agent.refusalHandling && { refusalHandling: recipe.agent.refusalHandling }),
+    ...(recipe.agent.sameRoundThinkTextPolicy !== undefined
+      ? { sameRoundThinkTextPolicy: recipe.agent.sameRoundThinkTextPolicy }
+      : {}),
+  };
+}

package/src/framework-strategy.ts

@@ -0,0 +1,70 @@
+import {
+  AutobiographicalStrategy,
+  PassthroughStrategy,
+  type ContextStrategy,
+} from '@animalabs/agent-framework';
+import type { Recipe, RecipeStrategy } from './recipe.js';
+import { FrontdeskStrategy } from './strategies/frontdesk-strategy.js';
+
+const PASSTHROUGH_KEYS: ReadonlyArray<keyof RecipeStrategy> = [
+  'enforceBudget',
+  'maxSpeculativeL1s',
+  'compressionRefusalCurveFallbacks',
+  'compressionContextBudgetTokens',
+  'positionedRecallPairs',
+  'recallHeaderTemplate',
+  'targetChunkTokens',
+  'mergeThreshold',
+  'summaryTargetTokens',
+  'l1BudgetTokens',
+  'l2BudgetTokens',
+  'l3BudgetTokens',
+  'toolResultMaxLastN',
+  'toolUseInputMaxTokens',
+  'adaptiveResolution',
+  'kvStableReachTokens',
+  'kvStableQualityGapRatio',
+  'compressionSlackRatio',
+  'overBudgetGraceRatio',
+  'foldingStrategy',
+  'speculativeProduction',
+  'l1HoldbackChunks',
+  'summaryParticipant',
+  'summarySystemPrompt',
+  'summaryUserPrompt',
+  'summaryContextLabel',
+];
+
+export function buildFrameworkStrategy(
+  recipe: Recipe,
+  model: string,
+  timeZone: string,
+): ContextStrategy {
+  const strategyConfig = recipe.agent.strategy;
+  const strategyType = strategyConfig?.type ?? 'autobiographical';
+  const autobiographicalOpts: Record<string, unknown> = {
+    headWindowTokens: strategyConfig?.headWindowTokens ?? 4000,
+    recentWindowTokens: strategyConfig?.recentWindowTokens ?? 30000,
+    compressionModel: strategyConfig?.compressionModel ?? model,
+    autoTickOnNewMessage: true,
+    maxMessageTokens: strategyConfig?.maxMessageTokens ?? 10000,
+    ...(strategyType === 'frontdesk' ? { timeZone } : {}),
+  };
+
+  for (const key of PASSTHROUGH_KEYS) {
+    const value = strategyConfig?.[key];
+    if (value !== undefined) autobiographicalOpts[key] = value;
+  }
+
+  // Autobiographical agents default to adaptive resolution unless a recipe
+  // opts out; frontdesk keeps its historical hierarchical renderer default.
+  if (strategyType === 'autobiographical' && autobiographicalOpts.adaptiveResolution === undefined) {
+    autobiographicalOpts.adaptiveResolution = true;
+  }
+
+  return strategyType === 'passthrough'
+    ? new PassthroughStrategy()
+    : strategyType === 'frontdesk'
+      ? new FrontdeskStrategy(autobiographicalOpts)
+      : new AutobiographicalStrategy(autobiographicalOpts);
+}

package/src/index.ts

@@ -24,15 +24,14 @@ import {
 import { LoggingAnthropicAdapter } from './logging-adapter.js';
 import { CallLedger } from './call-ledger.js';
 import { SettingsModule } from './modules/settings-module.js';
-import { AgentFramework, AutobiographicalStrategy, PassthroughStrategy, WorkspaceModule, resolveTimeZone, type Module, type MountConfig } from '@animalabs/agent-framework';
+import { AgentFramework, WorkspaceModule, resolveTimeZone, type Module, type MountConfig } from '@animalabs/agent-framework';
 import { resolve, join, basename } from 'node:path';
 import { appendFile, mkdir, stat, rename } from 'node:fs/promises';
 import { readFileSync, existsSync } from 'node:fs';
-import { FrontdeskStrategy } from './strategies/frontdesk-strategy.js';
 import { SubagentModule } from './modules/subagent-module.js';
 import { LessonsModule } from './modules/lessons-module.js';
 import { RetrievalModule } from './modules/retrieval-module.js';
-import type { RecipeWorkspaceMount, RecipeStrategy } from './recipe.js';
+import type { RecipeWorkspaceMount } from './recipe.js';
 import { TuiModule } from './modules/tui-module.js';
 import { TimeModule } from './modules/time-module.js';
 import { FleetModule, type FleetModuleConfig } from './modules/fleet-module.js';
@@ -56,6 +55,8 @@ import {
   parseRecipeArg,
 } from './recipe.js';
 import { createBranchState, resetBranchState, handleExport, type BranchState } from './commands.js';
+import { buildFrameworkAgentConfig } from './framework-agent-config.js';
+import { buildFrameworkStrategy } from './framework-strategy.js';
 
 export type { AppContext };
 
@@ -400,102 +401,14 @@ async function createFramework(
   // No server augmentation needed — gate is wired via FrameworkConfig.gate
 
   // -- Build strategy --
-  //
-  // Build the options object with typed property access — no
-  // `Record<string, unknown>` cast on `strategyConfig`. Every field we
-  // forward is declared on `RecipeStrategy` (see recipe.ts); a typo in a
-  // recipe (e.g. `l1BudgetTokes`) now fails at recipe validation rather
-  // than silently being a no-op at strategy construction. AutobiographicalStrategy
-  // and FrontdeskStrategy share this option bag today; if strategy-specific
-  // fields are ever added, this should split into per-strategy types.
-  const strategyConfig = recipe.agent.strategy;
-  const strategyType = strategyConfig?.type ?? 'autobiographical';
-  const autobiographicalOpts: Record<string, unknown> = {
-    headWindowTokens: strategyConfig?.headWindowTokens ?? 4000,
-    recentWindowTokens: strategyConfig?.recentWindowTokens ?? 30000,
-    compressionModel: strategyConfig?.compressionModel ?? model,
-    autoTickOnNewMessage: true,
-    maxMessageTokens: strategyConfig?.maxMessageTokens ?? 10000,
-    ...(strategyType === 'frontdesk' ? { timeZone } : {}),
-  };
-  // Forward optional tuning fields when set. The key list is typed
-  // against `RecipeStrategy`, so an unknown field name is a compile
-  // error here rather than a silent no-op at runtime.
-  const passthroughKeys: ReadonlyArray<keyof RecipeStrategy> = [
-    'enforceBudget',
-    'maxSpeculativeL1s',
-    'positionedRecallPairs',
-    'recallHeaderTemplate',
-    'targetChunkTokens',
-    'mergeThreshold',
-    'summaryTargetTokens',
-    'l1BudgetTokens',
-    'l2BudgetTokens',
-    'l3BudgetTokens',
-    'toolResultMaxLastN',
-    'toolUseInputMaxTokens',
-    'adaptiveResolution',
-    'kvStableReachTokens',
-    'kvStableQualityGapRatio',
-    'compressionSlackRatio',
-    'overBudgetGraceRatio',
-    'foldingStrategy',
-    'speculativeProduction',
-    'l1HoldbackChunks',
-    'summaryParticipant',
-    'summarySystemPrompt',
-    'summaryUserPrompt',
-    'summaryContextLabel',
-  ];
-  for (const key of passthroughKeys) {
-    const v = strategyConfig?.[key];
-    if (v !== undefined) autobiographicalOpts[key] = v;
-  }
-  // Adaptive resolution (document-based gradual compression) is the intended
-  // default for autobiographical agents. Frontdesk keeps the hierarchical
-  // renderer (its salience-biased L1 selection); it can still opt in via the
-  // recipe. A recipe may set `adaptiveResolution: false` to opt back out.
-  if (strategyType === 'autobiographical' && autobiographicalOpts.adaptiveResolution === undefined) {
-    autobiographicalOpts.adaptiveResolution = true;
-  }
-  const strategy = strategyType === 'passthrough'
-    ? new PassthroughStrategy()
-    : strategyType === 'frontdesk'
-      ? new FrontdeskStrategy(autobiographicalOpts)
-      : new AutobiographicalStrategy(autobiographicalOpts);
+  const strategy = buildFrameworkStrategy(recipe, model, timeZone);
+  const agentConfig = buildFrameworkAgentConfig(recipe, agentName, model, strategy);
 
   // -- Create framework --
   const framework = await AgentFramework.create({
     storePath,
     membrane,
-    agents: [
-      {
-        name: agentName,
-        model,
-        systemPrompt: recipe.agent.systemPrompt,
-        maxTokens: recipe.agent.maxTokens ?? 16384,
-        maxStreamTokens: recipe.agent.maxStreamTokens ?? 150000,
-        contextBudgetTokens: recipe.agent.contextBudgetTokens,
-        ...(recipe.agent.cacheTtl && { cacheTtl: recipe.agent.cacheTtl }),
-        ...(recipe.agent.provider === 'openai-responses' && {
-          providerParams: {
-            reasoning: {
-              effort: recipe.agent.responses?.reasoningEffort ?? 'high',
-              context: recipe.agent.responses?.reasoningContext ?? 'all_turns',
-            },
-            ...(recipe.agent.responses?.compactThreshold ? {
-              context_management: [{
-                type: 'compaction',
-                compact_threshold: recipe.agent.responses.compactThreshold,
-              }],
-            } : {}),
-          },
-        }),
-        strategy,
-        ...(recipe.agent.thinking && { thinking: recipe.agent.thinking }),
-        ...(recipe.agent.refusalHandling && { refusalHandling: recipe.agent.refusalHandling }),
-      },
-    ],
+    agents: [agentConfig],
     modules: moduleInstances,
     mcplServers: finalServers,
     gate: gateOptions,
@@ -503,6 +416,45 @@ async function createFramework(
   });
 
   // Wire post-creation hooks
+  // Compression-quarantine klaxon → the framework's ops-alert channel
+  // (failures.log + ops:alert trace + CONNECTOME_OPS_WEBHOOK). The strategy
+  // re-fires this every alarm interval for as long as ANY chunk is
+  // quarantined: quarantined spans stay raw, the fold floor creeps, and the
+  // picker eventually cannot fit the window — a guaranteed future outage
+  // that must never be a silent state.
+  // Duck-typed on both sides so version skew in either dep degrades to a
+  // no-op (the strategy's own stderr klaxon still fires) instead of a crash.
+  {
+    const alarmCapable = strategy as unknown as {
+      setQuarantineAlarmHandler?: (fn: (status: { count: number; keys: string[] }) => void) => void;
+    };
+    const notify = (framework as unknown as {
+      notifyOps?: (kind: string, agent: string, message: string, data?: Record<string, unknown>) => void;
+    }).notifyOps?.bind(framework);
+    if (alarmCapable.setQuarantineAlarmHandler && notify) {
+      alarmCapable.setQuarantineAlarmHandler((status) => {
+        if (status.count === 0) {
+          // All-clear travels the same channel the alarm did, under a
+          // DISTINCT kind: the alarm kind's 15-min ops cooldown must never
+          // swallow the stand-down (silence after an alarm is ambiguous).
+          notify(
+            'compression-quarantine-clear',
+            agentName,
+            'compression quarantine EMPTY — all debt paid; alarm stands down.',
+            { count: 0 },
+          );
+          return;
+        }
+        notify(
+          'compression-quarantine',
+          agentName,
+          `${status.count} chunk(s) in compression quarantine — spans stay raw and WILL eventually exhaust the context budget. Operator action required (inspect refusing content; branch, pin, or clear).`,
+          { count: status.count, keys: status.keys },
+        );
+      });
+    }
+  }
+
   if (subagentModule) {
     subagentModule.setFramework(framework);
   }
@@ -905,6 +857,28 @@ async function main() {
     },
   };
 
+  // Off-path refusal dragnet → ops alerts (observability M3): refusals on
+  // non-streamed calls (compression/summarizer drains, maintenance) never
+  // reach the framework's own noteRefusal — the 2026-07-15 mythos cascade
+  // started exactly there, silently. Surface them through the same
+  // opsAlert pipeline (failures.log + ops:alert trace + throttled webhook).
+  // Reads app.framework (not the closure) so session switches stay wired;
+  // feature-detects notifyOpsAlert for older framework versions.
+  if (adapter instanceof LoggingAnthropicAdapter) {
+    adapter.onRefusal = (info) => {
+      const fw = app.framework as unknown as {
+        notifyOpsAlert?: (kind: string, agent: string, msg: string, data?: Record<string, unknown>) => void;
+      };
+      fw.notifyOpsAlert?.(
+        'refusal-offpath',
+        app.agentName,
+        `off-path refusal (category=${info.category ?? 'unknown'}) on a ${info.messages}-message ` +
+          `complete() call (~${Math.round(info.inputTokens / 1000)}k tok) — likely compression/summarizer`,
+        { ...info },
+      );
+    };
+  }
+
   framework.start();
   setupSynesthete(app);
   setupMcplStderrLog(app, storePath);

package/src/logging-adapter.ts

@@ -30,8 +30,8 @@ import { appendFileSync } from 'node:fs';
 import { summarizeCacheControls, type ProviderCallRecord } from './call-ledger.js';
 
 /** Live read of the current reasoning setting. The host wires this to
- *  `SettingsModule.getReasoning()` so toggles via the `settings--reasoning_*`
- *  tools take effect on the next call without restart. */
+ *  `SettingsModule.getReasoning()` so toggles via the `agent_settings` tool's
+ *  reasoning_enabled field take effect on the next call without restart. */
 export type ReasoningGetter = () => { enabled: boolean; budgetTokens: number };
 export type ProviderCallObserver = (record: ProviderCallRecord) => void;
 
@@ -95,7 +95,7 @@ export class LoggingAnthropicAdapter extends AnthropicAdapter {
     // form with: `"thinking.type.enabled" is not supported for this model.
     // Use "thinking.type.adaptive"`. Under adaptive the model sizes its own
     // thinking, so `budgetTokens` is no longer sent (it still shows in
-    // reasoning_status as an informational hint).
+    // agent_settings as an informational hint).
     //
     // membrane's `ProviderRequest` doesn't type a top-level `thinking` field
     // (membrane is 0.5.68 — agent-framework is the package that went 0.6.0;
@@ -131,6 +131,24 @@ export class LoggingAnthropicAdapter extends AnthropicAdapter {
     };
   }
 
+  /**
+   * Off-path refusal dragnet (observability M3). The main inference driver
+   * instruments its own refusals (agent-framework noteRefusal), but that
+   * covers ONLY streamed agent turns. Every other model call in the process
+   * — compression/summarizer drains, maintenance — flows through this
+   * adapter's complete() and previously refused in silence; the 2026-07-15
+   * mythos cascade STARTED there and alerted nowhere. Fired for
+   * kind==='complete' only: agent turns stream, so this never double-reports
+   * a refusal the main driver already escalated.
+   */
+  onRefusal?: (info: {
+    kind: 'complete' | 'stream';
+    category?: string;
+    model: string;
+    messages: number;
+    inputTokens: number;
+  }) => void;
+
   private observeCall(
     kind: 'complete' | 'stream',
     timestamp: string,
@@ -140,6 +158,18 @@ export class LoggingAnthropicAdapter extends AnthropicAdapter {
     response?: ProviderResponse,
     error?: unknown,
   ): void {
+    const raw0 = (response as { raw?: { stop_reason?: string; stop_details?: { category?: string } } } | undefined)?.raw;
+    if (kind === 'complete' && raw0?.stop_reason === 'refusal' && this.onRefusal) {
+      try {
+        this.onRefusal({
+          kind,
+          category: raw0.stop_details?.category,
+          model: request.model,
+          messages: request.messages.length,
+          inputTokens: response?.usage.inputTokens ?? 0,
+        });
+      } catch { /* observers never affect provider traffic */ }
+    }
     if (!this.onCall) return;
     const cache = summarizeCacheControls(rawRequest);
     const raw = (response as { raw?: Record<string, unknown> } | undefined)?.raw;

package/src/mcpl-config.ts

@@ -25,6 +25,7 @@ export interface ServerFileEntry {
   disabledFeatureSets?: string[];
   enabledTools?: string[];
   disabledTools?: string[];
+  /** @deprecated One-time migration input for legacy installations. */
   channelSubscription?: 'auto' | 'manual' | string[];
 }
 

package/src/modules/channel-mode-module.ts

@@ -7,22 +7,22 @@
  * have to remember (and keep in sync) all three:
  *
  *   debounced  (wake on every message, batched):
- *     1. subscribe to the channel's ambient traffic (`<toolPrefix>--subscribe_channel`)
+ *     1. open the channel (`channel_open`)
  *     2. upsert a per-channel gate policy that DEBOUNCES the ambient tag
  *        (framework.addGatePolicy → gate.json, hot-reloaded) so a burst wakes the
  *        agent once after it settles
  *     3. pin subscription-gc to "off" for the channel, else a chatty channel
- *        auto-unsubscribes itself at the idle-char limit and silently leaves
+ *        auto-closes itself at the idle-char limit and silently leaves
  *        debounced mode
  *
  *   mentions  (revert to mentions/DMs only):
  *     1. remove the per-channel debounce gate policy
- *     2. unsubscribe from ambient traffic
+ *     2. close the channel
  *     3. restore subscription-gc to its default limit
  *
  * The SAME `channelId` string is used for all three subsystems — it's the id the
  * gate sees on an incoming event (`GateEventInfo.channelId`) and the id
- * subscription-gc counts/unsubscribes, so they line up by construction (this is
+ * subscription-gc counts/closes, so they line up by construction (this is
  * exactly how SubscriptionGcModule already operates).
  *
  * Steps are best-effort with per-step reporting rather than a hard transaction:
@@ -45,7 +45,7 @@ import type { AgentFramework } from '@animalabs/agent-framework';
 export interface ChannelModeConfig {
   /** MCPL server id that owns subscriptions (default 'discord'). */
   serverId?: string;
-  /** Tool-name prefix for that server (default `mcpl--<serverId>`). */
+  /** @deprecated Lifecycle tools are host-generic; retained for config compatibility. */
   toolPrefix?: string;
   /** subscription-gc module name, for pinning the idle limit (default 'subscription-gc'). */
   gcModuleName?: string;
@@ -69,13 +69,11 @@ export class ChannelModeModule implements Module {
   private callSeq = 0;
 
   private readonly serverId: string;
-  private readonly toolPrefix: string;
   private readonly gcModuleName: string;
   private readonly defaultDebounceMs: number;
 
   constructor(config: ChannelModeConfig = {}) {
     this.serverId = config.serverId ?? 'discord';
-    this.toolPrefix = config.toolPrefix ?? `mcpl--${this.serverId}`;
     this.gcModuleName = config.gcModuleName ?? 'subscription-gc';
     this.defaultDebounceMs =
       typeof config.defaultDebounceMs === 'number' && config.defaultDebounceMs > 0
@@ -103,12 +101,12 @@ export class ChannelModeModule implements Module {
         name: 'set_channel_mode',
         description:
           'Set how a channel gets your attention, in one step. ' +
-          '`mode: "debounced"` = wake on EVERY message but batched: it subscribes ' +
+          '`mode: "debounced"` = wake on EVERY message but batched: it opens ' +
           'to the channel, adds a gate rule that debounces its ambient traffic ' +
           '(one wake after the burst settles), and pins the channel so it is never ' +
-          'auto-unsubscribed for being chatty. `mode: "mentions"` reverts to ' +
-          'mentions/DMs only: it removes that gate rule, unsubscribes, and restores ' +
-          'the default auto-unsubscribe limit. `debounceMs` (100–300000, default ' +
+          'auto-closed for being chatty. `mode: "mentions"` reverts to ' +
+          'direct-address-only: it removes that gate rule, closes, and restores ' +
+          'the default auto-close limit. `debounceMs` (100–300000, default ' +
           `${this.defaultDebounceMs}) sets the quiet window for debounced mode.`,
         inputSchema: {
           type: 'object',
@@ -182,7 +180,7 @@ export class ChannelModeModule implements Module {
     const steps: StepResult[] = [];
 
     // 1. Subscribe to ambient traffic.
-    steps.push(await this.callToolStep('subscribe', `${this.toolPrefix}--subscribe_channel`, { channelId }));
+    steps.push(await this.callToolStep('open', 'channel_open', { channelId, serverId: this.serverId }));
 
     // 2. Upsert the per-channel ambient debounce policy (prepend so it beats a
     //    broad ambient defer/debounce — first match wins). Validation lives in
@@ -201,7 +199,7 @@ export class ChannelModeModule implements Module {
       steps.push({ step: 'gate-policy', ok: false, detail: errMsg(err) });
     }
 
-    // 3. Pin subscription-gc off so a chatty channel doesn't auto-unsubscribe
+    // 3. Pin subscription-gc off so a chatty channel doesn't auto-close
     //    itself back out of debounced mode.
     steps.push(
       await this.callToolStep('gc-off', `${this.gcModuleName}--set_channel_idle_limit`, {
@@ -224,10 +222,10 @@ export class ChannelModeModule implements Module {
       steps.push({ step: 'gate-policy', ok: false, detail: errMsg(err) });
     }
 
-    // 2. Unsubscribe from ambient traffic.
-    steps.push(await this.callToolStep('unsubscribe', `${this.toolPrefix}--unsubscribe_channel`, { channelId }));
+    // 2. Close ambient traffic through the generic host lifecycle.
+    steps.push(await this.callToolStep('close', 'channel_close', { channelId, serverId: this.serverId }));
 
-    // 3. Restore the default auto-unsubscribe limit.
+    // 3. Restore the default auto-close limit.
     steps.push(
       await this.callToolStep('gc-default', `${this.gcModuleName}--set_channel_idle_limit`, {
         channelId,