@animalabs/connectome-host 0.7.1 → 0.7.3

package/CHANGELOG.md

@@ -2,6 +2,61 @@
 
 ## Unreleased
 
+## 0.7.3 — 2026-08-01
+
+### Changed
+
+- **Prompt caching enabled on Bedrock for models that support it**
+  (Discord issue #35). The previous transport-wide `promptCaching: false`
+  was a workaround for "your request did not allow prompt caching" —
+  which turned out to be the account-level denial for 3.5 Sonnet v2
+  (caching there was preview-only and dropped at Bedrock's GA), not a
+  transport property. Caching is now gated per model
+  (`bedrockModelSupportsPromptCaching`): on for the Bedrock caching-GA
+  lineup (3.5 Haiku, 3.7 Sonnet, Claude 4+), off for the pre-GA families
+  (Claude v2/instant, Claude 3, 3.5 Sonnet — matched at the family
+  boundary, so bare aliases and `-latest` forms gate the same as dated
+  ids; non-Claude Bedrock ids are conservatively off). New recipe field
+  `agent.promptCaching: boolean` overrides the gate in either direction
+  on any provider, and lands at both layers — per-agent config and
+  Membrane's default for internal callers (compression/merge) — for
+  accounts/regions whose entitlements differ from the GA table.
+  `cacheTtl` is withheld at the host layer on bedrock (Agent Framework
+  still supplies its own default downstream; membrane ≥ 0.5.77 strips
+  the ttl field at the provider boundary, so the wire request never
+  carries it either way). Verified live 2026-07-31: every currently
+  invokable Claude on Bedrock (all 4-era; 3.5-era and opus-4-0514 are
+  EOL there) writes and reads the cache cleanly. Requires
+  `@animalabs/membrane` ≥ 0.5.77 (cache_control ttl strip, stream cache
+  usage capture, 4-era inference-profile model mapping); the dependency
+  and lockfile are bumped accordingly in this change.
+
+- **Subscription-GC closes carry honest provenance and respect explicit
+  opens** (Discord issue #5, the Mythos "channel settings keep resetting"
+  mechanism). GC closes are now recorded as `subscription-gc`, never
+  `agent-tool`; a channel the resident/operator explicitly opened is no
+  longer auto-closed under the *default* budget — a configured per-channel
+  numeric budget in `agent_settings.channel_idle_limits` counts as an
+  explicit idle lease and still closes at that budget. (The override state
+  records no actor — agent, operator, or imported are all possible — so
+  receipts say `configured-budget`, claiming no more than the state
+  proves.) Pins and policy-opened channels behave as before. Requires
+  agent-framework with machine-close provenance; against an older
+  framework GC behaves as it did.
+- **GC closes emit an operator-side ops receipt** (`subscription-gc-close`
+  via the framework ops channel: failures.log + `ops:alert` trace +
+  webhook) naming channel, threshold, decision source, and the restore
+  action — ids and thresholds only, no content. A durable listening-state
+  change no longer looks spontaneous from outside the transcript.
+
+## 0.7.2 — 2026-07-27
+
+### Added
+
+- **`LLM_CALLS_FULL_PAYLOADS` env flag** — retain the raw request on every
+  llm-call log entry, not only on refusal/error. Debugging aid; off by
+  default (the logs grow gigabytes fast with it on).
+
 ## 0.7.1 — 2026-07-26
 
 ### Changed

package/README.md

@@ -29,12 +29,7 @@ A recipe is a JSON file that configures everything domain-specific:
     "model": "claude-opus-4-6",
     "timezone": "America/Los_Angeles",
     "systemPrompt": "You are a ...",
-    "maxTokens": 16384,
-    "strategy": {
-      "type": "autobiographical",
-      "headWindowTokens": 4000,
-      "recentWindowTokens": 30000
-    }
+    "maxTokens": 16384
   },
   "mcpServers": {
     "my-server": {
@@ -44,9 +39,6 @@ A recipe is a JSON file that configures everything domain-specific:
     }
   },
   "modules": {
-    "subagents": true,
-    "lessons": true,
-    "retrieval": true,
     "wake": true,
     "files": { "namespace": "products" }
   },
@@ -60,6 +52,14 @@ A recipe is a JSON file that configures everything domain-specific:
 Chronicle and MCPL protocol timestamps remain epoch/UTC. If the recipe omits
 it, `AGENT_TIMEZONE` is used, then the process timezone.
 
+**Memory defaults**: `agent.strategy` may be omitted entirely. The default is
+the autobiographical memory strategy with adaptive resolution, **KV-stable
+folding** (compile plans that preserve prompt-cache prefixes), compression by
+the agent's own model, and summaries voiced as the agent itself
+(`summaryParticipant` defaults to `agent.name`). Set a `strategy` block only
+to tune windows/budgets or opt into a different strategy type — see
+`docs/AGENT-ONBOARDING.md` for sizing guidance on long-lived agents.
+
 ### Recipe loading
 
 | Command | Behavior |
@@ -122,8 +122,8 @@ subscription credits at a higher rate when applied.
 
 - **Web UI**: browser operator console (`modules.webui`) — live chat with full interiority (thinking, tool calls, streaming), agent/fleet tree, context makeup + compression coverage, call ledger with cache verdicts and billing-grade costs, health/ops alerts, Chronicle branch tree, lessons, MCPL config, workspace files; scoped read-only observer access via device keys
 - **TUI + readline modes**: OpenTUI interactive terminal or `--no-tui` for pipes/CI
-- **Subagent forking**: Spawn/fork parallel agents with fleet tree view (Tab to toggle)
-- **Persistent lessons**: Knowledge store with confidence scores, tags, and semantic retrieval
+- **Subagent forking** (opt-in, `modules.subagents`): Spawn/fork parallel agents with fleet tree view (Tab to toggle)
+- **Persistent lessons** (opt-in, `modules.lessons`): Knowledge store with confidence scores and tags. Automatic retrieval-injection of lessons into context (`modules.retrieval`) is a separate opt-in — it adds per-turn context churn and Haiku calls, so enable it only for agents that actually curate a lesson library
 - **Time-travel**: Chronicle-backed undo/redo, named checkpoints, branch exploration
 - **Session management**: Isolated sessions with auto-naming
 - **MCPL support**: Connect any MCP/MCPL server; wake subscriptions for selective event triggering

package/docs/AGENT-ONBOARDING.md

@@ -257,7 +257,8 @@ ln -sfn ../../../connectome-local/context-manager/node_modules/@animalabs/chroni
     }
   },
   "modules": { "webui": { "port": 7343, "host": "127.0.0.1",
-                          "basicAuth": { "username": "${WEBUI_USER}", "password": "${WEBUI_PASS}" } }
+                          "basicAuth": { "username": "${WEBUI_USER}", "password": "${WEBUI_PASS}" } },
+               "subagents": false, "lessons": false, "retrieval": false
                /* + wake policies, workspace mounts (files/, notes/) */ },
   "mcpServers": {
     "shell":   { /* terminal-sessions stdio server; env: SESSION_SERVER_TOKEN, SESSION_SERVER_PORT */ },
@@ -271,6 +272,24 @@ Use `"cacheTtl": "1h"` for Connectome deployments. This is also the runtime
 default when the field is omitted. Set `"5m"` only for intentionally rapid
 workloads whose cache is normally reused within five minutes.
 
+**`subagents`/`lessons`/`retrieval` are NOT part of the standard recipe.**
+All three are opt-in. RetrievalModule in particular injects context-dependent
+content into every compile (and spends two Haiku calls per turn), so it must
+be an explicit opt-in for agents that actually curate a lesson library.
+Current host code defaults all three to off, but keep the explicit `false`
+entries in the recipe anyway — older host checkouts treated these as opt-out,
+and an accidentally-enabled RetrievalModule has caused severe prompt-cache
+churn in the field.
+
+**Memory defaults.** Current host code defaults an omitted/partial `strategy`
+to the fleet-standard shape: autobiographical + `adaptiveResolution: true` +
+`foldingStrategy: "kv-stable"` + same-model compression (`compressionModel`
+falls back to `agent.model`) + `summaryParticipant` = `agent.name`. Keep the
+skeleton's explicit values anyway: older host checkouts default folding to
+`flat-profile` and summary voice to the literal `'Claude'` (the stranger's-voice
+hazard), and explicit values survive host downgrades and copy-paste to other
+deployments.
+
 **`.env`** (`chmod 600`). Common vars:
 
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@animalabs/connectome-host",
-  "version": "0.7.1",
+  "version": "0.7.3",
   "description": "General-purpose agent TUI host with recipe-based configuration",
   "type": "module",
   "scripts": {
@@ -17,7 +17,7 @@
     "@animalabs/agent-framework": "^0.7.2",
     "@animalabs/chronicle": "^0.2.0",
     "@animalabs/context-manager": "^0.6.0",
-    "@animalabs/membrane": "^0.5.75",
+    "@animalabs/membrane": "^0.5.77",
     "@opentui/core": "^0.1.82"
   },
   "devDependencies": {

package/scripts/warmup-session.ts

@@ -42,7 +42,7 @@ import { resolve } from 'node:path';
 import { JsStore } from '@animalabs/chronicle';
 import { ContextManager } from '@animalabs/context-manager';
 import { AutobiographicalStrategy } from '@animalabs/agent-framework';
-import { Membrane, AnthropicAdapter, type NormalizedResponse } from '@animalabs/membrane';
+import { Membrane, AnthropicAdapter, BedrockAdapter, type NormalizedResponse } from '@animalabs/membrane';
 import { SessionManager } from '../src/session-manager.js';
 import { resolveAgentName } from '../src/agent-name.js';
 
@@ -181,7 +181,13 @@ function formatDuration(sec: number): string {
 
 async function main() {
   const opts = parseArgs(process.argv);
-  if (!process.env.ANTHROPIC_API_KEY) {
+  const bedrockModel = /^([a-z]{2,6}\.)?anthropic\./.test(opts.model);
+  if (bedrockModel) {
+    if (!process.env.AWS_ACCESS_KEY_ID || !process.env.AWS_SECRET_ACCESS_KEY) {
+      console.error('Bedrock model id — set AWS_ACCESS_KEY_ID / AWS_SECRET_ACCESS_KEY (and AWS_REGION)');
+      process.exit(1);
+    }
+  } else if (!process.env.ANTHROPIC_API_KEY) {
     console.error('Set ANTHROPIC_API_KEY');
     process.exit(1);
   }
@@ -218,8 +224,16 @@ async function main() {
   // -- Membrane with token-spend hook --
   const price = priceOf(opts.model);
   const spend: Spend = { inputTokens: 0, outputTokens: 0, cost: 0 };
-  const adapter = new AnthropicAdapter({ apiKey: process.env.ANTHROPIC_API_KEY });
+  // Bedrock model ids (anthropic.* / <region>.anthropic.*) route through the
+  // BedrockAdapter with AWS_* env creds — legacy Claude models (revival
+  // sessions) exist nowhere else. Caching off: legacy models reject
+  // cache_control outright.
+  const isBedrock = /^([a-z]{2,6}\.)?anthropic\./.test(opts.model);
+  const adapter = isBedrock
+    ? new BedrockAdapter()
+    : new AnthropicAdapter({ apiKey: process.env.ANTHROPIC_API_KEY });
   const membrane = new Membrane(adapter, {
+    ...(isBedrock ? { defaultPromptCaching: false } : {}),
     // Imported sessions store assistant turns under participant `agentName`.
     // Membrane's default assistantParticipant is 'Claude'; if that disagrees
     // with the stored participant every assistant message maps to role

package/src/codex-subscription-adapter.ts

@@ -532,7 +532,19 @@ export class CodexSubscriptionAdapter implements ProviderAdapter {
         stopReason,
         stopSequence: undefined,
         usage: {
-          inputTokens: terminal.usage?.input_tokens ?? 0,
+          // OpenAI/Codex reports `input_tokens` INCLUSIVE of cached tokens,
+          // whereas the rest of the stack uses the additive Anthropic
+          // convention (inputTokens = fresh/uncached, cacheReadTokens added on
+          // top, so inputTokens + cacheReadTokens == total prompt). Report
+          // fresh-only here so that convention holds. Without this, every
+          // consumer that sums the buckets — the calibration realTotal
+          // (framework.ts), cost pricing, and gate metering — double-counts
+          // the cached prefix: on a heavily-cached turn real/est hit ~2.0,
+          // which the estimator rejected as out-of-band on full-cache compiles
+          // and (worse) ratcheted the multiplier upward on partial-cache ones,
+          // inflating estimates until the budget solver exhausted and the
+          // agent wedged (Sol, 2026-07-31).
+          inputTokens: Math.max(0, (terminal.usage?.input_tokens ?? 0) - cachedTokens),
           outputTokens: terminal.usage?.output_tokens ?? 0,
           cacheReadTokens: cachedTokens > 0 ? cachedTokens : undefined,
         },

package/src/framework-agent-config.ts

@@ -10,12 +10,60 @@ export type FrameworkAgentConfig = AgentConfig & {
   sameRoundThinkTextPolicy?: 'public' | 'private';
 };
 
+/**
+ * Prompt caching went GA on Bedrock in April 2025 for 3.5 Haiku, 3.7
+ * Sonnet, and Claude 4+ — but NOT for 3.5 Sonnet (either version). 1022
+ * ("3.6") was in the Dec 2024 preview and was dropped at GA — that
+ * account-level "your request did not allow prompt caching" is the error
+ * observed here 2026-07-21 (antra's diagnosis, confirmed against the AWS
+ * docs 2026-07-31; as of the same day's live probe every 3.5-era model
+ * is EOL on Bedrock anyway). So the gate denies the pre-GA FAMILIES —
+ * Claude v2/instant, Claude 3, 3.5 Sonnet — at the family boundary, so
+ * dated ids, bare aliases, -latest, and inference-profile forms
+ * (us.anthropic.claude-...) all resolve the same; 3.5 Haiku and 3.7
+ * Sonnet stay distinct and on. Non-Claude Bedrock ids (Nova etc.) are
+ * out of scope for this gate and conservatively off — membrane's
+ * BedrockAdapter only accepts Claude ids today. recipe.agent.
+ * promptCaching overrides in either direction for accounts/regions
+ * whose entitlements differ from the GA table. (Connectome issue #35.)
+ */
+export function bedrockModelSupportsPromptCaching(model: string): boolean {
+  const id = model.toLowerCase();
+  if (!id.includes('claude')) return false;
+  // (?![a-z0-9]) = family boundary: end of id, or a separator (-, ., :)
+  // before a date/qualifier — matches the whole family, not one spelling.
+  return !/claude-(v2|instant|3-(opus|sonnet|haiku)|3-5-sonnet)(?![a-z0-9])/.test(id);
+}
+
+export function resolvePromptCaching(recipe: Recipe, model: string): boolean | undefined {
+  if (recipe.agent.promptCaching !== undefined) return recipe.agent.promptCaching;
+  if (recipe.agent.provider === 'bedrock') return bedrockModelSupportsPromptCaching(model);
+  return undefined; // membrane default (on)
+}
+
+/**
+ * Membrane-level counterpart of resolvePromptCaching, spread into the
+ * Membrane constructor config. The per-agent flag only governs agent
+ * inference; internal callers (autobio compression, executeMerge) read
+ * Membrane's defaultPromptCaching — so an explicit recipe override must
+ * land at BOTH layers, on every provider, or `promptCaching: false` on
+ * an Anthropic recipe would silently keep caching on for internal calls.
+ */
+export function membraneCachingOverride(
+  recipe: Recipe,
+  model: string,
+): { defaultPromptCaching?: boolean } {
+  const promptCaching = resolvePromptCaching(recipe, model);
+  return promptCaching === undefined ? {} : { defaultPromptCaching: promptCaching };
+}
+
 export function buildFrameworkAgentConfig(
   recipe: Recipe,
   agentName: string,
   model: string,
   strategy: FrameworkAgentConfig['strategy'],
 ): FrameworkAgentConfig {
+  const promptCaching = resolvePromptCaching(recipe, model);
   return {
     name: agentName,
     model,
@@ -23,10 +71,17 @@ export function buildFrameworkAgentConfig(
     maxTokens: recipe.agent.maxTokens ?? 16384,
     maxStreamTokens: recipe.agent.maxStreamTokens ?? 150000,
     contextBudgetTokens: recipe.agent.contextBudgetTokens,
-    ...(recipe.agent.cacheTtl && { cacheTtl: recipe.agent.cacheTtl }),
-    // Bedrock legacy Claude models reject cache_control outright
-    // ("your request did not allow prompt caching") — suppress markers.
-    ...(recipe.agent.provider === 'bedrock' && { promptCaching: false }),
+    // cacheTtl is withheld at the HOST layer on bedrock: the transport
+    // only has the default 5m cache, and older membrane releases forward
+    // the ttl field Bedrock rejects. Note this is not the whole story —
+    // Agent Framework still supplies its own default ('1h') downstream
+    // when the host omits the field, and membrane ≥0.5.77 strips it at
+    // the provider boundary before wire dispatch. Requests are safe, but
+    // pre-adapter config is NOT cache-TTL telemetry; the wire truth lives
+    // at the adapter.
+    ...(recipe.agent.cacheTtl && recipe.agent.provider !== 'bedrock'
+      && { cacheTtl: recipe.agent.cacheTtl }),
+    ...(promptCaching !== undefined && { promptCaching }),
     // Prefill scaffold (anthropic-xml formatter), e.g. chapterx CLI-sim's
     // '<cmd>cat untitled.txt</cmd>' — part of migrating prefill-era bots.
     ...(recipe.agent.prefillUserMessage && { prefillUserMessage: recipe.agent.prefillUserMessage }),

package/src/framework-strategy.ts

@@ -88,6 +88,27 @@ export function buildFrameworkStrategy(
     autobiographicalOpts.adaptiveResolution = true;
   }
 
+  // Reasonable memory defaults for recipes that omit strategy tuning:
+  //
+  // - foldingStrategy 'kv-stable': the library's own fallback is
+  //   'flat-profile', which replans compile layouts without regard for
+  //   prompt-cache stability. Long-lived agents want cache-stable folds by
+  //   default; recipes can still pin 'flat-profile'/'oldest-first' explicitly.
+  //   (Only meaningful under adaptive resolution, so gate on it.)
+  // - summaryParticipant <agent name>: the library falls back to the literal
+  //   'Claude', which voices self-recollections as a stranger for any agent
+  //   not named Claude. Summaries should speak as the agent itself.
+  if (
+    strategyType === 'autobiographical' &&
+    autobiographicalOpts.adaptiveResolution !== false &&
+    autobiographicalOpts.foldingStrategy === undefined
+  ) {
+    autobiographicalOpts.foldingStrategy = 'kv-stable';
+  }
+  if (autobiographicalOpts.summaryParticipant === undefined && recipe.agent.name) {
+    autobiographicalOpts.summaryParticipant = recipe.agent.name;
+  }
+
   return strategyType === 'passthrough'
     ? new PassthroughStrategy()
     : strategyType === 'frontdesk'

package/src/index.ts

@@ -46,6 +46,7 @@ import { SubscriptionGcModule } from './modules/subscription-gc-module.js';
 import { ChannelModeModule } from './modules/channel-mode-module.js';
 import { WebUiModule } from './modules/web-ui-module.js';
 import { ObserversModule } from './modules/observers-module.js';
+import { IdentityModule } from './modules/identity-module.js';
 import { McplAdminModule } from './modules/mcpl-admin-module.js';
 import { TtsRelayModule } from './modules/tts-relay-module.js';
 import { loadMcplServers, applyAgentOverlay, DEFAULT_CONFIG_PATH, DEFAULT_AGENT_OVERLAY_PATH } from './mcpl-config.js';
@@ -62,7 +63,7 @@ import {
   parseRecipeArg,
 } from './recipe.js';
 import { createBranchState, resetBranchState, handleExport, type BranchState } from './commands.js';
-import { buildFrameworkAgentConfig } from './framework-agent-config.js';
+import { buildFrameworkAgentConfig, membraneCachingOverride } from './framework-agent-config.js';
 import { buildFrameworkStrategy } from './framework-strategy.js';
 import { loadExtensions } from './extensions.js';
 
@@ -146,6 +147,11 @@ async function resolveRecipe(): Promise<Recipe> {
 // Framework factory
 // ---------------------------------------------------------------------------
 
+function resolveModel(recipe: Recipe): string {
+  return config.model || recipe.agent.model ||
+    (recipe.agent.provider === 'openai-codex' ? 'gpt-5.4' : 'claude-opus-4-6');
+}
+
 async function createFramework(
   membrane: Membrane,
   storePath: string,
@@ -154,8 +160,7 @@ async function createFramework(
   settingsModule: SettingsModule,
   callLedger: CallLedger | null,
 ): Promise<AgentFramework> {
-  const model = config.model || recipe.agent.model ||
-    (recipe.agent.provider === 'openai-codex' ? 'gpt-5.4' : 'claude-opus-4-6');
+  const model = resolveModel(recipe);
   const modules = recipe.modules ?? {};
   const timeZone = resolveTimeZone(recipe.agent.timezone);
 
@@ -169,9 +174,10 @@ async function createFramework(
   // adapter can read its state for cross-cutting concerns like reasoning).
   const moduleInstances: Module[] = [new TuiModule(), new TimeModule(timeZone), settingsModule];
 
-  // Subagents
+  // Subagents. OPT-IN — not part of the standard recipe; enable explicitly
+  // via modules.subagents when an agent should fork parallel workers.
   let subagentModule: SubagentModule | null = null;
-  if (modules.subagents !== false) {
+  if (modules.subagents) {
     const subagentConfig = typeof modules.subagents === 'object' ? modules.subagents : {};
     subagentModule = new SubagentModule({
       parentAgentName: agentName,
@@ -181,9 +187,10 @@ async function createFramework(
     moduleInstances.push(subagentModule);
   }
 
-  // Lessons
+  // Lessons. OPT-IN — not part of the standard recipe; enable explicitly via
+  // modules.lessons for agents that curate a lesson library.
   let lessonsModule: LessonsModule | null = null;
-  if (modules.lessons !== false) {
+  if (modules.lessons) {
     const globalLessonsPath = resolve(join(storePath, '..', '..', 'lessons.json'));
     lessonsModule = new LessonsModule({ globalPath: globalLessonsPath });
     moduleInstances.push(lessonsModule);
@@ -219,8 +226,11 @@ async function createFramework(
     moduleInstances.push(new FleetModule(fleetModuleConfig));
   }
 
-  // Retrieval (requires lessons)
-  if (modules.retrieval !== false && lessonsModule) {
+  // Retrieval (requires lessons). OPT-IN — not part of the standard recipe:
+  // it injects context-dependent content into every compile (plus two Haiku
+  // calls per turn), which adds per-turn context churn. Enable explicitly via
+  // modules.retrieval only when an agent actually curates a lesson library.
+  if (modules.retrieval && lessonsModule) {
     const retrievalConfig = typeof modules.retrieval === 'object' ? modules.retrieval : {};
     moduleInstances.push(new RetrievalModule({
       membrane,
@@ -332,11 +342,27 @@ async function createFramework(
   // MCPL self-administration — opt-in per recipe (grants the agent the
   // ability to spawn arbitrary commands via mcpl_deploy; see recipe.ts).
   let mcplAdminModule: McplAdminModule | null = null;
-  if (modules.mcplAdmin === true) {
-    mcplAdminModule = new McplAdminModule({ timeZone });
+  if (modules.mcplAdmin === true || typeof modules.mcplAdmin === 'object') {
+    const surface = typeof modules.mcplAdmin === 'object' ? modules.mcplAdmin.surface : undefined;
+    mcplAdminModule = new McplAdminModule({ timeZone, ...(surface ? { surface } : {}) });
     moduleInstances.push(mcplAdminModule);
   }
 
+  // Archipelago identity — opt-in per recipe. Utilities-only: enrollment is
+  // one-time and token refresh is rare, so it costs no tool slots (see
+  // identity-module.ts header). Keypair lives at the dataDir level — an
+  // identity belongs to the deployment, not the session.
+  let identityModule: IdentityModule | null = null;
+  if (modules.identity !== undefined && modules.identity !== false) {
+    const idCfg = typeof modules.identity === 'object' ? modules.identity : {};
+    identityModule = new IdentityModule({
+      keyPath: process.env.IDENTITY_KEY_FILE || resolve(config.dataDir, 'identity-key.pem'),
+      home: idCfg.home ?? process.env.IDENTITY_HOME ?? 'id.animalabs.ai',
+      ...(idCfg.audience ? { defaultAudience: idCfg.audience } : {}),
+    });
+    moduleInstances.push(identityModule);
+  }
+
   // Web admin UI — opt-in per recipe
   let webUiModule: WebUiModule | null = null;
   if (modules.webui !== undefined && modules.webui !== false) {
@@ -356,7 +382,10 @@ async function createFramework(
       ...(callLedger ? { callLedger } : {}),
     });
     moduleInstances.push(webUiModule);
-    moduleInstances.push(new ObserversModule({ path: observersPath }));
+    moduleInstances.push(new ObserversModule({
+      path: observersPath,
+      ...(webuiConfig.observersSurface ? { surface: webuiConfig.observersSurface } : {}),
+    }));
   }
 
   // TTS relay tap — opt-in per recipe. Pure trace-bus consumer: mirrors the
@@ -415,6 +444,7 @@ async function createFramework(
       if (recipeEntry.url !== undefined) merged.url = recipeEntry.url;
       if (recipeEntry.transport !== undefined) merged.transport = recipeEntry.transport;
       if (recipeEntry.token !== undefined) merged.token = recipeEntry.token;
+      if (recipeEntry.access !== undefined) merged.access = recipeEntry.access;
       allServers.push(merged as { id: string; command?: string; url?: string; [k: string]: unknown });
     } else if (recipeEntry.command || recipeEntry.url) {
       // Recipe-defined server (not in the file config). Spread ALL recipe fields
@@ -426,12 +456,30 @@ async function createFramework(
   // Apply the agent overlay (mcpl-servers.agent.json): servers the agent
   // deployed for itself load unconditionally (no recipe opt-in), and
   // tombstones suppress recipe/file servers the agent unloaded.
-  const finalServers = applyAgentOverlay(allServers, DEFAULT_AGENT_OVERLAY_PATH).map((server) => ({
-    ...server,
-    // Stdio MCPL children inherit a single agent-facing wall clock. Protocol
-    // timestamps remain UTC; only their rendered text uses this setting.
-    env: { ...(server.env ?? {}), AGENT_TIMEZONE: timeZone },
-  }));
+  const finalServers = applyAgentOverlay(allServers, DEFAULT_AGENT_OVERLAY_PATH).map((server) => {
+    const withEnv: { id: string; command?: string; url?: string; [k: string]: unknown } = {
+      ...server,
+      // Stdio MCPL children inherit a single agent-facing wall clock. Protocol
+      // timestamps remain UTC; only their rendered text uses this setting.
+      env: { ...(server.env ?? {}), AGENT_TIMEZONE: timeZone },
+    };
+    // `access` is a declarative name (recipe/file/overlay); the credential
+    // provider it implies is attached HERE, at load time — fresh credential
+    // per dial via the identity module, never serialized, never in model
+    // context (see identity-module.ts header).
+    if (typeof withEnv.access === 'string' && withEnv.access) {
+      if (identityModule) {
+        const identity = identityModule;
+        const audience = withEnv.access as string;
+        withEnv.accessProvider = () => identity.accessFor(audience);
+      } else {
+        console.error(
+          `[mcpl] server "${server.id}": access "${withEnv.access}" declared but the recipe has no identity module — connecting without credentials`,
+        );
+      }
+    }
+    return withEnv;
+  });
 
   // No server augmentation needed — gate is wired via FrameworkConfig.gate
 
@@ -513,6 +561,7 @@ agents: [agentConfig],
 
   if (mcplAdminModule) {
     mcplAdminModule.setFramework(framework);
+    if (identityModule) mcplAdminModule.setIdentity(identityModule);
   }
 
   if (workspaceModule) {
@@ -827,13 +876,18 @@ async function main() {
         xTitle: recipe.agent.name ?? recipe.name,
       })
     : undefined;
-  // Bedrock: legacy Claude models (3.5 Sonnet 0620/1022, Opus 3) that have
-  // left the Anthropic API but survive on AWS. The adapter reads AWS_* env
-  // vars (AWS_REGION defaults us-west-2) and maps standard Claude model IDs
-  // to Bedrock IDs (explicit map + `anthropic.<id>-v1:0` fallback). Uses the
-  // Anthropic-native message shape, so NativeFormatter applies unchanged.
-  // No CallLedger: prompt caching is rejected outright by legacy Bedrock
-  // models (tested 2026-07-21). Wrapped for llm-calls.jsonl visibility.
+  // Bedrock: an alternate Claude transport. (Historically for models that
+  // left the direct API — as of 2026-07-31 every 3.5-era id and opus-4-0514
+  // are EOL on Bedrock too, so what actually runs here is the 4-era via
+  // inference profiles.) The adapter reads AWS_* env vars (AWS_REGION
+  // defaults us-west-2) and maps standard Claude model IDs to Bedrock IDs.
+  // Uses the Anthropic-native message shape, so NativeFormatter applies
+  // unchanged. Prompt caching is model-gated
+  // (bedrockModelSupportsPromptCaching): pre-GA families (Claude 3,
+  // 3.5 Sonnet) off, everything currently invokable caches — verified by
+  // live probe 2026-07-31. Still no CallLedger — it's
+  // anthropic-transport-only for now; cache metrics are visible in
+  // llm-calls.jsonl via the logging wrapper.
   const bedrockAdapter = provider === 'bedrock'
     ? new LoggingBedrockAdapter({}, llmLogPath)
     : undefined;
@@ -915,10 +969,13 @@ async function main() {
       : recipe.agent.formatter === 'anthropic-xml'
         ? new AnthropicXmlFormatter()
         : new NativeFormatter(),
-    // Bedrock legacy Claude models 400 on any cache_control block
-    // ("your request did not allow prompt caching") — suppress the
-    // historical promptCaching=true default on that transport.
-    ...(provider === 'bedrock' ? { defaultPromptCaching: false } : {}),
+    // Caching default for internal callers (autobio compression,
+    // executeMerge), which read Membrane's defaultPromptCaching rather
+    // than the per-agent flag. Applies on EVERY provider whenever the
+    // recipe/model resolves an explicit answer — an Anthropic recipe with
+    // promptCaching:false must disable internal calls too, and on bedrock
+    // the model gate decides (see bedrockModelSupportsPromptCaching).
+    ...membraneCachingOverride(recipe, resolveModel(recipe)),
     // Anchor the assistant role for internal callers that don't set
     // request.assistantParticipant themselves (autobio compression,
     // executeMerge). Mismatch here flips stored assistant turns to

package/src/logging-adapter.ts

@@ -32,7 +32,11 @@ import { summarizeCacheControls, type ProviderCallRecord } from './call-ledger.j
 /** Live read of the current reasoning setting. The host wires this to
  *  `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 ReasoningGetter = () => {
+  enabled: boolean;
+  budgetTokens: number;
+  display?: 'summarized' | 'omitted';
+};
 export type ProviderCallObserver = (record: ProviderCallRecord) => void;
 
 /** Exact first-system-block identity Anthropic requires on subscription
@@ -43,6 +47,11 @@ export type ProviderCallObserver = (record: ProviderCallRecord) => void;
  *  system-prompt-append uses). */
 const OAUTH_SYSTEM_IDENTITY = "You are Claude Code, Anthropic's official CLI for Claude.";
 
+/** Truthy env-flag parse: unset/''/'0'/'false' (any case) are off. */
+function envFlag(value: string | undefined): boolean {
+  return value !== undefined && value !== '' && value !== '0' && value.toLowerCase() !== 'false';
+}
+
 export class LoggingAnthropicAdapter extends AnthropicAdapter {
   private readonly logPath: string;
   private readonly getReasoning?: ReasoningGetter;
@@ -50,6 +59,14 @@ export class LoggingAnthropicAdapter extends AnthropicAdapter {
   /** True when authenticated with an OAuth/Bearer token instead of an API
    *  key; requests then need the identity block prepended (see above). */
   private readonly oauthMode: boolean;
+  /** LLM_CALLS_FULL_PAYLOADS=1: retain the full raw request on EVERY call,
+   *  not just refusals/errors. Purpose: pass/refusal contrast corpora — a
+   *  refusal's payload is only interpretable next to the passing payloads
+   *  around it (classifier-forensics finding, 2026-07-27: verdicts are a
+   *  near-deterministic function of the payload, so adjacent pairs isolate
+   *  the differentiator). Costs disk, not memory (the raw request is already
+   *  captured per-call for the summary); pair with llm-calls rotation. */
+  private readonly fullPayloads: boolean = envFlag(process.env.LLM_CALLS_FULL_PAYLOADS);
 
   constructor(
     config: ConstructorParameters<typeof AnthropicAdapter>[0],
@@ -106,9 +123,16 @@ export class LoggingAnthropicAdapter extends AnthropicAdapter {
     // request.extra; Object.assign(params, rest)`), so we route thinking
     // through the typed `extra` bag — no type assertion, and it survives the
     // next dependency reshuffle instead of hiding it from the compiler.
+    //
+    // `display`: models 4.7+ default to 'omitted' (empty `thinking` text,
+    // signature only). We pass the setting through — default 'summarized' —
+    // so reasoning summaries are visible again (stores, webui, estimators).
     return {
       ...request,
-      extra: { ...request.extra, thinking: { type: 'adaptive' } },
+      extra: {
+        ...request.extra,
+        thinking: { type: 'adaptive', display: r.display ?? 'summarized' },
+      },
     };
   }
 
@@ -206,6 +230,7 @@ export class LoggingAnthropicAdapter extends AnthropicAdapter {
   }
 
   private refusalRawRequest(response: ProviderResponse, rawRequest: unknown): unknown {
+    if (this.fullPayloads) return rawRequest;
     const raw = (response as { raw?: { stop_reason?: string } }).raw;
     return raw?.stop_reason === 'refusal' ? rawRequest : undefined;
   }

package/src/mcpl-config.ts

@@ -27,6 +27,14 @@ export interface ServerFileEntry {
   disabledTools?: string[];
   /** @deprecated One-time migration input for legacy installations. */
   channelSubscription?: 'auto' | 'manual' | string[];
+  /**
+   * Name of a network access grant (an archipelago audience, e.g.
+   * "eidoverse"). Purely declarative here: at load/deploy time the host
+   * attaches a credential provider that fetches something fresh on every
+   * dial via the identity module. The agent (and this file) never holds a
+   * credential — `access` is a name, not a secret.
+   */
+  access?: string;
 }
 
 export interface McplServersFile {