@animalabs/agent-framework 0.7.4 → 0.9.0

package/src/framework.ts

@@ -37,6 +37,7 @@ import type {
   ToolCall,
   ToolCallEvent,
   ToolResult,
+  CompletedToolCall,
   AgentConfig,
   InferenceRequest,
   AgentState,
@@ -52,21 +53,27 @@ import type {
   SameRoundThinkTextPolicy,
 } from './types/index.js';
 import { ProcessQueueImpl } from './queue.js';
+import { REFUSAL_REACTIONS, REFUSAL_REACTION_FALLBACK } from './refusal-reactions.js';
 import { Agent } from './agent.js';
 import { ModuleRegistry, isStateExistsError } from './module-registry.js';
 import { McplServerRegistry } from './mcpl/server-registry.js';
 import { FeatureSetManager } from './mcpl/feature-set-manager.js';
-import { ScopeManager } from './mcpl/scope-manager.js';
+import { computeGrant, CapabilityGrant, expandAdvertisementShorthand } from './mcpl/capability-grant.js';
+import { maskNegotiatedCapabilities } from './mcpl/capability-mask.js';
 import { HookOrchestrator } from './mcpl/hook-orchestrator.js';
 import { PushHandler, type McplPushEvent } from './mcpl/push-handler.js';
 import { parseProsePrefix } from './mcpl/prose-grammar.js';
 import { ProseStreamRouter } from './mcpl/prose-stream-router.js';
 import { InferenceRouter } from './mcpl/inference-router.js';
-import { ChannelRegistry } from './mcpl/channel-registry.js';
+import { ChannelRegistry, type ChannelToolOrigin } from './mcpl/channel-registry.js';
 import { ConversationRouter } from './mcpl/conversation-router.js';
 import { safeSlice } from './safe-slice.js';
 import type { WorkspaceModule } from './modules/workspace/index.js';
-import { toolResultDataToHistoryString } from './tool-result-history.js';
+import {
+  toolResultDataToHistoryString,
+  truncateForHistory,
+  DEFAULT_TOOL_RESULT_INLINE_MAX_CHARS,
+} from './tool-result-history.js';
 import { randomUUID } from 'node:crypto';
 import { PyRunner, buildInjectedTools } from './code-execution/py-runner.js';
 import {
@@ -134,6 +141,43 @@ const isConversationalInjection = (metadata?: MessageMetadata): boolean => {
   return true;
 };
 
+/**
+ * Rough token estimate for the blocks a continuation round is about to
+ * append to the live wire (issue #92 physical-window projection): the
+ * spilled tool-result strings at chars/4, a flat per-image cost for native
+ * image blocks the wire path preserves (provider vision tokens are
+ * resolution-dependent; 1600 ≈ a max-size Anthropic tile), mid-turn injected
+ * text at chars/4, and a small per-block envelope allowance. Deliberately a
+ * ceiling-ish heuristic — the cost of overestimating is one early recompile;
+ * the cost of underestimating is the 400 this projection exists to prevent.
+ */
+function estimateAppendedRoundTokens(
+  toolResults: CompletedToolCall[],
+  spilled: Map<string, { text: string; filePath: string | null }>,
+  injections: Array<{ content: ContentBlock[] }>,
+): number {
+  let chars = 0;
+  let images = 0;
+  for (const tc of toolResults) {
+    chars += spilled.get(tc.id)?.text.length ?? 0;
+    if (Array.isArray(tc.result.data)) {
+      for (const raw of tc.result.data) {
+        const b = raw as { type?: unknown };
+        if (b && typeof b === 'object' && b.type === 'image') images += 1;
+      }
+    }
+  }
+  for (const inj of injections) {
+    for (const block of inj.content) {
+      if (block.type === 'text' && typeof (block as { text?: unknown }).text === 'string') {
+        chars += (block as { text: string }).text.length;
+      }
+    }
+  }
+  const blockCount = toolResults.length + injections.length;
+  return Math.ceil(chars / 4) + images * 1600 + blockCount * 20;
+}
+
 /**
  * Explicit delivery tools whose successful use into a closed channel OPENS
  * it (send implies engagement — see openIfClosedForSend). Bare tool names,
@@ -224,6 +268,65 @@ const PROSE_HELP_TOOL: import('./types/index.js').ToolDefinition = {
 };
 /** Strip the `server--` MCPL prefix from a tool name. */
 const bareToolName = (n: string): string => n.split('--').pop()!;
+
+/** The single slot behind which every rarely-used capability lives. Only
+ *  advertised when at least one module contributes utilities — with none
+ *  registered the surface is byte-identical to before this existed. */
+const UTILS_TOOL: import('./types/index.js').ToolDefinition = {
+  name: 'utils',
+  description:
+    'Rarely-used utilities, behind one slot instead of each costing a tool. ' +
+    '"list" names them all with one-liners; "describe" returns one utility\'s full ' +
+    'input schema; "run" invokes it (args are validated against that schema — a ' +
+    'miss bounces back with the schema and the specific error).',
+  inputSchema: {
+    type: 'object' as const,
+    properties: {
+      action: { type: 'string', enum: ['list', 'describe', 'run'], description: 'What to do.' },
+      name: { type: 'string', description: 'Utility name from list (required for describe/run).' },
+      args: { type: 'object', description: "Arguments for run, per the utility's schema." },
+    },
+    required: ['action'],
+  },
+};
+
+/** First sentence (or line) of a description — what `utils list` shows. */
+const utilityOneLiner = (description: string): string => {
+  const line = description.split('\n')[0]!;
+  const dot = line.indexOf('. ');
+  return (dot >= 0 ? line.slice(0, dot + 1) : line).slice(0, 160);
+};
+
+/** Shallow validation of run args against a utility's declared inputSchema:
+ *  required keys, primitive types, enums. Deliberately not a full JSON-Schema
+ *  engine — handlers still hand-validate (they always did); this layer exists
+ *  so an arg-shape miss teaches by bounce instead of failing deep in a handler
+ *  with a less instructive message. Returns an error string or null. */
+function validateUtilityArgs(
+  input: unknown,
+  schema: import('./types/index.js').ToolDefinition['inputSchema'],
+): string | null {
+  if (input === null || typeof input !== 'object' || Array.isArray(input)) {
+    return 'args must be an object';
+  }
+  const obj = input as Record<string, unknown>;
+  for (const req of schema.required ?? []) {
+    if (!(req in obj) || obj[req] === undefined) return `missing required "${req}"`;
+  }
+  for (const [key, value] of Object.entries(obj)) {
+    const param = schema.properties?.[key];
+    if (!param || value === undefined) continue; // unknown keys: handler's business
+    if (param.enum && !(param.enum as unknown[]).includes(value)) {
+      return `"${key}" must be one of ${JSON.stringify(param.enum)}`;
+    }
+    if (param.type) {
+      const actual = Array.isArray(value) ? 'array' : value === null ? 'null' : typeof value;
+      const expected = param.type === 'integer' ? 'number' : param.type;
+      if (actual !== expected) return `"${key}" must be ${param.type}, got ${actual}`;
+    }
+  }
+  return null;
+}
 import { CheckpointManager } from './mcpl/checkpoint-manager.js';
 import { isToolAllowed } from './mcpl/tool-policy.js';
 import { EventGate } from './gate/event-gate.js';
@@ -234,10 +337,7 @@ import type {
   McplServerConfig,
   McplHostCapabilities,
   FeatureSetsChangedParams,
-  ScopeElevateParams,
-  ScopeElevateResult,
   BeforeInferenceParams,
-  AfterInferenceParams,
   PushEventParams,
   McplInferenceRequestParams,
   ChannelsRegisterParams,
@@ -451,6 +551,23 @@ interface Deferred<T> {
  *  the caller awaits plus the liveness/progress bookkeeping the watchdogs and
  *  the stream driver share. One map entry per run — created and torn down in
  *  runEphemeralToCompletion — so the pieces cannot desync. */
+/** One model-authored background (daemon) script — see runCodeExecution. */
+interface BackgroundScriptRecord {
+  id: string;
+  agentName: string;
+  runner: PyRunner;
+  /** The agent-authored source (line numbers in wake envelopes index into it). */
+  code: string;
+  startedAt: number;
+  wakes: number;
+  lastWakeAt: number | null;
+  /** Mount-prefixed workspace path of the journal, null when no workspace. */
+  logPath: string | null;
+  status: 'running' | 'finished' | 'died' | 'cancelled';
+  /** Set when cancel/dispose already settled this script (suppresses wakes). */
+  cancelled: boolean;
+}
+
 interface EphemeralRun {
   settle: Deferred<AgentSettleResult>;
   inferenceStarted: boolean;
@@ -511,8 +628,45 @@ export class AgentFramework {
    *  plain prose lands (2026-07-21 Cairn lounge misroute). Lives here — not in
    *  driveStream locals — so the pin survives a context-budget stream restart,
    *  which continues the same logical turn in a fresh driveStream. Cleared or
-   *  re-set at the start of every non-restart turn. */
+   *  re-set at the start of every non-restart turn. Since 2026-07-31 the pin
+   *  is no longer fully frozen: an ADDRESSED conversational injection — or a
+   *  conversational follow-up in a channel the agent itself explicitly sent
+   *  into this turn (turnEngagedChannels) — re-pins it at the boundary (see
+   *  the addressed re-pin block in the tool-result handler). Ambient chatter
+   *  elsewhere, reactions, and system markers still cannot move it. */
   private turnLocusPins: Map<string, string> = new Map();
+  /** Channels the agent EXPLICITLY sent into during the CURRENT turn
+   *  (SEND_ENGAGEMENT_TOOLS, successful calls), per agent. Second re-pin
+   *  signal: a conversational reply in a channel the agent just engaged is
+   *  addressed by context even without a mention (2026-07-31 n=7: q's
+   *  #portables follow-up — no @mention — was answered in trailing prose
+   *  that followed the stale pin into repligate's DM). No author-kind
+   *  filter: agent-residents are full participants, and the bot flag
+   *  tracks nothing that matters (antra). Reactions/system markers are
+   *  excluded by isConversationalInjection; the engaged-this-turn scope
+   *  keeps unrelated channels from moving the pin. Cleared at every fresh
+   *  turn's start; budget restarts keep it. */
+  private turnEngagedChannels: Map<string, Set<string>> = new Map();
+  /** Channels this turn's PLAIN PROSE was actually delivered to, in delivery
+   *  order (deduped at render). Feeds the `[delivered]` receipt appended at
+   *  logical turn end: explicit sends receipt themselves via their
+   *  tool_result, but auto-routed prose previously vanished into the router
+   *  with no in-window record — the agent could never see where its own
+   *  words landed (2026-07-31 misroute series; antra: minimal receipts).
+   *  Cleared at every fresh turn's start; budget restarts keep it (same
+   *  logical turn, receipt covers the whole turn). */
+  private turnProseDeliveries: Map<string, string[]> = new Map();
+  /** Count of plain-prose segments SUPPRESSED this turn by sticky
+   *  explicit-send silencing. The suppression rule itself is untouched
+   *  (antra, 2026-07-31: visibility is enough) — but it must never be a
+   *  silent black hole: Mythos multiplexed two threads in one round (prose
+   *  for the lane + explicit send for another channel, textbook per the
+   *  routing doc), the silencing ate the prose reply, and his own record
+   *  ("scene delivered to #mythos via plain speech — routing confirmed")
+   *  believed it delivered. The receipt now reports suppression, so the
+   *  author sees the segment's fate one turn later. Cleared each fresh
+   *  turn; budget restarts keep it. */
+  private turnProseSuppressed: Map<string, number> = new Map();
   /** A tool boundary injected fresh CONVERSATIONAL input (a real message —
    *  not a reaction or a system marker) into the live stream. Tells
    *  driveStream to clear sticky explicit-send suppression before handling
@@ -603,6 +757,25 @@ export class AgentFramework {
   // tool_use → tool_result adjacency required by the Anthropic API).
   private deferredMessages: Array<{ participant: string; content: ContentBlock[]; metadata?: MessageMetadata }> = [];
 
+  // Turn-alive markers (2026-07-31 Mythos phantom-skip incident): agentName →
+  // token of the turn currently in progress. Set at startAgentStream ENTRY —
+  // before hooks, compile, and stream setup, all of which await — and cleared
+  // token-matched when that turn's teardown finishes (driveStream finally /
+  // terminal failure path), so a successor turn's marker survives a
+  // predecessor's late finally. A turn is alive from dequeue to settled
+  // teardown: strictly longer than `activeStreams` membership, which begins
+  // only after the stream exists. Guarding addMessage on stream-liveness
+  // alone left the compile window open — a deferred message flushed by the
+  // previous turn's finally landed in the window MID-COMPILE of the turn its
+  // own wake had started: positioned before the new turn's blocks yet absent
+  // from its wire request. The agent then "skipped" a message it never saw
+  // (falsified history — it later confabulated an apology for the skip), and
+  // every subsequent compile diverged from the live prefix at that message
+  // (KV bust). Invariant: nothing enters the window between a turn's dequeue
+  // and its settle except that turn's own blocks.
+  private activeTurnTokens: Map<string, number> = new Map();
+  private nextTurnToken = 1;
+
   // Undo/redo state
   private turnCounters: Map<string, number> = new Map(); // agentName → next turnIndex
   private redoStacks: Map<string, RedoEntry[]> = new Map(); // agentName → redo entries
@@ -613,7 +786,6 @@ export class AgentFramework {
   // MCPL subsystems (null when no mcplServers configured)
   private mcplServerRegistry: McplServerRegistry | null = null;
   private featureSetManager: FeatureSetManager | null = null;
-  private scopeManager: ScopeManager | null = null;
   private hookOrchestrator: HookOrchestrator | null = null;
   private pushHandler: PushHandler | null = null;
   private inferenceRouter: InferenceRouter | null = null;
@@ -646,8 +818,23 @@ export class AgentFramework {
    *  deferred and applied to the final code_execution result instead of
    *  cancelling the stream mid-script (which would wedge the turn). */
   private scriptDeferredEndTurn: Set<string> = new Set();
+  /** Background (daemon) scripts: model-authored watchers that outlive their
+   *  spawning turn. Each gets a DEDICATED PyRunner; wake_agent() injects a
+   *  provenance envelope + payload and requests inference. Keyed by script id. */
+  private backgroundScripts: Map<string, BackgroundScriptRecord> = new Map();
+  private backgroundScriptCounter = 0;
+  /** Resident-set per-agent tool-result inline cap (chars), via
+   *  agent_settings `tool_result_inline_max_chars`. DURABLE: persisted in
+   *  framework state like the core runtime settings and restored at create
+   *  (antra + Sol, 08-06); reset clears it back to the residence default. */
+  private toolResultInlineMaxCharsOverride: Map<string, number> = new Map();
+  /** Durable residence-configured inline cap from
+   *  FrameworkConfig.toolResultInlineMaxChars; null → house default. */
+  private toolResultInlineMaxCharsConfig: number | null = null;
 
   private mcplTools: import('./types/index.js').ToolDefinition[] = [];
+  /** Namespaced tool name → stateful feature-set attribution from tools/list. */
+  private mcplToolFeatureSets: Map<string, string> = new Map();
   private mcplToolRefreshInFlight = false;
   private mcplToolRefreshPending = false;
   /** Maps tool prefix → serverId for dispatch routing. */
@@ -722,7 +909,12 @@ export class AgentFramework {
       queryMessages: (filter) => this.queryMessages(filter),
       pushEvent: (event) => this.pushEvent(event),
       onTrace: (listener) => this.onTrace(listener),
-      callTool: (call) => this.executeToolCall(call),
+      // The ONLY entry that confers module origin — a private closure the
+      // framework hands to its own module registry. The public
+      // executeToolCall() is shared with model/ephemeral callers and always
+      // stamps agent origin (see there).
+      callTool: (call) => this.executeToolCallFrom(call, { kind: 'module' }),
+      notifyOps: (kind, agentName, message, data) => this.notifyOps(kind, agentName, message, data),
     });
   }
 
@@ -918,6 +1110,20 @@ export class AgentFramework {
     // retained when enabled — everything downstream gates on the field.
     framework.codeExecutionConfig = config.codeExecution?.enabled ? config.codeExecution : null;
 
+    if (config.toolResultInlineMaxChars !== undefined) {
+      const cap = config.toolResultInlineMaxChars;
+      if (!Number.isFinite(cap) || cap < 1000) {
+        throw new Error('FrameworkConfig.toolResultInlineMaxChars must be a number >= 1000');
+      }
+      framework.toolResultInlineMaxCharsConfig = Math.floor(cap);
+    }
+
+    // Restore resident-set inline caps (agent_settings) — durable like the
+    // core runtime settings, same framework/state slot (antra + Sol, 08-06).
+    for (const [agentName, cap] of Object.entries(framework.readPersistedToolResultInlineCaps())) {
+      framework.toolResultInlineMaxCharsOverride.set(agentName, cap);
+    }
+
     // Initialize MCPL subsystems if configured
     if (config.mcplServers && config.mcplServers.length > 0) {
       // Validate tool prefixes: no collisions with module names or between servers
@@ -1017,6 +1223,17 @@ export class AgentFramework {
       runner.dispose();
     }
     this.codeExecutionRunners.clear();
+    // Background daemons die with the process (documented limitation) —
+    // mark cancelled FIRST so their settle path stays silent (no crash-wake
+    // into a framework that is shutting down).
+    for (const record of this.backgroundScripts.values()) {
+      if (record.status === 'running') {
+        record.cancelled = true;
+        record.status = 'cancelled';
+      }
+      record.runner.dispose();
+    }
+    this.backgroundScripts.clear();
 
     // Cancel all active streams
     for (const agent of this.agents.values()) {
@@ -1308,6 +1525,8 @@ export class AgentFramework {
       : [];
     return [
       ...moduleTools,
+      // Utilities collapse into one slot; absent entirely when none exist.
+      ...(this.moduleRegistry.getAllUtilities().length > 0 ? [UTILS_TOOL] : []),
       ...this.mcplTools,
       ...channelTools,
       ...gateTools,
@@ -1346,6 +1565,16 @@ export class AgentFramework {
   private collectAgentSettingsExtensions(): Map<string, AgentSettingsExtension> {
     const result = new Map<string, AgentSettingsExtension>();
     const taken = new Set<string>(AgentFramework.AGENT_SETTINGS_CORE_KEYS);
+    // Framework-owned extension: the resident's tool-result inline cap.
+    // Registered through the same extension surface modules use so
+    // get/update/reset all work with zero extra plumbing. DURABLE: persisted
+    // in framework state and restored at create, like the core runtime
+    // settings (antra + Sol, 08-06); reset returns to the residence default.
+    {
+      const ext = this.spillSettingsExtension();
+      ext.keys.forEach((k) => taken.add(k));
+      result.set('_framework', ext);
+    }
     for (const module of this.moduleRegistry.getAllModules()) {
       const ext = module.getAgentSettingsExtension?.();
       if (!ext) continue;
@@ -1362,6 +1591,54 @@ export class AgentFramework {
     return result;
   }
 
+  /** agent_settings extension for the spill gate (see spillOrTruncate). */
+  private spillSettingsExtension(): AgentSettingsExtension {
+    return {
+      properties: {
+        tool_result_inline_max_chars: {
+          type: 'number',
+          description:
+            'Inline size cap (chars) for tool results (successes and errors) and ' +
+            'background-script wake payloads. Content over the cap is written to a workspace ' +
+            'file under tool-results/ and replaced by a truncated preview + file reference. ' +
+            'This is YOUR durable setting: it persists across restarts, like your other ' +
+            'agent_settings. Update it when you want a different inline size; reset restores ' +
+            'the residence default. The effective cap is min(your value, your strategy\'s ' +
+            'per-message bound) — the bound is a safety ceiling, and the full content is ' +
+            'always in the spill file. get reports desired/_effective/_source/_clamped_by.',
+        },
+      },
+      keys: ['tool_result_inline_max_chars'],
+      get: (agentName: string) => {
+        const agent = this.agents.get(agentName);
+        const resolved = agent ? this.resolveToolResultInlineCap(agent) : null;
+        return {
+          tool_result_inline_max_chars:
+            this.toolResultInlineMaxCharsOverride.get(agentName) ?? null,
+          tool_result_inline_max_chars_effective: resolved?.cap ?? null,
+          tool_result_inline_max_chars_source: resolved?.source ?? null,
+          tool_result_inline_max_chars_clamped_by: resolved?.clampedBy ?? null,
+        };
+      },
+      update: (agentName: string, patch: Record<string, unknown>) => {
+        const n = Number(patch.tool_result_inline_max_chars);
+        if (!Number.isFinite(n) || n < 1000) {
+          throw new Error('tool_result_inline_max_chars must be a number >= 1000');
+        }
+        this.toolResultInlineMaxCharsOverride.set(agentName, Math.floor(n));
+        this.persistToolResultInlineCap(agentName, Math.floor(n));
+        return { tool_result_inline_max_chars: Math.floor(n) };
+      },
+      reset: (agentName: string, keys?: string[]) => {
+        if (!keys || keys.includes('tool_result_inline_max_chars')) {
+          this.toolResultInlineMaxCharsOverride.delete(agentName);
+          this.persistToolResultInlineCap(agentName, null);
+        }
+        return { tool_result_inline_max_chars: null };
+      },
+    };
+  }
+
   private captureInferenceToolSnapshot(agent: Agent): InferenceToolSnapshot {
     return {
       sameRoundThinkTextPolicy: agent.getEffectiveSameRoundThinkTextPolicy(),
@@ -1785,6 +2062,44 @@ export class AgentFramework {
     return overrides;
   }
 
+  /** Load resident-set inline caps from framework state, dropping (loudly)
+   *  anything that fails the same validation the live update enforces. */
+  private readPersistedToolResultInlineCaps(): Record<string, number> {
+    try {
+      const data = this.store.getStateJson(FRAMEWORK_STATE_ID) as {
+        toolResultInlineCaps?: Record<string, unknown>;
+      } | null;
+      const out: Record<string, number> = {};
+      for (const [name, value] of Object.entries(data?.toolResultInlineCaps ?? {})) {
+        const n = Number(value);
+        if (Number.isFinite(n) && n >= 1000) {
+          out[name] = Math.floor(n);
+        } else {
+          console.error(
+            `[agent-settings] dropping invalid persisted tool_result_inline_max_chars for '${name}': ${JSON.stringify(value)}`,
+          );
+        }
+      }
+      return out;
+    } catch {
+      return {};
+    }
+  }
+
+  /** Write (cap) or clear (null) one agent's resident-set inline cap. */
+  private persistToolResultInlineCap(agentName: string, cap: number | null): void {
+    const data = this.store.getStateJson(FRAMEWORK_STATE_ID);
+    const state = (data && typeof data === 'object' ? data : {}) as Record<string, unknown>;
+    const all = {
+      ...((state.toolResultInlineCaps as Record<string, number> | undefined) ?? {}),
+    };
+    if (cap === null) delete all[agentName];
+    else all[agentName] = cap;
+    if (Object.keys(all).length === 0) delete state.toolResultInlineCaps;
+    else state.toolResultInlineCaps = all;
+    this.store.setStateJson(FRAMEWORK_STATE_ID, state);
+  }
+
   private persistAgentRuntimeSettings(
     agentName: string,
     overrides: AgentRuntimeSettingsOverrides,
@@ -1972,6 +2287,12 @@ export class AgentFramework {
       // ephemeral agents leave checkpoint-tree keys and diagnostics map
       // entries behind for the life of the store/session.
       this.evictTurnCheckpoints(agent.name);
+      // Turn-alive marker, same spawn-and-dispose logic: a stalled ephemeral
+      // (watchdog fired, driveStream's terminal event lost) would strand its
+      // token forever — no wedge (ephemeral names are unique per run) but
+      // unbounded map growth. Blind delete is safe: the agent is already out
+      // of the map, and a late driveStream finally token-match no-ops.
+      this.activeTurnTokens.delete(agent.name);
     }
   }
 
@@ -2261,15 +2582,6 @@ export class AgentFramework {
     'chat:thread': 'Occurred in a thread',
   };
 
-  /** Refusal category → Discord reaction emoji. Unknown categories get 🛑. */
-  private static readonly REFUSAL_REACTIONS: Record<string, string> = {
-    bio: '☣️',
-    chem: '🧪',
-    nuclear: '☢️',
-    cyber: '💻',
-    reasoning_extraction: '🧠',
-  };
-
   /**
    * Mark an inference refusal visibly: react on the message that holds the
    * conversational locus (the most recent incoming channel message) with a
@@ -2286,7 +2598,7 @@ export class AgentFramework {
       const parts = incoming.channelId.split(':');
       if (parts[0] !== 'discord') return;
       const channelId = parts[parts.length - 1];
-      const emoji = AgentFramework.REFUSAL_REACTIONS[category] ?? '🛑';
+      const emoji = REFUSAL_REACTIONS[category] ?? REFUSAL_REACTION_FALLBACK;
       // Resolve the MCPL server that owns the locus channel and call
       // tools/call directly on its connection (bare tool name — no prefix
       // games), bypassing the agent event queue so no synthetic tool-result
@@ -2500,6 +2812,46 @@ export class AgentFramework {
     }
   }
 
+  /**
+   * Admin-level nudge: run an inference turn on the agent's CURRENT context
+   * without adding any message, event, or other context mutation. The turn
+   * compiles exactly what the agent already sees — useful after an /undo,
+   * a /hide, or whenever an operator wants the agent to take another look
+   * (or another swing) at where it stands, with zero context pollution.
+   *
+   * Queues a normal inference request (same path as gate wakes): if the
+   * agent is mid-turn it runs when the turn settles; a pending skip_reply
+   * self-wake is superseded like any other wake. Deliberately NOT gated on
+   * idle — "run when you're free" is the useful semantic. No suppression
+   * interplay: gate sleep filters events, not queued requests, so a nudge
+   * wakes even a sleeping agent (it's an admin override, like /unstick).
+   */
+  nudgeAgent(agentName?: string, requestedBy?: string): {
+    ok: boolean;
+    error?: string;
+    agentName?: string;
+    /** Agent state at queue time — 'idle' means the turn starts on the next
+     *  scheduler pass; anything else means it runs after the current turn. */
+    agentStatus?: string;
+  } {
+    const name = agentName ?? [...this.agents.keys()][0];
+    const agent = name ? this.agents.get(name) : undefined;
+    if (!name || !agent) {
+      return { ok: false, error: `Unknown agent: ${String(agentName ?? '(none registered)')}` };
+    }
+    const agentStatus = this.activeTurnTokens.has(name) && agent.state.status === 'idle'
+      ? 'idle+turn-alive'
+      : agent.state.status;
+    this.pendingRequests.push({
+      agentName: name,
+      reason: requestedBy ? `admin-nudge (${requestedBy})` : 'admin-nudge',
+      source: 'admin',
+      timestamp: Date.now(),
+    });
+    console.error(`[nudge] agent=${name} queued by=${requestedBy ?? 'unknown'} status=${agentStatus}`);
+    return { ok: true, agentName: name, agentStatus };
+  }
+
   /**
    * Handle a `host/command` request from an MCPL surface server (e.g. a
    * Discord slash command). Currently supports:
@@ -2508,6 +2860,9 @@ export class AgentFramework {
    *   `undoLastTurn`). The response includes the last message the agent
    *   would see in its context after the undo, obtained via the transparent
    *   `previewActivation` render (no inference, no Chronicle writes).
+   *
+   *   nudge — run inference on the current context with NO new events
+   *   (see `nudgeAgent`).
    */
   private async handleHostCommand(
     serverId: string,
@@ -2530,8 +2885,16 @@ export class AgentFramework {
      *  outcome report is posted to the channel asynchronously. */
     started?: boolean;
     cap?: number;
+    /** For `nudge`: agent state at queue time ('idle' = runs immediately,
+     *  else it runs once the current turn settles). */
+    agentStatus?: string;
   }> {
-    if (params.command !== 'undo' && params.command !== 'hide' && params.command !== 'unstick') {
+    if (
+      params.command !== 'undo' &&
+      params.command !== 'hide' &&
+      params.command !== 'unstick' &&
+      params.command !== 'nudge'
+    ) {
       return { ok: false, error: `Unknown host command: ${String(params.command)}` };
     }
 
@@ -2540,6 +2903,16 @@ export class AgentFramework {
       return { ok: false, error: `Unknown agent: ${String(agentName)}` };
     }
 
+    // nudge: queue an inference on the current context — no message, no
+    // event, no context mutation (see nudgeAgent).
+    if (params.command === 'nudge') {
+      const r = this.nudgeAgent(
+        agentName,
+        params.requesterName ?? params.requesterId ?? `mcpl:${serverId}`,
+      );
+      return { ok: r.ok, error: r.error, agentStatus: r.agentStatus };
+    }
+
     // unstick: force the refusal-rewind loop on demand (even if the agent's
     // autoRewind toggle is off). Redacts the turn that fed the refusal and
     // re-runs, up to `cap` times, until the model stops refusing. Kicks the
@@ -3443,21 +3816,18 @@ export class AgentFramework {
             this.pendingAssistantBlocks.delete(agent.name);
           }
 
-          // Compute truncation limit from agent's strategy (maxMessageTokens * 4 chars)
-          const maxChars = this.getMaxToolResultChars(agent);
-
-          // Store tool results as a user message (tool_result blocks).
-          // Use the history serializer so MCP image blocks become a short
-          // `[image: type, size]` placeholder instead of megabytes of base64
-          // that would corrupt under truncation.
-          const toolResultContent: ContentBlock[] = currentState.toolResults.map(tc => ({
-            type: 'tool_result' as const,
-            toolUseId: tc.id,
-            content: tc.result.isError
-              ? tc.result.error ?? 'Unknown error'
-              : toolResultDataToHistoryString(tc.result.data, maxChars),
-            isError: tc.result.isError,
-          }));
+          // Effective inline cap: agent_settings override → durable config →
+          // house default, clamped to the strategy bound (see resolver).
+          const maxChars = this.resolveToolResultInlineCap(agent).cap;
+
+          // Oversized results — successes AND errors — spill to a workspace
+          // file (truncated preview + file reference) instead of being
+          // blind-truncated. Computed ONCE per call and reused for both the
+          // history copy and the live wire copy below — the two must stay
+          // byte-matched (the window stores what the membrane sends;
+          // divergence breaks the compile prefix).
+          const { blocks: toolResultContent, spilled } =
+            await this.buildStoredToolResultContent(currentState.toolResults, maxChars);
           agent.getContextManager().addMessage('user', toolResultContent);
 
           // Flush any messages that were deferred while this turn was in
@@ -3529,6 +3899,113 @@ export class AgentFramework {
             && agent.lastStreamInputTokens > 0
             && agent.lastStreamInputTokens > agent.maxStreamTokens;
 
+          // Physical-window projection (issue #92): a turn's continuation
+          // rounds append to the compiled request without recompiling, so a
+          // turn that starts near the compile target can walk past the
+          // provider's HARD cap mid-turn and take a wire 400 — the compile
+          // was legal, the growth wasn't. Project the next round's real size
+          // (cache-inclusive input of the prior round + the blocks about to
+          // be appended + reserve for the response) and, when it would cross
+          // the physical window, break the stream through the same
+          // budget-restart path — a fresh compile folds the history back
+          // under budget instead of dispatching a doomed request.
+          // Projection terms: prior round's real input + prior round's
+          // OUTPUT (the just-generated thinking/text/tool_use joins the next
+          // round's input — omitting it is a systematic underestimate) +
+          // blocks about to be appended + reserve for the next response.
+          const projectedRealTokens = currentState.stream
+            && agent.physicalWindowTokens !== undefined
+            && agent.lastStreamRealInputTokens > 0
+            ? agent.lastStreamRealInputTokens
+              + agent.lastStreamOutputTokens
+              + estimateAppendedRoundTokens(currentState.toolResults, spilled, midTurnInjections)
+              + agent.maxTokens
+            : 0;
+          const overPhysical = projectedRealTokens > (agent.physicalWindowTokens ?? Infinity);
+
+          // Addressed re-pin (2026-07-31 Mythos misroutes, antra-ratified):
+          // when someone ADDRESSES the agent mid-turn from another channel
+          // (mention / reply / DM — the same chat:addressed signal the
+          // turn-START batch policy prefers), the agent's subsequent plain
+          // prose almost always answers THEM. Six recorded misroutes
+          // delivered those answers to the stale frozen locus instead (the
+          // LabClaude answer into #hospital_commons mid-examination; the
+          // hospital scene into antra's DM). Re-pin the turn locus to the
+          // LAST addressed conversational injection, at segment granularity:
+          // prose routed in earlier rounds already went to the old pin,
+          // which was correct when it was delivered. Ambient chatter,
+          // reactions, and system markers still cannot move the pin — the
+          // 2026-07-21 Cairn hijack protection is unchanged; this extends
+          // the ratified addressed-outranks-ambient principle from turn
+          // start to boundaries. Locus mode only (explicit mode has no pin).
+          // Skipped on endTurn/overBudget: no further prose this stream, and
+          // a stale "for this turn" notice would be pure noise.
+          //
+          // The notice rides the SAME injection batch — stored right after
+          // the flushed messages and appended to midTurnInjections — so the
+          // window byte-matches the wire (short event-style notice: the
+          // classifier-safe D-class from the 2026-07-24 ablation). It also
+          // updates lastAnnouncedLocus so the next turn's announce-on-change
+          // diffs against what the agent was actually last told.
+          if (
+            agent.proseRouting !== 'explicit' &&
+            !shouldEndTurn && !overBudget && currentState.stream
+          ) {
+            // Two signals qualify an injection to move the pin (n=6 + n=7):
+            //  - chat:addressed — someone explicitly spoke TO the agent
+            //    (mention / reply / DM);
+            //  - a conversational follow-up in a channel the agent itself
+            //    explicitly sent into THIS turn (turnEngagedChannels) —
+            //    conversation the agent just engaged continues without
+            //    re-mentioning it (2026-07-31: q's #portables reply, no @,
+            //    answered in prose that followed the stale pin into
+            //    repligate's DM). Deliberately NO author-kind filter: this
+            //    fleet's participants include agent-residents whose speech
+            //    is as conversational as anyone's — the Discord bot flag
+            //    tracks nothing that matters here (antra, 2026-07-31).
+            //    Reactions and system markers are already excluded by
+            //    isConversationalInjection, and the engaged-this-turn scope
+            //    keeps unrelated channels from moving the pin.
+            const engaged = this.turnEngagedChannels.get(agent.name);
+            const lastQualifying = [...midTurnInjections].reverse().find((inj) => {
+              const m = inj.metadata as Record<string, unknown> | undefined;
+              if (!isConversationalInjection(inj.metadata)) return false;
+              if (typeof m?.channelId !== 'string') return false;
+              const tags = m.tags as string[] | undefined;
+              if (isAddressedMessage(tags, m)) return true;
+              return engaged?.has(m.channelId as string) === true;
+            });
+            const newLocus = (lastQualifying?.metadata as Record<string, unknown> | undefined)
+              ?.channelId as string | undefined;
+            if (newLocus && this.turnLocusPins.get(agent.name) !== newLocus) {
+              const prevPin = this.turnLocusPins.get(agent.name) ?? null;
+              this.turnLocusPins.set(agent.name, newLocus);
+              this.lastAnnouncedLocus.set(agent.name, newLocus);
+              const label = this.channelRegistry?.getDescriptor(newLocus)?.label;
+              const shown = label && label !== newLocus
+                ? `${label.startsWith('#') ? label : `#${label}`} (${newLocus})`
+                : newLocus;
+              const noticeContent: ContentBlock[] = [{
+                type: 'text',
+                text:
+                  `[routing] The conversation moved to ${shown} — your plain ` +
+                  'speech now lands there for the rest of this turn. Other ' +
+                  'channels need an explicit send tool.',
+              }];
+              const noticeMeta = { system: true, kind: 'routing-notice' } as MessageMetadata;
+              try {
+                const id = agent.getContextManager().addMessage('user', noticeContent, noticeMeta);
+                this.emitTrace({ type: 'message:added', messageId: id, source: 'routing-notice' });
+                midTurnInjections.push({ participant: 'user', content: noticeContent, metadata: noticeMeta });
+                console.error(
+                  `[routing] ${agent.name}: mid-turn addressed re-pin ${prevPin ?? '(none)'} -> ${newLocus}`,
+                );
+              } catch (err) {
+                console.error('mid-turn locus re-pin: failed to record routing notice:', err);
+              }
+            }
+          }
+
           if (shouldEndTurn) {
             // endTurn: messages already stored above, cancel stream, reset to idle.
             if (currentState.stream) {
@@ -3543,7 +4020,7 @@ export class AgentFramework {
             this.eventGate?.onInferenceEnded(agent.name);
             this.settleAgent(agent.name, { stopReason: 'turn_ended', speech: '' });
             this.emitTrace({ type: 'inference:turn_ended', agentName: agent.name });
-          } else if (overBudget) {
+          } else if (overBudget || overPhysical) {
             // Context budget exceeded: break the stream, let compile() compress.
             // Mark the cancel as framework-initiated BEFORE cancelling: the
             // membrane delivers `aborted` before the restart bumps streamId,
@@ -3553,14 +4030,27 @@ export class AgentFramework {
             // endTurn above).
             if (currentState.stream) {
               this.frameworkCancelledStreams.set(`${agent.name}:${agent.streamId}`, 'budget_restart');
+              // Cancel the LIVE stream object directly (like the endTurn
+              // branch above): at a tool boundary the state machine reads
+              // 'ready', and Agent.cancelStream only signals the stream from
+              // 'streaming'/'waiting_for_tools' — so the old call left the
+              // provider stream parked forever awaiting tool results that
+              // would never come (zombie: driveStream's finally never ran,
+              // its activeStreams entry survived until the restart's stream
+              // overwrote it). Harmless by accident before turn-alive
+              // tracking; a genuine teardown leak after it.
+              currentState.stream.cancel();
             }
             agent.cancelStream();
             this.emitTrace({
               type: 'inference:stream_restarted',
               agentName: agent.name,
-              reason: 'context_budget',
-              inputTokens: agent.lastStreamInputTokens,
-              budget: agent.maxStreamTokens,
+              // 'physical_window' only when the budget check alone would
+              // have let the doomed request through — overBudget keeps its
+              // established label for existing consumers.
+              reason: overBudget ? 'context_budget' : 'physical_window',
+              inputTokens: overBudget ? agent.lastStreamInputTokens : projectedRealTokens,
+              budget: overBudget ? agent.maxStreamTokens : (agent.physicalWindowTokens ?? 0),
             });
             this.pendingRequests.push({
               agentName: agent.name,
@@ -3574,7 +4064,7 @@ export class AgentFramework {
             // messages (membrane ≥0.5.72) — appended after the tool_result
             // envelope so the next round of THIS turn hears them.
             const membraneResults = currentState.toolResults.map(tc =>
-              this.toMembraneToolResult(tc.id, tc.result, maxChars)
+              this.toMembraneToolResult(tc.id, tc.result, maxChars, spilled.get(tc.id))
             );
             currentState.stream.provideToolResults(
               membraneResults,
@@ -3773,6 +4263,12 @@ export class AgentFramework {
           ? (event.metadata.guildName as string)
           : undefined,
         tags: event.tags,
+        missedMessages: typeof event.metadata?.missedMessages === 'number'
+          ? event.metadata.missedMessages
+          : undefined,
+        missedCharacters: typeof event.metadata?.missedCharacters === 'number'
+          ? event.metadata.missedCharacters
+          : undefined,
       });
       if (invitation) {
         incomingContent.push(invitation.block);
@@ -4080,6 +4576,17 @@ export class AgentFramework {
    * this should see WHO addressed it WHERE, not a wall of snowflake ids. Raw
    * ids remain only inside the tool-argument instructions, where they are the
    * literal values to pass.
+   *
+   * 2026-08-05 accuracy pass: the old "you won't receive more from it unless
+   * you join" was wrong in both directions — direct addresses (mentions,
+   * replies to the agent) DO still arrive, and nothing warned that answering
+   * via option 1 leaves the human's natural un-@'d follow-up invisible (Sol
+   * answered four #architecture mentions over four days while the follow-ups
+   * to her own replies were silently dropped). The wording now states the
+   * actual delivery model, and option 1 carries the consequence inline. When
+   * the surface tracks a missed-ambient tally (discord-mcpl sends
+   * `missedMessages`/`missedCharacters` in push origin), the invitation shows
+   * the count — the cost of staying out, as a number, at decision time.
    */
   private buildClosedChannelInvitation(opts: {
     serverId: string;
@@ -4089,6 +4596,10 @@ export class AgentFramework {
     authorName: string;
     guildName?: string;
     tags?: string[];
+    /** Ambient messages dropped in this channel while closed (surface-tracked). */
+    missedMessages?: number;
+    /** Characters across those dropped messages. */
+    missedCharacters?: number;
   }): { block: ContentBlock; metadataPatch: Record<string, unknown> } | null {
     if (!this.channelRegistry) return null;
     if (!opts.tags?.includes('chat:addressed')) return null;
@@ -4098,13 +4609,23 @@ export class AgentFramework {
     const label = opts.channelLabel ?? descriptor?.label;
     const channelLabel = label ? `#${label}` : `"${opts.channelId}"`;
     const place = opts.guildName ? `${channelLabel} in "${opts.guildName}"` : channelLabel;
+    const missedCount = opts.missedMessages ?? 0;
+    const missedNote =
+      missedCount > 0
+        ? `While closed, ${missedCount} message${missedCount === 1 ? '' : 's'}` +
+          (opts.missedCharacters ? ` (~${opts.missedCharacters} chars)` : '') +
+          ` have passed there without you. `
+        : '';
     const block: ContentBlock = {
       type: 'text',
       text:
         `\n[Channel invitation] ${opts.authorName} addressed you in ${place} — ` +
-        `a channel you haven't joined. You're seeing this one message; you won't receive more from it unless you join. ` +
+        `a channel you haven't joined. Only messages that address you directly (an @-mention or ` +
+        `a reply to one of your messages) reach you from it; the rest of its traffic is invisible to you. ` +
+        missedNote +
         `Your options:\n` +
-        `1. Reply without joining — write your reply this turn prefixed with ">>${channelLabel}"; it will be delivered there.\n` +
+        `1. Reply without joining — write your reply this turn prefixed with ">>${channelLabel}"; it will be delivered there. ` +
+        `Note: follow-ups to your reply will NOT reach you unless they @-mention you or use the reply feature on your message.\n` +
         `2. Join the channel — call channel_open with channelId "${opts.channelId}" and serverId "${opts.serverId}"` +
         (maxBackscroll > 0
           ? `; to also read recent history, add backscroll (a number up to ${maxBackscroll}) and beforeMessageId "${opts.messageId}".\n`
@@ -4167,6 +4688,9 @@ export class AgentFramework {
         authorName: typeof origin.authorName === 'string' && origin.authorName ? origin.authorName : 'Someone',
         guildName: typeof origin.guildName === 'string' && origin.guildName ? origin.guildName : undefined,
         tags: event.tags,
+        missedMessages: typeof origin.missedMessages === 'number' ? origin.missedMessages : undefined,
+        missedCharacters:
+          typeof origin.missedCharacters === 'number' ? origin.missedCharacters : undefined,
       });
       if (invitation) {
         content.push(invitation.block);
@@ -4292,8 +4816,24 @@ export class AgentFramework {
         continue;
       }
 
-      // Skip if agent is busy (inferring, streaming, or waiting for tools)
-      if (agent.state.status === 'inferring' || agent.state.status === 'streaming' || agent.state.status === 'waiting_for_tools') {
+      // Skip if agent is busy (inferring, streaming, or waiting for tools) —
+      // or if a turn is alive at all (activeTurnTokens): the state machine
+      // goes idle at endTurn's reset while driveStream teardown is still
+      // pending, and a successor turn dequeued in that gap compiles while the
+      // predecessor's deferred flush can still write (2026-07-31 Mythos).
+      // Turn-alive spans dequeue → settled teardown; wakes wait it out.
+      //
+      // EXCEPT a context-budget restart: it CONTINUES the turn whose token is
+      // held — queueing it behind its own turn's teardown is a deadlock when
+      // that teardown lags (the cancelled stream's `aborted` event is
+      // asynchronous and, historically, not even guaranteed — see the
+      // overBudget branch). The restart's startAgentStream overwrites the
+      // token; the predecessor frame's late finally no-ops via token-match.
+      // This mirrors how the restart has always overwritten activeStreams
+      // rather than waiting for the old stream's teardown.
+      const isBudgetRestart = requests.some((r) => r.reason === 'context_budget_restart');
+      const turnAlive = !isBudgetRestart && this.activeTurnTokens.has(agentName);
+      if (turnAlive || agent.state.status === 'inferring' || agent.state.status === 'streaming' || agent.state.status === 'waiting_for_tools') {
         // Re-queue requests, but warn if they've been pending too long
         const oldest = Math.min(...requests.map(r => r.timestamp));
         if (
@@ -4305,15 +4845,22 @@ export class AgentFramework {
           // (up to 100/sec after the scheduler backoff), adding avoidable work
           // precisely while the agent was already under pressure.
           this.staleWarnAt.set(agentName, now);
+          // Surface turn-alive separately from the state machine: status can
+          // read 'idle' while a turn's teardown is pending, and a LEAKED turn
+          // token would look exactly like this — permanently requeued wakes.
+          // This line is the wedge's tell (idle+turn-alive, forever).
+          const shownStatus = turnAlive && agent.state.status === 'idle'
+            ? 'idle+turn-alive'
+            : agent.state.status;
           this.emitTrace({
             type: 'inference:request_stale',
             agentName,
-            agentStatus: agent.state.status,
+            agentStatus: shownStatus,
             requestCount: requests.length,
             oldestRequestAge: now - oldest,
           });
           console.error(
-            `[inference-stale] agent=${agentName} busy (${agent.state.status}) — ` +
+            `[inference-stale] agent=${agentName} busy (${shownStatus}) — ` +
             `${requests.length} request(s) waiting ${Math.round((now - oldest) / 1000)}s`,
           );
         }
@@ -4363,6 +4910,77 @@ export class AgentFramework {
     }
   }
 
+  /** Record prose segments suppressed by explicit-send silencing. */
+  private recordProseSuppression(agentName: string, count: number): void {
+    if (count <= 0) return;
+    this.turnProseSuppressed.set(agentName, (this.turnProseSuppressed.get(agentName) ?? 0) + count);
+  }
+
+  /** Record a successful plain-prose delivery for this turn's receipt. */
+  private recordProseDelivery(
+    agentName: string,
+    outcome: { delivered: boolean; channelId: string } | null | undefined,
+  ): void {
+    if (!outcome?.delivered) return;
+    let list = this.turnProseDeliveries.get(agentName);
+    if (!list) {
+      list = [];
+      this.turnProseDeliveries.set(agentName, list);
+    }
+    list.push(outcome.channelId);
+  }
+
+  /**
+   * Append the turn's `[delivered]` receipt: one compact system message
+   * naming where this turn's plain prose actually landed (channels in
+   * delivery order, deduped). Explicit sends receipt themselves via their
+   * tool_result; auto-routed prose previously left no in-window trace, so
+   * the agent could never see where its own words went — misroutes were
+   * invisible to it until a human reported them (2026-07-31 series).
+   * Called ONLY at logical turn end (stream 'complete', or the endTurn
+   * cancel path after the speech chain settles) — never mid-stream, where a
+   * window-only insert would diverge from the wire. No-op when the turn
+   * delivered nothing. Failures are already marked separately
+   * ([discord-send-failed]); this is the success half.
+   */
+  private appendProseDeliveryReceipt(agent: Agent): void {
+    const list = this.turnProseDeliveries.get(agent.name);
+    const suppressed = this.turnProseSuppressed.get(agent.name) ?? 0;
+    if ((!list || list.length === 0) && suppressed === 0) return;
+    this.turnProseDeliveries.delete(agent.name);
+    this.turnProseSuppressed.delete(agent.name);
+    const seen = new Set<string>();
+    const shown: string[] = [];
+    for (const id of list ?? []) {
+      if (seen.has(id)) continue;
+      seen.add(id);
+      const label = this.channelRegistry?.getDescriptor(id)?.label;
+      shown.push(
+        label && label !== id
+          ? `${label.startsWith('#') ? label : `#${label}`} (${id})`
+          : id,
+      );
+    }
+    const suppressedNote =
+      suppressed > 0
+        ? `${suppressed} plain-speech segment(s) suppressed (explicit send in the same round — resend with a send tool if it was meant to be heard)`
+        : '';
+    const text =
+      shown.length > 0
+        ? `[delivered] plain speech → ${shown.join(' · ')}${suppressedNote ? ` · ${suppressedNote}` : ''}`
+        : `[delivered] nothing — ${suppressedNote}`;
+    try {
+      const mid = agent.getContextManager().addMessage(
+        'user',
+        [{ type: 'text', text }],
+        { system: true, kind: 'delivery-receipt' } as MessageMetadata,
+      );
+      this.emitTrace({ type: 'message:added', messageId: mid, source: 'delivery-receipt' });
+    } catch (err) {
+      console.error('delivery receipt append failed:', err);
+    }
+  }
+
   /**
    * Announce-on-change locus notice (turn-frozen routing). Appends a durable
    * `[routing]` window message when the turn's effective outbound locus
@@ -4637,6 +5255,85 @@ export class AgentFramework {
   }
 
   private async startAgentStream(agent: Agent, trigger?: InferenceRequest, attempt = 0): Promise<void> {
+    // Mark the turn alive before ANYTHING awaits (hooks, compile, stream
+    // setup): from here until this turn's teardown, cross-turn writers defer
+    // (addMessage guard) instead of appending — nothing may enter the window
+    // between a turn's dequeue and its settle except the turn's own blocks.
+    // A retry re-enters with a fresh token; teardown clears token-matched.
+    //
+    // The try/finally is the leak-proofing: a token whose owner never clears
+    // it permanently requeues every wake for the agent (the 'idle+turn-alive'
+    // wedge — worse than any single lost turn). Ownership is handed off
+    // exactly once, to driveStream, the moment the stream handle is
+    // registered; on every other exit — including a throw from the turn-start
+    // flush, recordTurnCheckpoint, or locus resolution, none of which the
+    // inner catch covers (ENOSPC-class store writes live there) — the finally
+    // clears our own token. Token-matched, so when a retry frame has replaced
+    // the token, or the terminal-failure branch already deleted it, this
+    // no-ops instead of clobbering a successor's marker.
+    const turnToken = this.nextTurnToken++;
+    this.activeTurnTokens.set(agent.name, turnToken);
+    let tokenHandedOff = false;
+    try {
+      tokenHandedOff = await this.beginAgentTurn(agent, trigger, attempt, turnToken);
+    } finally {
+      if (!tokenHandedOff && this.activeTurnTokens.get(agent.name) === turnToken) {
+        this.activeTurnTokens.delete(agent.name);
+      }
+    }
+  }
+
+  /**
+   * Body of startAgentStream, split out so the caller's try/finally owns the
+   * turn token unconditionally. Returns true iff the token was handed off to
+   * driveStream (whose finally then owns clearing it).
+   */
+  private async beginAgentTurn(
+    agent: Agent,
+    trigger: InferenceRequest | undefined,
+    attempt: number,
+    turnToken: number,
+  ): Promise<boolean> {
+    // Flush messages deferred during the PREVIOUS turn — before the
+    // checkpoint, the locus announcement, and the compile — so a turn started
+    // by a queued wake actually CONTAINS the message that woke it. (2026-07-31
+    // Mythos: a DM's wake fired a turn whose compile ran before the deferred
+    // DM flushed; the model saw only the routing-shift notice, reasonably
+    // skipped, and the DM then landed before the skip in the window — false
+    // "saw it and ignored it" history plus KV divergence. Flushed here, the
+    // payload rides its own wake, and the notice/payload can never split.)
+    // Primary agent only — deferred messages are framework-level, meant for
+    // the main conversation (same target rule as the tool-boundary flush).
+    // Fresh turns only: a context-budget restart continues the same logical
+    // turn, and flushing there would insert messages between its rounds.
+    // Before recordTurnCheckpoint: these are the turn's inputs, not its
+    // products — undoing the turn must not destroy them.
+    if (
+      attempt === 0 &&
+      trigger?.reason !== 'context_budget_restart' &&
+      this.deferredMessages.length > 0
+    ) {
+      const target = (this.primaryAgentName ? this.agents.get(this.primaryAgentName) : undefined) ?? agent;
+      if (target === agent) {
+        const deferred = this.deferredMessages.splice(0);
+        for (const msg of deferred) {
+          // Per-message try/catch (mirrors announceLocusIfChanged): one
+          // poison message — or a transient store-write failure — must not
+          // abort the turn or drop the messages behind it in the queue.
+          try {
+            const id = agent.getContextManager().addMessage(msg.participant, msg.content, msg.metadata);
+            this.emitTrace({ type: 'message:added', messageId: id, source: 'deferred-flush:turn-start' });
+          } catch (err) {
+            console.error(
+              `[deferred-flush] turn-start flush failed to store a message for ${agent.name} ` +
+              `(participant=${msg.participant}):`,
+              err,
+            );
+          }
+        }
+      }
+    }
+
     // Record turn checkpoint before inference (only on first attempt, not retries)
     if (attempt === 0) {
       this.recordTurnCheckpoint(agent.name);
@@ -4678,6 +5375,12 @@ export class AgentFramework {
     // KV stability).
     if (trigger?.reason !== 'context_budget_restart') {
       if (attempt === 0) this.maybePrimeProseMode(agent);
+      // Fresh turn: forget the previous turn's explicit-send engagements and
+      // prose deliveries — both are strictly turn-scoped (a restart continues
+      // the same logical turn and keeps them).
+      this.turnEngagedChannels.delete(agent.name);
+      this.turnProseDeliveries.delete(agent.name);
+      this.turnProseSuppressed.delete(agent.name);
       if (agent.proseRouting === 'explicit') {
         // Explicit prose routing: there is no locus. The model names every
         // destination in-band (`>>` prefixes); the only turn state is the
@@ -4777,6 +5480,9 @@ export class AgentFramework {
         compiledRequest,
       );
       this.activeStreams.set(agent.name, handle);
+      // Handoff: driveStream captured the token in its synchronous prefix;
+      // its finally now owns clearing it. The caller's finally must not.
+      return true;
     } catch (error) {
       // The early typing indicator has no driveStream `finally` on this path —
       // a hook/compile/stream-setup failure must not leave "typing…" stuck.
@@ -4794,8 +5500,18 @@ export class AgentFramework {
       const action = this.errorPolicy.onInferenceError(err, agent.name, attempt);
       if (action.retry) {
         await new Promise((resolve) => setTimeout(resolve, action.delayMs));
+        // The retry re-enters startAgentStream, which replaces this frame's
+        // turn token with its own; cleanup belongs to the innermost frame.
         await this.startAgentStream(agent, trigger, attempt + 1);
       } else {
+        // Terminal failure with no driveStream: this frame owns teardown.
+        // Token-matched (like the finally in driveStream) so a stale frame
+        // can never clear a successor turn's marker. A leaked token would
+        // permanently requeue every wake for this agent (same wedge shape as
+        // the eventGate `inferring` leak) — every exit path must clear it.
+        if (this.activeTurnTokens.get(agent.name) === turnToken) {
+          this.activeTurnTokens.delete(agent.name);
+        }
         this.settleAgent(agent.name, {
           stopReason: 'exhausted',
           speech: '',
@@ -4819,6 +5535,12 @@ export class AgentFramework {
           this.pushEvent(action.emit);
         }
       }
+      // No handoff on either failure branch: the terminal branch deleted the
+      // token above; the retry branch's recursive startAgentStream replaced
+      // it with the inner frame's token. Returning false lets the caller's
+      // token-matched finally no-op in both cases (and actually clear it if
+      // something above threw before either branch ran).
+      return false;
     }
   }
 
@@ -4833,6 +5555,10 @@ export class AgentFramework {
     const startTime = Date.now();
     const requestId = `${agent.name}-${startTime}-${Math.random().toString(36).slice(2, 8)}`;
     const myStreamId = agent.streamId;
+    // This turn's alive-marker, set at startAgentStream entry. Safe to read
+    // from the map here: the turn-alive busy check in processInferenceRequests
+    // means no successor turn can have replaced it while we compiled.
+    const myTurnToken = this.activeTurnTokens.get(agent.name);
     let hadToolCalls = false;
 
     // ---- Present-while-acting turn state ---------------------------------
@@ -4857,7 +5583,8 @@ export class AgentFramework {
     const enqueueSpeech = (text: string, locus: string | null): void => {
       turnSpeechChain = turnSpeechChain
         .then(async () => {
-          await this.channelRegistry!.routeSpeech(agent.name, text, locus);
+          const outcome = await this.channelRegistry!.routeSpeech(agent.name, text, locus);
+          this.recordProseDelivery(agent.name, outcome);
         })
         .catch((err) => console.error('mid-turn speech routing failed:', err));
     };
@@ -4899,8 +5626,27 @@ export class AgentFramework {
     // streams that delivery would refuse), emission is capability-gated in
     // the registry (`channels.streaming`), and delivery via deliverProse
     // remains the sole authoritative send.
-    const outgoingInferenceId = `inf_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+    const newOutgoingInferenceId = (): string =>
+      `inf_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+    // NOT const: a membrane refusal retry abandons everything streamed so
+    // far, and the surface must not concatenate two attempts. Re-minting the
+    // id makes the discarded attempt's chunk buffer orphaned (never
+    // finalized) instead of being appended to — see the 'retrying' case.
+    let outgoingInferenceId = newOutgoingInferenceId();
     let outgoingIndex = 0;
+
+    // §10.5 inference/lifecycle: `started` now, exactly one terminal in the
+    // finally below (the one block every exit path shares). Which terminal
+    // is decided by the paths themselves: default completed, catch sets
+    // failed, a framework-cancelled stream sets aborted. Best-effort
+    // notifications — consumers dedupe by inferenceId and keep a timeout.
+    let lifecyclePhase: 'completed' | 'aborted' | 'failed' = 'completed';
+    this.hookOrchestrator?.emitLifecycle({
+      inferenceId: outgoingInferenceId,
+      conversationId: agent.name,
+      turnIndex: 0,
+      phase: 'started',
+    });
     const proseStream = this.channelRegistry
       ? new ProseStreamRouter({
           mode: agent.proseRouting === 'explicit' ? 'explicit' : 'locus',
@@ -4950,6 +5696,38 @@ export class AgentFramework {
             }
             break;
 
+          case 'retrying': {
+            // Membrane is re-issuing after a content-policy refusal. Per the
+            // RetryingEvent contract we must DISCARD everything this call has
+            // emitted: the tokens above were already streamed to the surface
+            // as outgoing chunks, and appending a second attempt to them
+            // would show the human two half-answers spliced together.
+            //
+            // Re-mint the outgoing id so the partial buffer is orphaned
+            // rather than continued (delivery is authoritative via
+            // deliverProse and has not happened yet — nothing has been
+            // *sent*, only previewed), and reset the prose router so its
+            // destination bookkeeping starts clean for the new attempt.
+            console.error(
+              `[refusal-retry] agent=${agent.name} membrane retry ` +
+                `${event.attempt}/${event.maxAttempts}` +
+                (event.category ? ` category=${event.category}` : '') +
+                ' — discarding the refused attempt',
+            );
+            outgoingInferenceId = newOutgoingInferenceId();
+            outgoingIndex = 0;
+            proseStream?.reset();
+            this.emitTrace({
+              type: 'inference:tokens',
+              agentName: agent.name,
+              content: '',
+              blockType: 'text',
+              blockIndex: 0,
+              channelId: typingChannel ?? undefined,
+            });
+            break;
+          }
+
           case 'block': {
             const { event: phase, index, block } = event.event;
             this.emitTrace({
@@ -5067,6 +5845,9 @@ export class AgentFramework {
                     console.error(
                       `[routing] ${agent.name}: mid-turn round [${roundToolNames.join(', ')}] -> prose NOT routed (turn silenced)`,
                     );
+                    // Visible in the turn-end receipt — silencing must never
+                    // be a silent black hole (n=8: the flying-scene reply).
+                    this.recordProseSuppression(agent.name, roundSegments.length);
                   } else if (hasSameRoundPrivateThink) {
                     console.error(
                       `[routing] ${agent.name}: mid-turn round [${roundToolNames.join(', ')}] -> prose NOT routed (same_round_think_text_policy=private)`,
@@ -5114,17 +5895,15 @@ export class AgentFramework {
                 agent.addAssistantResponse(pending);
                 this.pendingAssistantBlocks.delete(agent.name);
               }
-              // Store tool results
+              // Store tool results — same bounded spill policy as the
+              // ordinary path (issue #89: this guard path must not become the
+              // one door a giant blob still walks through).
               const readyState = agent.state as AgentState;
               if (readyState.status === 'ready') {
-                const toolResultContent: ContentBlock[] = readyState.toolResults.map(tc => ({
-                  type: 'tool_result' as const,
-                  toolUseId: tc.id,
-                  content: tc.result.isError
-                    ? (tc.result.error ?? 'Unknown error')
-                    : toolResultDataToHistoryString(tc.result.data),
-                  isError: tc.result.isError,
-                }));
+                const { blocks: toolResultContent } = await this.buildStoredToolResultContent(
+                  readyState.toolResults,
+                  this.resolveToolResultInlineCap(agent).cap,
+                );
                 agent.getContextManager().addMessage('user', toolResultContent);
               }
             }
@@ -5153,40 +5932,10 @@ export class AgentFramework {
               agent.addAssistantResponse(terminalContent);
             }
 
-            // Run afterInference hooks (no-op if no MCPL servers)
-            if (this.hookOrchestrator) {
-              try {
-                const speechText = response.content
-                  .filter((block: ContentBlock): block is ContentBlock & { type: 'text' } => block.type === 'text')
-                  .map((b) => b.text)
-                  .join('\n');
-
-                const afterParams: AfterInferenceParams = {
-                  inferenceId: requestId,
-                  conversationId: agent.name,
-                  turnIndex: 0,
-                  userMessage: null,
-                  assistantMessage: speechText,
-                  model: {
-                    id: agent.model,
-                    vendor: 'unknown',
-                    contextWindow: 200000,
-                    capabilities: ['tools'],
-                  },
-                  usage: {
-                    inputTokens: response.usage?.inputTokens ?? 0,
-                    outputTokens: response.usage?.outputTokens ?? 0,
-                    cacheCreationTokens: response.details?.usage?.cacheCreationTokens,
-                    cacheReadTokens: response.details?.usage?.cacheReadTokens,
-                  },
-                };
-
-                await this.hookOrchestrator.afterInference(afterParams);
-              } catch (error) {
-                // Fail-open: continue with speech dispatch
-                console.error('afterInference hook error:', error);
-              }
-            }
+            // §10.5: context/afterInference is removed in 0.5.0 — no
+            // content leaves the host here. Turn boundaries are announced
+            // by the metadata-only inference/lifecycle notifications
+            // emitted in driveStream's start/exit paths.
 
             // Separate speech from thoughts — for MODULE dispatch only
             // (dispatchSpeech / TUI rendering below). This split does NOT
@@ -5283,6 +6032,18 @@ export class AgentFramework {
               let handledByRewind = false;
               const rh = agent.refusalHandling;
               const forced = this.forcedRewind.get(agent.name);
+
+              // NOTE: plain retries are NOT done here. `refusalHandling.retries`
+              // is handed to membrane (see Agent.startActivation), which
+              // replays the SAME request at the provider seam — immediately,
+              // cache-warm, and without recompiling into a different window.
+              // A framework-level requeue was tried first and is strictly
+              // worse: it recompiles, so attempts are correlated rather than
+              // fresh draws against a probabilistic threshold, and it cannot
+              // tell a streaming consumer to discard the abandoned attempt.
+              // By the time a refusal reaches here, membrane's retries are
+              // already spent — so this path is the escalation: rewind (if
+              // enabled), then the reaction.
               // Shed exactly one more (newest, in-sequence) turn and keep the
               // single episode marker current. `budgetLeft` bounds the loop.
               const doRewind = (
@@ -5340,7 +6101,16 @@ export class AgentFramework {
                 );
               }
 
-              if (!handledByRewind) void this.reactToRefusal(agent.name, category);
+              // The reaction is the LAST resort: retries spent, rewind not
+              // applicable. That makes it an honest signal to humans that the
+              // border is close, rather than noise on every near-threshold
+              // flip. (It must not re-enter any agent's context — the emoji
+              // is suppressed at the surface via
+              // DISCORD_SUPPRESS_REACTION_EMOJIS; without that, marking a
+              // refusal feeds the next one.)
+              if (!handledByRewind) {
+                void this.reactToRefusal(agent.name, category);
+              }
             } else {
               // A turn that completed WITHOUT a refusal ends the rewind episode:
               // the model responded. Leave the consolidated marker in place as
@@ -5406,7 +6176,8 @@ export class AgentFramework {
                     `[routing] ${agent.name}: text-only turn -> routing speech -> ${locus ?? '(none)'}`,
                   );
                   try {
-                    await this.channelRegistry.routeSpeech(agent.name, speechText, locus);
+                    const outcome = await this.channelRegistry.routeSpeech(agent.name, speechText, locus);
+                    this.recordProseDelivery(agent.name, outcome);
                   } catch (err) {
                     console.error('speech routing failed:', err);
                   }
@@ -5460,6 +6231,9 @@ export class AgentFramework {
                   `[routing] ${agent.name}: tool-call turn [${toolNames.join(', ') || 'none'}] -> trailing prose NOT routed ` +
                   `(${silenced ? 'silencing tool / explicit send' : 'no trailing prose'})`,
                 );
+                if (silenced && segments.length > 0) {
+                  this.recordProseSuppression(agent.name, segments.length);
+                }
               } else {
                 // Reuse the locus pinned at the turn's first live-routed
                 // segment (or resolve it now for a turn whose only prose is
@@ -5475,7 +6249,8 @@ export class AgentFramework {
                 // Deliver sequentially (await each) so the segments land in order.
                 for (const seg of segments) {
                   try {
-                    await this.channelRegistry.routeSpeech(agent.name, seg, locus);
+                    const outcome = await this.channelRegistry.routeSpeech(agent.name, seg, locus);
+                    this.recordProseDelivery(agent.name, outcome);
                   } catch (err) {
                     console.error('speech routing failed:', err);
                   }
@@ -5486,6 +6261,15 @@ export class AgentFramework {
             // BEFORE dispatchSpeech. Locus routing is speech dispatch and
             // doesn't depend on the status field, so it correctly runs after.
 
+            // Logical turn end (normal completion): drop the `[delivered]`
+            // receipt. All deliveries are settled — the live chain was
+            // awaited before trailing dispatch, and trailing/text-only
+            // segments were awaited in-loop. Locus mode only; explicit-mode
+            // envelopes acknowledge themselves through the prose gateway.
+            if (agent.proseRouting !== 'explicit') {
+              this.appendProseDeliveryReceipt(agent);
+            }
+
             // Explicit-prose `!` continuation: a prose segment this turn asked
             // to keep going (`>>#x !` / `>>private !`) — start another turn
             // now instead of pausing until the next external event. This gives
@@ -5566,9 +6350,26 @@ export class AgentFramework {
             // reset, no settle, no spurious inference:exhausted (which would
             // reject an ephemeral's promise mid-run and bump the failure
             // streak). Gate release + stream teardown happen in `finally`.
-            if (this.frameworkCancelledStreams.delete(`${agent.name}:${myStreamId}`)) {
-              this.eventGate?.onInferenceEnded(agent.name);
-              return;
+            {
+              const cancelKey = `${agent.name}:${myStreamId}`;
+              const cancelKind = this.frameworkCancelledStreams.get(cancelKey);
+              if (cancelKind !== undefined) {
+                this.frameworkCancelledStreams.delete(cancelKey);
+                lifecyclePhase = 'aborted'; // §10.5 — terminal emitted in finally
+                this.eventGate?.onInferenceEnded(agent.name);
+                // endTurn IS a logical turn end — earlier rounds may have
+                // live-routed prose (narrate → skip_reply is a real shape),
+                // so settle the delivery chain and drop the receipt. A
+                // budget restart continues the same logical turn: the
+                // deliveries map persists (cleared only at fresh turn
+                // start) and the continuation stream's end writes ONE
+                // receipt for the whole turn.
+                if (cancelKind === 'turn_ended' && agent.proseRouting !== 'explicit') {
+                  await turnSpeechChain;
+                  this.appendProseDeliveryReceipt(agent);
+                }
+                return;
+              }
             }
             const reason = event.reason ?? 'unknown';
             // Only reset if this is still the active stream (a budget restart
@@ -5609,6 +6410,11 @@ export class AgentFramework {
 
           case 'usage': {
             agent.lastStreamInputTokens = event.usage.inputTokens;
+            agent.lastStreamRealInputTokens =
+              (event.usage.inputTokens ?? 0) +
+              (event.usage.cacheCreationTokens ?? 0) +
+              (event.usage.cacheReadTokens ?? 0);
+            agent.lastStreamOutputTokens = event.usage.outputTokens ?? 0;
 
             // Closed-loop estimator calibration (2026-07-12). Sample the REAL
             // prefix size of THIS API call (fresh + cache write + cache read)
@@ -5681,9 +6487,21 @@ export class AgentFramework {
         durationMs,
       });
       this.abortAgentScript(agent.name, 'stream threw');
+      lifecyclePhase = 'failed'; // §10.5 — terminal emitted in finally
       agent.reset();
       this.eventGate?.onInferenceEnded(agent.name);
     } finally {
+      // §10.5: exactly one terminal per `started`, on every exit path the
+      // host controls. Which one was decided by the path taken (default
+      // completed; catch → failed; framework-cancel → aborted). A host
+      // crash emits nothing — that is the documented best-effort limit, and
+      // why consumers keep their safety timeout.
+      this.hookOrchestrator?.emitLifecycle({
+        inferenceId: outgoingInferenceId,
+        conversationId: agent.name,
+        turnIndex: 0,
+        phase: lifecyclePhase,
+      });
       // Clear the gate's inference flag on EVERY exit path (paired with the
       // onInferenceStarted in startAgentStream). The branch-level calls above
       // are kept but are best-effort; if any exit path bypassed them the agent
@@ -5717,6 +6535,17 @@ export class AgentFramework {
         this.disposeConversationAgent(agent.name);
       }
 
+      // The turn is torn down — release the turn-alive marker BEFORE the
+      // deferred flush below, so the flush appends at the settled tail.
+      // Token-matched: if a successor turn already owns the agent (endTurn
+      // reset the state machine before this finally ran — the 2026-07-31
+      // interleave), leave its marker alone; the guarded addMessage below
+      // then re-defers, and the successor's own turn-start flush / boundary
+      // injection / teardown delivers the messages at a correct position.
+      if (myTurnToken !== undefined && this.activeTurnTokens.get(agent.name) === myTurnToken) {
+        this.activeTurnTokens.delete(agent.name);
+      }
+
       // Flush any deferred messages (e.g. if stream failed while tools were pending)
       if (this.deferredMessages.length > 0 && this.pendingAssistantBlocks.size === 0) {
         const deferred = this.deferredMessages.splice(0);
@@ -5731,8 +6560,23 @@ export class AgentFramework {
    * Execute a tool call and return the result.
    * Routes to the appropriate handler (module registry or MCPL).
    * Used by SubagentModule to dispatch tool calls for ephemeral agents.
+   *
+   * This public entry always carries AGENT origin. Ephemeral/promise-based
+   * callers are models, and provenance must identify which internal path a
+   * call entered through — a public method shared with model callers can
+   * never confer module trust, whatever the input claims. Module origin
+   * exists only through the private closure handed to ModuleRegistry
+   * (ctx.callTool → executeToolCallFrom with {kind:'module'}). Callers that
+   * don't identify themselves fail safe to agent semantics too.
    */
   async executeToolCall(call: ToolCall): Promise<ToolResult> {
+    return this.executeToolCallFrom(call, {
+      kind: 'agent',
+      agentName: call.callerAgentName ?? '__ephemeral__',
+    });
+  }
+
+  private async executeToolCallFrom(call: ToolCall, origin: ChannelToolOrigin): Promise<ToolResult> {
     // Client-side programmatic tool calling for promise-based callers
     // (SubagentModule ephemerals). Keyed by callerAgentName so each ephemeral
     // gets its own interpreter state.
@@ -5753,6 +6597,27 @@ export class AgentFramework {
       }
     }
 
+    // Synthesized channel tools. This route was missing: when
+    // subscription-GC moved off the retired MCPL unsubscribe tool onto the
+    // generic channel_close (discord-mcpl b095a9f), module-originated
+    // closes started failing downstream as "Invalid tool name format" —
+    // the janitor had been silently broken since. `origin` is trusted
+    // dispatch context established at the call boundary above, not
+    // inferred from which method was used: only the ModuleRegistry closure
+    // carries module provenance (see handleToolClose). The agent-only
+    // synthesized verbs (think, skip_reply) are deliberately not routed
+    // here.
+    if (call.name.startsWith('channel_') && this.channelRegistry) {
+      return this.channelRegistry.handleChannelToolCall(call.name, call.input, origin);
+    }
+
+    // The utils meta-tool — programmatic callers (code_execution scripts,
+    // ephemerals, ModuleContext.callTool) reach utilities the same way the
+    // model does.
+    if (call.name === 'utils') {
+      return this.handleUtilsToolCall(call.callerAgentName ?? '__ephemeral__', call);
+    }
+
     // Module tools
     return this.moduleRegistry.handleToolCall(call);
   }
@@ -5849,7 +6714,51 @@ export class AgentFramework {
    * results reach the running script and never the model context.
    */
   private async runCodeExecution(agentName: string, call: ToolCall): Promise<ToolResult> {
-    const input = (call.input ?? {}) as { code?: unknown };
+    const input = (call.input ?? {}) as {
+      code?: unknown;
+      background?: unknown;
+      action?: unknown;
+      script_id?: unknown;
+    };
+
+    // Management surface: the agent's own daemon fleet is inspectable and
+    // killable through the same tool that spawns it.
+    if (input.action === 'list') {
+      const scripts = [...this.backgroundScripts.values()]
+        .filter((s) => s.agentName === agentName)
+        .map((s) => ({
+          script_id: s.id,
+          status: s.status,
+          started_at: new Date(s.startedAt).toISOString(),
+          wakes: s.wakes,
+          last_wake_at: s.lastWakeAt ? new Date(s.lastWakeAt).toISOString() : null,
+          log: s.logPath,
+        }));
+      return { success: true, data: { background_scripts: scripts } };
+    }
+    if (input.action === 'cancel') {
+      if (typeof input.script_id !== 'string') {
+        return { success: false, error: 'cancel requires `script_id`', isError: true };
+      }
+      const record = this.backgroundScripts.get(input.script_id);
+      if (!record || record.agentName !== agentName) {
+        return { success: false, error: `no background script '${input.script_id}'`, isError: true };
+      }
+      if (record.status === 'running') {
+        record.cancelled = true;
+        record.status = 'cancelled';
+        record.runner.abort('cancelled by agent');
+        record.runner.dispose();
+      }
+      return {
+        success: true,
+        data: { script_id: record.id, status: record.status, log: record.logPath },
+      };
+    }
+    if (input.action !== undefined && input.action !== 'run') {
+      return { success: false, error: `unknown action ${JSON.stringify(input.action)}`, isError: true };
+    }
+
     if (typeof input.code !== 'string' || input.code.trim() === '') {
       return {
         success: false,
@@ -5866,6 +6775,10 @@ export class AgentFramework {
       surface.map((t) => t.name).filter((name) => name !== CODE_EXECUTION_TOOL_NAME),
     );
 
+    if (input.background === true) {
+      return this.startBackgroundScript(agentName, input.code, injected);
+    }
+
     const runner = this.getOrCreateScriptRunner(agentName);
     this.scriptDeferredEndTurn.delete(agentName);
     const exec = await runner.exec(input.code, injected);
@@ -5879,6 +6792,351 @@ export class AgentFramework {
     };
   }
 
+  // ---------------------------------------------------------------------------
+  // Background (daemon) scripts — model-authored watchers that outlive the turn
+  // ---------------------------------------------------------------------------
+
+  /**
+   * Start a background script: dedicated interpreter, output journaled to a
+   * workspace file, wake_agent() available in-script. The tool result
+   * returns immediately; the script runs until it ends, hits the lifetime
+   * ceiling, or is cancelled. Scripts DIE WITH THE HOST PROCESS — that
+   * limitation is stated in the tool description so agents can calibrate
+   * how much to rely on an armed wake.
+   */
+  private startBackgroundScript(
+    agentName: string,
+    code: string,
+    injected: import('./code-execution/py-runner.js').InjectedTool[],
+  ): ToolResult {
+    // v1: primary-agent-only. A conversation fork's or ephemeral's daemon
+    // would outlive its owner and its wake would land in the primary
+    // conversation anyway — refuse loudly instead of surprising anyone.
+    if (this.primaryAgentName && agentName !== this.primaryAgentName) {
+      return {
+        success: false,
+        error: 'background scripts are available to the primary agent only',
+        isError: true,
+      };
+    }
+    const cfg = this.codeExecutionConfig;
+    const maxScripts = cfg?.maxBackgroundScripts ?? 3;
+    const runningCount = [...this.backgroundScripts.values()]
+      .filter((s) => s.agentName === agentName && s.status === 'running').length;
+    if (runningCount >= maxScripts) {
+      return {
+        success: false,
+        error: `background script limit reached (${maxScripts} running). ` +
+          'Use code_execution {"action": "list"} to inspect and {"action": "cancel", "script_id": ...} to free a slot.',
+        isError: true,
+      };
+    }
+
+    const scriptId = `bg-${++this.backgroundScriptCounter}`;
+    const lifetimeMs = cfg?.backgroundMaxLifetimeMs ?? 86_400_000;
+
+    // Journal: a file under the agent's first read-write workspace mount so
+    // their existing read/grep/shell tools work on it. Python appends
+    // directly to the materialized path; watch-mode mounts sync it back to
+    // the chronicle tree on their usual cadence.
+    let logPath: string | null = null;
+    let logAbsPath: string | null = null;
+    const workspace = this.getWorkspaceModule();
+    if (workspace) {
+      const mountName = this.firstWritableMountName(workspace);
+      if (mountName) {
+        logPath = `${mountName}/background-scripts/${scriptId}.log`;
+        logAbsPath = workspace.resolveAbsolutePath(logPath);
+      }
+    }
+
+    const runner = new PyRunner({
+      pythonPath: cfg?.pythonPath,
+      toolCallTimeoutMs: cfg?.toolCallTimeoutMs,
+      scriptTimeoutMs: cfg?.scriptTimeoutMs,
+      idleReclaimMs: 0, // dedicated runner; lifetime is the exec deadline
+      label: `${agentName}:${scriptId}`,
+      onToolCall: (toolName, args) => this.handleScriptToolCall(agentName, toolName, args),
+    });
+
+    const record: BackgroundScriptRecord = {
+      id: scriptId,
+      agentName,
+      runner,
+      code,
+      startedAt: Date.now(),
+      wakes: 0,
+      lastWakeAt: null,
+      logPath,
+      status: 'running',
+      cancelled: false,
+    };
+    this.backgroundScripts.set(scriptId, record);
+    this.emitTrace({
+      type: 'tool:started', module: 'code_execution', tool: `background:${scriptId}`,
+      callId: scriptId, input: { lines: code.split('\n').length },
+    });
+
+    void runner
+      .exec(code, injected, {
+        logPath: logAbsPath,
+        lifetimeMs,
+        onWake: (line, payload) => this.handleScriptWake(record, line, payload),
+      })
+      .then((exec) => this.settleBackgroundScript(record, exec))
+      .catch((err) => {
+        // exec never rejects by contract; this is the belt-and-suspenders.
+        console.error(`[pytc:${agentName}:${scriptId}] background exec rejected: ${String(err)}`);
+        this.settleBackgroundScript(record, {
+          stdout: '', stderr: String(err), returnCode: 1, aborted: true,
+        });
+      });
+
+    return {
+      success: true,
+      data: {
+        status: 'background script started',
+        script_id: scriptId,
+        log: logPath ?? 'no writable workspace mount — output is not retrievable; only wake_agent() reaches you',
+        lifetime_hours: Math.round(lifetimeMs / 3_600_000 * 10) / 10,
+        note: 'The script dies if the host process restarts. Manage with code_execution {"action": "list"|"cancel"}.',
+      },
+    };
+  }
+
+  /** First read-write mount name, or null. */
+  private firstWritableMountName(workspace: WorkspaceModule): string | null {
+    const mounts = (workspace as unknown as {
+      getMounts?: () => Array<{ name: string; mode: string }>;
+    }).getMounts?.();
+    if (mounts) {
+      const rw = mounts.find((m) => m.mode !== 'read-only');
+      return rw?.name ?? null;
+    }
+    return null;
+  }
+
+  /**
+   * wake_agent() from a background script: enforce the per-script wake cap
+   * and rate floor (delay, not drop — the script awaits the ack), then
+   * inject the provenance envelope + payload and request inference.
+   * Resolves null on delivery; an error string refuses the wake (raises
+   * RuntimeError inside the script).
+   */
+  private async handleScriptWake(
+    record: BackgroundScriptRecord,
+    line: number,
+    payload: unknown,
+  ): Promise<string | null> {
+    if (record.cancelled) return 'script was cancelled';
+    const cfg = this.codeExecutionConfig;
+    const maxWakes = cfg?.maxWakesPerScript ?? 100;
+    if (record.wakes >= maxWakes) {
+      return `wake limit reached (${maxWakes} per script)`;
+    }
+    const floorMs = cfg?.wakeMinIntervalMs ?? 60_000;
+    if (record.lastWakeAt !== null) {
+      const wait = record.lastWakeAt + floorMs - Date.now();
+      if (wait > 0) {
+        await new Promise((r) => {
+          const t = setTimeout(r, wait);
+          (t as { unref?: () => void }).unref?.();
+        });
+        if (record.cancelled) return 'script was cancelled';
+      }
+    }
+    record.wakes += 1;
+    record.lastWakeAt = Date.now();
+
+    const elapsedMin = Math.round((Date.now() - record.startedAt) / 60_000);
+    const payloadJson = payload === undefined || payload === null
+      ? 'null'
+      : JSON.stringify(payload, null, 1) ?? String(payload);
+    const agent = this.agents.get(record.agentName);
+    // Same resolved cap as tool results (override applies here too); an
+    // unknown agent still gets the bounded house default, never unbounded.
+    const maxChars = agent
+      ? this.resolveToolResultInlineCap(agent).cap
+      : DEFAULT_TOOL_RESULT_INLINE_MAX_CHARS;
+    const { text: payloadText } = await this.spillOrTruncate(
+      payloadJson, maxChars, `${record.id}-wake${record.wakes}`,
+    );
+
+    const envelope =
+      `[background script ${record.id}] Woke you: wake_agent() called at line ${line} of your script, ` +
+      `${elapsedMin}m after you started it (wake ${record.wakes} of ${maxWakes}).\n` +
+      `Arguments:\n${payloadText}\n` +
+      (record.logPath ? `Script output so far: workspace file ${record.logPath}\n` : '') +
+      `Script status: still running`;
+
+    this.injectScriptWake(record, envelope);
+    return null;
+  }
+
+  /** Background script ended (clean, crash, deadline, cancel/dispose). */
+  private settleBackgroundScript(
+    record: BackgroundScriptRecord,
+    exec: import('./code-execution/py-runner.js').ExecResult,
+  ): void {
+    record.runner.dispose();
+    if (record.status === 'running') {
+      record.status = exec.returnCode === 0 ? 'finished' : 'died';
+    }
+    this.emitTrace({
+      type: 'tool:completed', module: 'code_execution', tool: `background:${record.id}`,
+      callId: record.id, durationMs: Date.now() - record.startedAt,
+    });
+    // Crash honesty: a resident sleeping on a promise must never have that
+    // promise die silently. Deliberate cancels/disposes stay silent (the
+    // agent or host chose them); clean exits stay silent (the null path).
+    if (record.status === 'died' && !record.cancelled) {
+      const tail = (exec.tail ?? exec.stderr ?? '').slice(-2000);
+      const elapsedMin = Math.round((Date.now() - record.startedAt) / 60_000);
+      const envelope =
+        `[background script ${record.id}] Your background script DIED ${elapsedMin}m after start ` +
+        `(it did not call wake_agent and is no longer watching).\n` +
+        `Last output:\n${tail || '(none)'}\n` +
+        (record.logPath ? `Full journal: workspace file ${record.logPath}` : '');
+      this.injectScriptWake(record, envelope);
+    }
+    // Keep a short memory of settled scripts for {"action":"list"}, then drop.
+    const settled = [...this.backgroundScripts.values()]
+      .filter((s) => s.agentName === record.agentName && s.status !== 'running');
+    for (const old of settled.slice(0, Math.max(0, settled.length - 5))) {
+      this.backgroundScripts.delete(old.id);
+    }
+  }
+
+  /**
+   * Deliver a background-script event: provenance envelope into the agent's
+   * context + an inference request. Deliberately does NOT consult the event
+   * gate — the agent armed this wake themselves (wake-through-sleep
+   * authority); it enters tagged so gate policies could be taught about it
+   * later if that ever needs revisiting.
+   */
+  private injectScriptWake(record: BackgroundScriptRecord, envelope: string): void {
+    try {
+      const messageId = this.addMessage('user', [{ type: 'text', text: envelope }], {
+        source: 'background-script',
+        scriptId: record.id,
+        tags: ['script:wake'],
+      });
+      this.pendingRequests.push({
+        agentName: record.agentName,
+        reason: 'script:wake',
+        source: 'code_execution',
+        timestamp: Date.now(),
+      });
+      this.emitTrace({
+        type: 'message:added',
+        messageId,
+        source: `background-script:${record.id}`,
+      });
+    } catch (err) {
+      console.error(
+        `[pytc:${record.agentName}:${record.id}] wake injection failed: ${err instanceof Error ? err.message : String(err)}`,
+      );
+    }
+  }
+
+  /**
+   * Oversized content policy (antra, 2026-07-31; completed for issue #89):
+   * never hit the agent in the face with a huge blob, never silently destroy
+   * it either. Content over the inline cap is materialized to a workspace
+   * file (readable with the agent's own tools — deterministic name, kept
+   * until the workspace owner deletes it) and replaced by a truncated head +
+   * a trailing file reference. Falls back to EXPLICIT plain truncation when
+   * there is no writable workspace. Cap resolution lives in
+   * resolveToolResultInlineCap; callers pass the resolved cap.
+   */
+  /**
+   * One spill policy for every stored tool_result block: serialize (history
+   * serializer — image blocks become placeholders), then spill/truncate at
+   * the resolved cap. Errors follow the same policy as successes — a giant
+   * error string is exactly as context-hostile as a giant success (issue
+   * #89). Returns the stored blocks plus the per-call spill outcomes so the
+   * live wire copy can reuse the identical strings.
+   */
+  private async buildStoredToolResultContent(
+    toolResults: CompletedToolCall[],
+    maxChars: number | undefined,
+  ): Promise<{
+    blocks: ContentBlock[];
+    spilled: Map<string, { text: string; filePath: string | null }>;
+  }> {
+    const spilled = new Map<string, { text: string; filePath: string | null }>();
+    const dateLabel = new Date().toISOString().slice(0, 10);
+    for (const tc of toolResults) {
+      const raw = tc.result.isError
+        ? tc.result.error ?? 'Unknown error'
+        : toolResultDataToHistoryString(tc.result.data, undefined);
+      spilled.set(tc.id, await this.spillOrTruncate(raw, maxChars, `${dateLabel}-${tc.id}`));
+    }
+    const blocks: ContentBlock[] = toolResults.map(tc => ({
+      type: 'tool_result' as const,
+      toolUseId: tc.id,
+      content: spilled.get(tc.id)!.text,
+      isError: tc.result.isError,
+    }));
+    return { blocks, spilled };
+  }
+
+  private async spillOrTruncate(
+    content: string,
+    cap: number | undefined,
+    label: string,
+  ): Promise<{ text: string; filePath: string | null }> {
+    if (!cap || content.length <= cap) return { text: content, filePath: null };
+
+    const workspace = this.getWorkspaceModule();
+    const mountName = workspace ? this.firstWritableMountName(workspace) : null;
+    if (workspace && mountName) {
+      const safeLabel = label.replace(/[^A-Za-z0-9._-]/g, '_').slice(0, 80);
+      const path = `${mountName}/tool-results/${safeLabel}.txt`;
+      let failure: string;
+      try {
+        const result = await workspace.writeBinary(path, Buffer.from(content, 'utf8'), 'text/plain');
+        if (result.success) {
+          return {
+            text: safeSlice(content, 0, cap)
+              + `\n\n[truncated — showing ${cap} of ${content.length} chars; full content: workspace file ${path}. `
+              + 'Read/grep it with your file tools, or raise the inline cap via '
+              + 'agent_settings update tool_result_inline_max_chars.]',
+            filePath: path,
+          };
+        }
+        failure = result.error ?? 'write refused';
+      } catch (err) {
+        failure = err instanceof Error ? err.message : String(err);
+      }
+      // A workspace was there and the write FAILED — say that, loudly and
+      // distinctly. Telling the agent "no writable workspace" would teach
+      // them their residence lacks a capability it actually has.
+      failure = failure.slice(0, 200);
+      this.emitTrace({
+        type: 'tool:spill_failed',
+        label: safeLabel,
+        path,
+        contentLength: content.length,
+        error: failure,
+      });
+      console.error(
+        `[spill] workspace write failed for ${path} (${content.length} chars): ${failure}`,
+      );
+      return {
+        text: safeSlice(content, 0, cap)
+          + `\n\n[truncated — showing ${cap} of ${content.length} chars; spill to workspace file ${path} FAILED`
+          + ` (${failure}); content over the cap was not retained]`,
+        filePath: null,
+      };
+    }
+    return {
+      text: safeSlice(content, 0, cap)
+        + '\n\n[truncated — original was ' + content.length + ' chars; no writable workspace, full content not retained]',
+      filePath: null,
+    };
+  }
+
   private getOrCreateScriptRunner(agentName: string): PyRunner {
     let runner = this.codeExecutionRunners.get(agentName);
     if (!runner) {
@@ -5924,9 +7182,10 @@ export class AgentFramework {
       return `Error: ${result.error ?? 'tool call failed'}`;
     }
     if (result.data === undefined) return '';
-    const agent = this.agents.get(agentName);
-    const maxChars = agent ? this.getMaxToolResultChars(agent) : undefined;
-    return toolResultDataToHistoryString(result.data, maxChars);
+    // Scripts get (nearly) full data — the script environment IS the spill:
+    // filtering big results in code is the whole point. 5MB protocol safety
+    // cap only; no context-cap truncation, no file spill.
+    return toolResultDataToHistoryString(result.data, 5_000_000);
   }
 
   /**
@@ -5982,18 +7241,35 @@ export class AgentFramework {
     }
   }
 
-  private toMembraneToolResult(callId: string, afResult: ToolResult, maxChars?: number): MembraneToolResult {
+  private toMembraneToolResult(
+    callId: string,
+    afResult: ToolResult,
+    maxChars?: number,
+    /** Pre-spilled outcome from the history path — used for the non-image
+     *  path so the live wire copy byte-matches what the window stored. */
+    precomputed?: { text: string; filePath: string | null },
+  ): MembraneToolResult {
     if (afResult.isError) {
-      return { toolUseId: callId, content: afResult.error ?? 'Unknown error', isError: true };
+      // Same spill policy as successes: reuse the history copy so a giant
+      // error string stays bounded on the wire too (byte-matched).
+      return {
+        toolUseId: callId,
+        content: precomputed?.text ?? truncateForHistory(
+          afResult.error ?? 'Unknown error', DEFAULT_TOOL_RESULT_INLINE_MAX_CHARS),
+        isError: true,
+      };
     }
     // MCPL tool results arrive as `data: McpToolResultContent[]` — preserve image
     // blocks natively rather than JSON-stringifying them away. Anything else
     // (objects, scalars) falls through to JSON. The error path was handled
     // above, so isError is always false on these return paths.
-    const blocks = this.tryNativeToolResultContent(afResult.data, maxChars);
+    const blocks = this.tryNativeToolResultContent(afResult.data, maxChars, precomputed?.filePath ?? null);
     if (blocks) {
       return { toolUseId: callId, content: blocks, isError: false };
     }
+    if (precomputed !== undefined) {
+      return { toolUseId: callId, content: precomputed.text, isError: false };
+    }
     // JSON.stringify returns the VALUE undefined (not a string) for undefined
     // input — a module tool returning `{ success: true }` with no data would
     // otherwise make `content.length` below throw a TypeError mid-turn.
@@ -6012,7 +7288,13 @@ export class AgentFramework {
    * `maxChars`, when provided, caps each accompanying text block so an image
    * inlined alongside an enormous text payload can't blow the context.
    */
-  private tryNativeToolResultContent(data: unknown, maxChars?: number): ToolResultContentBlock[] | null {
+  private tryNativeToolResultContent(
+    data: unknown,
+    maxChars?: number,
+    /** Spill file written by the history path — referenced from truncation
+     *  notices so an image-adjacent giant text block stays recoverable. */
+    spillPath: string | null = null,
+  ): ToolResultContentBlock[] | null {
     if (!Array.isArray(data)) return null;
     let hasImage = false;
     const blocks: ToolResultContentBlock[] = [];
@@ -6023,7 +7305,9 @@ export class AgentFramework {
         let text = b.text;
         if (maxChars && text.length > maxChars) {
           text = safeSlice(text, 0, maxChars)
-            + '\n\n[truncated — original was ' + text.length + ' chars]';
+            + '\n\n[truncated — original was ' + text.length + ' chars'
+            + (spillPath ? `; full serialized result: workspace file ${spillPath}` : '')
+            + ']';
         }
         blocks.push({ type: 'text', text });
       } else if (b.type === 'image' && typeof b.data === 'string' && typeof b.mimeType === 'string') {
@@ -6039,13 +7323,45 @@ export class AgentFramework {
     return hasImage ? blocks : null;
   }
 
-  private getMaxToolResultChars(agent: Agent): number | undefined {
+  /** Strategy-derived per-message bound (maxMessageTokens * 4 chars). */
+  private strategyDerivedToolResultChars(agent: Agent): number | undefined {
     const strategy = agent.getContextManager().getStrategy();
     const maxTokens = strategy.maxMessageTokens;
     if (maxTokens && maxTokens > 0) return maxTokens * 4;
     return undefined;
   }
 
+  /**
+   * Effective tool-result inline cap for an agent, with provenance. Desired
+   * value: resident's durable agent_settings value → residence
+   * FrameworkConfig.toolResultInlineMaxChars → house default (5000).
+   * Effective value: min(desired, strategy bound) for EVERY source — the
+   * strategy's per-message safety limit is a ceiling, not a suggestion
+   * (Sol's #94 ruling: a durable preference must not be a durable path for
+   * one tool result to exceed maxMessageTokens; the way to see the whole
+   * result is the spill file, not an over-bound blob in live context).
+   */
+  private resolveToolResultInlineCap(agent: Agent): {
+    cap: number;
+    source: 'agent-settings-override' | 'framework-config' | 'default';
+    /** Set when the desired value was reduced to the strategy bound. */
+    clampedBy: 'strategy-bound' | null;
+  } {
+    const override = this.toolResultInlineMaxCharsOverride.get(agent.name);
+    const configured = this.toolResultInlineMaxCharsConfig;
+    const desired = override ?? configured ?? DEFAULT_TOOL_RESULT_INLINE_MAX_CHARS;
+    const source = override !== undefined
+      ? 'agent-settings-override' as const
+      : configured !== null ? 'framework-config' as const : 'default' as const;
+    const strategyBound = this.strategyDerivedToolResultChars(agent);
+    const clamped = strategyBound !== undefined && strategyBound < desired;
+    return {
+      cap: clamped ? strategyBound : desired,
+      source,
+      clampedBy: clamped ? 'strategy-bound' : null,
+    };
+  }
+
   private approximateDecodedBase64Bytes(base64: string): number {
     const padding = base64.endsWith('==') ? 2 : base64.endsWith('=') ? 1 : 0;
     return Math.max(0, Math.floor(base64.length * 3 / 4) - padding);
@@ -6173,6 +7489,11 @@ export class AgentFramework {
     }
 
     // Route the agent's typed, allowlisted hot-settings surface.
+    if (enrichedCall.name === 'utils') {
+      this.dispatchUtilsToolCall(agentName, enrichedCall);
+      return;
+    }
+
     if (enrichedCall.name === 'agent_settings') {
       this.dispatchAgentSettingsToolCall(agentName, enrichedCall);
       return;
@@ -6217,6 +7538,25 @@ export class AgentFramework {
     // synthesized channel tools, but they aren't `channel_`-prefixed so they
     // need an explicit route here.
     if ((enrichedCall.name === 'think' || enrichedCall.name === 'skip_reply') && this.channelRegistry) {
+      // skip_reply(wake_in_seconds): arm a gate self-wake so "not replying
+      // NOW" can also mean "back in a moment" — ends the turn, then wakes
+      // the agent after N seconds unless something else wakes it first
+      // (any turn start cancels the pending self-wake). Armed here because
+      // the framework owns the EventGate; the registry only words the
+      // confirmation. Without a gate the field is stripped so that
+      // confirmation never claims a wake that can't happen.
+      if (enrichedCall.name === 'skip_reply') {
+        const inputObj = (enrichedCall.input ?? {}) as Record<string, unknown>;
+        const secs = Number(inputObj.wake_in_seconds);
+        const wants = inputObj.wake_in_seconds !== undefined && Number.isFinite(secs) && secs > 0;
+        if (wants && this.eventGate) {
+          const { inMs } = this.eventGate.armSelfWake(agentName, secs, 'skip_reply');
+          console.error(`[self-wake] agent=${agentName} armed in ${Math.round(inMs / 1000)}s (skip_reply)`);
+        } else if (inputObj.wake_in_seconds !== undefined && !this.eventGate) {
+          delete inputObj.wake_in_seconds;
+          console.error(`[self-wake] agent=${agentName} wake_in_seconds requested but no EventGate — ignored`);
+        }
+      }
       this.dispatchChannelToolCall(agentName, enrichedCall);
       return;
     }
@@ -6331,15 +7671,27 @@ export class AgentFramework {
 
     // Defer non-tool_result messages while a tool cycle is mid-flight
     // (pendingAssistantBlocks: preserves tool_use → tool_result adjacency)
-    // OR while the target agent has a live stream at all. A message stored
-    // mid-stream lands BEFORE the turn's assistant blocks in the window even
-    // though the live conversation never saw it — so the next compile
-    // diverges from the live prefix (prompt-cache bust) and the message
-    // misses mid-turn injection. Deferred messages flush at the agent's next
-    // tool boundary (where they are ALSO injected into the live stream —
-    // hear-while-acting) or in driveStream's finally when the turn ends.
+    // OR while the target agent has a turn in progress AT ALL. A message
+    // stored mid-turn lands BEFORE the turn's assistant blocks in the window
+    // even though the live conversation never saw it — so the next compile
+    // diverges from the live prefix (prompt-cache bust), the message misses
+    // mid-turn injection, and the window falsely testifies the agent saw it
+    // and moved on. Turn-alive (activeTurnTokens) is the guard, not stream-
+    // alive: a turn exists from dequeue through hooks + compile before its
+    // stream registers in activeStreams, and the 2026-07-31 Mythos incident
+    // was precisely a deferred flush landing inside that compile window.
+    // (activeStreams is kept as a belt-and-suspenders backstop.) Deferred
+    // messages flush at the next turn's START (before its compile — riding
+    // their own wake), at the agent's next tool boundary (where they are
+    // ALSO injected into the live stream — hear-while-acting), or in
+    // driveStream's finally when the turn ends.
     const hasToolResult = content.some(b => b.type === 'tool_result');
-    if (!hasToolResult && (this.pendingAssistantBlocks.size > 0 || this.activeStreams.has(agent.name))) {
+    if (
+      !hasToolResult &&
+      (this.pendingAssistantBlocks.size > 0 ||
+        this.activeTurnTokens.has(agent.name) ||
+        this.activeStreams.has(agent.name))
+    ) {
       this.deferredMessages.push({ participant, content, metadata });
       return '' as MessageId; // Deferred — flushed at the next boundary
     }
@@ -6832,7 +8184,6 @@ export class AgentFramework {
   ): Promise<void> {
     this.mcplServerRegistry = new McplServerRegistry();
     this.featureSetManager = new FeatureSetManager();
-    this.scopeManager = new ScopeManager();
     this.hookOrchestrator = new HookOrchestrator(this.mcplServerRegistry, this.featureSetManager);
 
     // Build prefix map and store configs for tool routing
@@ -6950,15 +8301,35 @@ export class AgentFramework {
 
     // Host capabilities advertised during the MCP handshake — stored so
     // servers can also be connected later at runtime (connectMcplServer).
+    // §5.2: the host advertises what it actually implements. 0.5.0-draft:
+    // afterInference is GONE (replaced by inference/lifecycle, §10.5), and
+    // the previously under-advertised inferenceRequest + channels — both
+    // implemented for years — are declared (AUDIT-001/issue #76 item 12).
     this.mcplHostCapabilities = {
-      version: '0.4',
+      version: '0.5',
       pushEvents: true,
       contextHooks: {
         beforeInference: true,
-        afterInference: { blocking: true },
+      },
+      inferenceLifecycle: true,
+      // modelInfo is NOT advertised: §12.2's result requires all four of
+      // {id, vendor, contextWindow, capabilities} and the host has no
+      // truthful source for contextWindow/capabilities (grep: none exists).
+      // Advertising a capability answered with a malformed partial response
+      // is worse than honest unsupported (Sol, PR #79 re-review). The
+      // handler below answers an explicit error rather than hanging (§6.6).
+      inferenceRequest: { streaming: true },
+      channels: {
+        register: true,
+        lifecycle: true,
+        publish: true,
+        incoming: true,
+        streaming: true,
+        acknowledge: true,
+        typing: true,
       },
       featureSets: true,
-    };
+    } as McplHostCapabilities;
 
     for (const config of serverConfigs) {
       try {
@@ -7371,30 +8742,228 @@ export class AgentFramework {
     // releases control traffic needed for registration and marker service.
     this.wireMcplEvents(connection);
 
-    // Initialize feature sets if server advertises MCPL capabilities
-    this.registerMcplServerFeatures(config, connection);
-
     if (deferAwareness) {
+      // Staged startup: both planes are closed, so the §5.3 policy
+      // round-trip cannot let any buffered traffic slip — establish the
+      // grant now, before staging ever releases.
+      await this.registerMcplServerFeatures(config, connection);
       this.emitTrace({ type: 'module:added', moduleName: `mcpl:${config.id}` });
       return;
     }
 
     const awarenessBarrier = this.installMcplDataPlaneGate();
-    this.releaseMcplDataPlaneGate(awarenessBarrier);
+    // NO early release: both planes stay closed through accounting AND the
+    // §5.3 policy round-trip below (PR #79 review blocker 3 — the early
+    // control flush released channels-register/changed before any grant
+    // existed). The awareness drain rides tools/call RESPONSES, which are
+    // never event-buffered, so it needs no plane release to make progress.
     try {
       await awarenessBarrier.promise;
-      this.completeMcplDataPlaneGate(awarenessBarrier);
     } catch (error) {
       // Startup cannot fail open on a broken awareness ledger. Disable the
       // reconnecting stub/connection before propagating the distinct error to
       // initializeMcpl, which tears down any other servers and aborts create().
+      // Ordering matters: awareness accounting settles BEFORE the §5.3
+      // policy round-trip below, so an accounting failure aborts with the
+      // grant still empty and every buffered event still behind the gate —
+      // a failed startup never reports a released data plane. (The reverse
+      // order let a push arrive during the policy await and get flushed by
+      // teardown.)
       await connection.close().catch(() => {});
       throw error;
     }
 
+    // §5.3 initial policy handshake — after accounting, before the gate
+    // completes: the grant is established (or knowingly left empty) before
+    // ANY buffered traffic (control or data) flows. complete() then
+    // ready()s both planes through the admission gate.
+    await this.registerMcplServerFeatures(config, connection);
+    this.completeMcplDataPlaneGate(awarenessBarrier);
+
     this.emitTrace({ type: 'module:added', moduleName: `mcpl:${config.id}` });
   }
 
+  /** Per-connection §17.8 fetch limiter: at most one in-flight fetch, at
+   *  most one queued behind it (announcements coalesce), floor between
+   *  completed fetches. Exceeding the floor drops the excess with a
+   *  diagnostic — the host bounds the rate; it never depends on server
+   *  coalescing. */
+  private manifestRefreshState: Map<string, { inFlight: boolean; queued: boolean; lastCompletedAt: number }> = new Map();
+  private static readonly MANIFEST_FETCH_FLOOR_MS = 5_000;
+
+  /**
+   * §17.5 host processing: fetch the complete manifest, validate exactly as
+   * at initialize, diff, apply §6.7 consequences (removals eagerly even
+   * when other declarations are invalid; additions only through
+   * tell→receipt→activate), emit ONE change receipt (§17.6).
+   */
+  private async handleManifestChanged(
+    connection: McplServerConnection,
+    announce: { revision?: string; domains?: string[] },
+  ): Promise<void> {
+    const st = this.manifestRefreshState.get(connection.id)
+      ?? { inFlight: false, queued: false, lastCompletedAt: 0 };
+    this.manifestRefreshState.set(connection.id, st);
+    if (st.inFlight) {
+      // Coalesce: one queued refresh re-runs after the current fetch — the
+      // fetch is always of the CURRENT manifest, so N announcements need at
+      // most one trailing fetch (§17.8).
+      st.queued = true;
+      return;
+    }
+    const sinceLast = Date.now() - st.lastCompletedAt;
+    if (sinceLast < AgentFramework.MANIFEST_FETCH_FLOOR_MS) {
+      if (!st.queued) {
+        st.queued = true;
+        setTimeout(() => {
+          const cur = this.manifestRefreshState.get(connection.id);
+          if (cur?.queued && !cur.inFlight) {
+            cur.queued = false;
+            void this.handleManifestChanged(connection, announce).catch(() => {});
+          }
+        }, AgentFramework.MANIFEST_FETCH_FLOOR_MS - sinceLast).unref?.();
+      }
+      return;
+    }
+
+    st.inFlight = true;
+    try {
+      const config = this.mcplServerConfigs.get(connection.id);
+      if (!config) return;
+
+      // §17.4 fetch. A server that cannot answer keeps its previous
+      // manifest in force — an unparseable/failed fetch teaches nothing and
+      // narrows nothing (§17.5 step 1).
+      let fetched: import('./mcpl/types.js').McplCapabilities | null;
+      try {
+        fetched = await connection.sendManifestRequest();
+      } catch (err) {
+        console.error(`[mcpl] ${connection.id}: mcpl/manifest fetch failed — previous manifest stands (§17.5): ${err instanceof Error ? err.message : err}`);
+        return;
+      }
+      if (!fetched || typeof fetched !== 'object') {
+        console.error(`[mcpl] ${connection.id}: mcpl/manifest returned no object — previous manifest stands (§17.5)`);
+        return;
+      }
+
+      // Validate exactly as at initialize: expand §5.1 shorthand, apply the
+      // config mask, recompute the grant. Unknown names mint nothing;
+      // invalid declarations fail closed in derivation — and REMOVALS still
+      // apply, because the new grant/derivation simply lacks whatever no
+      // longer validates (§17.5 step 1's partial-invalid rule falls out of
+      // computing forward from the fetched content).
+      const expanded = expandAdvertisementShorthand(fetched);
+      const { capabilities: masked, dropped } = maskNegotiatedCapabilities(expanded, config);
+      const newGrant = computeGrant(masked, config, { mcpToolsAdvertised: connection.mcpToolsAdvertised });
+
+      const oldEffective = new Set(connection.grant.effectiveList());
+      const newEffective = new Set(newGrant.effectiveList());
+      const revoked = [...oldEffective].filter((p) => !newEffective.has(p)).sort();
+      const added = [...newEffective].filter((p) => !oldEffective.has(p)).sort();
+
+      const oldDeclared = Object.keys(this.featureSetManager?.getDeclaredFeatureSets(connection.id) ?? {});
+      const oldEnabled = oldDeclared.filter((n) => this.featureSetManager?.isEnabled(connection.id, n));
+
+      // §6.7 REDUCTION FIRST, atomically, before the server is told:
+      // security cannot wait on consent. The interim grant is new∩old — no
+      // revoked path survives, no added path activates yet.
+      const hadReduction = revoked.length > 0;
+      if (hadReduction) {
+        const interim = new CapabilityGrant(
+          new Set([...newEffective].filter((p) => oldEffective.has(p))),
+          [...newGrant.deniedPaths],
+        );
+        connection.establishGrant(interim);
+      }
+
+      // PHASE 1 — pre-receipt: live feature state derives from ACTIVE
+      // authority (the interim grant when reduced, the standing grant
+      // otherwise), never from the unactivated full grant. Feature state
+      // must obey the same §6.7 ordering the grant does: a newly added
+      // capability-backed feature set cannot be host-enabled while its
+      // capability is still absent from the active grant (Sol, PR #84
+      // review). Declarations come from the fetched manifest either way —
+      // a set absent from the new manifest is gone regardless.
+      const cfg = { enabledFeatureSets: config.enabledFeatureSets, disabledFeatureSets: config.disabledFeatureSets };
+      const maskedOrEmpty = masked ?? ({ version: '0.5' } as import('./mcpl/types.js').McplCapabilities);
+      this.featureSetManager!.initializeServer(connection.id, maskedOrEmpty, cfg, connection.grant);
+
+      // The Request DESCRIBES the proposed new policy — derived from the
+      // full new grant on a scratch manager, installing nothing.
+      const updateParams = new FeatureSetManager().initializeServer(connection.id, maskedOrEmpty, cfg, newGrant);
+      updateParams.effectiveCapabilities = newGrant.effectiveList();
+      if (newGrant.deniedPaths.length > 0) updateParams.deniedCapabilities = [...newGrant.deniedPaths];
+
+      // Tell → receipt → activate (§6.7). PHASE 2 by outcome:
+      //  accepted  → full grant + full-derived feature state;
+      //  refused   → honor fallback: 'close' closes the transport;
+      //              'mcp-only' (or absent) = empty grant + empty-derived
+      //              feature state, mirroring the §5.3 initial path;
+      //  unanswered → interim grant and interim-derived state stand.
+      let negotiated = false;
+      try {
+        const receipt = await connection.sendFeatureSetsUpdateRequest(updateParams);
+        if (receipt && receipt.accepted === false) {
+          const fallback = receipt.fallback ?? 'mcp-only';
+          console.error(`[mcpl] ${connection.id} refused post-manifest policy — fallback: ${fallback}`);
+          if (fallback === 'close') {
+            await connection.close();
+            return;
+          }
+          connection.establishGrant(CapabilityGrant.empty());
+          this.featureSetManager!.initializeServer(connection.id, maskedOrEmpty, cfg, CapabilityGrant.empty());
+        } else {
+          connection.establishGrant(newGrant);
+          this.featureSetManager!.initializeServer(connection.id, maskedOrEmpty, cfg, newGrant);
+          connection.manifestState.lastNegotiatedAt = Date.now();
+          negotiated = true;
+        }
+      } catch {
+        console.error(`[mcpl] ${connection.id} did not answer post-manifest policy — expansion does not activate (§6.7); interim state stands`);
+      }
+
+      // Adopt the validated manifest + tracking. droppedCapabilities is
+      // REPLACED unconditionally — an empty new mask must clear stale paths
+      // (Sol, PR #84 review).
+      connection.capabilities = masked;
+      connection.manifestState.lastValidatedRevision =
+        typeof (fetched as { revision?: unknown }).revision === 'string'
+          ? (fetched as { revision: string }).revision : null;
+      connection.manifestState.lastFetchedAt = Date.now();
+      connection.droppedCapabilities = new Set(dropped);
+
+      const newDeclared = Object.keys(this.featureSetManager?.getDeclaredFeatureSets(connection.id) ?? {});
+      const newEnabled = newDeclared.filter((n) => this.featureSetManager?.isEnabled(connection.id, n));
+      const degraded = oldEnabled.filter((n) => !newEnabled.includes(n)).sort();
+      const restored = newEnabled.filter((n) => !oldEnabled.includes(n)).sort();
+
+      // §17.6: ONE receipt per manifest change, closed host-derived impact
+      // vocabulary, never a server-authored flag.
+      const impacts: Array<{ impact: string; subject: string; disposition: string }> = [
+        ...revoked.map((p) => ({ impact: 'capability-revoked', subject: p, disposition: 'applied' })),
+        ...added.map((p) => ({ impact: 'capability-expansion-pending', subject: p, disposition: negotiated ? 'applied' : 'decision-needed' })),
+        ...degraded.map((n) => ({ impact: 'feature-degraded', subject: n, disposition: 'applied' })),
+        ...restored.map((n) => ({ impact: 'feature-restored', subject: n, disposition: negotiated ? 'applied' : 'decision-needed' })),
+      ];
+      this.emitTrace({
+        type: 'mcpl:manifest-change-receipt',
+        serverId: connection.id,
+        revision: connection.manifestState.lastValidatedRevision,
+        announcedDomains: announce.domains ?? [],
+        impacts,
+      });
+      this.handleToolsListChanged(connection.id);
+    } finally {
+      st.inFlight = false;
+      st.lastCompletedAt = Date.now();
+      if (st.queued) {
+        st.queued = false;
+        setTimeout(() => { void this.handleManifestChanged(connection, announce).catch(() => {}); },
+          AgentFramework.MANIFEST_FETCH_FLOOR_MS).unref?.();
+      }
+    }
+  }
+
   /**
    * (Re-)establish a server's host-side MCPL registration: feature-set state
    * (plus the featureSets/update sent to the server), scope patterns, and
@@ -7410,12 +8979,18 @@ export class AgentFramework {
    * already has a tree), so checkpoint trees preserved across a transient
    * disconnect are resumed, not reset.
    */
-  private registerMcplServerFeatures(
+  private async registerMcplServerFeatures(
     config: import('./mcpl/types.js').McplServerConfig,
     connection: McplServerConnection,
-  ): void {
+  ): Promise<void> {
     if (!connection.capabilities) return;
 
+    // §5.4: compute the effective grant from the (config-masked)
+    // advertisement. Not yet active — expansion activates only after the
+    // receipt (§6.7); until then the connection's grant is empty and every
+    // privileged inbound method is rejected.
+    const grant = computeGrant(connection.capabilities, config, { mcpToolsAdvertised: connection.mcpToolsAdvertised });
+
     const updateParams = this.featureSetManager!.initializeServer(
       config.id,
       connection.capabilities,
@@ -7423,16 +8998,60 @@ export class AgentFramework {
         enabledFeatureSets: config.enabledFeatureSets,
         disabledFeatureSets: config.disabledFeatureSets,
       },
+      grant,
     );
 
-    // Inform server which feature sets are enabled/disabled
-    if (updateParams.enabled?.length || updateParams.disabled?.length) {
-      connection.sendFeatureSetsUpdate(updateParams);
+    // §5.3: initial policy MUST be a Request, MUST precede first fan-out,
+    // and MUST be sent even when nothing is enabled or disabled — a server
+    // defaulted to fully disabled has to be told. The response is a
+    // degradation receipt (§6.7): consequence testimony, never policy
+    // authority — nothing in it may widen the grant.
+    updateParams.effectiveCapabilities = grant.effectiveList();
+    if (grant.deniedPaths.length > 0) {
+      updateParams.deniedCapabilities = [...grant.deniedPaths];
+    }
+
+    try {
+      const receipt = await connection.sendFeatureSetsUpdateRequest(updateParams);
+      if (receipt && receipt.accepted === false) {
+        const fallback = receipt.fallback ?? 'mcp-only';
+        console.error(
+          `[mcpl] ${config.id} refused initial policy (${receipt.reason ?? 'no reason'}) — fallback: ${fallback}`,
+        );
+        if (fallback === 'close') {
+          await connection.close();
+          return;
+        }
+        // mcp-only (§3.2): grant stays empty, MCPL privileged surface stays
+        // dark, plain MCP tools keep working. MUST NOT widen in response to
+        // the refusal — a human can change config; the policy engine cannot.
+        return;
+      }
+      // Expansion activates on receipt (§6.7).
+      connection.establishGrant(grant);
+      if (receipt?.accepted === true && receipt.mode === 'degraded') {
+        for (const uf of receipt.unavailableFeatures ?? []) {
+          console.error(
+            `[mcpl] ${config.id} degraded: ${uf.featureSet} (${uf.effect}; missing ${uf.missingCapabilities.join(', ')})`,
+          );
+        }
+      }
+    } catch (err) {
+      // A pre-0.5 server treats the Request as a notification and never
+      // answers. §6.7: an unanswered expansion simply does not activate —
+      // grant stays empty, connection is effectively MCP-only. This WILL
+      // dark every un-migrated MCPL server's privileged surface; accepted
+      // deliberately for the single-release rollout (issue #76 item 9).
+      console.error(
+        `[mcpl] ${config.id} did not answer the initial policy Request — ` +
+          `MCPL privileged surface stays disabled (§6.7 unanswered expansion): ` +
+          (err instanceof Error ? err.message : String(err)),
+      );
+      return;
     }
 
-    // Configure scope whitelist/blacklist patterns
     if (config.scopes) {
-      this.scopeManager!.configureAll(config.scopes);
+      console.error(`[mcpl] ${config.id}: config \`scopes\` is ignored — §7 Scoped Access removed in 0.5.0`);
     }
 
     // Register stateful feature sets with checkpoint manager (Step 8)
@@ -7548,23 +9167,62 @@ export class AgentFramework {
   listMcplServers(): Array<{
     id: string;
     connected: boolean;
+    retrying: boolean;
     toolPrefix: string;
     toolCount: number;
+    /** True only after the §5.3 policy receipt activated the grant. */
+    policyEstablished: boolean;
+    /** Sole normative authorization allowlist for the connection (§5.4). */
+    effectiveGrant: string[];
+    /** Advertised paths removed by host enabled/disabled capability config. */
+    maskedCapabilities: string[];
+    /** Advertised paths removed by a host deny-by-default rule (§13.4). */
+    deniedCapabilities: string[];
+    /** Host-owned authority; deliberately separate from the portable grant. */
+    allowHostCommands: boolean;
+    /**
+     * Per-transport §17 facts about the last manifest this host fetched and
+     * acted on. The revision is server-authored and equality-only; these are
+     * not the server's manifestChanged announcements.
+     */
+    manifestState: {
+      lastValidatedRevision: string | null;
+      lastFetchedAt: number | null;
+      lastNegotiatedAt: number | null;
+    };
     command?: string;
     url?: string;
   }> {
     const result: Array<{
-      id: string; connected: boolean; toolPrefix: string; toolCount: number;
+      id: string; connected: boolean; retrying: boolean;
+      toolPrefix: string; toolCount: number; policyEstablished: boolean;
+      effectiveGrant: string[]; maskedCapabilities: string[];
+      deniedCapabilities: string[]; allowHostCommands: boolean;
+      manifestState: {
+        lastValidatedRevision: string | null;
+        lastFetchedAt: number | null;
+        lastNegotiatedAt: number | null;
+      };
       command?: string; url?: string;
     }> = [];
     for (const [id, config] of this.mcplServerConfigs) {
       const prefix = config.toolPrefix ?? `mcpl--${id}`;
       const connection = this.mcplServerRegistry?.getServer(id) ?? null;
+      const connected = connection?.isConnected ?? false;
       result.push({
         id,
-        connected: connection?.isConnected ?? false,
+        connected,
+        retrying: !connected && (connection?.willReconnect ?? false),
         toolPrefix: prefix,
         toolCount: this.mcplTools.filter(t => t.name.startsWith(`${prefix}--`)).length,
+        policyEstablished: connection?.policyEstablished ?? false,
+        effectiveGrant: connection?.grant.effectiveList() ?? [],
+        maskedCapabilities: [...(connection?.droppedCapabilities ?? [])].sort(),
+        deniedCapabilities: [...(connection?.grant.deniedPaths ?? [])].sort(),
+        allowHostCommands: config.allowHostCommands === true,
+        manifestState: connection
+          ? { ...connection.manifestState }
+          : { lastValidatedRevision: null, lastFetchedAt: null, lastNegotiatedAt: null },
         command: config.command,
         url: config.url,
       });
@@ -7583,26 +9241,15 @@ export class AgentFramework {
       this.emitTrace({ type: 'mcpl:server-stderr', serverId: connection.id, line: params.line });
     });
 
-    // Handle dynamic feature set changes from server
-    connection.on('feature-sets-changed', (params: FeatureSetsChangedParams) => {
-      this.featureSetManager?.handleFeatureSetsChanged(connection.id, params);
-    });
+    // featureSets/changed is REMOVED in 0.5.0 — the connection answers it
+    // -32601 (superseded by SPEC §17's host-diffed manifest fetch); no
+    // listener, and nothing mutates declarations off a server-authored
+    // change payload.
 
     // Handle scope elevation requests
-    connection.on('scope-elevate', async (
-      params: ScopeElevateParams,
-      responder?: { respond: (result: unknown) => void; respondError: (code: number, message: string) => void },
-    ) => {
-      if (this.scopeManager && responder) {
-        try {
-          const result: ScopeElevateResult = await this.scopeManager.handleElevation(params);
-          responder.respond(result);
-        } catch (error) {
-          const err = error instanceof Error ? error : new Error(String(error));
-          responder.respondError(-32603, err.message);
-        }
-      }
-    });
+    // §7 Scoped Access is removed in 0.5.0. scope/elevate is answered
+    // -32601 at the connection (server-connection.ts) and never reaches the
+    // framework; the ScopeManager and config `scopes` wiring went with it.
 
     // Handle push events (Step 6)
     connection.on('push-event', async (
@@ -7638,9 +9285,51 @@ export class AgentFramework {
       await this.channelRegistry?.handleRegister(connection.id, params, responder as never);
     });
 
-    // Handle channel changes (Step 7)
-    connection.on('channels-changed', async (params: ChannelsChangedParams) => {
-      await this.channelRegistry?.handleChanged(connection.id, params);
+    // Handle channel changes (Step 7) — §14.5 dual-mode: the responder is
+    // present for the Request form and carries itemized added-descriptor
+    // results; absent for Notifications, where rejection is itemwise
+    // filtering plus a diagnostic trace.
+    connection.on('channels-changed', async (
+      params: ChannelsChangedParams,
+      responder?: { respond: (result: unknown) => void },
+    ) => {
+      await this.channelRegistry?.handleChanged(connection.id, params, responder as never);
+    });
+
+    // §6.6/§12: requests that previously had no handler and hung forever
+    // (AUDIT-001 item 4). The connection-level grant gate has already run.
+    // §17.3: a manifest-change announcement. Rate-limited re-fetch → diff
+    // → §6.7 consequences → one receipt. The announcement itself carries no
+    // payload and no authority; everything below acts on FETCHED content.
+    connection.on('manifest-changed', (params: { revision?: string; domains?: string[] }) => {
+      void this.handleManifestChanged(connection, params).catch((err) => {
+        console.error(`[mcpl] ${connection.id} manifest refresh failed:`, err instanceof Error ? err.message : err);
+      });
+    });
+
+    connection.on('channels-list', (
+      _params: unknown,
+      responder?: { respond: (result: unknown) => void },
+    ) => {
+      responder?.respond({
+        channels: this.channelRegistry?.descriptorsForServer(connection.id) ?? [],
+      });
+    });
+
+    connection.on('model-info', (
+      _params: unknown,
+      responder?: { respond: (result: unknown) => void; respondError?: (code: number, message: string, data?: unknown) => void },
+    ) => {
+      // §12.2 requires ALL FOUR of {id, vendor, contextWindow, capabilities}
+      // in the DIRECT result shape, and numeric contextWindow cannot express
+      // "unknown". The host has no truthful source for it, so modelInfo is
+      // not advertised and this answers an explicit error instead of a
+      // malformed partial (§6.6: a method that will never be answered
+      // truthfully MUST error, not fabricate).
+      responder?.respondError?.(
+        -32601,
+        'model/info unavailable: host does not advertise modelInfo (no truthful contextWindow source)',
+      );
     });
 
     // Handle incoming channel messages (Step 7)
@@ -7699,19 +9388,25 @@ export class AgentFramework {
       // reconnect observes it before doing work that could wake an agent. The
       // connection paused its data plane before wiring the fresh transport.
       const awarenessBarrier = this.installMcplDataPlaneGate();
-      try {
-        const config = this.mcplServerConfigs.get(connection.id);
-        if (config) {
-          this.registerMcplServerFeatures(config, connection);
+      // Async: the §5.3 policy Request must be answered (re-establishing the
+      // grant) before the data-plane barrier releases — otherwise the first
+      // post-reconnect events land while the grant is still empty and are
+      // rejected fail-closed instead of delivered.
+      void (async () => {
+        try {
+          const config = this.mcplServerConfigs.get(connection.id);
+          if (config) {
+            await this.registerMcplServerFeatures(config, connection);
+          }
+        } catch (error) {
+          console.error(
+            `MCPL server "${connection.id}" re-registration after reconnect failed:`,
+            error instanceof Error ? error.message : error,
+          );
         }
-      } catch (error) {
-        console.error(
-          `MCPL server "${connection.id}" re-registration after reconnect failed:`,
-          error instanceof Error ? error.message : error,
-        );
-      }
-      this.releaseMcplDataPlaneGate(awarenessBarrier);
-      this.handleToolsListChanged(connection.id);
+        this.releaseMcplDataPlaneGate(awarenessBarrier);
+        this.handleToolsListChanged(connection.id);
+      })();
       void awarenessBarrier.promise.then(() => {
         if (
           awarenessBarrier.requiresBarrier
@@ -7826,6 +9521,7 @@ export class AgentFramework {
     if (!this.mcplServerRegistry) return;
 
     const tools: import('./types/index.js').ToolDefinition[] = [];
+    const toolFeatureSets = new Map<string, string>();
 
     for (const server of this.mcplServerRegistry.getAllServers()) {
       const config = this.mcplServerConfigs.get(server.id);
@@ -7834,13 +9530,26 @@ export class AgentFramework {
         const result = await server.sendToolsList();
         for (const tool of result.tools) {
           if (!isToolAllowed(tool.name, config)) continue;
+          const namespacedName = `${prefix}--${tool.name}`;
+          const attributedTool = tool as typeof tool & {
+            featureSet?: unknown;
+            _meta?: { featureSet?: unknown };
+          };
+          const featureSet = typeof attributedTool.featureSet === 'string'
+            ? attributedTool.featureSet
+            : typeof attributedTool._meta?.featureSet === 'string'
+              ? attributedTool._meta.featureSet
+              : undefined;
           // MCP tool schemas are generic JSON Schema; cast to membrane's ToolDefinition format
           const schema = tool.inputSchema as import('./types/index.js').ToolDefinition['inputSchema'];
           tools.push({
-            name: `${prefix}--${tool.name}`,
+            name: namespacedName,
             description: tool.description ?? '',
             inputSchema: schema,
           });
+          if (featureSet !== undefined) {
+            toolFeatureSets.set(namespacedName, featureSet);
+          }
         }
       } catch {
         // Server may not support tools/list — skip silently
@@ -7848,6 +9557,7 @@ export class AgentFramework {
     }
 
     this.mcplTools = tools;
+    this.mcplToolFeatureSets = toolFeatureSets;
   }
 
   /**
@@ -7945,20 +9655,47 @@ export class AgentFramework {
     const args = (call.input && typeof call.input === 'object') ? call.input as Record<string, unknown> : {};
 
     // Build state params for stateful tools (Step 8).
-    // Host-managed state is single-valued per server, so inject the host-managed
-    // set's `state` for any call; otherwise fall back to a server-managed set's
-    // opaque `checkpoint`. Never blindly pick "first stateful" — when a server
-    // mixes host-managed (e.g. a feed) and server-managed (e.g. post/undo) sets,
-    // that misattributes the feed's state.
+    // A tools/list attribution selects that exact stateful set. Untagged tools
+    // retain the host-managed or unique server-managed fallback, but never guess
+    // between multiple server-managed sets.
     let stateParams: { state?: unknown; checkpoint?: string } | undefined;
+    let attributedFeatureSet: string | null = null;
     if (this.checkpointManager) {
-      const hostFs = this.checkpointManager.getHostManagedFeatureSet(serverId);
-      if (hostFs) {
-        stateParams = { state: this.checkpointManager.getCurrentState(serverId, hostFs) };
+      const toolFeatureSet = this.mcplToolFeatureSets.get(call.name);
+      if (toolFeatureSet !== undefined) {
+        if (
+          this.checkpointManager.isHostManaged(serverId, toolFeatureSet)
+          || this.checkpointManager.getStatefulFeatureSet(serverId, toolFeatureSet) !== null
+        ) {
+          attributedFeatureSet = toolFeatureSet;
+        } else {
+          console.warn(
+            `[mcpl] Tool "${call.name}" declares unknown or non-stateful feature set ` +
+            `"${toolFeatureSet}"; skipping state exchange.`,
+          );
+        }
       } else {
-        const fs = this.checkpointManager.getStatefulFeatureSet(serverId);
-        if (fs) {
-          const cp = this.checkpointManager.getCurrentCheckpoint(serverId, fs);
+        attributedFeatureSet = this.checkpointManager.getHostManagedFeatureSet(serverId)
+          ?? this.checkpointManager.getStatefulFeatureSet(serverId);
+        if (
+          attributedFeatureSet === null
+          && this.checkpointManager.hasAmbiguousServerManagedFeatureSets(serverId)
+        ) {
+          console.warn(
+            `[mcpl] Tool "${call.name}" has no feature-set attribution and server ` +
+            `"${serverId}" has multiple server-managed stateful feature sets; ` +
+            'skipping state exchange.',
+          );
+        }
+      }
+
+      if (attributedFeatureSet !== null) {
+        if (this.checkpointManager.isHostManaged(serverId, attributedFeatureSet)) {
+          stateParams = {
+            state: this.checkpointManager.getCurrentState(serverId, attributedFeatureSet),
+          };
+        } else {
+          const cp = this.checkpointManager.getCurrentCheckpoint(serverId, attributedFeatureSet);
           if (cp) stateParams = { checkpoint: cp };
         }
       }
@@ -7970,15 +9707,10 @@ export class AgentFramework {
         this.emitTrace({ type: 'tool:completed', module: `mcpl:${serverId}`, tool: toolName, callId: call.id, durationMs });
 
         // Record checkpoint from stateful tool response (Step 8).
-        // Attribute to the set the server tagged (result.state.featureSet) first;
-        // else the host-managed set (host-managed checkpoints carry data/patch);
-        // else the single stateful set. Avoids recording a feed checkpoint onto a
-        // server-managed set just because it registered first.
+        // Explicit response attribution is authoritative. Otherwise use the
+        // tool-derived (or safe single-set) attribution chosen before the call.
         if (result.state && this.checkpointManager) {
-          const tagged = result.state.featureSet;
-          const fs = tagged
-            ?? this.checkpointManager.getHostManagedFeatureSet(serverId)
-            ?? this.checkpointManager.getStatefulFeatureSet(serverId);
+          const fs = result.state.featureSet ?? attributedFeatureSet;
           if (fs && this.checkpointManager.isStateful(serverId, fs)) {
             this.checkpointManager.recordCheckpoint(serverId, fs, result.state);
           }
@@ -8003,6 +9735,23 @@ export class AgentFramework {
             this.channelRegistry
               .openIfClosedForSend(target, serverId)
               .then(({ status, channelId, label }) => {
+                // Turn-scoped engagement record (mid-turn re-pin, 2026-07-31
+                // n=7): a human follow-up in a channel the agent explicitly
+                // sent into this turn counts as conversationally addressed.
+                // Recorded here — not eagerly — because injection metadata
+                // carries the CANONICAL channel id (descriptor form), while
+                // send args often carry the raw provider id; this callback
+                // has the resolved form. The already-open path resolves on
+                // the microtask queue, i.e. before the tool-result event
+                // that evaluates injections.
+                if (status !== 'unknown-channel' && status !== 'ambiguous') {
+                  let engaged = this.turnEngagedChannels.get(agentName);
+                  if (!engaged) {
+                    engaged = new Set();
+                    this.turnEngagedChannels.set(agentName, engaged);
+                  }
+                  engaged.add(channelId ?? target);
+                }
                 if (status === 'opened') {
                   console.error(
                     `[channel] ${agentName}: explicit ${toolName} into closed channel ${target} — opened (send implies engagement)`,
@@ -8113,22 +9862,45 @@ export class AgentFramework {
     this.emitTrace({ type: 'tool:started', module: 'channels', tool: call.name, callId: call.id, input: call.input });
     const startTime = Date.now();
 
-    this.channelRegistry!.handleChannelToolCall(call.name, call.input)
+    this.channelRegistry!.handleChannelToolCall(call.name, call.input, { kind: 'agent', agentName })
       .then((result) => {
         const durationMs = Date.now() - startTime;
         this.emitTrace({ type: 'tool:completed', module: 'channels', tool: call.name, callId: call.id, durationMs });
         // A successful channel_open plants the agent's feet in the opened
-        // channel: pin it as this turn's reply locus so plain-text speech
-        // written right after opening routes THERE. Found live 2026-07-21
-        // (Aria bring-up): open → plain-text reply → "no locus (no
-        // home/active channel, defaultPublishChannel null)" on a turn with
-        // no channel trigger (post-restart continuation). Next turn start
-        // re-resolves the locus as usual (startAgentStream set/delete).
+        // channel. The agent's own deliberate open is the strongest "my next
+        // words go here" signal in the system — stronger than any injection —
+        // so it MOVES the current turn's prose pin (turnLocusPins), not just
+        // the next turn's trigger state. (The original 2026-07-21 Aria fix
+        // set only activeTriggerChannels, which resolveLocus reads at the
+        // NEXT turn's freeze — the turn-frozen refactor had silently
+        // regressed the "reply right after opening" case; found while
+        // mapping the routing logic 2026-07-31, antra-ratified fix.) The
+        // announcement rides THIS TOOL RESULT — model-requested content,
+        // distance zero, the safest role there is — instead of a separate
+        // window notice. lastAnnouncedLocus tracks it so announce-on-change
+        // stays coherent. Locus-mode agents only: explicit mode has no pin.
         if (call.name === 'channel_open' && result?.success) {
           const opened =
             (result.data as { channelId?: string } | undefined)?.channelId
             ?? (call.input as { channelId?: string } | undefined)?.channelId;
-          if (opened) this.activeTriggerChannels.set(agentName, opened);
+          if (opened) {
+            this.activeTriggerChannels.set(agentName, opened);
+            const openerAgent = this.agents.get(agentName);
+            if (openerAgent && openerAgent.proseRouting !== 'explicit') {
+              this.turnLocusPins.set(agentName, opened);
+              this.lastAnnouncedLocus.set(agentName, opened);
+              result = {
+                ...result,
+                data: {
+                  ...(result.data as Record<string, unknown> | undefined),
+                  routing: 'Your plain speech now lands in this channel. Other channels need an explicit send tool.',
+                },
+              };
+              console.error(
+                `[routing] ${agentName}: channel_open -> pin moved to ${opened} (announced in tool result)`,
+              );
+            }
+          }
         }
         this.pushEvent({
           type: 'tool-result',
@@ -8340,6 +10112,38 @@ export class AgentFramework {
         if (typeof input.path !== 'string' || input.path.length === 0) {
           throw new Error('read_image: `path` (mount-prefixed) is required');
         }
+        // Anthropic rejects images >5MB (and >8000px); guard the hard byte
+        // limit here — resizing is out of scope without an image library.
+        const MAX_IMAGE_BYTES = 5 * 1024 * 1024;
+        // Prefer the workspace module's own read_image handler when it exists:
+        // it reads tree-first with a FILESYSTEM FALLBACK, so binaries that live
+        // only on disk (shell-created files, pre-fix mangled tree blobs) still
+        // render. The legacy tree-only path below stays for older workspace
+        // modules that don't advertise the tool.
+        if (
+          typeof workspace.handleToolCall === 'function' &&
+          typeof workspace.getTools === 'function' &&
+          workspace.getTools().some((tool) => tool.name === 'read_image')
+        ) {
+          const result = await workspace.handleToolCall({ ...call, name: 'read_image' });
+          if (result.success && Array.isArray(result.data)) {
+            const image = result.data.find(
+              (block): block is { type: 'image'; data: string; mimeType: string } =>
+                typeof block === 'object' && block !== null &&
+                (block as { type?: unknown }).type === 'image' &&
+                typeof (block as { data?: unknown }).data === 'string',
+            );
+            const byteLength = image ? Math.floor((image.data.length * 3) / 4) : 0;
+            if (byteLength > MAX_IMAGE_BYTES) {
+              throw new Error(
+                `read_image: "${input.path}" is ~${byteLength} bytes — ` +
+                `over the ${MAX_IMAGE_BYTES}-byte model limit`,
+              );
+            }
+          }
+          finish(result);
+          return;
+        }
         const read = await workspace.readBinary(input.path);
         if ('error' in read) throw new Error(read.error);
         const mediaType = sniffImageMediaType(read.data);
@@ -8349,9 +10153,6 @@ export class AgentFramework {
             '(png/jpeg/gif/webp — checked by magic bytes, not extension)',
           );
         }
-        // Anthropic rejects images >5MB (and >8000px); guard the hard byte
-        // limit here — resizing is out of scope without an image library.
-        const MAX_IMAGE_BYTES = 5 * 1024 * 1024;
         if (read.data.byteLength > MAX_IMAGE_BYTES) {
           throw new Error(
             `read_image: "${input.path}" is ${read.data.byteLength} bytes — ` +
@@ -8525,6 +10326,83 @@ export class AgentFramework {
     })();
   }
 
+  /** The `utils` meta-tool: list/describe/run over module utilities
+   *  (Module.getUtilities). Shared by the model-facing dispatcher and the
+   *  programmatic path (executeToolCall), so code_execution scripts and
+   *  ephemerals reach utilities too. */
+  private async handleUtilsToolCall(agentName: string, call: ToolCall): Promise<ToolResult> {
+    const input = (call.input ?? {}) as { action?: unknown; name?: unknown; args?: unknown };
+    const utilities = this.moduleRegistry.getAllUtilities();
+    const available = (): string =>
+      utilities.length ? utilities.map((u) => u.name).join(', ') : '(none registered)';
+    switch (input.action) {
+      case 'list':
+        return {
+          success: true,
+          data: utilities.map((u) => ({ name: u.name, description: utilityOneLiner(u.description) })),
+        };
+      case 'describe': {
+        const def = utilities.find((u) => u.name === input.name);
+        if (!def) {
+          return { success: false, isError: true, error: `No utility "${String(input.name)}". Available: ${available()}` };
+        }
+        return { success: true, data: def };
+      }
+      case 'run': {
+        const def = utilities.find((u) => u.name === input.name);
+        if (!def) {
+          return { success: false, isError: true, error: `No utility "${String(input.name)}". Available: ${available()}` };
+        }
+        const args = input.args ?? {};
+        const problem = validateUtilityArgs(args, def.inputSchema);
+        if (problem) {
+          // Teach by bounce: the error carries the schema, so the retry needs
+          // no describe round-trip.
+          return {
+            success: false,
+            isError: true,
+            error: `${problem}. Schema for ${def.name}: ${JSON.stringify(def.inputSchema)}`,
+          };
+        }
+        // Same dispatch as a first-class tool call — the module cannot tell
+        // which surface the call came through.
+        return this.moduleRegistry.handleToolCall({
+          id: call.id,
+          name: def.name,
+          input: args,
+          callerAgentName: agentName,
+        });
+      }
+      default:
+        return { success: false, isError: true, error: 'action must be "list", "describe", or "run"' };
+    }
+  }
+
+  private dispatchUtilsToolCall(agentName: string, call: ToolCall): void {
+    this.emitTrace({ type: 'tool:started', module: 'framework', tool: 'utils', callId: call.id, input: call.input });
+    const startedAt = Date.now();
+    void this.handleUtilsToolCall(agentName, call)
+      .catch((err): ToolResult => ({
+        success: false,
+        error: err instanceof Error ? err.message : String(err),
+        isError: true,
+      }))
+      .then((result) => {
+        if (result.success) {
+          this.emitTrace({ type: 'tool:completed', module: 'framework', tool: 'utils', callId: call.id, durationMs: Date.now() - startedAt });
+        } else {
+          this.emitTrace({ type: 'tool:failed', module: 'framework', tool: 'utils', callId: call.id, error: result.error ?? 'unknown error' });
+        }
+        this.pushEvent({
+          type: 'tool-result',
+          callId: call.id,
+          agentName,
+          moduleName: 'framework',
+          result,
+        });
+      });
+  }
+
   private dispatchAgentSettingsToolCall(agentName: string, call: ToolCall): void {
     this.emitTrace({
       type: 'tool:started',
@@ -8775,12 +10653,11 @@ export class AgentFramework {
       conversationId: agent.name,
       turnIndex: 0, // Simplified; needs per-conversation counter TODO
       userMessage: null, // Could extract from trigger context
-      model: {
-        id: agent.model,
-        vendor: 'unknown',
-        contextWindow: 200000,
-        capabilities: ['tools'],
-      },
+      // Truthful fields only (§10.1 honesty over completeness): id is real,
+      // vendor/contextWindow/capabilities have no source in this host and
+      // are omitted rather than fabricated — the hardcoded 200000 was false
+      // for residents configured at 300k/600k.
+      model: { id: agent.model },
       channels: this.channelRegistry?.buildChannelContext(agent.name),
     };
   }