@animalabs/agent-framework 0.6.6 → 0.6.7

package/src/framework.ts

@@ -1,14 +1,19 @@
 import { join } from 'node:path';
 import { appendFileSync, mkdirSync } from 'node:fs';
+import { createHash } from 'node:crypto';
 import { JsStore } from '@animalabs/chronicle';
-import type { Membrane, ContentBlock, NormalizedRequest, YieldingStream, ToolResult as MembraneToolResult, ToolResultContentBlock } from '@animalabs/membrane';
+import type { Membrane, ContentBlock, NormalizedRequest, NormalizedResponse, YieldingStream, ToolResult as MembraneToolResult, ToolResultContentBlock } from '@animalabs/membrane';
 import { MembraneError } from '@animalabs/membrane';
 import { ContextManager, PassthroughStrategy } from '@animalabs/context-manager';
 import type {
+  BranchGenerationInfo,
   MessageId,
   MessageMetadata,
   MessageQuery,
   MessageQueryResult,
+  PrimarySummaryContract,
+  PrimarySummaryIdentity,
+  PrimarySummaryProjection,
   StoredMessage,
 } from '@animalabs/context-manager';
 import type {
@@ -47,9 +52,11 @@ import type {
   AgentRuntimeSettingsPatch,
   AgentRuntimeSettingsOverrides,
   AgentRuntimeSettingsSnapshot,
+  AgentSettingsExtension,
+  SameRoundThinkTextPolicy,
 } from './types/index.js';
 import { ProcessQueueImpl } from './queue.js';
-import { Agent } from './agent.js';
+import { Agent, type ActivationCompileArtifacts } 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';
@@ -60,8 +67,10 @@ import { InferenceRouter } from './mcpl/inference-router.js';
 import { ChannelRegistry } 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 { splitProseSegments } from './prose-segments.js';
+import { canonicalJsonStringify } from './canonical-json.js';
 
 /**
  * Tools whose presence suppresses auto-routing of the surrounding prose,
@@ -71,15 +80,14 @@ import { splitProseSegments } from './prose-segments.js';
  *   - explicit delivery tools (channel_publish / *send_message /
  *     *reply_message / *send_dm) — already sent the message, so routing the
  *     prose again would double-post.
- * `think` is deliberately NOT here: it is silent *reasoning*, but prose
- * written around a think is the agent's actual voice and must be delivered.
+ * `think` is deliberately NOT here: it is silent *reasoning*, and same-round
+ * prose beside it is governed separately by same_round_think_text_policy.
  *
- * Scope: mid-turn rounds apply this PER ROUND (a round's prose is suppressed
- * only by a silencing tool in that same round — live delivery can't be
- * retracted by a later round's skip_reply); the turn's TRAILING prose keeps
- * the historical turn-wide rule (any silencing tool anywhere in the turn
- * suppresses it), preserving the "send_message then 'sent it.' postscript"
- * double-post guard.
+ * Scope: an explicit delivery suppresses prose from that round onward until
+ * another external message is injected. The suppression prevents a
+ * `send_message` followed by "sent it" from double-posting, but a new message
+ * starts a new conversational round and must be answerable with plain prose.
+ * `skip_reply` ends the turn at the tool-result boundary.
  */
 const SILENCING_TOOLS = new Set([
   'skip_reply', 'channel_publish', 'send_message', 'reply_message', 'send_dm',
@@ -108,16 +116,31 @@ import type {
 } from './mcpl/types.js';
 import type { ContextInjection } from '@animalabs/context-manager';
 import { formatZonedDateTime, resolveTimeZone } from './timezone.js';
+import {
+  DEFAULT_DISCORD_AWARENESS_EMOJI,
+  DiscordAwarenessOutbox,
+  defaultDiscordAwarenessOutboxPath,
+  extractDiscordAwarenessRefs,
+} from './recovery/discord-awareness-outbox.js';
 
 const FRAMEWORK_STATE_ID = 'framework/state';
 const CONVERSATION_ROUTER_STATE_ID = 'framework/conversation-router';
 const INFERENCE_LOG_ID = 'framework/inference-log';
 const PROCESS_LOG_ID = 'framework/process-log';
+const PRIMARY_SUMMARY_FALLBACK_STATE_ID = 'framework/primary-summary-fallback';
+const PRIMARY_SUMMARY_SETTLEMENT_METADATA_KEY = 'primarySummarySettlement';
+const PRIMARY_SUMMARY_SETTLEMENT_VERSION = 1;
+const PRIMARY_SUMMARY_SETTLEMENT_MAX_ID_LENGTH = 1024;
+const PRIMARY_SUMMARY_SETTLEMENT_MAX_NAME_LENGTH = 256;
+const PRIMARY_SUMMARY_SETTLEMENT_MAX_REASON_LENGTH = 256;
 const TURN_CHECKPOINTS_ID = 'framework/turn-checkpoints'; // legacy single-map layout, read-only fallback
 const TURN_CHECKPOINTS_TREE_ID = 'framework/turn-checkpoints/tree';
 
 /** Maximum number of turn checkpoints to keep per agent. */
 const MAX_TURN_CHECKPOINTS = 20;
+const DEFAULT_DISCORD_AWARENESS_DEADLINE_MS = 10_000;
+const MIN_DISCORD_AWARENESS_DEADLINE_MS = 50;
+const MAX_DISCORD_AWARENESS_DEADLINE_MS = 60_000;
 
 interface TurnCheckpoint {
   agentName: string;
@@ -127,11 +150,165 @@ interface TurnCheckpoint {
   timestamp: number;
 }
 
+type DiscordAwarenessDrainOutcome =
+  | { status: 'delivered'; delivered: number; failed: number }
+  | { status: 'unavailable'; accounted: number };
+
+interface DiscordAwarenessBarrier {
+  generation: number;
+  requiresBarrier: boolean;
+  promise: Promise<DiscordAwarenessDrainOutcome>;
+}
+
+function normalizeDiscordAwarenessDeadline(value: number | undefined): number {
+  if (value === undefined || !Number.isFinite(value) || value <= 0) {
+    return DEFAULT_DISCORD_AWARENESS_DEADLINE_MS;
+  }
+  return Math.max(
+    MIN_DISCORD_AWARENESS_DEADLINE_MS,
+    Math.min(MAX_DISCORD_AWARENESS_DEADLINE_MS, Math.floor(value)),
+  );
+}
+
+class DiscordAwarenessAccountingError extends Error {
+  constructor(operation: string, cause: unknown) {
+    const detail = cause instanceof Error ? cause.message : String(cause);
+    super(`Discord awareness accounting failed during ${operation}: ${detail}`, { cause });
+    this.name = 'DiscordAwarenessAccountingError';
+  }
+}
+
 interface RedoEntry {
   branchName: string;
   checkpoint: TurnCheckpoint;
 }
 
+interface InferenceToolSnapshot {
+  sameRoundThinkTextPolicy: SameRoundThinkTextPolicy;
+}
+
+type PrimarySummaryFallbackStatus =
+  | 'success'
+  | 'refusal'
+  | 'held'
+  | 'pending'
+  | 'error'
+  | 'timeout_unknown';
+
+interface PrimarySummaryFallbackRetryDispatch {
+  originalRequestId: string;
+  baselineRequestId: string;
+  intentId: string;
+  branch: { id: string; generation: number };
+  candidateSummaries: PrimarySummaryIdentity[];
+  originalArtifacts: ActivationCompileArtifacts;
+  originalProjectionKeys: string[];
+  expectedRetryRequestHash: string;
+  requestBudgetTokens: number;
+  originalRequestInputBoundTokens: number;
+  originalProviderInputTokens?: number;
+}
+
+interface PrimarySummaryFallbackIntentRecord {
+  intentId: string;
+  createdAt: number;
+  baselineRequestId: string;
+  candidateSummaries: PrimarySummaryIdentity[];
+  retryRequestHash: string;
+  retryCompleteBoundTokens: number;
+  requestBudgetTokens: number;
+  retryRequestId?: string;
+  dispatchedAt?: number;
+  quarantinePersistedAt?: number;
+  outputs?: PrimarySummaryFallbackOutputRecord[];
+  toolDispatches?: PrimarySummaryFallbackToolDispatchRecord[];
+  finalizedAt?: number;
+}
+
+interface PrimarySummaryFallbackOutputRecord {
+  phase: string;
+  contentHash: string;
+  messageId: string;
+  blockTypes: string[];
+  persistedAt: number;
+}
+
+type PrimarySummarySettlementOutcome = 'success' | 'held';
+type PrimarySummarySettlementRole = 'assistant' | 'user';
+type PrimarySummarySettlementKind = 'assistant_output' | 'generated_tool_result';
+
+interface PrimarySummarySettlementMetadata {
+  version: number;
+  requestId: string;
+  settlementId: string;
+  agentName: string;
+  dispatchKind: PrimarySummaryRequestRecord['dispatchKind'];
+  outcome: PrimarySummarySettlementOutcome;
+  stopReason?: string;
+  holdReason?: string;
+  providerInputTokens?: number;
+  visibleAssistantOutput: boolean;
+  executedToolCalls: number;
+  branch: { id: string; name: string; generation: number };
+  role: PrimarySummarySettlementRole;
+  kind: PrimarySummarySettlementKind;
+  entryIndex: number;
+  entryCount: number;
+}
+
+interface PrimarySummaryLogicalSettlementEntry {
+  messages: StoredMessage[];
+  settlement: PrimarySummarySettlementMetadata;
+  participant: string;
+  content: ContentBlock[];
+  bodyGroupId?: string;
+}
+
+interface PrimarySummaryFallbackToolDispatchRecord {
+  callId: string;
+  inputHash: string;
+  recordedAt: number;
+}
+
+interface PrimarySummaryRequestRecord {
+  requestId: string;
+  agentName: string;
+  namespace: string;
+  timestamp: number;
+  dispatchKind: 'primary' | 'primary_summary_fallback_retry';
+  branch: { id: string; name: string; generation: number };
+  projection: PrimarySummaryProjection | null;
+  requestInputBoundTokens: number;
+  requestCompleteBoundTokens: number;
+  providerInputTokens?: number;
+  systemHash: string;
+  modelConfigHash: string;
+  toolContractHash: string;
+  stopReason?: string;
+  visibleAssistantOutput: boolean;
+  executedToolCalls: number;
+  finalStatus: PrimarySummaryFallbackStatus;
+  fallbackIntent?: PrimarySummaryFallbackIntentRecord;
+  fallbackStatus?: PrimarySummaryFallbackStatus;
+  fallbackHeldReason?: string;
+}
+
+interface PrimarySummaryFallbackState {
+  requests: PrimarySummaryRequestRecord[];
+}
+
+interface ContextBudgetRestartDispatch {
+  requestId: string;
+  dispatchKind: 'primary' | 'primary_summary_fallback_retry';
+  originalRequestId?: string;
+  intentId?: string;
+}
+
+interface PendingInferenceRequest extends InferenceRequest {
+  primarySummaryFallbackRetry?: PrimarySummaryFallbackRetryDispatch;
+  contextBudgetRestart?: ContextBudgetRestartDispatch;
+}
+
 /**
  * Default inference policy - infer if any request exists for the agent.
  */
@@ -145,6 +322,11 @@ class DefaultInferencePolicy implements InferencePolicy {
   }
 }
 
+function isPermanentDiscordReactionFailure(message: string): boolean {
+  return /unknown message|unknown channel|missing access|missing permissions|missing permission|cannot access|channel .* not found|message .* not found/i
+    .test(message);
+}
+
 /**
  * Default error policy - retry with exponential backoff.
  *
@@ -274,6 +456,13 @@ interface EphemeralRun {
   toolCallsCount: number;
 }
 
+interface ActiveStreamContext {
+  requestId: string;
+  trigger?: PendingInferenceRequest;
+  compiledRequest?: NormalizedRequest;
+  artifacts?: ActivationCompileArtifacts;
+}
+
 /** Cap an API error message for inline use in a rewind marker: keep enough to
  *  identify the failure class without pasting a wall of provider JSON into the
  *  agent's context. */
@@ -290,7 +479,7 @@ export class AgentFramework {
   private moduleRegistry: ModuleRegistry;
   private inferencePolicy: InferencePolicy;
   private errorPolicy: ErrorPolicy;
-  private pendingRequests: InferenceRequest[] = [];
+  private pendingRequests: PendingInferenceRequest[] = [];
   /**
    * Per-agent channel that triggered the agent's CURRENT inference turn, if any
    * (item-3 redux). Read by the ChannelRegistry's `activeChannelResolver` to
@@ -312,20 +501,30 @@ export class AgentFramework {
   private maintenanceRunId = 0;
   private currentMaintenanceRun: ContextMaintenanceRun | null = null;
   private maintenanceHistory: ContextMaintenanceRun[] = [];
-  /** Last time we console-warned about stale (busy-requeued) inference requests, per agent. */
+  /** Last time we reported stale (busy-requeued) inference requests, per agent. */
   private staleWarnAt = new Map<string, number>();
   /** Per-agent last inference activity (epoch ms), for /healthz + doctor tooling. */
   private lastInferenceAt = new Map<string, { startedAt?: number; endedAt?: number; failedAt?: number; lastError?: string }>();
   private processLoggingPersist: boolean;
   private processLoggingBroadcast: boolean;
   private activeStreams: Map<string, Promise<void>> = new Map();
+  private activeStreamContexts: Map<string, ActiveStreamContext> = new Map();
+  private primarySummaryStateLock: Promise<void> = Promise.resolve();
 
   /** Per-agent output locus pinned for the CURRENT logical turn (see
    *  resolveTurnLocus in driveStream). 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 at the
-   *  start of every non-restart turn. */
+   *  continues the same logical turn in a fresh driveStream. A mid-turn
+   *  injected channel message replaces the pin for the next conversational
+   *  round; otherwise it remains stable. Cleared at the start of every
+   *  non-restart turn. */
   private turnLocusPins: Map<string, string> = new Map();
+  /** A tool boundary injected fresh external input into the live stream.
+   *  Presence (including a null value) tells driveStream to clear sticky
+   *  explicit-send suppression before handling the next model round. A
+   *  string also moves that round's reply locus to the newest injected
+   *  channel. */
+  private midTurnRoutingResets: Map<string, string | null> = new Map();
   private pendingAssistantBlocks: Map<string, ContentBlock[]> = new Map();
   /** Streams the FRAMEWORK cancelled for non-terminal reasons, keyed
    *  `${agentName}:${streamId}`: an endTurn tool result or a context-budget
@@ -439,6 +638,15 @@ export class AgentFramework {
    *  subsystem can be lazily initialized by connectMcplServer when the
    *  framework started with zero configured servers. */
   private mcplInferenceRoutingConfig: import('./mcpl/types.js').InferenceRoutingPolicy | null = null;
+  /** Durable, non-Chronicle projection queue for messages removed by a branch. */
+  private discordAwarenessOutbox: DiscordAwarenessOutbox | null = null;
+  private discordAwarenessEmoji = DEFAULT_DISCORD_AWARENESS_EMOJI;
+  private discordAwarenessDeadlineMs = DEFAULT_DISCORD_AWARENESS_DEADLINE_MS;
+  /** Serialize per-server drains so reconnect and an online undo cannot race. */
+  private discordAwarenessDrains: Map<string, Promise<DiscordAwarenessDrainOutcome>> = new Map();
+  /** Framework-global inference gate; older generations cannot release it. */
+  private discordAwarenessBarrier: DiscordAwarenessBarrier | null = null;
+  private discordAwarenessBarrierGeneration = 0;
 
   // EventGate (null when FrameworkConfig.gate is omitted)
   private eventGate: EventGate | null = null;
@@ -459,6 +667,9 @@ export class AgentFramework {
     processLoggingPersist: boolean,
     processLoggingBroadcast: boolean,
     timeZone: string,
+    discordAwarenessOutbox: DiscordAwarenessOutbox | null,
+    discordAwarenessEmoji: string,
+    discordAwarenessDeadlineMs: number,
   ) {
     this.store = store;
     this.ownsStore = ownsStore;
@@ -470,6 +681,9 @@ export class AgentFramework {
     this.processLoggingPersist = processLoggingPersist;
     this.processLoggingBroadcast = processLoggingBroadcast;
     this.timeZone = timeZone;
+    this.discordAwarenessOutbox = discordAwarenessOutbox;
+    this.discordAwarenessEmoji = discordAwarenessEmoji;
+    this.discordAwarenessDeadlineMs = discordAwarenessDeadlineMs;
     this.queue = new ProcessQueueImpl();
     this.usageTracker = new UsageTracker({
       emitTrace: (e: UsageUpdatedEvent) => this.emitTrace({ ...e }),
@@ -551,6 +765,18 @@ export class AgentFramework {
       }
     }
 
+    try {
+      store.registerState({ id: PRIMARY_SUMMARY_FALLBACK_STATE_ID, strategy: 'snapshot' });
+    } catch {
+      // Already registered
+    }
+
+    const discordAwarenessOutboxPath = config.discordAwarenessOutboxPath
+      ?? (config.storePath ? defaultDiscordAwarenessOutboxPath(config.storePath) : undefined);
+    const discordAwarenessOutbox = discordAwarenessOutboxPath
+      ? new DiscordAwarenessOutbox(discordAwarenessOutboxPath)
+      : null;
+
     const framework = new AgentFramework(
       store,
       ownsStore,
@@ -562,16 +788,46 @@ export class AgentFramework {
       processLoggingPersist,
       processLoggingBroadcast,
       resolveTimeZone(config.timeZone),
+      discordAwarenessOutbox,
+      config.discordAwarenessEmoji ?? DEFAULT_DISCORD_AWARENESS_EMOJI,
+      normalizeDiscordAwarenessDeadline(config.discordAwarenessDeadlineMs),
     );
 
-    // Restore persisted usage data (if any) from prior session
-    framework.restoreUsageState();
+    // If an offline recovery process crashed after switching Chronicle but
+    // before committing its prepared marker batch, the active branch is the
+    // commit record. Promote it now; no quarantined content is read.
+    if (discordAwarenessOutbox) {
+      try {
+        const activated = discordAwarenessOutbox.activatePreparedForBranch(
+          store.currentBranch().name,
+          store.listBranches(),
+        );
+        if (activated > 0) {
+          console.error(
+            `[discord-awareness] recovered ${activated} prepared batch(es) for active branch ${store.currentBranch().name}`,
+          );
+        }
+      } catch (error) {
+        // The branch may be safe, but reporting the framework ready while its
+        // durable awareness projection is unreadable creates a half-ready
+        // host whose data plane can never be released safely.
+        throw new DiscordAwarenessAccountingError('startup reconciliation', error);
+      }
+    }
 
     // Create agents
     for (const agentConfig of config.agents) {
       await framework.createAgent(agentConfig);
     }
 
+    // Restore persisted usage data (if any) from prior session
+    framework.restoreUsageState();
+    await framework.reconcilePrimarySummaryFallbackStateOnStartup();
+
+    // Finish any branch-local suppression interrupted after Chronicle switched
+    // branches. This runs before modules, MCPL connections, or inbound traffic.
+    await framework.resumePreparedDiscordSuppressions();
+
     // Add modules
     for (const module of config.modules) {
       await framework.addModule(module);
@@ -821,11 +1077,10 @@ export class AgentFramework {
   }
 
   private async runQueuedMaintenance(): Promise<void> {
-    const allTools = this.getAllTools();
     const queued = [...this.agents.values()].flatMap((agent) => {
       const cm = agent.getContextManager();
-      const tools = allTools.filter((tool) => agent.canUseTool(tool.name));
-      cm.setToolDefinitions(tools);
+      const tools = this.getToolsForAgent(agent.name).filter((tool) => agent.canUseTool(tool.name));
+      cm.setToolDefinitions?.(tools);
       if (cm.isReady()) return [];
       const pending = cm.getPendingWork()?.description;
       const progress = this.contextProgress(cm);
@@ -1028,10 +1283,138 @@ export class AgentFramework {
       ...this.mcplTools,
       ...channelTools,
       ...gateTools,
-      AgentFramework.AGENT_SETTINGS_TOOL,
+      this.buildAgentSettingsTool(),
+      ...(this.getWorkspaceModule() ? [AgentFramework.SAVE_IMAGE_TOOL] : []),
     ];
   }
 
+  /** The registered workspace module, if any (used by save_image). */
+  private getWorkspaceModule(): WorkspaceModule | undefined {
+    const module = this.moduleRegistry.getAllModules().find((m) => m.name === 'workspace');
+    return module && typeof (module as WorkspaceModule).writeBinary === 'function'
+      ? (module as WorkspaceModule)
+      : undefined;
+  }
+
+  /** Core agent_settings keys — extension keys must not collide with these. */
+  private static readonly AGENT_SETTINGS_CORE_KEYS = [
+    'context_budget_tokens',
+    'tail_tokens',
+    'transition_pace_tokens',
+    'same_round_think_text_policy',
+  ];
+
+  /**
+   * Collect module-declared agent_settings extensions (Module.getAgentSettingsExtension),
+   * keyed by owning module name. Extensions whose keys collide with the core
+   * settings or an earlier extension are skipped loudly — silent shadowing
+   * would make updates route to the wrong owner.
+   */
+  private collectAgentSettingsExtensions(): Map<string, AgentSettingsExtension> {
+    const result = new Map<string, AgentSettingsExtension>();
+    const taken = new Set<string>(AgentFramework.AGENT_SETTINGS_CORE_KEYS);
+    for (const module of this.moduleRegistry.getAllModules()) {
+      const ext = module.getAgentSettingsExtension?.();
+      if (!ext) continue;
+      const collision = ext.keys.find((k) => taken.has(k));
+      if (collision) {
+        console.error(
+          `[agent-settings] extension from module '${module.name}' skipped: key '${collision}' already taken`,
+        );
+        continue;
+      }
+      ext.keys.forEach((k) => taken.add(k));
+      result.set(module.name, ext);
+    }
+    return result;
+  }
+
+  private captureInferenceToolSnapshot(agent: Agent): InferenceToolSnapshot {
+    return {
+      sameRoundThinkTextPolicy: agent.getEffectiveSameRoundThinkTextPolicy(),
+    };
+  }
+
+  private buildThinkTool(
+    policy: SameRoundThinkTextPolicy,
+  ): import('./types/index.js').ToolDefinition {
+    return {
+      name: 'think',
+      description:
+        'Reason privately. The think({content}) argument stays in your own context and is NOT sent ' +
+        'to channels or other surfaces. ' +
+        (policy === 'private'
+          ? 'Your current same_round_think_text_policy is private, so ordinary text emitted in the SAME native assistant round as think() is withheld from channel routing. Later rounds without think() route normally.'
+          : 'Your current same_round_think_text_policy is public, so ordinary text emitted in the SAME native assistant round as think() may still be routed publicly as your speech. Later rounds without think() route normally.'
+        ) +
+        ' Use think() to work things out privately. To inspect or change this policy, use agent_settings get/update on same_round_think_text_policy. To deliberately not reply this turn, call skip_reply instead.',
+      inputSchema: {
+        type: 'object' as const,
+        properties: {
+          content: {
+            type: 'string',
+            description: 'Your private thought / reasoning (optional; not sent anywhere).',
+          },
+        },
+        required: [],
+      },
+    };
+  }
+
+  /** agent_settings tool definition with module extension fields merged in. */
+  private buildAgentSettingsTool(): import('./types/index.js').ToolDefinition {
+    const base = AgentFramework.AGENT_SETTINGS_TOOL;
+    const extensions = this.collectAgentSettingsExtensions();
+    if (extensions.size === 0) return base;
+    const baseSchema = base.inputSchema as {
+      type: string;
+      properties: Record<string, unknown>;
+      required?: string[];
+    };
+    const extProperties: Record<string, unknown> = {};
+    const extKeys: string[] = [];
+    for (const ext of extensions.values()) {
+      Object.assign(extProperties, ext.properties);
+      extKeys.push(...ext.keys);
+    }
+    const settingsProp = baseSchema.properties.settings as { items?: { enum?: string[] } };
+    return {
+      ...base,
+      description:
+        base.description +
+        ` Additional host-managed settings also live here: ${extKeys.join(', ')}.`,
+      inputSchema: {
+        ...baseSchema,
+        properties: {
+          ...baseSchema.properties,
+          ...extProperties,
+          settings: {
+            ...(baseSchema.properties.settings as Record<string, unknown>),
+            items: {
+              ...(settingsProp.items as Record<string, unknown>),
+              enum: [...(settingsProp.items?.enum ?? []), ...extKeys],
+            },
+          },
+        },
+      } as unknown as import('./types/index.js').ToolDefinition['inputSchema'],
+    };
+  }
+
+  private getToolsForAgent(
+    agentName: string,
+    snapshot?: InferenceToolSnapshot,
+  ): import('./types/index.js').ToolDefinition[] {
+    return this.getAllTools().map((tool) => {
+      if (tool.name === 'think') {
+        return this.buildThinkTool(
+          snapshot?.sameRoundThinkTextPolicy
+            ?? this.getAgentRuntimeSettings(agentName).sameRoundThinkTextPolicy,
+        );
+      }
+      return tool;
+    });
+  }
+
   getAgentRuntimeSettings(agentName: string): AgentRuntimeSettingsSnapshot {
     const agent = this.agents.get(agentName);
     if (!agent) throw new Error(`Unknown agent: ${agentName}`);
@@ -1124,7 +1507,7 @@ export class AgentFramework {
       throw new Error(`Agent not found: ${agentName}`);
     }
 
-    const tools = this.getAllTools().filter((t) => agent.canUseTool(t.name));
+    const tools = this.getToolsForAgent(agentName).filter((t) => agent.canUseTool(t.name));
 
     // Default: no dynamic injection gathering → fully transparent (no
     // inference, no Chronicle writes, no external RPC). Opt in explicitly.
@@ -1279,6 +1662,22 @@ export class AgentFramework {
     }
   }
 
+  private validatePersistedAgentRuntimeSettings(
+    agentName: string,
+    overrides: AgentRuntimeSettingsOverrides,
+  ): AgentRuntimeSettingsOverrides {
+    if (
+      overrides.sameRoundThinkTextPolicy !== undefined &&
+      overrides.sameRoundThinkTextPolicy !== 'public' &&
+      overrides.sameRoundThinkTextPolicy !== 'private'
+    ) {
+      throw new Error(
+        `Invalid persisted sameRoundThinkTextPolicy for agent "${agentName}": ${JSON.stringify(overrides.sameRoundThinkTextPolicy)}`,
+      );
+    }
+    return overrides;
+  }
+
   private persistAgentRuntimeSettings(
     agentName: string,
     overrides: AgentRuntimeSettingsOverrides,
@@ -1329,17 +1728,1333 @@ export class AgentFramework {
       // Data persists in the store under the namespace for investigation.
     };
 
-    return { agent, contextManager, cleanup };
+    return { agent, contextManager, cleanup };
+  }
+
+  private createDeferred<T>(): Deferred<T> {
+    let resolve!: (value: T) => void;
+    let reject!: (reason?: unknown) => void;
+    const promise = new Promise<T>((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+    return { promise, resolve, reject };
+  }
+
+  private hashJson(value: unknown): string {
+    return createHash('sha256').update(canonicalJsonStringify(value), 'utf8').digest('hex');
+  }
+
+  private estimateStringTokens(text: string, overhead = 0): number {
+    return Math.ceil(Buffer.byteLength(text, 'utf8') / 4) + overhead;
+  }
+
+  private estimateUnknownTokens(value: unknown, overhead = 0): number {
+    return this.estimateStringTokens(JSON.stringify(value) ?? 'null', overhead);
+  }
+
+  private estimateRequestInputBoundTokens(request: NormalizedRequest): number {
+    let total = 96;
+    total += this.estimateStringTokens(request.system ?? '', 48);
+    for (const message of request.messages) {
+      total += 24;
+      total += this.estimateStringTokens(message.participant, 8);
+      if ((message as { cacheBreakpoint?: boolean }).cacheBreakpoint) total += 8;
+      for (const block of message.content) {
+        switch (block.type) {
+          case 'text':
+            total += this.estimateStringTokens(block.text, 24);
+            break;
+          case 'thinking':
+            total += this.estimateStringTokens(block.thinking, 32);
+            total += block.signature ? this.estimateStringTokens(block.signature, 8) : 0;
+            break;
+          case 'redacted_thinking':
+            total += this.estimateUnknownTokens(block, 32);
+            break;
+          default:
+            total += this.estimateUnknownTokens(block, 32);
+            break;
+        }
+      }
+    }
+    if (request.tools && request.tools.length > 0) {
+      total += 32;
+      for (const tool of request.tools) {
+        total += this.estimateUnknownTokens({
+          name: tool.name,
+          description: tool.description,
+          inputSchema: tool.inputSchema,
+        }, 48);
+      }
+    }
+    total += this.estimateUnknownTokens(request.config, 48);
+    if (request.providerParams !== undefined) {
+      total += this.estimateUnknownTokens(request.providerParams, 32);
+    }
+    total += request.promptCaching ? 16 : 0;
+    total += request.cacheTtl ? this.estimateStringTokens(request.cacheTtl, 8) : 0;
+    total += request.assistantParticipant
+      ? this.estimateStringTokens(request.assistantParticipant, 8)
+      : 0;
+    return total;
+  }
+
+  private estimateRequestCompleteBoundTokens(request: NormalizedRequest): number {
+    const reserve = typeof request.config.maxTokens === 'number' && Number.isFinite(request.config.maxTokens)
+      ? request.config.maxTokens
+      : 0;
+    return this.estimateRequestInputBoundTokens(request) + reserve + 96;
+  }
+
+  private primarySummaryAdmissionBoundTokens(
+    originalRequestInputTokens: number,
+    expandedRequest: NormalizedRequest,
+    originalProviderInputTokens: number | undefined,
+  ): number {
+    const expandedInput = this.estimateRequestInputBoundTokens(expandedRequest);
+    const expandedComplete = this.estimateRequestCompleteBoundTokens(expandedRequest);
+    if (originalProviderInputTokens === undefined) return expandedComplete;
+    const reserve = typeof expandedRequest.config.maxTokens === 'number' && Number.isFinite(expandedRequest.config.maxTokens)
+      ? expandedRequest.config.maxTokens
+      : 0;
+    const positiveDelta = Math.max(0, expandedInput - originalRequestInputTokens);
+    return Math.max(
+      expandedComplete,
+      originalProviderInputTokens + positiveDelta + reserve + 96,
+    );
+  }
+
+  private readPrimarySummaryFallbackState(): PrimarySummaryFallbackState {
+    const raw = (this.store as { getStateJson?: (id: string) => unknown } | undefined)
+      ?.getStateJson?.(PRIMARY_SUMMARY_FALLBACK_STATE_ID);
+    if (!raw || typeof raw !== 'object') return { requests: [] };
+    const requests = Array.isArray((raw as { requests?: unknown[] }).requests)
+      ? ((raw as { requests: PrimarySummaryRequestRecord[] }).requests)
+      : [];
+    return { requests };
+  }
+
+  private writePrimarySummaryFallbackState(state: PrimarySummaryFallbackState): void {
+    this.store.setStateJson(PRIMARY_SUMMARY_FALLBACK_STATE_ID, state);
+  }
+
+  private async withPrimarySummaryStateLock<T>(work: () => Promise<T> | T): Promise<T> {
+    const previous = this.primarySummaryStateLock;
+    let release!: () => void;
+    this.primarySummaryStateLock = new Promise<void>((resolve) => { release = resolve; });
+    await previous;
+    try {
+      return await work();
+    } finally {
+      release();
+    }
+  }
+
+  private async reconcilePrimarySummaryFallbackStateOnStartup(): Promise<void> {
+    const alerts: Array<{ agentName: string; requestId: string; reason: string }> = [];
+    const unsettledRequests = (await this.withPrimarySummaryStateLock(() =>
+      this.readPrimarySummaryFallbackState().requests
+        .filter((record) =>
+          record.finalStatus === 'pending'
+          || record.finalStatus === 'refusal'
+          || record.fallbackStatus === 'pending',
+        )
+        .map((record) => structuredClone(record)),
+    )) as PrimarySummaryRequestRecord[];
+
+    const resolvedRequestIds = new Set<string>();
+    for (const record of unsettledRequests) {
+      const result = await this.finalizePrimarySummarySettlementOnStartup(record);
+      if (result === 'finalized') {
+        resolvedRequestIds.add(record.requestId);
+        continue;
+      }
+      if (result && typeof result === 'object' && 'invalidReason' in result) {
+        resolvedRequestIds.add(record.requestId);
+        alerts.push({ agentName: record.agentName, requestId: record.requestId, reason: result.invalidReason });
+        await this.markPrimarySummaryRequestRestartFailure(record, result.invalidReason);
+      }
+    }
+
+    await this.withPrimarySummaryStateLock(() => {
+      const state = this.readPrimarySummaryFallbackState();
+      let changed = false;
+      state.requests = state.requests.map((record) => {
+        if (resolvedRequestIds.has(record.requestId)) return record;
+        if (record.dispatchKind === 'primary_summary_fallback_retry' && (
+          record.finalStatus === 'pending' || record.finalStatus === 'refusal'
+        )) {
+          changed = true;
+          const reason = 'primary_summary_fallback_unresolved_on_restart';
+          alerts.push({ agentName: record.agentName, requestId: record.requestId, reason });
+          return {
+            ...record,
+            finalStatus: 'held',
+            fallbackHeldReason: reason,
+          };
+        }
+        if (record.fallbackIntent && record.fallbackStatus === 'pending') {
+          changed = true;
+          const reason = 'primary_summary_fallback_unresolved_on_restart';
+          alerts.push({ agentName: record.agentName, requestId: record.requestId, reason });
+          return {
+            ...record,
+            fallbackStatus: 'held',
+            fallbackHeldReason: reason,
+          };
+        }
+        if (record.finalStatus === 'refusal') {
+          changed = true;
+          const reason = 'primary_summary_request_unresolved_on_restart';
+          alerts.push({ agentName: record.agentName, requestId: record.requestId, reason });
+          return {
+            ...record,
+            finalStatus: 'held',
+            fallbackStatus: 'held',
+            fallbackHeldReason: reason,
+          };
+        }
+        if (record.finalStatus === 'pending') {
+          changed = true;
+          const reason = 'primary_summary_request_unresolved_on_restart';
+          alerts.push({ agentName: record.agentName, requestId: record.requestId, reason });
+          return {
+            ...record,
+            finalStatus: 'timeout_unknown',
+            fallbackHeldReason: reason,
+          };
+        }
+        return record;
+      });
+      if (changed) this.writePrimarySummaryFallbackState({ requests: state.requests.slice(-256) });
+    });
+    for (const alert of alerts) {
+      this.opsAlert('refusal-held', alert.agentName, alert.reason, {
+        data: { requestId: alert.requestId },
+      });
+    }
+  }
+
+  private primarySummaryIdentityKey(identity: PrimarySummaryIdentity): string {
+    return [
+      identity.id,
+      identity.contentHash,
+      identity.carrierHash,
+      identity.sourceLeafHash,
+    ].join('\u0000');
+  }
+
+  private primarySummaryProjectionKeys(projection: PrimarySummaryProjection | null): string[] {
+    return projection?.selectedSummaries.map((selection) =>
+      this.primarySummaryIdentityKey(selection.identity),
+    ) ?? [];
+  }
+
+  private primarySummaryFallbackConfig(agent: Agent): {
+    enabled: boolean;
+    maxNewSummaries: number;
+    requestBudgetTokens: number;
+  } {
+    const raw = (agent.refusalHandling as {
+      primarySummaryFallback?: {
+        enabled?: boolean;
+        maxNewSummaries?: number;
+        requestBudgetTokens?: number;
+      };
+    } | undefined)?.primarySummaryFallback;
+    const fallbackBudgetBase = agent.contextBudgetTokens ?? 100_000;
+    return {
+      enabled: raw?.enabled === true,
+      maxNewSummaries:
+        typeof raw?.maxNewSummaries === 'number' && Number.isSafeInteger(raw.maxNewSummaries)
+          ? Math.max(0, raw.maxNewSummaries)
+          : 4,
+      requestBudgetTokens:
+        typeof raw?.requestBudgetTokens === 'number' && Number.isFinite(raw.requestBudgetTokens) && raw.requestBudgetTokens > 0
+          ? raw.requestBudgetTokens
+          : fallbackBudgetBase + agent.maxTokens,
+    };
+  }
+
+  private latestCompatibleHealthyPrimaryRequest(
+    current: PrimarySummaryRequestRecord,
+    state: PrimarySummaryFallbackState,
+  ): PrimarySummaryRequestRecord | null {
+    for (let i = state.requests.length - 1; i >= 0; i--) {
+      const candidate = state.requests[i]!;
+      if (candidate.requestId === current.requestId) continue;
+      if (candidate.agentName !== current.agentName) continue;
+      if (candidate.namespace !== current.namespace) continue;
+      if (candidate.branch.id !== current.branch.id) continue;
+      if (candidate.branch.generation !== current.branch.generation) continue;
+      if (candidate.systemHash !== current.systemHash) continue;
+      if (candidate.modelConfigHash !== current.modelConfigHash) continue;
+      if (candidate.toolContractHash !== current.toolContractHash) continue;
+      if (candidate.dispatchKind !== 'primary') continue;
+      if (candidate.fallbackIntent || candidate.fallbackStatus) continue;
+      if (candidate.finalStatus !== 'success') continue;
+      return candidate;
+    }
+    return null;
+  }
+
+  private async persistPrimarySummaryRequestRecord(record: PrimarySummaryRequestRecord): Promise<void> {
+    await this.withPrimarySummaryStateLock(() => {
+      const state = this.readPrimarySummaryFallbackState();
+      const requests = state.requests.filter((entry) => entry.requestId !== record.requestId);
+      requests.push(record);
+      this.writePrimarySummaryFallbackState({ requests: requests.slice(-256) });
+    });
+  }
+
+  private async updatePrimarySummaryRequestRecord(
+    requestId: string,
+    update: (record: PrimarySummaryRequestRecord) => PrimarySummaryRequestRecord,
+  ): Promise<PrimarySummaryRequestRecord | null> {
+    return this.withPrimarySummaryStateLock(() => {
+      const state = this.readPrimarySummaryFallbackState();
+      const index = state.requests.findIndex((entry) => entry.requestId === requestId);
+      if (index < 0) return null;
+      state.requests[index] = update(state.requests[index]!);
+      this.writePrimarySummaryFallbackState({ requests: state.requests.slice(-256) });
+      return state.requests[index]!;
+    });
+  }
+
+  private async getPrimarySummaryRequestRecord(requestId: string): Promise<PrimarySummaryRequestRecord | null> {
+    return this.withPrimarySummaryStateLock(() => {
+      const state = this.readPrimarySummaryFallbackState();
+      return state.requests.find((entry) => entry.requestId === requestId) ?? null;
+    });
+  }
+
+  private primarySummaryContractsMatch(
+    left: PrimarySummaryContract & { systemHash: string },
+    right: PrimarySummaryContract & { systemHash: string },
+  ): boolean {
+    return left.systemHash === right.systemHash
+      && left.modelConfigHash === right.modelConfigHash
+      && left.toolContractHash === right.toolContractHash;
+  }
+
+  private primarySummaryFallbackOutputPhaseHash(blocks: ReadonlyArray<ContentBlock>): string {
+    return this.hashJson(blocks);
+  }
+
+  private primarySummaryFallbackBlockTypes(blocks: ReadonlyArray<ContentBlock>): string[] {
+    return blocks.map((block) => block.type);
+  }
+
+  private static readonly NON_EXECUTED_TOOL_RESULT_TEXT = '[tool not executed]';
+
+  private buildNonExecutedToolResults(
+    blocks: ReadonlyArray<ContentBlock>,
+  ): ContentBlock[] {
+    const seenToolUseIds = new Set<string>();
+    return blocks
+      .filter((block): block is ContentBlock & { type: 'tool_use'; id: string } => block.type === 'tool_use')
+      .filter((block) => {
+        if (seenToolUseIds.has(block.id)) return false;
+        seenToolUseIds.add(block.id);
+        return true;
+      })
+      .map((block) => ({
+        type: 'tool_result' as const,
+        toolUseId: block.id,
+        content: AgentFramework.NON_EXECUTED_TOOL_RESULT_TEXT,
+        isError: true,
+      }));
+  }
+
+  private buildPrimarySummarySettlementId(
+    record: Pick<PrimarySummaryRequestRecord, 'dispatchKind'>,
+    outcome: PrimarySummarySettlementOutcome,
+  ): string {
+    return `${record.dispatchKind}:${outcome}:terminal:v${PRIMARY_SUMMARY_SETTLEMENT_VERSION}`;
+  }
+
+  private buildPrimarySummarySettlementMetadata(
+    record: PrimarySummaryRequestRecord,
+    options: {
+      outcome: PrimarySummarySettlementOutcome;
+      settlementId?: string;
+      stopReason?: string;
+      holdReason?: string;
+      providerInputTokens?: number;
+      visibleAssistantOutput: boolean;
+      executedToolCalls: number;
+      entryIndex: number;
+      entryCount: number;
+      role: PrimarySummarySettlementRole;
+      kind: PrimarySummarySettlementKind;
+    },
+  ): MessageMetadata {
+    const settlementId = options.settlementId ?? this.buildPrimarySummarySettlementId(record, options.outcome);
+    return {
+      [PRIMARY_SUMMARY_SETTLEMENT_METADATA_KEY]: {
+        version: PRIMARY_SUMMARY_SETTLEMENT_VERSION,
+        requestId: record.requestId,
+        settlementId,
+        agentName: record.agentName,
+        dispatchKind: record.dispatchKind,
+        outcome: options.outcome,
+        ...(options.stopReason ? { stopReason: options.stopReason } : {}),
+        ...(options.holdReason ? { holdReason: options.holdReason } : {}),
+        ...(options.providerInputTokens !== undefined
+          ? { providerInputTokens: options.providerInputTokens }
+          : {}),
+        visibleAssistantOutput: options.visibleAssistantOutput,
+        executedToolCalls: options.executedToolCalls,
+        branch: {
+          id: record.branch.id,
+          name: record.branch.name,
+          generation: record.branch.generation,
+        },
+        role: options.role,
+        kind: options.kind,
+        entryIndex: options.entryIndex,
+        entryCount: options.entryCount,
+      } satisfies PrimarySummarySettlementMetadata,
+    };
+  }
+
+  private isBoundedNonEmptyString(value: unknown, maxLength: number): value is string {
+    return typeof value === 'string' && value.length > 0 && value.length <= maxLength;
+  }
+
+  private isSafeNonNegativeInteger(value: unknown): value is number {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;
+  }
+
+  private primarySummarySettlementRequestId(message: StoredMessage): string | null {
+    const raw = message.metadata?.[PRIMARY_SUMMARY_SETTLEMENT_METADATA_KEY];
+    if (!raw || typeof raw !== 'object') return null;
+    const requestId = (raw as { requestId?: unknown }).requestId;
+    return typeof requestId === 'string' ? requestId : null;
+  }
+
+  private parsePrimarySummarySettlementMetadata(
+    message: StoredMessage,
+  ): PrimarySummarySettlementMetadata | { invalidReason: string } | null {
+    const raw = message.metadata?.[PRIMARY_SUMMARY_SETTLEMENT_METADATA_KEY];
+    if (!raw || typeof raw !== 'object') return null;
+    const candidate = raw as Partial<PrimarySummarySettlementMetadata>;
+    if (
+      candidate.version !== PRIMARY_SUMMARY_SETTLEMENT_VERSION ||
+      !this.isBoundedNonEmptyString(candidate.requestId, PRIMARY_SUMMARY_SETTLEMENT_MAX_ID_LENGTH) ||
+      !this.isBoundedNonEmptyString(candidate.settlementId, PRIMARY_SUMMARY_SETTLEMENT_MAX_ID_LENGTH) ||
+      !this.isBoundedNonEmptyString(candidate.agentName, PRIMARY_SUMMARY_SETTLEMENT_MAX_NAME_LENGTH) ||
+      (candidate.dispatchKind !== 'primary' && candidate.dispatchKind !== 'primary_summary_fallback_retry') ||
+      (candidate.outcome !== 'success' && candidate.outcome !== 'held') ||
+      typeof candidate.visibleAssistantOutput !== 'boolean' ||
+      !this.isSafeNonNegativeInteger(candidate.executedToolCalls) ||
+      !this.isSafeNonNegativeInteger(candidate.entryIndex) ||
+      !this.isSafeNonNegativeInteger(candidate.entryCount) ||
+      (candidate.role !== 'assistant' && candidate.role !== 'user') ||
+      (candidate.kind !== 'assistant_output' && candidate.kind !== 'generated_tool_result') ||
+      !candidate.branch ||
+      !this.isBoundedNonEmptyString(candidate.branch.id, PRIMARY_SUMMARY_SETTLEMENT_MAX_ID_LENGTH) ||
+      !this.isBoundedNonEmptyString(candidate.branch.name, PRIMARY_SUMMARY_SETTLEMENT_MAX_NAME_LENGTH) ||
+      !this.isSafeNonNegativeInteger(candidate.branch.generation) ||
+      candidate.entryCount < 1 ||
+      candidate.entryIndex >= candidate.entryCount ||
+      (candidate.stopReason !== undefined
+        && !this.isBoundedNonEmptyString(candidate.stopReason, PRIMARY_SUMMARY_SETTLEMENT_MAX_REASON_LENGTH)) ||
+      (candidate.holdReason !== undefined
+        && !this.isBoundedNonEmptyString(candidate.holdReason, PRIMARY_SUMMARY_SETTLEMENT_MAX_REASON_LENGTH)) ||
+      (candidate.providerInputTokens !== undefined
+        && !this.isSafeNonNegativeInteger(candidate.providerInputTokens)) ||
+      (candidate.outcome === 'held' && candidate.holdReason === undefined) ||
+      (candidate.outcome === 'success' && candidate.holdReason !== undefined)
+    ) {
+      return { invalidReason: 'primary_summary_settlement_metadata_invalid_on_restart' };
+    }
+    return candidate as PrimarySummarySettlementMetadata;
+  }
+
+  private primarySummarySettlementMetadataConsistent(
+    left: PrimarySummarySettlementMetadata,
+    right: PrimarySummarySettlementMetadata,
+  ): boolean {
+    return left.version === right.version
+      && left.requestId === right.requestId
+      && left.settlementId === right.settlementId
+      && left.agentName === right.agentName
+      && left.dispatchKind === right.dispatchKind
+      && left.outcome === right.outcome
+      && left.stopReason === right.stopReason
+      && left.holdReason === right.holdReason
+      && left.providerInputTokens === right.providerInputTokens
+      && left.visibleAssistantOutput === right.visibleAssistantOutput
+      && left.executedToolCalls === right.executedToolCalls
+      && left.branch.id === right.branch.id
+      && left.branch.name === right.branch.name
+      && left.branch.generation === right.branch.generation
+      && left.entryCount === right.entryCount;
+  }
+
+  private primarySummaryShardEnvelopeConsistent(
+    participant: string,
+    left: PrimarySummarySettlementMetadata,
+    candidateParticipant: string,
+    right: PrimarySummarySettlementMetadata,
+  ): boolean {
+    return participant === candidateParticipant
+      && this.primarySummarySettlementMetadataConsistent(left, right)
+      && left.role === right.role
+      && left.kind === right.kind
+      && left.entryIndex === right.entryIndex;
+  }
+
+  private primarySummaryLogicalSettlementEntries(
+    agent: Agent,
+    requestId: string,
+  ): PrimarySummaryLogicalSettlementEntry[] | { invalidReason: string } {
+    const allMessages = agent.getContextManager().getAllMessages()
+      .slice()
+      .sort((left, right) => left.sequence - right.sequence);
+    const entries: PrimarySummaryLogicalSettlementEntry[] = [];
+    for (let index = 0; index < allMessages.length;) {
+      const message = allMessages[index]!;
+      if (this.primarySummarySettlementRequestId(message) !== requestId) {
+        index++;
+        continue;
+      }
+      const parsed = this.parsePrimarySummarySettlementMetadata(message);
+      if (!parsed) {
+        index++;
+        continue;
+      }
+      if ('invalidReason' in parsed) return parsed;
+
+      if (message.bodyGroupId === undefined) {
+        if (message.shardIndex !== undefined) {
+          return { invalidReason: 'primary_summary_settlement_shard_group_invalid_on_restart' };
+        }
+        entries.push({
+          messages: [message],
+          settlement: parsed,
+          participant: message.participant,
+          content: message.content,
+        });
+        index++;
+        continue;
+      }
+
+      const groupId = message.bodyGroupId;
+      if (!this.isBoundedNonEmptyString(groupId, PRIMARY_SUMMARY_SETTLEMENT_MAX_ID_LENGTH)) {
+        return { invalidReason: 'primary_summary_settlement_shard_group_invalid_on_restart' };
+      }
+      if (index > 0 && allMessages[index - 1]?.bodyGroupId === groupId) {
+        return { invalidReason: 'primary_summary_settlement_shard_group_invalid_on_restart' };
+      }
+
+      const groupMessages: StoredMessage[] = [];
+      while (index < allMessages.length && allMessages[index]!.bodyGroupId === groupId) {
+        groupMessages.push(allMessages[index]!);
+        index++;
+      }
+      if (allMessages.slice(index).some((candidate) => candidate.bodyGroupId === groupId)) {
+        return { invalidReason: 'primary_summary_settlement_shard_group_invalid_on_restart' };
+      }
+
+      const orderedGroupMessages: StoredMessage[] = [];
+      let expectedShardIndex = 0;
+      for (const groupMessage of groupMessages) {
+        if (this.primarySummarySettlementRequestId(groupMessage) !== requestId) {
+          return { invalidReason: 'primary_summary_settlement_shard_group_invalid_on_restart' };
+        }
+        const groupParsed = this.parsePrimarySummarySettlementMetadata(groupMessage);
+        if (!groupParsed) {
+          return { invalidReason: 'primary_summary_settlement_shard_group_invalid_on_restart' };
+        }
+        if ('invalidReason' in groupParsed) return groupParsed;
+        if (!this.primarySummaryShardEnvelopeConsistent(
+          message.participant,
+          parsed,
+          groupMessage.participant,
+          groupParsed,
+        )) {
+          return { invalidReason: 'primary_summary_settlement_shard_group_invalid_on_restart' };
+        }
+        if (groupMessage.shardIndex !== expectedShardIndex) {
+          return { invalidReason: 'primary_summary_settlement_shard_group_invalid_on_restart' };
+        }
+        orderedGroupMessages.push(groupMessage);
+        expectedShardIndex++;
+      }
+
+      entries.push({
+        messages: orderedGroupMessages,
+        settlement: parsed,
+        participant: message.participant,
+        content: orderedGroupMessages.flatMap((groupMessage) => groupMessage.content),
+        bodyGroupId: groupId,
+      });
+    }
+    return entries;
+  }
+
+  private primarySummaryContentMatches(
+    left: ReadonlyArray<ContentBlock>,
+    right: ReadonlyArray<ContentBlock>,
+  ): boolean {
+    return this.primarySummaryFallbackOutputPhaseHash(left) === this.primarySummaryFallbackOutputPhaseHash(right);
+  }
+
+  private async persistPrimarySummaryChronicleEntries(
+    agent: Agent,
+    entries: Array<{ participant: string; content: ContentBlock[]; metadata?: MessageMetadata }>,
+  ): Promise<string[]> {
+    const messageIds: string[] = [];
+    for (const entry of entries) {
+      if (entry.content.length === 0) continue;
+      messageIds.push(agent.getContextManager().addMessage(entry.participant, entry.content, entry.metadata));
+    }
+    return messageIds;
+  }
+
+  private async markPrimarySummaryRequestRestartFailure(
+    record: PrimarySummaryRequestRecord,
+    reason: string,
+  ): Promise<void> {
+    if (record.dispatchKind === 'primary_summary_fallback_retry') {
+      const parent = await this.findPrimarySummaryRetryParent(record.requestId);
+      await this.updatePrimarySummaryRequestRecord(record.requestId, (entry) => ({
+        ...entry,
+        finalStatus: 'held',
+        fallbackHeldReason: reason,
+      }));
+      if (parent) {
+        await this.updatePrimarySummaryRequestRecord(parent.originalRequestId, (entry) => ({
+          ...entry,
+          finalStatus: 'held',
+          fallbackStatus: 'held',
+          fallbackHeldReason: reason,
+        }));
+      }
+      return;
+    }
+    await this.updatePrimarySummaryRequestRecord(record.requestId, (current) => ({
+      ...current,
+      finalStatus: 'held',
+      fallbackStatus: 'held',
+      fallbackHeldReason: reason,
+    }));
+  }
+
+  private async persistPrimarySummaryHeldOutput(
+    agent: Agent,
+    requestId: string,
+    holdReason: string,
+    options: {
+      stopReason?: string;
+      providerInputTokens?: number;
+      visibleAssistantOutput: boolean;
+      executedToolCalls: number;
+      assistantBlocks: ContentBlock[];
+      retryDispatch?: PrimarySummaryFallbackRetryDispatch;
+      retryPhase?: string;
+      holdData?: Record<string, unknown>;
+    },
+  ): Promise<void> {
+    const record = await this.getPrimarySummaryRequestRecord(requestId);
+    if (!record) {
+      throw new Error(`Primary summary request '${requestId}' disappeared before held-output persistence`);
+    }
+    const placeholderBlocks = this.buildNonExecutedToolResults(options.assistantBlocks);
+    const entryCount = placeholderBlocks.length > 0 ? 2 : 1;
+    const assistantMetadata = this.buildPrimarySummarySettlementMetadata(record, {
+      outcome: 'held',
+      stopReason: options.stopReason,
+      holdReason,
+      providerInputTokens: options.providerInputTokens,
+      visibleAssistantOutput: options.visibleAssistantOutput,
+      executedToolCalls: options.executedToolCalls,
+      entryIndex: 0,
+      entryCount,
+      role: 'assistant',
+      kind: 'assistant_output',
+    });
+    const settlementId =
+      (assistantMetadata[PRIMARY_SUMMARY_SETTLEMENT_METADATA_KEY] as PrimarySummarySettlementMetadata).settlementId;
+    const placeholderMetadata = placeholderBlocks.length > 0
+      ? this.buildPrimarySummarySettlementMetadata(record, {
+          outcome: 'held',
+          settlementId,
+          stopReason: options.stopReason,
+          holdReason,
+          providerInputTokens: options.providerInputTokens,
+          visibleAssistantOutput: options.visibleAssistantOutput,
+          executedToolCalls: options.executedToolCalls,
+          entryIndex: 1,
+          entryCount,
+          role: 'user',
+          kind: 'generated_tool_result',
+        })
+      : undefined;
+    const messageIds = await this.persistPrimarySummaryChronicleEntries(agent, [
+      { participant: agent.name, content: options.assistantBlocks, metadata: assistantMetadata },
+      ...(placeholderBlocks.length > 0 && placeholderMetadata
+        ? [{ participant: 'user', content: placeholderBlocks, metadata: placeholderMetadata }]
+        : []),
+    ]);
+    if (options.retryDispatch && options.retryPhase && options.assistantBlocks.length > 0) {
+      await this.recordPrimarySummaryRetryOutput(
+        options.retryDispatch.originalRequestId,
+        options.retryDispatch.intentId,
+        {
+          phase: options.retryPhase,
+          contentHash: this.primarySummaryFallbackOutputPhaseHash(options.assistantBlocks),
+          messageId: messageIds[0] ?? '',
+          blockTypes: this.primarySummaryFallbackBlockTypes(options.assistantBlocks),
+          persistedAt: Date.now(),
+        },
+      );
+    }
+    if (options.retryDispatch) {
+      await this.holdPrimarySummaryRetryFamily(
+        agent,
+        requestId,
+        options.retryDispatch,
+        holdReason,
+        options.holdData,
+      );
+      return;
+    }
+    await this.holdPrimarySummaryRequest(agent, requestId, holdReason, options.holdData);
+  }
+
+  private async findPrimarySummaryRetryParent(
+    retryRequestId: string,
+  ): Promise<{ originalRequestId: string; intentId: string } | null> {
+    return this.withPrimarySummaryStateLock(() => {
+      const state = this.readPrimarySummaryFallbackState();
+      for (const record of state.requests) {
+        const intent = record.fallbackIntent;
+        if (intent?.retryRequestId === retryRequestId) {
+          return { originalRequestId: record.requestId, intentId: intent.intentId };
+        }
+      }
+      return null;
+    });
+  }
+
+  private async finalizePrimarySummarySettlementOnStartup(
+    record: PrimarySummaryRequestRecord,
+  ): Promise<'finalized' | { invalidReason: string } | false> {
+    const agent = this.agents.get(record.agentName);
+    if (!agent) return false;
+    const settlementEntries = this.primarySummaryLogicalSettlementEntries(agent, record.requestId);
+    if ('invalidReason' in settlementEntries) return settlementEntries;
+    if (settlementEntries.length === 0) {
+      return false;
+    }
+    const currentBranch = agent.getCurrentBranchGeneration();
+    const assistantEntry = settlementEntries[0]!;
+    const settlement = assistantEntry.settlement;
+    if (
+      assistantEntry.participant !== record.agentName ||
+      settlement.agentName !== record.agentName ||
+      settlement.dispatchKind !== record.dispatchKind ||
+      settlement.entryIndex !== 0 ||
+      settlement.role !== 'assistant' ||
+      settlement.kind !== 'assistant_output'
+    ) {
+      return { invalidReason: 'primary_summary_settlement_invalid_assistant_marker_on_restart' };
+    }
+    if (!currentBranch) {
+      return { invalidReason: 'primary_summary_settlement_branch_unknown_on_restart' };
+    }
+    if (
+      settlement.branch.id !== record.branch.id ||
+      settlement.branch.name !== record.branch.name ||
+      settlement.branch.generation !== record.branch.generation ||
+      settlement.branch.id !== currentBranch.id ||
+      settlement.branch.name !== currentBranch.name ||
+      settlement.branch.generation !== currentBranch.generation
+    ) {
+      return { invalidReason: 'primary_summary_settlement_branch_mismatch_on_restart' };
+    }
+    if (settlement.entryCount < 1 || settlement.entryCount > 2) {
+      return { invalidReason: 'primary_summary_settlement_entry_count_invalid_on_restart' };
+    }
+    const entriesByIndex = new Map<number, PrimarySummaryLogicalSettlementEntry>();
+    for (const entry of settlementEntries) {
+      if (!this.primarySummarySettlementMetadataConsistent(settlement, entry.settlement)) {
+        return { invalidReason: 'primary_summary_settlement_marker_conflict_on_restart' };
+      }
+      if (entriesByIndex.has(entry.settlement.entryIndex)) {
+        return { invalidReason: 'primary_summary_settlement_duplicate_entry_on_restart' };
+      }
+      entriesByIndex.set(entry.settlement.entryIndex, entry);
+    }
+    const placeholderEntry = entriesByIndex.get(1);
+    if (
+      placeholderEntry
+      && (
+        placeholderEntry.participant !== 'user'
+        || placeholderEntry.settlement.role !== 'user'
+        || placeholderEntry.settlement.kind !== 'generated_tool_result'
+      )
+    ) {
+      return { invalidReason: 'primary_summary_settlement_placeholder_marker_invalid_on_restart' };
+    }
+    if ([...entriesByIndex.keys()].some((index) => index !== 0 && index !== 1)) {
+      return { invalidReason: 'primary_summary_settlement_out_of_order_entries_on_restart' };
+    }
+    const expectedPlaceholder = settlement.outcome === 'held'
+      ? this.buildNonExecutedToolResults(assistantEntry.content)
+      : [];
+    if (settlement.outcome === 'success') {
+      if (settlement.entryCount !== 1 || placeholderEntry) {
+        return { invalidReason: 'primary_summary_success_settlement_shape_invalid_on_restart' };
+      }
+    } else {
+      const expectedEntryCount = expectedPlaceholder.length > 0 ? 2 : 1;
+      if (settlement.entryCount !== expectedEntryCount) {
+        return { invalidReason: 'primary_summary_held_settlement_shape_invalid_on_restart' };
+      }
+      if (placeholderEntry) {
+        if (!this.primarySummaryContentMatches(placeholderEntry.content, expectedPlaceholder)) {
+          return { invalidReason: 'primary_summary_settlement_placeholder_content_mismatch_on_restart' };
+        }
+      } else if (expectedPlaceholder.length > 0) {
+        const placeholderMetadata = this.buildPrimarySummarySettlementMetadata(record, {
+          outcome: 'held',
+          settlementId: settlement.settlementId,
+          stopReason: settlement.stopReason,
+          holdReason: settlement.holdReason,
+          providerInputTokens: settlement.providerInputTokens,
+          visibleAssistantOutput: settlement.visibleAssistantOutput,
+          executedToolCalls: settlement.executedToolCalls,
+          entryIndex: 1,
+          entryCount: settlement.entryCount,
+          role: 'user',
+          kind: 'generated_tool_result',
+        });
+        await this.persistPrimarySummaryChronicleEntries(agent, [
+          { participant: 'user', content: expectedPlaceholder, metadata: placeholderMetadata },
+        ]);
+      }
+    }
+
+    if (record.dispatchKind === 'primary_summary_fallback_retry') {
+      const parent = await this.findPrimarySummaryRetryParent(record.requestId);
+      if (!parent) return { invalidReason: 'primary_summary_fallback_parent_missing_on_restart' };
+      if (settlement.outcome === 'success') {
+        await this.updatePrimarySummaryRequestRecord(record.requestId, (entry) => ({
+          ...entry,
+          stopReason: settlement.stopReason ?? entry.stopReason,
+          providerInputTokens: settlement.providerInputTokens ?? entry.providerInputTokens,
+          visibleAssistantOutput: settlement.visibleAssistantOutput,
+          executedToolCalls: settlement.executedToolCalls,
+          finalStatus: 'success',
+          fallbackHeldReason: undefined,
+        }));
+        await this.updatePrimarySummaryRequestRecord(parent.originalRequestId, (entry) => {
+          const intent = entry.fallbackIntent;
+          return {
+            ...entry,
+            finalStatus: 'success',
+            fallbackStatus: 'success',
+            fallbackHeldReason: undefined,
+            fallbackIntent: intent && intent.intentId === parent.intentId
+              ? { ...intent, finalizedAt: intent.finalizedAt ?? Date.now() }
+              : intent,
+          };
+        });
+        return 'finalized';
+      }
+      await this.updatePrimarySummaryRequestRecord(record.requestId, (entry) => ({
+        ...entry,
+        stopReason: settlement.stopReason ?? entry.stopReason,
+        providerInputTokens: settlement.providerInputTokens ?? entry.providerInputTokens,
+        visibleAssistantOutput: settlement.visibleAssistantOutput,
+        executedToolCalls: settlement.executedToolCalls,
+        finalStatus: 'held',
+        fallbackHeldReason: settlement.holdReason,
+      }));
+      await this.updatePrimarySummaryRequestRecord(parent.originalRequestId, (entry) => ({
+        ...entry,
+        finalStatus: 'held',
+        fallbackStatus: 'held',
+        fallbackHeldReason: settlement.holdReason,
+      }));
+      return 'finalized';
+    }
+
+    await this.updatePrimarySummaryRequestRecord(record.requestId, (entry) => ({
+      ...entry,
+      stopReason: settlement.stopReason ?? entry.stopReason,
+      providerInputTokens: settlement.providerInputTokens ?? entry.providerInputTokens,
+      visibleAssistantOutput: settlement.visibleAssistantOutput,
+      executedToolCalls: settlement.executedToolCalls,
+      finalStatus: settlement.outcome === 'success' ? 'success' : 'held',
+      fallbackStatus: settlement.outcome === 'success' ? entry.fallbackStatus : 'held',
+      fallbackHeldReason: settlement.outcome === 'held' ? settlement.holdReason : undefined,
+    }));
+    return 'finalized';
+  }
+
+  private summarizePrimarySummaryRetryRequest(request: NormalizedRequest): Record<string, unknown> {
+    const blockCounts = new Map<string, number>();
+    for (const message of request.messages) {
+      for (const block of message.content) {
+        blockCounts.set(block.type, (blockCounts.get(block.type) ?? 0) + 1);
+      }
+    }
+    return {
+      kind: 'primary_summary_fallback_retry',
+      requestHash: this.hashJson(request),
+      systemHash: this.hashJson(request.system ?? ''),
+      messageCount: request.messages.length,
+      toolCount: request.tools?.length ?? 0,
+      participantCount: [...new Set(request.messages.map((message) => message.participant))].length,
+      blockCounts: Object.fromEntries([...blockCounts.entries()].sort(([left], [right]) => left.localeCompare(right))),
+      promptCaching: request.promptCaching === true,
+      cacheTtl: request.cacheTtl,
+      assistantParticipant: request.assistantParticipant,
+      requestCompleteBoundTokens: this.estimateRequestCompleteBoundTokens(request),
+    };
+  }
+
+  private summarizePrimarySummaryRetryResponse(response: NormalizedResponse): Record<string, unknown> {
+    const blockCounts = new Map<string, number>();
+    for (const block of response.content) {
+      blockCounts.set(block.type, (blockCounts.get(block.type) ?? 0) + 1);
+    }
+    return {
+      kind: 'primary_summary_fallback_retry',
+      stopReason: response.stopReason,
+      rawAssistantTextHash: response.rawAssistantText
+        ? this.hashJson(response.rawAssistantText)
+        : undefined,
+      blockCounts: Object.fromEntries([...blockCounts.entries()].sort(([left], [right]) => left.localeCompare(right))),
+      toolCallIds: response.toolCalls.map((call: { id: string }) => call.id),
+      usage: response.usage
+        ? {
+            inputTokens: response.usage.inputTokens,
+            outputTokens: response.usage.outputTokens,
+          }
+        : undefined,
+    };
+  }
+
+  private async claimPrimarySummaryRetryIntent(
+    originalRequestId: string,
+    intentId: string,
+    retryRequestId: string,
+  ): Promise<'claimed' | 'duplicate' | 'missing'> {
+    let outcome: 'claimed' | 'duplicate' | 'missing' = 'missing';
+    await this.updatePrimarySummaryRequestRecord(originalRequestId, (record) => {
+      const intent = record.fallbackIntent;
+      if (!intent || intent.intentId !== intentId || record.fallbackStatus !== 'pending') {
+        return record;
+      }
+      if (intent.retryRequestId && intent.retryRequestId !== retryRequestId) {
+        outcome = 'duplicate';
+        return record;
+      }
+      outcome = 'claimed';
+      return {
+        ...record,
+        fallbackIntent: {
+          ...intent,
+          retryRequestId,
+          dispatchedAt: intent.dispatchedAt ?? Date.now(),
+        },
+      };
+    });
+    return outcome;
+  }
+
+  private async validatePrimarySummaryRetryMutation(
+    agent: Agent,
+    requestId: string,
+    retryDispatch: PrimarySummaryFallbackRetryDispatch,
+    compiledRequest: NormalizedRequest,
+    artifacts: ActivationCompileArtifacts,
+    phase: string,
+  ): Promise<{ ok: true } | { ok: false; reason: string; data: Record<string, unknown> }> {
+    const branch = agent.getCurrentBranchGeneration();
+    if (!branch || branch.id !== retryDispatch.branch.id || branch.generation !== retryDispatch.branch.generation) {
+      return {
+        ok: false,
+        reason: `primary_summary_fallback_branch_changed_${phase}`,
+        data: {
+          expectedBranchId: retryDispatch.branch.id,
+          expectedGeneration: retryDispatch.branch.generation,
+          actualBranchId: branch?.id,
+          actualGeneration: branch?.generation,
+        },
+      };
+    }
+    const requestHash = this.hashJson(compiledRequest);
+    if (requestHash !== retryDispatch.expectedRetryRequestHash) {
+      return {
+        ok: false,
+        reason: `primary_summary_fallback_request_changed_${phase}`,
+        data: {
+          expectedRetryRequestHash: retryDispatch.expectedRetryRequestHash,
+          actualRetryRequestHash: requestHash,
+        },
+      };
+    }
+    if (
+      this.primarySummaryProjectionKeys(artifacts.compileResult.primarySummaryProjection ?? null).join('\u0000') !==
+      retryDispatch.originalProjectionKeys.join('\u0000')
+    ) {
+      return {
+        ok: false,
+        reason: `primary_summary_fallback_projection_changed_${phase}`,
+        data: {
+          expectedProjectionKeys: retryDispatch.originalProjectionKeys,
+          actualProjectionKeys: this.primarySummaryProjectionKeys(
+            artifacts.compileResult.primarySummaryProjection ?? null,
+          ),
+        },
+      };
+    }
+    if (!this.primarySummaryContractsMatch(artifacts.contract, retryDispatch.originalArtifacts.contract)) {
+      return {
+        ok: false,
+        reason: `primary_summary_fallback_contract_changed_${phase}`,
+        data: {
+          expectedContract: retryDispatch.originalArtifacts.contract,
+          actualContract: artifacts.contract,
+        },
+      };
+    }
+    const original = await this.getPrimarySummaryRequestRecord(retryDispatch.originalRequestId);
+    if (
+      !original?.fallbackIntent ||
+      original.fallbackIntent.intentId !== retryDispatch.intentId ||
+      original.fallbackIntent.retryRequestId !== requestId ||
+      original.fallbackStatus !== 'pending'
+    ) {
+      return {
+        ok: false,
+        reason: `primary_summary_fallback_intent_changed_${phase}`,
+        data: {
+          expectedIntentId: retryDispatch.intentId,
+          actualIntentId: original?.fallbackIntent?.intentId,
+          retryRequestId: original?.fallbackIntent?.retryRequestId,
+          fallbackStatus: original?.fallbackStatus,
+        },
+      };
+    }
+    return { ok: true };
+  }
+
+  private async recordPrimarySummaryRetryQuarantine(
+    originalRequestId: string,
+    intentId: string,
+  ): Promise<void> {
+    await this.updatePrimarySummaryRequestRecord(originalRequestId, (record) => {
+      const intent = record.fallbackIntent;
+      if (!intent || intent.intentId !== intentId || intent.quarantinePersistedAt) return record;
+      return {
+        ...record,
+        fallbackIntent: {
+          ...intent,
+          quarantinePersistedAt: Date.now(),
+        },
+      };
+    });
+  }
+
+  private async recordPrimarySummaryRetryOutput(
+    originalRequestId: string,
+    intentId: string,
+    output: PrimarySummaryFallbackOutputRecord,
+  ): Promise<void> {
+    await this.updatePrimarySummaryRequestRecord(originalRequestId, (record) => {
+      const intent = record.fallbackIntent;
+      if (!intent || intent.intentId !== intentId) return record;
+      const existing = intent.outputs?.find((entry) => entry.phase === output.phase);
+      if (
+        existing &&
+        existing.contentHash === output.contentHash &&
+        existing.messageId === output.messageId
+      ) {
+        return record;
+      }
+      if (existing) {
+        throw new Error(`Primary summary fallback output phase '${output.phase}' changed after persistence`);
+      }
+      return {
+        ...record,
+        fallbackIntent: {
+          ...intent,
+          outputs: [...(intent.outputs ?? []), output],
+        },
+      };
+    });
+  }
+
+  private async recordPrimarySummaryRetryToolDispatch(
+    originalRequestId: string,
+    intentId: string,
+    call: ToolCall,
+  ): Promise<void> {
+    await this.updatePrimarySummaryRequestRecord(originalRequestId, (record) => {
+      const intent = record.fallbackIntent;
+      if (!intent || intent.intentId !== intentId) return record;
+      const inputHash = this.hashJson(call.input);
+      const existing = intent.toolDispatches?.find((entry) => entry.callId === call.id);
+      if (existing?.inputHash === inputHash) return record;
+      if (existing) {
+        throw new Error(`Primary summary fallback tool dispatch '${call.id}' changed after persistence`);
+      }
+      return {
+        ...record,
+        fallbackIntent: {
+          ...intent,
+          toolDispatches: [
+            ...(intent.toolDispatches ?? []),
+            {
+              callId: call.id,
+              inputHash,
+              recordedAt: Date.now(),
+            },
+          ],
+        },
+      };
+    });
+  }
+
+  private async resolveContextBudgetRestartDispatch(
+    requestId: string,
+    retryDispatch?: PrimarySummaryFallbackRetryDispatch,
+  ): Promise<ContextBudgetRestartDispatch> {
+    const retryIdentity = retryDispatch
+      ? {
+          requestId,
+          dispatchKind: 'primary_summary_fallback_retry' as const,
+          originalRequestId: retryDispatch.originalRequestId,
+          intentId: retryDispatch.intentId,
+        }
+      : null;
+    const record = await this.getPrimarySummaryRequestRecord(requestId);
+    if (record?.dispatchKind === 'primary_summary_fallback_retry' && retryIdentity) {
+      return retryIdentity;
+    }
+    if (retryIdentity) {
+      const original = await this.getPrimarySummaryRequestRecord(retryIdentity.originalRequestId);
+      if (
+        original?.fallbackIntent?.intentId === retryIdentity.intentId
+        && original.fallbackIntent.retryRequestId === requestId
+      ) {
+        return retryIdentity;
+      }
+    }
+    return {
+      requestId,
+      dispatchKind: 'primary',
+    };
+  }
+
+  private contextBudgetRestartMatchesIdentity(
+    request: PendingInferenceRequest,
+    identity: ContextBudgetRestartDispatch,
+  ): boolean {
+    if (request.reason !== 'context_budget_restart') return false;
+    const restart = request.contextBudgetRestart;
+    if (!restart) return false;
+    if (restart.dispatchKind !== identity.dispatchKind) return false;
+    if (restart.requestId !== identity.requestId) return false;
+    if (identity.dispatchKind !== 'primary_summary_fallback_retry') return true;
+    return restart.originalRequestId === identity.originalRequestId
+      && restart.intentId === identity.intentId;
+  }
+
+  private clearQueuedContextBudgetRestart(identity: ContextBudgetRestartDispatch): number {
+    const before = this.pendingRequests.length;
+    this.pendingRequests = this.pendingRequests.filter(
+      (request) => !this.contextBudgetRestartMatchesIdentity(request, identity),
+    );
+    return before - this.pendingRequests.length;
+  }
+
+  private async markPrimarySummaryRetrySuccess(
+    requestId: string,
+    retryDispatch: PrimarySummaryFallbackRetryDispatch,
+    stopReason: string | undefined,
+    providerInputTokens: number | undefined,
+    visibleAssistantOutput: boolean,
+    executedToolCalls: number,
+  ): Promise<void> {
+    await this.updatePrimarySummaryRequestRecord(requestId, (record) => ({
+      ...record,
+      stopReason,
+      providerInputTokens,
+      visibleAssistantOutput,
+      executedToolCalls,
+      finalStatus: 'success',
+      fallbackHeldReason: undefined,
+    }));
+    await this.updatePrimarySummaryRequestRecord(retryDispatch.originalRequestId, (record) => {
+      const intent = record.fallbackIntent;
+      return {
+        ...record,
+        finalStatus: 'success',
+        fallbackStatus: 'success',
+        fallbackHeldReason: undefined,
+        fallbackIntent: intent && intent.intentId === retryDispatch.intentId
+          ? { ...intent, finalizedAt: Date.now() }
+          : intent,
+      };
+    });
   }
 
-  private createDeferred<T>(): Deferred<T> {
-    let resolve!: (value: T) => void;
-    let reject!: (reason?: unknown) => void;
-    const promise = new Promise<T>((res, rej) => {
-      resolve = res;
-      reject = rej;
+  private async holdPrimarySummaryRetryFamily(
+    agent: Agent,
+    requestId: string,
+    retryDispatch: PrimarySummaryFallbackRetryDispatch,
+    reason: string,
+    data?: Record<string, unknown>,
+    options?: { emitChronicleMarker?: boolean; stopReason?: string },
+  ): Promise<void> {
+    const clearedQueuedContextBudgetRestarts = this.clearQueuedContextBudgetRestart({
+      requestId,
+      dispatchKind: 'primary_summary_fallback_retry',
+      originalRequestId: retryDispatch.originalRequestId,
+      intentId: retryDispatch.intentId,
     });
-    return { promise, resolve, reject };
+    const holdData = clearedQueuedContextBudgetRestarts > 0
+      ? { ...(data ?? {}), clearedQueuedContextBudgetRestarts }
+      : data;
+    await this.updatePrimarySummaryRequestRecord(requestId, (record) => ({
+      ...record,
+      ...(options?.stopReason ? { stopReason: options.stopReason } : {}),
+      finalStatus: 'held',
+      fallbackHeldReason: reason,
+    }));
+    await this.updatePrimarySummaryRequestRecord(retryDispatch.originalRequestId, (record) => ({
+      ...record,
+      finalStatus: 'held',
+      fallbackStatus: 'held',
+      fallbackHeldReason: reason,
+    }));
+    this.opsAlert('refusal-held', agent.name, reason, { data: holdData });
+    if (options?.emitChronicleMarker === false) return;
+    try {
+      agent.getContextManager().addMessage(
+        'user',
+        [{
+          type: 'text',
+          text:
+            `[refusal-held] Your previous turn was refused by the provider and ` +
+            `is being held for operator review rather than silently retried. ` +
+            `Automatic raw-expansion recovery was either unsafe or unsuccessful.`,
+        }],
+        { system: true, kind: 'refusal-held', reason },
+      );
+    } catch (error) {
+      console.error('[refusal-held] could not record chronicle marker:', error);
+    }
+  }
+
+  private async primarySummaryRetryAlreadySucceeded(
+    requestId: string,
+    retryDispatch: PrimarySummaryFallbackRetryDispatch,
+  ): Promise<boolean> {
+    const [retryRecord, originalRecord] = await Promise.all([
+      this.getPrimarySummaryRequestRecord(requestId),
+      this.getPrimarySummaryRequestRecord(retryDispatch.originalRequestId),
+    ]);
+    return retryRecord?.finalStatus === 'success'
+      || originalRecord?.fallbackStatus === 'success'
+      || originalRecord?.finalStatus === 'success';
+  }
+
+  private async primarySummaryRetryFamilyAlreadySettled(
+    requestId: string,
+    retryDispatch: PrimarySummaryFallbackRetryDispatch,
+  ): Promise<boolean> {
+    const [retryRecord, originalRecord] = await Promise.all([
+      this.getPrimarySummaryRequestRecord(requestId),
+      this.getPrimarySummaryRequestRecord(retryDispatch.originalRequestId),
+    ]);
+    return retryRecord?.finalStatus === 'held'
+      || retryRecord?.finalStatus === 'success'
+      || originalRecord?.fallbackStatus === 'held'
+      || originalRecord?.fallbackStatus === 'success'
+      || originalRecord?.finalStatus === 'held'
+      || originalRecord?.finalStatus === 'success';
+  }
+
+  private async holdPrimarySummaryRequest(
+    agent: Agent,
+    requestId: string,
+    reason: string,
+    data?: Record<string, unknown>,
+  ): Promise<void> {
+    await this.updatePrimarySummaryRequestRecord(requestId, (record) => ({
+      ...record,
+      finalStatus: 'held',
+      fallbackStatus: 'held',
+      fallbackHeldReason: reason,
+    }));
+    this.opsAlert('refusal-held', agent.name, reason, { data });
+    try {
+      agent.getContextManager().addMessage(
+        'user',
+        [{
+          type: 'text',
+          text:
+            `[refusal-held] Your previous turn was refused by the provider and ` +
+            `is being held for operator review rather than silently retried. ` +
+            `Automatic raw-expansion recovery was either unsafe or unsuccessful.`,
+        }],
+        { system: true, kind: 'refusal-held', reason },
+      );
+    } catch (error) {
+      console.error('[refusal-held] could not record chronicle marker:', error);
+    }
+  }
+
+  private hasVisibleAssistantOutput(blocks: ReadonlyArray<ContentBlock>): boolean {
+    return blocks.some((block) => block.type !== 'thinking' && block.type !== 'redacted_thinking');
+  }
+
+  private buildPrimarySummaryRequestRecord(
+    agent: Agent,
+    requestId: string,
+    dispatchKind: PrimarySummaryRequestRecord['dispatchKind'],
+    request: NormalizedRequest,
+    artifacts: ActivationCompileArtifacts | undefined,
+    branch: BranchGenerationInfo | null,
+    stopReason: string | undefined,
+    visibleAssistantOutput: boolean,
+    executedToolCalls: number,
+    providerInputTokens: number | undefined,
+    finalStatus: PrimarySummaryFallbackStatus,
+  ): PrimarySummaryRequestRecord {
+    const projection = artifacts?.compileResult.primarySummaryProjection ?? null;
+    return {
+      requestId,
+      agentName: agent.name,
+      namespace: projection?.namespace ?? `agents/${agent.name}`,
+      timestamp: Date.now(),
+      dispatchKind,
+      branch: branch
+        ? { id: branch.id, name: branch.name, generation: branch.generation }
+        : { id: 'unknown', name: 'unknown', generation: -1 },
+      projection,
+      requestInputBoundTokens: this.estimateRequestInputBoundTokens(request),
+      requestCompleteBoundTokens: this.estimateRequestCompleteBoundTokens(request),
+      providerInputTokens,
+      systemHash: artifacts?.contract.systemHash ?? this.hashJson(request.system ?? ''),
+      modelConfigHash: artifacts?.contract.modelConfigHash ?? this.hashJson({ request: request.config }),
+      toolContractHash: artifacts?.contract.toolContractHash ?? this.hashJson(request.tools ?? []),
+      stopReason,
+      visibleAssistantOutput,
+      executedToolCalls,
+      finalStatus,
+    };
   }
 
   /** Liveness ping for an active ephemeral run (no-op otherwise). */
@@ -1633,11 +3348,44 @@ export class AgentFramework {
     inputSchema: { type: 'object' },
   };
 
+  /** Synthesized save_image tool — present when a workspace module is
+   *  registered. Lets the agent persist an image it has already seen in its
+   *  own context (Discord attachments arrive inlined as base64 and are
+   *  otherwise unreachable as files). */
+  private static readonly SAVE_IMAGE_TOOL: import('./types/index.js').ToolDefinition = {
+    name: 'save_recent_image',
+    description:
+      'Save one or more recent images from your own context to workspace files. ' +
+      'Images are counted back from the most recent (index 0). A single image is ' +
+      'written to `path` as given (e.g. "project/photos/cat.png"); when `count` > 1 ' +
+      'the range index..index+count-1 is saved with numeric suffixes ' +
+      '("cat-0.png", "cat-1.png", …; 0 = the newest of the range). Saved files are ' +
+      'visible via workspace tools and the /files/ endpoint.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        path: {
+          type: 'string',
+          description: 'Mount-prefixed destination path, e.g. "project/photos/name.png".',
+        },
+        index: {
+          type: 'number',
+          description: 'Which image, counting back from the most recent (0 = most recent). Default 0.',
+        },
+        count: {
+          type: 'number',
+          description: 'How many images to save, starting at `index` and going further back. Default 1.',
+        },
+      },
+      required: ['path'],
+    },
+  };
+
   private static readonly AGENT_SETTINGS_TOOL: import('./types/index.js').ToolDefinition = {
     name: 'agent_settings',
     description:
       'Read or change your hot runtime settings. This intentionally exposes only ' +
-      'context budget, recent raw tail size, and transition pace; model, prompts, ' +
+      'context budget, recent raw tail size, transition pace, and same-round think text routing; model, prompts, ' +
       'folding strategy, and other restart-bound configuration are not mutable here. ' +
       'Lower context budgets converge gradually under the transition pace before ' +
       'becoming the hard live limit; increases take effect immediately.',
@@ -1648,9 +3396,16 @@ export class AgentFramework {
         context_budget_tokens: { type: 'number', description: 'Total input context budget, including the reserved response allowance.' },
         tail_tokens: { type: 'number', description: 'Recent raw context retained verbatim.' },
         transition_pace_tokens: { type: 'number', description: 'Maximum ordinary KV re-read/perturbation per compile while converging.' },
+        same_round_think_text_policy: {
+          type: 'string',
+          enum: ['public', 'private'],
+          description:
+            'Routing policy for ordinary text emitted in the same native assistant round as think(). ' +
+            "Omitted in the recipe preserves the compatibility carry-forward: public.",
+        },
         settings: {
           type: 'array',
-          items: { type: 'string', enum: ['context_budget_tokens', 'tail_tokens', 'transition_pace_tokens'] },
+          items: { type: 'string', enum: ['context_budget_tokens', 'tail_tokens', 'transition_pace_tokens', 'same_round_think_text_policy'] },
           description: 'For reset: settings to restore to recipe values. Omit to reset all.',
         },
       },
@@ -1943,6 +3698,9 @@ export class AgentFramework {
     undone?: number;
     requested?: number;
     messagesRemoved?: number;
+    /** Discord addresses removed by message-granular undo. The durable outbox
+     *  owns eventual delivery; this is also returned for immediate surfaces. */
+    removedRefs?: Array<{ serverId: string; channelId: string; messageId: string }>;
     hidden?: number;
     /** For `hide`: the Discord (channelId, messageId) of each removed message
      *  that carried one — so the surface can mark them with a reaction. */
@@ -2089,8 +3847,26 @@ export class AgentFramework {
         };
       }
       const target = allMessages[allMessages.length - 1 - n];
-      const branchName = cm.branchAt(target.id, `undo-msgs/${agentName}/${Date.now()}`);
+      const discarded = allMessages.slice(allMessages.length - n);
+      const removedRefs = extractDiscordAwarenessRefs(discarded);
+      const sourceBranch = this.store.currentBranch().name;
+      const targetBranch = `undo-msgs/${agentName}/${Date.now()}`;
+
+      // Prepare the external side effect before switching Chronicle. If the
+      // process dies after the switch but before activate(), startup promotes
+      // this batch by matching targetBranch to the active branch.
+      const markerBatch = this.discordAwarenessOutbox?.prepare({
+        agentName,
+        sourceBranch,
+        targetBranch,
+        refs: removedRefs,
+        emoji: this.discordAwarenessEmoji,
+      }) ?? null;
+
+      const branchName = cm.branchAt(target.id, targetBranch);
       await cm.switchBranch(branchName);
+      if (markerBatch) this.discordAwarenessOutbox!.activate(markerBatch.id);
+      await this.syncDiscordAwarenessMarkers();
 
       // Materialize config files from the new branch (fire-and-forget; gate
       // picks up via mtime) — mirrors undoLastTurn.
@@ -2109,6 +3885,7 @@ export class AgentFramework {
       return {
         ok: true,
         messagesRemoved: n,
+        removedRefs,
         lastVisible: await this.lastVisiblePreview(agentName),
       };
     }
@@ -2138,6 +3915,8 @@ export class AgentFramework {
       return { ok: true, undone: 0, requested, lastVisible: null };
     }
 
+    await this.syncDiscordAwarenessMarkers();
+
     return { ok: true, undone, requested, lastVisible: await this.lastVisiblePreview(agentName) };
   }
 
@@ -2727,7 +4506,11 @@ export class AgentFramework {
 
     const agent = new Agent(config, contextManager, this.membrane);
     const restoredSettings = this.readAgentRuntimeSettings(config.name);
-    if (restoredSettings) agent.restoreRuntimeSettings(restoredSettings);
+    if (restoredSettings) {
+      agent.restoreRuntimeSettings(
+        this.validatePersistedAgentRuntimeSettings(config.name, restoredSettings),
+      );
+    }
     this.agents.set(config.name, agent);
     this.agentConfigs.set(config.name, config);
 
@@ -2763,12 +4546,21 @@ export class AgentFramework {
     // Check for inference requests
     await this.processInferenceRequests();
 
-    // Yield to the event loop between iterations.
-    // Full 10ms sleep when truly idle; minimal yield when streams are active
-    // (needed to let stream microtasks and tool-call callbacks execute).
-    if (!event && this.pendingRequests.length === 0) {
+    // Yield to the event loop between iterations. A pending inference request
+    // is not necessarily runnable: while its agent is streaming or waiting for
+    // tools, processInferenceRequests() deliberately requeues it. Treating that
+    // requeued request as "work made progress" creates a microtask-only polling
+    // loop. If activeStreams bookkeeping is absent/stale at the same time, the
+    // old code had no await at all and starved the tool-result and HTTP I/O that
+    // could make the agent runnable again (the Sol outage, 2026-07-15).
+    //
+    // No queue event means no foreground progress, so always take the normal
+    // polling backoff. After an event, retain the low-latency macrotask yield
+    // while background work remains. Both paths give Bun/Node a real event-loop
+    // turn; neither can recurse forever through already-resolved promises.
+    if (!event) {
       await new Promise((resolve) => setTimeout(resolve, 10));
-    } else if (this.activeStreams.size > 0) {
+    } else if (this.pendingRequests.length > 0 || this.activeStreams.size > 0) {
       await new Promise((resolve) => setTimeout(resolve, 0));
     }
   }
@@ -2811,6 +4603,7 @@ export class AgentFramework {
         // Cast to AgentState to bypass TypeScript's control flow narrowing
         const currentState = agent.state as AgentState;
         if (currentState.status === 'ready') {
+          const activeStreamContext = this.activeStreamContexts.get(agent.name);
           // Flush pending assistant blocks (tool_use + preamble text) to context
           const pendingBlocks = this.pendingAssistantBlocks.get(agent.name);
           if (pendingBlocks) {
@@ -2883,6 +4676,25 @@ export class AgentFramework {
             }
           }
 
+          // A newly injected message begins a new conversational round inside
+          // the same provider inference. Remember that boundary for
+          // driveStream: an explicit send in the preceding round must not
+          // silence the reply, and the newest channel-bearing injection is
+          // now the reply locus. Map presence matters even without a channel
+          // (CLI/module input): it still clears the prior send suppression.
+          if (midTurnInjections.length > 0) {
+            const injectedChannelId = midTurnInjections.reduce<string | null>(
+              (latest, injection) => {
+                const candidate = injection.metadata?.channelId;
+                return typeof candidate === 'string' && candidate.length > 0
+                  ? candidate
+                  : latest;
+              },
+              null,
+            );
+            this.midTurnRoutingResets.set(agent.name, injectedChannelId);
+          }
+
           // Check if any tool result requested endTurn
           const shouldEndTurn = currentState.toolResults.some(tc => tc.result.endTurn);
 
@@ -2913,6 +4725,59 @@ export class AgentFramework {
             // a terminal failure — rejecting an ephemeral's promise mid-run
             // and emitting a spurious inference:exhausted (same race shape as
             // endTurn above).
+            const requestId = activeStreamContext?.requestId;
+            const primarySummaryRetry = activeStreamContext?.trigger?.primarySummaryFallbackRetry;
+            const compiledRequest = activeStreamContext?.compiledRequest;
+            const artifacts = activeStreamContext?.artifacts;
+            const restartDispatch = await this.resolveContextBudgetRestartDispatch(
+              requestId ?? `${agent.name}:context_budget_restart`,
+              primarySummaryRetry,
+            );
+            if (
+              restartDispatch.dispatchKind === 'primary_summary_fallback_retry'
+              && requestId
+              && primarySummaryRetry
+              && compiledRequest
+              && artifacts
+            ) {
+              const validation = await this.validatePrimarySummaryRetryMutation(
+                agent,
+                requestId,
+                primarySummaryRetry,
+                compiledRequest,
+                artifacts,
+                'before_context_budget_restart_hold',
+              );
+              if (!validation.ok) {
+                await this.holdPrimarySummaryRetryFamily(
+                  agent,
+                  requestId,
+                  primarySummaryRetry,
+                  validation.reason,
+                  validation.data,
+                  { emitChronicleMarker: false, stopReason: 'abort' },
+                );
+              } else {
+                await this.holdPrimarySummaryRetryFamily(
+                  agent,
+                  requestId,
+                  primarySummaryRetry,
+                  'primary_summary_fallback_context_budget_restart_required',
+                  {
+                    inputTokens: agent.lastStreamInputTokens,
+                    budget: agent.maxStreamTokens,
+                    originalRequestId: primarySummaryRetry.originalRequestId,
+                    intentId: primarySummaryRetry.intentId,
+                  },
+                  { emitChronicleMarker: false, stopReason: 'abort' },
+                );
+              }
+              this.frameworkCancelledStreams.set(`${agent.name}:${agent.streamId}`, 'budget_restart');
+              currentState.stream?.cancel();
+              agent.reset();
+              this.settleAgent(agent.name, { stopReason: 'completed', speech: '' });
+              return;
+            }
             if (currentState.stream) {
               this.frameworkCancelledStreams.set(`${agent.name}:${agent.streamId}`, 'budget_restart');
             }
@@ -2929,6 +4794,8 @@ export class AgentFramework {
               reason: 'context_budget_restart',
               source: 'framework',
               timestamp: Date.now(),
+              channelId: activeStreamContext?.trigger?.channelId,
+              contextBudgetRestart: restartDispatch,
             });
           } else if (currentState.stream) {
             // Streaming path: convert results and resume the stream.
@@ -3515,7 +5382,7 @@ export class AgentFramework {
     const state = this.createFrameworkState();
 
     // Group requests by agent
-    const requestsByAgent = new Map<string, InferenceRequest[]>();
+    const requestsByAgent = new Map<string, PendingInferenceRequest[]>();
     for (const req of this.pendingRequests) {
       const existing = requestsByAgent.get(req.agentName) ?? [];
       existing.push(req);
@@ -3526,7 +5393,8 @@ export class AgentFramework {
     this.pendingRequests = [];
 
     // Check each agent
-    for (const [agentName, requests] of requestsByAgent) {
+    for (const [agentName, queuedRequests] of requestsByAgent) {
+      let requests = queuedRequests;
       const agent = this.agents.get(agentName);
       if (!agent) {
         // Agent not found — request is orphaned. Emit warning and drop.
@@ -3546,7 +5414,15 @@ export class AgentFramework {
       if (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 (now - oldest > STALE_REQUEST_MS) {
+        if (
+          now - oldest > STALE_REQUEST_MS &&
+          (this.staleWarnAt.get(agentName) ?? 0) < now - 60_000
+        ) {
+          // Trace and stderr share the throttle. The old code throttled only
+          // stderr, so a long-running tool call generated one trace per poll
+          // (up to 100/sec after the scheduler backoff), adding avoidable work
+          // precisely while the agent was already under pressure.
+          this.staleWarnAt.set(agentName, now);
           this.emitTrace({
             type: 'inference:request_stale',
             agentName,
@@ -3554,19 +5430,28 @@ export class AgentFramework {
             requestCount: requests.length,
             oldestRequestAge: now - oldest,
           });
-          // Loud (but throttled) note that requests are waiting on a busy agent.
-          if ((this.staleWarnAt.get(agentName) ?? 0) < now - 60_000) {
-            this.staleWarnAt.set(agentName, now);
-            console.error(
-              `[inference-stale] agent=${agentName} busy (${agent.state.status}) — ` +
-              `${requests.length} request(s) waiting ${Math.round((now - oldest) / 1000)}s`,
-            );
-          }
+          console.error(
+            `[inference-stale] agent=${agentName} busy (${agent.state.status}) — ` +
+            `${requests.length} request(s) waiting ${Math.round((now - oldest) / 1000)}s`,
+          );
         }
         this.pendingRequests.push(...requests);
         continue;
       }
 
+      if (this.discordAwarenessBarrier) {
+        this.pendingRequests.push(...requests);
+        continue;
+      }
+
+      requests = requests.filter((request) =>
+        request.reason !== 'context_budget_restart'
+        || request.contextBudgetRestart?.dispatchKind !== 'primary_summary_fallback_retry'
+      );
+      if (requests.length === 0) {
+        continue;
+      }
+
       // Check policy
       if (!this.inferencePolicy.shouldInfer(agentName, requests, state)) {
         // Loud drop: a queued request that dies here is otherwise invisible —
@@ -3580,7 +5465,12 @@ export class AgentFramework {
       }
 
       // Start streaming inference (non-blocking — driveStream runs in background)
-      const trigger = requests[0];
+      const trigger = requests.find((request) => request.primarySummaryFallbackRetry) ?? requests[0]!;
+      if (trigger.primarySummaryFallbackRetry) {
+        for (const request of requests) {
+          if (request !== trigger) this.pendingRequests.push(request);
+        }
+      }
       // Route this turn's auto-published speech to the channel that triggered
       // it (item-3 redux). A batched wake may carry several triggering channels
       // (messages arrived in >1 channel while the agent was busy/idle) — reply
@@ -3597,9 +5487,9 @@ export class AgentFramework {
     }
   }
 
-  private async startAgentStream(agent: Agent, trigger?: InferenceRequest, attempt = 0): Promise<void> {
+  private async startAgentStream(agent: Agent, trigger?: PendingInferenceRequest, attempt = 0): Promise<void> {
     // Record turn checkpoint before inference (only on first attempt, not retries)
-    if (attempt === 0) {
+    if (attempt === 0 && trigger?.reason !== 'primary-summary-fallback-retry') {
       this.recordTurnCheckpoint(agent.name);
       this.redoStacks.delete(agent.name); // new work invalidates redo
     }
@@ -3620,54 +5510,276 @@ export class AgentFramework {
     this.emitTrace({ type: 'inference:started', agentName: agent.name });
     this.eventGate?.onInferenceStarted(agent.name);
     this.lastInferenceAt.set(agent.name, { ...this.lastInferenceAt.get(agent.name), startedAt: Date.now() });
+    const requestId = `${agent.name}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
 
     try {
-      const allTools = this.getAllTools();
+      const requestSnapshot = this.captureInferenceToolSnapshot(agent);
+      const allTools = this.getToolsForAgent(agent.name, requestSnapshot);
       const tools = allTools.filter((t) => agent.canUseTool(t.name));
+      const fallbackConfig = this.primarySummaryFallbackConfig(agent);
+      const retryDispatch = trigger?.primarySummaryFallbackRetry;
+      let compiledRequest: NormalizedRequest;
+      let artifacts: ActivationCompileArtifacts;
+      let branch = agent.getCurrentBranchGeneration();
+
+      if (retryDispatch) {
+        if (!fallbackConfig.enabled) {
+          await this.holdPrimarySummaryRequest(
+            agent,
+            retryDispatch.originalRequestId,
+            'primary_summary_fallback_disabled_before_retry',
+          );
+          agent.reset();
+          this.settleAgent(agent.name, { stopReason: 'completed', speech: '' });
+          this.eventGate?.onInferenceEnded(agent.name);
+          this.lastInferenceAt.set(agent.name, { ...this.lastInferenceAt.get(agent.name), endedAt: Date.now() });
+          return;
+        }
 
-      // Gather context from modules (pull-based) and MCPL hooks (push-based)
-      // Both produce ContextInjection[] that get merged before inference.
-      let injections: ContextInjection[] | undefined;
+        const claim = await this.claimPrimarySummaryRetryIntent(
+          retryDispatch.originalRequestId,
+          retryDispatch.intentId,
+          requestId,
+        );
+        if (claim !== 'claimed') {
+          await this.holdPrimarySummaryRequest(
+            agent,
+            retryDispatch.originalRequestId,
+            claim === 'duplicate'
+              ? 'primary_summary_fallback_duplicate_retry_blocked'
+              : 'primary_summary_fallback_retry_intent_missing',
+            { intentId: retryDispatch.intentId, retryRequestId: requestId },
+          );
+          agent.reset();
+          this.settleAgent(agent.name, { stopReason: 'completed', speech: '' });
+          this.eventGate?.onInferenceEnded(agent.name);
+          this.lastInferenceAt.set(agent.name, { ...this.lastInferenceAt.get(agent.name), endedAt: Date.now() });
+          return;
+        }
 
-      // Module gatherContext (fail-open, per-module timeout — the module's
-      // contextTimeoutMs, else the registry default). Injections are
-      // channel-scoped via scopeInjectionsForAgent, matching the MCPL hook
-      // injections below, so conversation forks don't see cross-channel
-      // content.
-      try {
-        const moduleInjections = this.scopeInjectionsForAgent(
-          agent.name,
-          await this.moduleRegistry.gatherContext(agent.name),
+        if (
+          !branch ||
+          branch.id !== retryDispatch.branch.id ||
+          branch.generation !== retryDispatch.branch.generation
+        ) {
+          await this.holdPrimarySummaryRequest(
+            agent,
+            retryDispatch.originalRequestId,
+            'primary_summary_fallback_branch_changed_before_retry',
+            {
+              expectedBranchId: retryDispatch.branch.id,
+              expectedGeneration: retryDispatch.branch.generation,
+              actualBranchId: branch?.id,
+              actualGeneration: branch?.generation,
+            },
+          );
+          agent.reset();
+          this.settleAgent(agent.name, { stopReason: 'completed', speech: '' });
+          this.eventGate?.onInferenceEnded(agent.name);
+          this.lastInferenceAt.set(agent.name, { ...this.lastInferenceAt.get(agent.name), endedAt: Date.now() });
+          return;
+        }
+
+        const rebuilt = agent.buildPrimarySummaryRawExpansionRequest(
+          retryDispatch.originalArtifacts,
+          retryDispatch.candidateSummaries,
+          tools,
         );
-        if (moduleInjections.length > 0) {
-          injections = moduleInjections;
+        compiledRequest = rebuilt.request;
+        artifacts = rebuilt.artifacts;
+
+        const rebuiltHash = this.hashJson(compiledRequest);
+        if (
+          rebuiltHash !== retryDispatch.expectedRetryRequestHash ||
+          this.primarySummaryProjectionKeys(artifacts.compileResult.primarySummaryProjection ?? null).join('\u0000') !==
+            retryDispatch.originalProjectionKeys.join('\u0000')
+        ) {
+          await this.holdPrimarySummaryRequest(
+            agent,
+            retryDispatch.originalRequestId,
+            'primary_summary_fallback_revalidation_failed_before_retry',
+            {
+              expectedRetryRequestHash: retryDispatch.expectedRetryRequestHash,
+              actualRetryRequestHash: rebuiltHash,
+            },
+          );
+          agent.reset();
+          this.settleAgent(agent.name, { stopReason: 'completed', speech: '' });
+          this.eventGate?.onInferenceEnded(agent.name);
+          this.lastInferenceAt.set(agent.name, { ...this.lastInferenceAt.get(agent.name), endedAt: Date.now() });
+          return;
         }
-      } catch (error) {
-        console.error('Module gatherContext error:', error);
-      }
 
-      // MCPL beforeInference hooks (fail-open)
-      if (this.hookOrchestrator) {
+        const retryRecord = this.buildPrimarySummaryRequestRecord(
+          agent,
+          requestId,
+          'primary_summary_fallback_retry',
+          compiledRequest,
+          artifacts,
+          branch,
+          undefined,
+          false,
+          0,
+          undefined,
+          'pending',
+        );
+        await this.persistPrimarySummaryRequestRecord(retryRecord);
+
+        const admittedTokens = this.primarySummaryAdmissionBoundTokens(
+          retryDispatch.originalRequestInputBoundTokens,
+          compiledRequest,
+          retryDispatch.originalProviderInputTokens,
+        );
+        if (admittedTokens > retryDispatch.requestBudgetTokens) {
+          await this.holdPrimarySummaryRequest(
+            agent,
+            requestId,
+            'primary_summary_fallback_retry_over_budget',
+            {
+              admittedTokens,
+              requestBudgetTokens: retryDispatch.requestBudgetTokens,
+              retryRequestHash: rebuiltHash,
+            },
+          );
+          await this.updatePrimarySummaryRequestRecord(retryDispatch.originalRequestId, (record) => ({
+            ...record,
+            fallbackStatus: 'held',
+            fallbackHeldReason: 'primary_summary_fallback_retry_over_budget',
+          }));
+          agent.reset();
+          this.settleAgent(agent.name, { stopReason: 'completed', speech: '' });
+          this.eventGate?.onInferenceEnded(agent.name);
+          this.lastInferenceAt.set(agent.name, { ...this.lastInferenceAt.get(agent.name), endedAt: Date.now() });
+          return;
+        }
+      } else {
+        // Gather context from modules (pull-based) and MCPL hooks (push-based)
+        // Both produce ContextInjection[] that get merged before inference.
+        let injections: ContextInjection[] | undefined;
+
+        // Module gatherContext (fail-open, per-module timeout — the module's
+        // contextTimeoutMs, else the registry default). Injections are
+        // channel-scoped via scopeInjectionsForAgent, matching the MCPL hook
+        // injections below, so conversation forks don't see cross-channel
+        // content.
         try {
-          const hookParams = this.buildBeforeInferenceParams(agent, trigger);
-          const hookInjections = this.scopeInjectionsForAgent(
+          const moduleInjections = this.scopeInjectionsForAgent(
             agent.name,
-            await this.hookOrchestrator.beforeInference(hookParams),
+            await this.moduleRegistry.gatherContext(agent.name),
           );
-          if (hookInjections.length > 0) {
-            injections = injections ? [...injections, ...hookInjections] : hookInjections;
+          if (moduleInjections.length > 0) {
+            injections = moduleInjections;
           }
         } catch (error) {
-          console.error('beforeInference hook error:', error);
+          console.error('Module gatherContext error:', error);
+        }
+
+        // MCPL beforeInference hooks (fail-open)
+        if (this.hookOrchestrator) {
+          try {
+            const hookParams = this.buildBeforeInferenceParams(agent, trigger);
+            const hookInjections = this.scopeInjectionsForAgent(
+              agent.name,
+              await this.hookOrchestrator.beforeInference(hookParams),
+            );
+            if (hookInjections.length > 0) {
+              injections = injections ? [...injections, ...hookInjections] : hookInjections;
+            }
+          } catch (error) {
+            console.error('beforeInference hook error:', error);
+          }
         }
-      }
 
-      const { stream, request: compiledRequest } = await agent.startStreamWithInjections(tools, injections);
+        const prepared = await agent.prepareActivationRequest(tools, injections);
+        compiledRequest = prepared.request;
+        artifacts = prepared.artifacts;
+        branch = agent.getCurrentBranchGeneration();
+
+        if (fallbackConfig.enabled) {
+          const record = this.buildPrimarySummaryRequestRecord(
+            agent,
+            requestId,
+            'primary',
+            compiledRequest,
+            artifacts,
+            branch,
+            undefined,
+            false,
+            0,
+            undefined,
+            'pending',
+          );
+          await this.persistPrimarySummaryRequestRecord(record);
+          const expandedByQuarantine =
+            artifacts.compileResult.primarySummaryProjection?.selectedSummaries.some(
+              (selection) => selection.renderedAs === 'raw_expansion',
+            ) ?? false;
+          if (expandedByQuarantine) {
+            const admittedTokens = this.estimateRequestCompleteBoundTokens(compiledRequest);
+            if (admittedTokens > fallbackConfig.requestBudgetTokens) {
+              await this.holdPrimarySummaryRequest(
+                agent,
+                requestId,
+                'primary_summary_quarantine_over_budget',
+                {
+                  admittedTokens,
+                  requestBudgetTokens: fallbackConfig.requestBudgetTokens,
+                },
+              );
+              agent.reset();
+              this.settleAgent(agent.name, { stopReason: 'completed', speech: '' });
+              this.eventGate?.onInferenceEnded(agent.name);
+              this.lastInferenceAt.set(agent.name, { ...this.lastInferenceAt.get(agent.name), endedAt: Date.now() });
+              return;
+            }
+          }
+        }
+      }
 
-      const handle = this.driveStream(agent, stream, trigger, attempt, compiledRequest);
+      const { stream } = agent.startStreamFromRequest(compiledRequest, artifacts);
+      this.activeStreamContexts.set(agent.name, {
+        requestId,
+        trigger,
+        compiledRequest,
+        artifacts,
+      });
+      const handle = this.driveStream(
+        agent,
+        stream,
+        requestSnapshot,
+        requestId,
+        trigger,
+        attempt,
+        compiledRequest,
+        artifacts,
+      );
       this.activeStreams.set(agent.name, handle);
     } catch (error) {
       const err = error instanceof Error ? error : new Error(String(error));
+      if (trigger?.primarySummaryFallbackRetry) {
+        await this.updatePrimarySummaryRequestRecord(requestId, (record) => ({
+          ...record,
+          finalStatus: 'held',
+          fallbackHeldReason: err.message,
+        }));
+        await this.updatePrimarySummaryRequestRecord(trigger.primarySummaryFallbackRetry.originalRequestId, (record) => ({
+          ...record,
+          finalStatus: 'held',
+          fallbackStatus: 'held',
+          fallbackHeldReason: err.message,
+        }));
+        this.opsAlert('refusal-held', agent.name, err.message, {
+          data: { requestId, originalRequestId: trigger.primarySummaryFallbackRetry.originalRequestId },
+        });
+        agent.reset();
+        this.settleAgent(agent.name, {
+          stopReason: 'completed',
+          speech: '',
+        });
+        this.eventGate?.onInferenceEnded(agent.name);
+        this.lastInferenceAt.set(agent.name, { ...this.lastInferenceAt.get(agent.name), endedAt: Date.now() });
+        return;
+      }
       this.emitTrace({
         type: 'inference:failed',
         agentName: agent.name,
@@ -3710,27 +5822,35 @@ export class AgentFramework {
   private async driveStream(
     agent: Agent,
     stream: YieldingStream,
-    trigger?: InferenceRequest,
+    requestSnapshot: InferenceToolSnapshot,
+    requestId: string,
+    trigger?: PendingInferenceRequest,
     attempt = 0,
-    compiledRequest?: NormalizedRequest
+    compiledRequest?: NormalizedRequest,
+    artifacts?: ActivationCompileArtifacts,
   ): Promise<void> {
     const startTime = Date.now();
-    const requestId = `${agent.name}-${startTime}-${Math.random().toString(36).slice(2, 8)}`;
     const myStreamId = agent.streamId;
     let hadToolCalls = false;
+    let executedToolCalls = 0;
+    const primarySummaryConfig = this.primarySummaryFallbackConfig(agent);
+    const primarySummaryRetry = trigger?.primarySummaryFallbackRetry;
+    let primarySummaryQuarantinePersisted = false;
+    const fallbackRetryRequestForLog =
+      primarySummaryRetry && compiledRequest
+        ? this.summarizePrimarySummaryRetryRequest(compiledRequest)
+        : compiledRequest ?? { note: 'streaming request' };
 
     // ---- Present-while-acting turn state ---------------------------------
-    // Output locus for THIS turn: resolved lazily at the first routed prose
-    // segment and pinned for the rest of the turn (mid-turn rounds AND the
-    // trailing prose at 'complete'), so one turn's voice stays in one channel
-    // even when a queued inbound from another channel overwrites the
-    // per-agent triggering channel between segments (PR #32). The pin lives
-    // in `turnLocusPins` so it survives a context-budget stream restart. A
-    // null resolution is NOT pinned — a turn whose locus is unresolvable
-    // early (e.g. heartbeat-triggered) may still resolve a channel by the
-    // time later prose routes.
-    if (trigger?.reason !== 'context_budget_restart') {
+    // Output locus for the current CONVERSATIONAL ROUND: resolved lazily and
+    // kept stable across tool-only rounds. A channel message injected at a
+    // tool boundary replaces the pin before the next model round, because a
+    // single provider inference can now contain several conversations. The
+    // pin lives in `turnLocusPins` so it survives a context-budget restart. A
+    // null resolution is not pinned.
+    if (trigger?.reason !== 'context_budget_restart' && trigger?.reason !== 'primary-summary-fallback-retry') {
       this.turnLocusPins.delete(agent.name);
+      this.midTurnRoutingResets.delete(agent.name);
     }
     const resolveTurnLocus = (): string | null => {
       let locus = this.turnLocusPins.get(agent.name) ?? null;
@@ -3757,10 +5877,9 @@ export class AgentFramework {
         .catch((err) => console.error('mid-turn speech routing failed:', err));
     };
 
-    // Sticky silencing: once any round uses a SILENCING_TOOLS member,
-    // prose from that round ONWARD is suppressed — skip_reply means "stay
-    // silent", an explicit send means "I deliver my own words". Earlier
-    // rounds' prose was already delivered live and cannot be retracted.
+    // Sticky explicit-send suppression: prose after send_message stays quiet
+    // to prevent a redundant "sent it" postscript. Fresh injected input
+    // clears it, because the following prose is a reply to a new message.
     let turnSilenced = false;
 
     // Live routing is only trusted when the membrane provides verbatim
@@ -3777,11 +5896,128 @@ export class AgentFramework {
     // responding to, for the whole duration of this turn. Started here (paired
     // with the finally below, so it can never leak) and refreshed on a 7s
     // interval by the ChannelRegistry until stopped on any exit path.
-    const typingChannel = this.channelRegistry
+    let typingChannel = this.channelRegistry
       ? trigger?.channelId ?? this.channelRegistry.getDefaultPublishChannel()
       : null;
     if (typingChannel) this.channelRegistry!.startTyping(typingChannel);
 
+    const adoptInjectedRound = (): void => {
+      if (!this.midTurnRoutingResets.has(agent.name)) return;
+      const nextLocus = this.midTurnRoutingResets.get(agent.name) ?? null;
+      this.midTurnRoutingResets.delete(agent.name);
+
+      // A new human/agent message, not merely a tool result, means any earlier
+      // explicit delivery has completed its conversational job.
+      turnSilenced = false;
+
+      if (nextLocus) {
+        this.turnLocusPins.set(agent.name, nextLocus);
+        if (typingChannel !== nextLocus) {
+          if (typingChannel) this.channelRegistry?.stopTyping(typingChannel);
+          typingChannel = nextLocus;
+          this.channelRegistry?.startTyping(nextLocus);
+        }
+      }
+    };
+
+    const persistPrimarySummaryRetryQuarantine = async (): Promise<boolean> => {
+      if (!primarySummaryRetry || primarySummaryQuarantinePersisted || !artifacts) return true;
+      const validation = await this.validatePrimarySummaryRetryMutation(
+        agent,
+        requestId,
+        primarySummaryRetry,
+        compiledRequest!,
+        artifacts,
+        'before_quarantine',
+      );
+      if (!validation.ok) {
+        await this.holdPrimarySummaryRetryFamily(
+          agent,
+          requestId,
+          primarySummaryRetry,
+          validation.reason,
+          validation.data,
+          { emitChronicleMarker: false },
+        );
+        stream.cancel();
+        agent.reset();
+        this.settleAgent(agent.name, { stopReason: 'completed', speech: '' });
+        return false;
+      }
+      try {
+        const quarantinePrimarySummaryForPrimaryLane =
+          agent.getContextManager().quarantinePrimarySummaryForPrimaryLane;
+        if (typeof quarantinePrimarySummaryForPrimaryLane !== 'function') {
+          throw new Error('Primary summary quarantine is unavailable in the active context strategy');
+        }
+        await quarantinePrimarySummaryForPrimaryLane.call(
+          agent.getContextManager(),
+          artifacts.contract,
+          primarySummaryRetry.candidateSummaries,
+        );
+        primarySummaryQuarantinePersisted = true;
+        await this.recordPrimarySummaryRetryQuarantine(
+          primarySummaryRetry.originalRequestId,
+          primarySummaryRetry.intentId,
+        );
+        return true;
+      } catch (error) {
+        const reason = 'primary_summary_fallback_quarantine_failed';
+        await this.holdPrimarySummaryRetryFamily(agent, requestId, primarySummaryRetry, reason, {
+          error: error instanceof Error ? error.message : String(error),
+        });
+        stream.cancel();
+        agent.reset();
+        this.settleAgent(agent.name, { stopReason: 'completed', speech: '' });
+        return false;
+      }
+    };
+
+    const persistPrimarySummaryRetryOutput = async (
+      phase: string,
+      blocks: ContentBlock[],
+      participant = agent.name,
+      metadata?: MessageMetadata,
+    ): Promise<boolean> => {
+      if (!primarySummaryRetry || !artifacts) return true;
+      if (blocks.length === 0) return true;
+      const validation = await this.validatePrimarySummaryRetryMutation(
+        agent,
+        requestId,
+        primarySummaryRetry,
+        compiledRequest!,
+        artifacts,
+        `before_${phase}`,
+      );
+      if (!validation.ok) {
+        await this.holdPrimarySummaryRetryFamily(
+          agent,
+          requestId,
+          primarySummaryRetry,
+          validation.reason,
+          validation.data,
+          { emitChronicleMarker: false },
+        );
+        stream.cancel();
+        agent.reset();
+        this.settleAgent(agent.name, { stopReason: 'completed', speech: '' });
+        return false;
+      }
+      const messageId = agent.getContextManager().addMessage(participant, blocks, metadata);
+      await this.recordPrimarySummaryRetryOutput(
+        primarySummaryRetry.originalRequestId,
+        primarySummaryRetry.intentId,
+        {
+          phase,
+          contentHash: this.primarySummaryFallbackOutputPhaseHash(blocks),
+          messageId,
+          blockTypes: this.primarySummaryFallbackBlockTypes(blocks),
+          persistedAt: Date.now(),
+        },
+      );
+      return true;
+    };
+
     try {
       for await (const event of stream) {
         this.touchEphemeralRun(agent.name, true);
@@ -3809,8 +6045,8 @@ export class AgentFramework {
           }
 
           case 'tool-calls': {
+            adoptInjectedRound();
             hadToolCalls = true;
-            this.recordEphemeralToolCalls(agent.name, event.calls.length);
             this.emitTrace({
               type: 'inference:tool_calls_yielded',
               agentName: agent.name,
@@ -3849,7 +6085,51 @@ export class AgentFramework {
 
             agent.enterWaitingForTools(event.calls, stream);
 
+            if (!(await persistPrimarySummaryRetryQuarantine())) {
+              return;
+            }
+
+            if (primarySummaryRetry) {
+              const phase = `tool_round_${event.context.depth ?? 0}`;
+              if (!(await persistPrimarySummaryRetryOutput(phase, assistantBlocks))) {
+                return;
+              }
+              this.pendingAssistantBlocks.delete(agent.name);
+            }
+
+            executedToolCalls += event.calls.length;
+            this.recordEphemeralToolCalls(agent.name, event.calls.length);
+
             for (const call of event.calls) {
+              if (primarySummaryRetry) {
+                const validation = await this.validatePrimarySummaryRetryMutation(
+                  agent,
+                  requestId,
+                  primarySummaryRetry,
+                  compiledRequest!,
+                  artifacts!,
+                  `before_tool_dispatch_${call.id}`,
+                );
+                if (!validation.ok) {
+                  await this.holdPrimarySummaryRetryFamily(
+                    agent,
+                    requestId,
+                    primarySummaryRetry,
+                    validation.reason,
+                    validation.data,
+                    { emitChronicleMarker: false },
+                  );
+                  stream.cancel();
+                  agent.reset();
+                  this.settleAgent(agent.name, { stopReason: 'completed', speech: '' });
+                  return;
+                }
+                await this.recordPrimarySummaryRetryToolDispatch(
+                  primarySummaryRetry.originalRequestId,
+                  primarySummaryRetry.intentId,
+                  call,
+                );
+              }
               this.dispatchToolCall(agent.name, call);
             }
 
@@ -3866,6 +6146,9 @@ export class AgentFramework {
             // note above — the fallback preamble is cumulative in XML mode).
             if (this.channelRegistry) {
               const roundToolNames = event.calls.map((c) => c.name);
+              const hasSameRoundPrivateThink =
+                roundToolNames.includes('think') &&
+                requestSnapshot.sameRoundThinkTextPolicy === 'private';
               if (roundToolNames.some((n) => SILENCING_TOOLS.has(bareToolName(n)))) {
                 turnSilenced = true;
               }
@@ -3877,6 +6160,10 @@ export class AgentFramework {
                     console.error(
                       `[routing] ${agent.name}: mid-turn round [${roundToolNames.join(', ')}] -> prose NOT routed (turn silenced)`,
                     );
+                  } else if (hasSameRoundPrivateThink) {
+                    console.error(
+                      `[routing] ${agent.name}: mid-turn round [${roundToolNames.join(', ')}] -> prose NOT routed (same_round_think_text_policy=private)`,
+                    );
                   } else {
                     const locus = resolveTurnLocus();
                     console.error(
@@ -3894,6 +6181,7 @@ export class AgentFramework {
           }
 
           case 'complete': {
+            adoptInjectedRound();
             const durationMs = Date.now() - startTime;
             const response = event.response;
 
@@ -3934,14 +6222,6 @@ export class AgentFramework {
               }
             }
 
-            // Add assistant response to context.
-            // If we had tool calls, each round's blocks (thinking + text +
-            // tool_use) were already stored as pendingAssistantBlocks and
-            // flushed when tool results arrived. Only store TRAILING content
-            // — blocks after the last tool block. A type-based filter would
-            // double-store earlier rounds' text/thinking AND detach signed
-            // thinking blocks from their tool_use turn (the API requires
-            // thinking to precede tool_use in the same assistant turn).
             const lastToolIdx = response.content.reduce(
               (last: number, b: ContentBlock, i: number) =>
                 b.type === 'tool_use' || b.type === 'tool_result' ? i : last,
@@ -3950,12 +6230,259 @@ export class AgentFramework {
             const terminalContent = lastToolIdx >= 0
               ? response.content.slice(lastToolIdx + 1)
               : response.content;
+            const heldAssistantContent = response.content;
+            const visibleAssistantOutput = this.hasVisibleAssistantOutput(response.content);
+            const providerInputTokens =
+              response.usage?.inputTokens ??
+              response.details?.usage?.inputTokens;
+
+            if (primarySummaryConfig.enabled && compiledRequest && artifacts && response.stopReason === 'refusal') {
+              const stopDetails = (response.raw?.response as {
+                stop_details?: { category?: string; explanation?: string };
+              } | undefined)?.stop_details;
+              const category = stopDetails?.category ?? 'unknown';
+              console.error(
+                `[inference-refusal] agent=${agent.name} category=${category}` +
+                  (stopDetails?.explanation ? ` explanation=${stopDetails.explanation}` : ''),
+              );
+              this.noteRefusal(agent.name, category, response.details?.usage
+                ? {
+                    input: response.details.usage.inputTokens,
+                    output: response.details.usage.outputTokens,
+                  }
+                : undefined);
+
+              const currentRecord = await this.updatePrimarySummaryRequestRecord(requestId, (record) => ({
+                ...record,
+                stopReason: response.stopReason,
+                providerInputTokens,
+                visibleAssistantOutput,
+                executedToolCalls,
+                finalStatus: 'refusal',
+              }));
+
+              const holdReasonData = {
+                category,
+                visibleAssistantOutput,
+                executedToolCalls,
+                candidateLimit: primarySummaryConfig.maxNewSummaries,
+              };
+
+              if (primarySummaryRetry) {
+                const reason = visibleAssistantOutput
+                  ? 'primary_summary_fallback_retry_partial_output'
+                  : executedToolCalls > 0
+                    ? 'primary_summary_fallback_retry_tool_already_executed'
+                    : 'primary_summary_fallback_retry_refusal';
+                if (visibleAssistantOutput || executedToolCalls > 0) {
+                  await this.persistPrimarySummaryHeldOutput(agent, requestId, reason, {
+                    stopReason: response.stopReason,
+                    providerInputTokens,
+                    visibleAssistantOutput,
+                    executedToolCalls,
+                    assistantBlocks: heldAssistantContent,
+                    retryDispatch: primarySummaryRetry,
+                    retryPhase: 'refusal_visible_output',
+                    holdData: holdReasonData,
+                  });
+                } else {
+                  await this.holdPrimarySummaryRetryFamily(
+                    agent,
+                    requestId,
+                    primarySummaryRetry,
+                    reason,
+                    holdReasonData,
+                  );
+                }
+              } else if (visibleAssistantOutput || executedToolCalls > 0 || !currentRecord?.projection) {
+                const reason = visibleAssistantOutput
+                  ? 'primary_summary_refusal_partial_output'
+                  : executedToolCalls > 0
+                    ? 'primary_summary_refusal_tool_already_executed'
+                    : 'primary_summary_refusal_no_projection';
+                if (visibleAssistantOutput || executedToolCalls > 0) {
+                  await this.persistPrimarySummaryHeldOutput(agent, requestId, reason, {
+                    stopReason: response.stopReason,
+                    providerInputTokens,
+                    visibleAssistantOutput,
+                    executedToolCalls,
+                    assistantBlocks: heldAssistantContent,
+                    holdData: holdReasonData,
+                  });
+                } else {
+                  await this.holdPrimarySummaryRequest(agent, requestId, reason, holdReasonData);
+                }
+              } else {
+                const state = this.readPrimarySummaryFallbackState();
+                const baseline = this.latestCompatibleHealthyPrimaryRequest(currentRecord, state);
+                if (!baseline?.projection) {
+                  await this.holdPrimarySummaryRequest(
+                    agent,
+                    requestId,
+                    'primary_summary_refusal_no_compatible_healthy_baseline',
+                    holdReasonData,
+                  );
+                } else {
+                  const baselineKeys = new Set(this.primarySummaryProjectionKeys(baseline.projection));
+                  const candidates = currentRecord.projection.selectedSummaries
+                    .filter((selection) => !baselineKeys.has(this.primarySummaryIdentityKey(selection.identity)))
+                    .map((selection) => selection.identity);
+                  if (candidates.length === 0) {
+                    await this.holdPrimarySummaryRequest(
+                      agent,
+                      requestId,
+                      'primary_summary_refusal_no_newly_admitted_candidates',
+                      holdReasonData,
+                    );
+                  } else if (candidates.length > primarySummaryConfig.maxNewSummaries) {
+                    await this.holdPrimarySummaryRequest(
+                      agent,
+                      requestId,
+                      'primary_summary_refusal_too_many_candidates',
+                      { ...holdReasonData, candidateCount: candidates.length },
+                    );
+                  } else {
+                    try {
+                      const retry = agent.buildPrimarySummaryRawExpansionRequest(
+                        artifacts,
+                        candidates,
+                        compiledRequest.tools ?? [],
+                      );
+                      const retryRequestHash = this.hashJson(retry.request);
+                      const admittedTokens = this.primarySummaryAdmissionBoundTokens(
+                        currentRecord.requestInputBoundTokens,
+                        retry.request,
+                        providerInputTokens,
+                      );
+                      if (admittedTokens > primarySummaryConfig.requestBudgetTokens) {
+                        await this.holdPrimarySummaryRequest(
+                          agent,
+                          requestId,
+                          'primary_summary_refusal_retry_over_budget',
+                          {
+                            ...holdReasonData,
+                            admittedTokens,
+                            requestBudgetTokens: primarySummaryConfig.requestBudgetTokens,
+                          },
+                        );
+                      } else {
+                        const intentId = `${requestId}:fallback:${Math.random().toString(36).slice(2, 8)}`;
+                        await this.updatePrimarySummaryRequestRecord(requestId, (record) => ({
+                          ...record,
+                          fallbackIntent: {
+                            intentId,
+                            createdAt: Date.now(),
+                            baselineRequestId: baseline.requestId,
+                            candidateSummaries: candidates,
+                            retryRequestHash,
+                            retryCompleteBoundTokens: admittedTokens,
+                            requestBudgetTokens: primarySummaryConfig.requestBudgetTokens,
+                          },
+                          fallbackStatus: 'pending',
+                        }));
+                        this.pendingRequests.push({
+                          agentName: agent.name,
+                          reason: 'primary-summary-fallback-retry',
+                          source: 'framework',
+                          timestamp: Date.now(),
+                          channelId: trigger?.channelId,
+                          primarySummaryFallbackRetry: {
+                            originalRequestId: requestId,
+                            baselineRequestId: baseline.requestId,
+                            intentId,
+                            branch: {
+                              id: currentRecord.branch.id,
+                              generation: currentRecord.branch.generation,
+                            },
+                            candidateSummaries: candidates,
+                            originalArtifacts: artifacts,
+                            originalProjectionKeys: this.primarySummaryProjectionKeys(currentRecord.projection),
+                            expectedRetryRequestHash: retryRequestHash,
+                            requestBudgetTokens: primarySummaryConfig.requestBudgetTokens,
+                            originalRequestInputBoundTokens: currentRecord.requestInputBoundTokens,
+                            originalProviderInputTokens: providerInputTokens,
+                          },
+                        });
+                      }
+                    } catch (error) {
+                      await this.holdPrimarySummaryRequest(
+                        agent,
+                        requestId,
+                        'primary_summary_refusal_retry_build_failed',
+                        {
+                          ...holdReasonData,
+                          error: error instanceof Error ? error.message : String(error),
+                        },
+                      );
+                    }
+                  }
+                }
+              }
+
+              agent.reset();
+              this.eventGate?.onInferenceEnded(agent.name);
+              this.settleAgent(agent.name, { stopReason: 'completed', speech: '' });
+              continue;
+            }
+
+            if (!(await persistPrimarySummaryRetryQuarantine())) {
+              return;
+            }
+
+            // Add assistant response to context.
+            // If we had tool calls, each round's blocks (thinking + text +
+            // tool_use) were already stored as pendingAssistantBlocks and
+            // flushed when tool results arrived. Only store TRAILING content
+            // — blocks after the last tool block. A type-based filter would
+            // double-store earlier rounds' text/thinking AND detach signed
+            // thinking blocks from their tool_use turn (the API requires
+            // thinking to precede tool_use in the same assistant turn).
             if (lastToolIdx >= 0) {
               if (terminalContent.length > 0) {
-                agent.addAssistantResponse(terminalContent);
+                if (primarySummaryRetry) {
+                  const retryRecord = await this.getPrimarySummaryRequestRecord(requestId);
+                  const terminalMetadata = retryRecord
+                    ? this.buildPrimarySummarySettlementMetadata(retryRecord, {
+                        outcome: 'success',
+                        stopReason: response.stopReason,
+                        providerInputTokens,
+                        visibleAssistantOutput,
+                        executedToolCalls,
+                        entryIndex: 0,
+                        entryCount: 1,
+                        role: 'assistant',
+                        kind: 'assistant_output',
+                      })
+                    : undefined;
+                  if (!(await persistPrimarySummaryRetryOutput('terminal', terminalContent, agent.name, terminalMetadata))) {
+                    return;
+                  }
+                } else {
+                  agent.addAssistantResponse(terminalContent);
+                }
               }
             } else {
-              agent.addAssistantResponse(terminalContent);
+              if (primarySummaryRetry) {
+                const retryRecord = await this.getPrimarySummaryRequestRecord(requestId);
+                const terminalMetadata = retryRecord && terminalContent.length > 0
+                  ? this.buildPrimarySummarySettlementMetadata(retryRecord, {
+                      outcome: 'success',
+                      stopReason: response.stopReason,
+                      providerInputTokens,
+                      visibleAssistantOutput,
+                      executedToolCalls,
+                      entryIndex: 0,
+                      entryCount: 1,
+                      role: 'assistant',
+                      kind: 'assistant_output',
+                    })
+                  : undefined;
+                if (!(await persistPrimarySummaryRetryOutput('terminal', terminalContent, agent.name, terminalMetadata))) {
+                  return;
+                }
+              } else {
+                agent.addAssistantResponse(terminalContent);
+              }
             }
 
             // Run afterInference hooks (no-op if no MCPL servers)
@@ -4017,6 +6544,50 @@ export class AgentFramework {
                 }
               : undefined;
 
+            if (primarySummaryRetry && artifacts) {
+              const validation = await this.validatePrimarySummaryRetryMutation(
+                agent,
+                requestId,
+                primarySummaryRetry,
+                compiledRequest!,
+                artifacts,
+                'before_success_markers',
+              );
+              if (!validation.ok) {
+                await this.holdPrimarySummaryRetryFamily(
+                  agent,
+                  requestId,
+                  primarySummaryRetry,
+                  validation.reason,
+                  validation.data,
+                  { emitChronicleMarker: false },
+                );
+                return;
+              }
+            }
+
+            if (primarySummaryConfig.enabled) {
+              if (primarySummaryRetry) {
+                await this.markPrimarySummaryRetrySuccess(
+                  requestId,
+                  primarySummaryRetry,
+                  response.stopReason,
+                  providerInputTokens,
+                  visibleAssistantOutput,
+                  executedToolCalls,
+                );
+              } else {
+                await this.updatePrimarySummaryRequestRecord(requestId, (record) => ({
+                  ...record,
+                  stopReason: response.stopReason,
+                  providerInputTokens,
+                  visibleAssistantOutput,
+                  executedToolCalls,
+                  finalStatus: 'success',
+                }));
+              }
+            }
+
             // Reset agent state before emitting inference:completed. Traces are
             // observability-only, but external synchronous listeners should
             // still see the terminal state at the terminal trace boundary.
@@ -4055,8 +6626,10 @@ export class AgentFramework {
               agentName: agent.name,
               requestId,
               success: true,
-              request: compiledRequest ?? { note: 'streaming request' },
-              response: response.raw ?? { note: 'streaming response' },
+              request: fallbackRetryRequestForLog,
+              response: primarySummaryRetry
+                ? this.summarizePrimarySummaryRetryResponse(response)
+                : response.raw ?? { note: 'streaming response' },
               durationMs,
               tokenUsage,
               stopReason: response.stopReason,
@@ -4209,15 +6782,17 @@ export class AgentFramework {
               // speech/thoughts split is left untouched (module/TUI rendering
               // unaffected) — this only governs what reaches the channel.
               //
-              // Silencing here is the sticky flag ∪ turn-wide scan: the scan
-              // (over the whole turn's tool_use blocks) covers the fallback
-              // path and the "send_message then a 'sent it.' postscript"
-              // double-post guard; the sticky flag is its live-rounds twin.
+              // Native round routing uses the live sticky flag, which a fresh
+              // injected message can reset. The legacy/fallback path has no
+              // reliable round boundaries, so retain its historical turn-wide
+              // scan to avoid double-posting.
               const toolNames = response.content
                 .filter((b) => b.type === 'tool_use')
                 .map((b) => (b as unknown as { name?: string }).name)
                 .filter((n): n is string => typeof n === 'string');
-              const silenced = turnSilenced || toolNames.some((n) => SILENCING_TOOLS.has(bareToolName(n)));
+              const silenced = liveProseRouting
+                ? turnSilenced
+                : turnSilenced || toolNames.some((n) => SILENCING_TOOLS.has(bareToolName(n)));
 
               const segments = splitProseSegments(liveProseRouting ? terminalContent : response.content);
 
@@ -4276,13 +6851,30 @@ export class AgentFramework {
               requestId,
               success: false,
               error: err.message,
-              request: compiledRequest ?? { note: 'streaming request failed' },
+              request: fallbackRetryRequestForLog,
               durationMs,
             });
 
             // Only reset + retry if this is still the active stream
             if (agent.streamId !== myStreamId) break;
 
+            if (primarySummaryRetry) {
+              await this.holdPrimarySummaryRetryFamily(
+                agent,
+                requestId,
+                primarySummaryRetry,
+                'primary_summary_fallback_retry_stream_error',
+                { error: err.message },
+              );
+              agent.reset();
+              this.eventGate?.onInferenceEnded(agent.name);
+              this.settleAgent(agent.name, {
+                stopReason: 'completed',
+                speech: '',
+              });
+              return;
+            }
+
             agent.reset();
 
             const action = this.errorPolicy.onInferenceError(err, agent.name, attempt);
@@ -4322,6 +6914,17 @@ export class AgentFramework {
             // 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}`)) {
+              if (primarySummaryRetry) {
+                if (!(await this.primarySummaryRetryFamilyAlreadySettled(requestId, primarySummaryRetry))) {
+                  await this.holdPrimarySummaryRetryFamily(
+                    agent,
+                    requestId,
+                    primarySummaryRetry,
+                    'primary_summary_fallback_retry_cancelled_before_success',
+                    { frameworkCancelled: true },
+                  );
+                }
+              }
               this.eventGate?.onInferenceEnded(agent.name);
               return;
             }
@@ -4330,6 +6933,40 @@ export class AgentFramework {
             // may have already started a new stream, bumping streamId)
             if (agent.streamId === myStreamId) {
               const durationMs = Date.now() - startTime;
+              if (primarySummaryRetry) {
+                await this.holdPrimarySummaryRetryFamily(
+                  agent,
+                  requestId,
+                  primarySummaryRetry,
+                  `stream_aborted:${reason}`,
+                  { reason },
+                  { stopReason: 'abort' },
+                );
+                agent.reset();
+                this.eventGate?.onInferenceEnded(agent.name);
+                this.logInference({
+                  timestamp: startTime,
+                  agentName: agent.name,
+                  requestId,
+                  success: false,
+                  error: `Stream aborted: ${reason}`,
+                  request: fallbackRetryRequestForLog,
+                  durationMs,
+                });
+                this.settleAgent(agent.name, {
+                  stopReason: 'completed',
+                  speech: '',
+                });
+                return;
+              }
+              if (primarySummaryConfig.enabled) {
+                await this.updatePrimarySummaryRequestRecord(requestId, (record) => ({
+                  ...record,
+                  stopReason: 'abort',
+                  finalStatus: 'error',
+                  fallbackHeldReason: `stream_aborted:${reason}`,
+                }));
+              }
               agent.reset();
               this.settleAgent(agent.name, {
                 stopReason: 'exhausted',
@@ -4353,7 +6990,7 @@ export class AgentFramework {
                 requestId,
                 success: false,
                 error: `Stream aborted: ${reason}`,
-                request: compiledRequest ?? { note: 'streaming request aborted' },
+                request: fallbackRetryRequestForLog,
                 durationMs,
               });
               this.eventGate?.onInferenceEnded(agent.name);
@@ -4405,12 +7042,63 @@ export class AgentFramework {
       // inference:exhausted so ephemeral agent promises can settle.
       const err = error instanceof Error ? error : new Error(String(error));
       const durationMs = Date.now() - startTime;
+      if (primarySummaryRetry) {
+        if (await this.primarySummaryRetryAlreadySucceeded(requestId, primarySummaryRetry)) {
+          this.logInference({
+            timestamp: startTime,
+            agentName: agent.name,
+            requestId,
+            success: true,
+            request: fallbackRetryRequestForLog,
+            response: { kind: 'primary_summary_fallback_retry', postSuccessError: err.message },
+            durationMs,
+          });
+          agent.reset();
+          this.eventGate?.onInferenceEnded(agent.name);
+          this.settleAgent(agent.name, {
+            stopReason: 'completed',
+            speech: '',
+          });
+          return;
+        }
+        await this.holdPrimarySummaryRetryFamily(
+          agent,
+          requestId,
+          primarySummaryRetry,
+          'primary_summary_fallback_retry_stream_threw',
+          { error: err.message },
+        );
+      } else if (primarySummaryConfig.enabled) {
+        await this.updatePrimarySummaryRequestRecord(requestId, (record) => ({
+          ...record,
+          finalStatus: 'error',
+          fallbackHeldReason: err.message,
+        }));
+      }
       this.emitTrace({
         type: 'inference:failed',
         agentName: agent.name,
         error: err.message,
         stack: err.stack,
       });
+      if (primarySummaryRetry) {
+        this.logInference({
+          timestamp: startTime,
+          agentName: agent.name,
+          requestId,
+          success: false,
+          error: `Stream threw: ${err.message}`,
+          request: fallbackRetryRequestForLog,
+          durationMs,
+        });
+        agent.reset();
+        this.eventGate?.onInferenceEnded(agent.name);
+        this.settleAgent(agent.name, {
+          stopReason: 'completed',
+          speech: '',
+        });
+        return;
+      }
       this.settleAgent(agent.name, {
         stopReason: 'exhausted',
         speech: '',
@@ -4431,7 +7119,7 @@ export class AgentFramework {
         requestId,
         success: false,
         error: `Stream threw: ${err.message}`,
-        request: compiledRequest ?? { note: 'streaming request threw' },
+        request: fallbackRetryRequestForLog,
         durationMs,
       });
       agent.reset();
@@ -4452,6 +7140,7 @@ export class AgentFramework {
       this.channelRegistry?.stopTyping();
       this.frameworkCancelledStreams.delete(`${agent.name}:${myStreamId}`);
       this.activeStreams.delete(agent.name);
+      this.activeStreamContexts.delete(agent.name);
       this.pendingAssistantBlocks.delete(agent.name);
 
       // A conversation fork whose TTL closure turn just finished is done for
@@ -4589,6 +7278,51 @@ export class AgentFramework {
     return undefined;
   }
 
+  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);
+  }
+
+  private sanitizeProcessLogValue(value: unknown, seen = new WeakMap<object, unknown>()): unknown {
+    if (value && typeof value === 'object') {
+      const seenValue = seen.get(value);
+      if (seenValue) return seenValue;
+    }
+    if (Array.isArray(value)) {
+      const clone: unknown[] = [];
+      seen.set(value, clone);
+      for (const item of value) {
+        clone.push(this.sanitizeProcessLogValue(item, seen));
+      }
+      return clone;
+    }
+    if (!value || typeof value !== 'object') {
+      return value;
+    }
+
+    const record = value as Record<string, unknown>;
+    if (record.type === 'image' && typeof record.data === 'string' && typeof record.mimeType === 'string') {
+      const clone: Record<string, unknown> = {};
+      seen.set(value, clone);
+      for (const [key, child] of Object.entries(record)) {
+        if (key === 'data' || key === 'mimeType') continue;
+        clone[key] = this.sanitizeProcessLogValue(child, seen);
+      }
+      clone.type = 'image';
+      clone.mimeType = record.mimeType;
+      clone.approxByteLength = this.approximateDecodedBase64Bytes(record.data);
+      clone.redacted = true;
+      return clone;
+    }
+
+    const clone: Record<string, unknown> = {};
+    seen.set(value, clone);
+    for (const [key, child] of Object.entries(record)) {
+      clone[key] = this.sanitizeProcessLogValue(child, seen);
+    }
+    return clone;
+  }
+
   private logInference(entry: InferenceLogEntry): void {
     // Store large request/response as blobs
     const entryToStore = { ...entry };
@@ -4622,15 +7356,15 @@ export class AgentFramework {
   private logProcessEvent(event: ProcessEvent, responses: ModuleProcessResponse[]): void {
     const entry: ProcessLogEntry = {
       timestamp: Date.now(),
-      processEvent: event,
-      responses,
+      processEvent: this.sanitizeProcessLogValue(event) as ProcessEvent,
+      responses: this.sanitizeProcessLogValue(responses) as ModuleProcessResponse[],
     };
 
     // Blob threshold: 10KB
     const BLOB_THRESHOLD = 10000;
 
     const entryToStore = { ...entry };
-    const responsesJson = JSON.stringify(responses);
+    const responsesJson = JSON.stringify(entry.responses);
     if (responsesJson.length > BLOB_THRESHOLD) {
       const blobId = this.store.storeBlob(Buffer.from(responsesJson), 'application/json');
       entryToStore.responses = { blobId };
@@ -4676,6 +7410,11 @@ export class AgentFramework {
       return;
     }
 
+    if (enrichedCall.name === 'save_recent_image') {
+      this.dispatchSaveImageToolCall(agentName, enrichedCall);
+      return;
+    }
+
     // Route gate_status tool
     if (enrichedCall.name === 'gate_status' && this.eventGate) {
       this.dispatchGateToolCall(agentName, enrichedCall);
@@ -4939,12 +7678,23 @@ export class AgentFramework {
    * work, per-agent status + last inference activity. Cheap and read-only.
    */
   healthSnapshot(): Record<string, unknown> {
+    const primarySummary = this.readPrimarySummaryFallbackState();
     return {
       at: new Date().toISOString(),
       uptimeSec: Math.round(process.uptime()),
       gate: this.eventGate?.inferenceDiagnostics() ?? null,
       pendingRequests: this.pendingRequests.length,
       activeStreams: [...this.activeStreams.keys()],
+      primarySummaryFallback: {
+        requests: primarySummary.requests.length,
+        pendingDispatches: primarySummary.requests.filter((record) => record.finalStatus === 'pending').length,
+        unresolvedIntents: primarySummary.requests.filter((record) => record.fallbackStatus === 'pending').length,
+        held: primarySummary.requests.filter((record) =>
+          record.finalStatus === 'held' ||
+          record.finalStatus === 'timeout_unknown' ||
+          record.fallbackStatus === 'held' ||
+          record.fallbackStatus === 'timeout_unknown').length,
+      },
       agents: [...this.agents.entries()].map(([name, agent]) => ({
         name,
         status: agent.state.status,
@@ -4979,6 +7729,22 @@ export class AgentFramework {
    *     every ~15 min instead of flooding the channel on every occurrence.
    * See connectome docs/observability.md.
    */
+  /**
+   * Public ops-alert entry point for host-wired alarms that originate
+   * OUTSIDE the framework (e.g. context-manager's repeating
+   * compression-quarantine klaxon, wired in the host at strategy
+   * construction). Same sinks and cooldown as internal alerts:
+   * failures.log + ops:alert trace + CONNECTOME_OPS_WEBHOOK.
+   */
+  notifyOps(
+    kind: string,
+    agentName: string,
+    message: string,
+    data?: Record<string, unknown>,
+  ): void {
+    this.opsAlert(kind, agentName, message, { data });
+  }
+
   private opsAlert(
     kind: string,
     agentName: string,
@@ -5074,6 +7840,17 @@ export class AgentFramework {
     return {};
   }
 
+  /**
+   * Public entry to the ops-alert pipeline (failures.log + ops:alert trace +
+   * throttled webhook) for host-level detectors OUTSIDE the framework's own
+   * inference driver — e.g. the host's logging adapter catching refusals on
+   * off-path calls (compression/summarizer, maintenance) that noteRefusal
+   * never sees. Same per-(agent,kind) cooldown as everything else.
+   */
+  notifyOpsAlert(kind: string, agentName: string, message: string, data?: Record<string, unknown>): void {
+    this.opsAlert(kind, agentName, message, { data });
+  }
+
   private noteInferenceExhausted(
     agentName: string,
     reason: string,
@@ -5355,8 +8132,16 @@ export class AgentFramework {
 
     for (const config of serverConfigs) {
       try {
-        await this.connectMcplServerInternal(config);
+        // Stage every startup connection with both planes closed. This removes
+        // server-order dependence: no early heartbeat/shell push can become
+        // model-visible before a later Discord connection has joined the same
+        // awareness generation.
+        await this.connectMcplServerInternal(config, true);
       } catch (error) {
+        if (error instanceof DiscordAwarenessAccountingError) {
+          await this.mcplServerRegistry.closeAll();
+          throw error;
+        }
         // Fail-open: log and continue with remaining servers
         const err = error instanceof Error ? error : new Error(String(error));
         console.error(`Failed to connect MCPL server "${config.id}":`, err.message);
@@ -5374,10 +8159,353 @@ export class AgentFramework {
       }
     }
 
+    // Start the durable drain only after all startup connections are staged.
+    // The awareness tools/call is written before control-plane registration is
+    // flushed, preserving the server-side queue -> registration -> call order.
+    const startupBarrier = this.installMcplDataPlaneGate();
+    this.releaseMcplDataPlaneGate(startupBarrier);
+    try {
+      await startupBarrier.promise;
+      this.completeMcplDataPlaneGate(startupBarrier);
+    } catch (error) {
+      await this.mcplServerRegistry.closeAll();
+      throw error;
+    }
+
     // Discover tools from all connected servers
     await this.refreshMcplTools();
   }
 
+  /** Reconcile the durable ledger with Chronicle, then deliver every server's work. */
+  async syncDiscordAwarenessMarkers(_onlyServerId?: string): Promise<void> {
+    if (!this.discordAwarenessOutbox) return;
+    // A targeted retry may discover pending work for other Discord servers
+    // during reconciliation. Safety is global, so one generation accounts for
+    // all pending operations before releasing any MCPL data plane.
+    const barrier = this.installMcplDataPlaneGate();
+    this.releaseMcplDataPlaneGate(barrier);
+    try {
+      await barrier.promise;
+      this.completeMcplDataPlaneGate(barrier);
+    } catch (error) {
+      await this.failMcplDataPlaneGate(barrier, 'explicit synchronization', error);
+      throw error;
+    }
+  }
+
+  private async resumePreparedDiscordSuppressions(): Promise<void> {
+    if (!this.discordAwarenessOutbox) return;
+    const batches = this.discordAwarenessOutbox.preparedSuppressionsForBranch(
+      this.store.currentBranch().name,
+      this.store.listBranches(),
+    );
+    for (const batch of batches) {
+      const agent = this.agents.get(batch.agentName);
+      if (!agent) {
+        throw new Error(
+          `Cannot resume Discord suppression ${batch.id}: agent ${batch.agentName} is not configured`,
+        );
+      }
+      const cm = agent.getContextManager();
+      for (const interval of [...(batch.suppressionIntervals ?? [])].reverse()) {
+        const from = cm.getMessage(interval.fromId as MessageId);
+        const to = cm.getMessage(interval.toId as MessageId);
+        if (!from && !to) continue; // This interval committed before the crash.
+        if (!from || !to) {
+          throw new Error(
+            `Cannot safely resume Discord suppression ${batch.id}: interval ` +
+              `${interval.fromId}..${interval.toId} is only partially present`,
+          );
+        }
+        if (interval.fromId === interval.toId) cm.removeMessage(from.id);
+        else cm.removeMessages(from.id, to.id);
+      }
+      this.discordAwarenessOutbox.activate(batch.id);
+      console.error(`[discord-awareness] resumed suppression batch ${batch.id}`);
+    }
+  }
+
+  /**
+   * Deliver every due ref independently. Permanent Discord failures are kept
+   * in the ledger for audit but do not block later operations; retryable
+   * failures remain pending for the next reconnect/list-change attempt.
+   */
+  private drainDiscordAwarenessOutbox(
+    serverId: string,
+  ): Promise<DiscordAwarenessDrainOutcome> {
+    if (!this.discordAwarenessOutbox) {
+      return Promise.resolve({ status: 'delivered', delivered: 0, failed: 0 });
+    }
+    const existing = this.discordAwarenessDrains.get(serverId);
+    if (existing) return existing;
+
+    const drain = (async () => {
+      const connection = this.mcplServerRegistry?.getServer(serverId);
+      if (!connection?.isConnected) {
+        const operations = this.readDiscordAwarenessPending(serverId);
+        for (const operation of operations) {
+          this.writeDiscordAwarenessFailure(
+            operation.batchId,
+            operation.ref,
+            operation.action,
+            'Awareness delivery not attempted: MCPL connection unavailable',
+            false,
+          );
+        }
+        if (operations.length > 0) {
+          console.error(
+            `[discord-awareness] ${serverId}: connection unavailable; ` +
+              `durably deferred=${operations.length}`,
+          );
+        }
+        return { status: 'unavailable' as const, accounted: operations.length };
+      }
+
+      let delivered = 0;
+      let failed = 0;
+      const attempted = new Set<string>();
+      while (true) {
+        const operations = this.readDiscordAwarenessPending(serverId).filter((operation) => {
+          const key = `${operation.batchId}\0${operation.ref.channelId}\0${operation.ref.messageId}\0${operation.action}`;
+          if (attempted.has(key)) return false;
+          attempted.add(key);
+          return true;
+        });
+        if (operations.length === 0) break;
+        for (const operation of operations) {
+          const ref = operation.ref;
+          const channelId = ref.channelId.startsWith('discord:')
+            ? ref.channelId.split(':').at(-1)!
+            : ref.channelId;
+          let deliveryError: string | undefined;
+          try {
+            const tool = operation.action === 'add' ? 'add_reaction' : 'remove_reaction';
+            const result = await connection.sendToolsCallWithDeadline(tool, {
+              channelId,
+              messageId: ref.messageId,
+              emoji: operation.emoji,
+            }, this.discordAwarenessDeadlineMs);
+            if (result.isError) {
+              deliveryError = result.content
+                .map((content) => content.text ?? '')
+                .filter(Boolean)
+                .join('; ') || `Discord ${tool} returned an error`;
+            }
+          } catch (error) {
+            deliveryError = error instanceof Error ? error.message : String(error);
+          }
+
+          if (deliveryError !== undefined) {
+            const permanent = isPermanentDiscordReactionFailure(deliveryError);
+            this.writeDiscordAwarenessFailure(
+              operation.batchId,
+              ref,
+              operation.action,
+              deliveryError,
+              permanent,
+            );
+            failed++;
+            console.error(
+              `[discord-awareness] ${operation.action} failed for ${ref.channelId}/${ref.messageId}` +
+                ` (${permanent ? 'permanent' : 'retryable'}): ${deliveryError}`,
+            );
+          } else {
+            this.writeDiscordAwarenessSuccess(operation.batchId, ref, operation.action);
+            delivered++;
+          }
+        }
+      }
+      if (delivered > 0 || failed > 0) {
+        console.error(
+          `[discord-awareness] ${serverId}: delivered=${delivered} failed=${failed}`,
+        );
+      }
+      return { status: 'delivered' as const, delivered, failed };
+    })().finally(() => {
+      this.discordAwarenessDrains.delete(serverId);
+    });
+
+    this.discordAwarenessDrains.set(serverId, drain);
+    return drain;
+  }
+
+  private readDiscordAwarenessPending(serverId?: string) {
+    try {
+      return this.discordAwarenessOutbox!.pending(serverId);
+    } catch (error) {
+      throw new DiscordAwarenessAccountingError(
+        `ledger read${serverId ? ` for ${serverId}` : ''}`,
+        error,
+      );
+    }
+  }
+
+  private writeDiscordAwarenessSuccess(
+    batchId: string,
+    ref: import('./recovery/discord-awareness-outbox.js').DiscordAwarenessRef,
+    action: import('./recovery/discord-awareness-outbox.js').DiscordAwarenessAction,
+  ): void {
+    try {
+      this.discordAwarenessOutbox!.recordSuccess(batchId, ref, action);
+    } catch (error) {
+      throw new DiscordAwarenessAccountingError('recordSuccess ledger write', error);
+    }
+  }
+
+  private writeDiscordAwarenessFailure(
+    batchId: string,
+    ref: import('./recovery/discord-awareness-outbox.js').DiscordAwarenessRef,
+    action: import('./recovery/discord-awareness-outbox.js').DiscordAwarenessAction,
+    errorMessage: string,
+    permanent: boolean,
+  ): void {
+    try {
+      this.discordAwarenessOutbox!.recordFailure(
+        batchId,
+        ref,
+        action,
+        errorMessage,
+        permanent,
+      );
+    } catch (error) {
+      throw new DiscordAwarenessAccountingError('recordFailure ledger write', error);
+    }
+  }
+
+  private beginDiscordAwarenessBarrier(): {
+    requiresBarrier: boolean;
+    promise: Promise<DiscordAwarenessDrainOutcome>;
+  } {
+    if (!this.discordAwarenessOutbox) {
+      return {
+        requiresBarrier: false,
+        promise: Promise.resolve({ status: 'delivered', delivered: 0, failed: 0 }),
+      };
+    }
+    try {
+      this.discordAwarenessOutbox.reconcileForBranch(
+        this.store.currentBranch().name,
+        this.store.listBranches(),
+      );
+    } catch (error) {
+      throw new DiscordAwarenessAccountingError('branch reconciliation', error);
+    }
+    const pending = this.readDiscordAwarenessPending();
+    if (pending.length === 0) {
+      return {
+        requiresBarrier: false,
+        promise: Promise.resolve({ status: 'delivered', delivered: 0, failed: 0 }),
+      };
+    }
+    const serverIds = [...new Set(pending.map((operation) => operation.ref.serverId))];
+    const promise = Promise.all(
+      serverIds.map((serverId) => this.drainDiscordAwarenessOutbox(serverId)),
+    ).then((outcomes): DiscordAwarenessDrainOutcome => {
+      if (outcomes.every((outcome) => outcome.status === 'unavailable')) {
+        return {
+          status: 'unavailable',
+          accounted: outcomes.reduce(
+            (count, outcome) => count + (outcome.status === 'unavailable' ? outcome.accounted : 0),
+            0,
+          ),
+        };
+      }
+      return {
+        status: 'delivered',
+        delivered: outcomes.reduce(
+          (count, outcome) => count + (outcome.status === 'delivered' ? outcome.delivered : 0),
+          0,
+        ),
+        failed: outcomes.reduce(
+          (count, outcome) => count + (outcome.status === 'delivered' ? outcome.failed : 0),
+          0,
+        ),
+      };
+    });
+    return { requiresBarrier: true, promise };
+  }
+
+  /**
+   * Install one framework-global Discord-awareness generation before releasing
+   * any inference-bearing event. With pending work, every MCPL data plane is
+   * paused while all control planes remain live. With no pending work, ready()
+   * runs synchronously so request responders preserve their historical
+   * same-stack behavior.
+   */
+  private installMcplDataPlaneGate(): DiscordAwarenessBarrier {
+    for (const connection of this.mcplServerRegistry?.getAllServers() ?? []) {
+      connection.pauseDataPlane();
+    }
+    const generation = ++this.discordAwarenessBarrierGeneration;
+
+    let begun: ReturnType<AgentFramework['beginDiscordAwarenessBarrier']>;
+    try {
+      begun = this.beginDiscordAwarenessBarrier();
+    } catch (error) {
+      begun = {
+        requiresBarrier: true,
+        promise: Promise.reject(error),
+      };
+    }
+    const barrier: DiscordAwarenessBarrier = { generation, ...begun };
+    this.discordAwarenessBarrier = barrier;
+    return barrier;
+  }
+
+  private releaseMcplDataPlaneGate(
+    barrier: DiscordAwarenessBarrier,
+  ): void {
+    if (this.discordAwarenessBarrier !== barrier) return;
+    if (barrier.requiresBarrier) {
+      for (const connection of this.mcplServerRegistry?.getAllServers() ?? []) {
+        connection.readyControlPlane();
+      }
+      return;
+    }
+    this.completeMcplDataPlaneGate(barrier);
+  }
+
+  private completeMcplDataPlaneGate(
+    barrier: DiscordAwarenessBarrier,
+  ): boolean {
+    if (this.discordAwarenessBarrier !== barrier) return false;
+    this.discordAwarenessBarrier = null;
+    for (const connection of this.mcplServerRegistry?.getAllServers() ?? []) {
+      // ready() can synchronously flush a nested list-change notification that
+      // installs a newer global generation. Never let this older completion
+      // release any remaining server behind that newer gate.
+      if (this.discordAwarenessBarrier !== null) return false;
+      connection.ready();
+    }
+    return this.discordAwarenessBarrier === null;
+  }
+
+  private async failMcplDataPlaneGate(
+    barrier: DiscordAwarenessBarrier,
+    context: string,
+    error: unknown,
+  ): Promise<void> {
+    if (this.discordAwarenessBarrier !== barrier) return;
+    const err = error instanceof Error ? error : new Error(String(error));
+    console.error(`[discord-awareness] ${context} failed globally:`, err.message);
+    const connections = this.mcplServerRegistry?.getAllServers() ?? [];
+    for (const connection of connections) {
+      this.emitTrace({
+        type: 'mcpl:server-error',
+        serverId: connection.id,
+        error: `Discord awareness accounting unhealthy: ${err.message}`,
+      });
+    }
+    await Promise.all(connections.map(async (connection) => {
+      await connection.reconnectAfterFailure().catch((closeError) => {
+        console.error(
+          `[discord-awareness] could not recycle unhealthy connection ${connection.id}:`,
+          closeError instanceof Error ? closeError.message : closeError,
+        );
+      });
+    }));
+  }
+
   /**
    * Connect a single MCPL server: register routing entries, open the
    * connection, wire events, and initialize feature sets / scopes /
@@ -5386,6 +8514,7 @@ export class AgentFramework {
    */
   private async connectMcplServerInternal(
     config: import('./mcpl/types.js').McplServerConfig,
+    deferAwareness = false,
   ): Promise<void> {
     if (!this.mcplServerRegistry || !this.mcplHostCapabilities) {
       throw new Error('MCPL subsystem is not initialized');
@@ -5408,14 +8537,31 @@ export class AgentFramework {
 
     const connection = await this.mcplServerRegistry.addServer(config, this.mcplHostCapabilities);
 
-    // Wire event listeners then flush any events that arrived during the
-    // handshake window (between setupMessageRouting and now).
+    // Wire listeners before either startup staging or the runtime global gate
+    // releases control traffic needed for registration and marker service.
     this.wireMcplEvents(connection);
-    connection.ready();
 
     // Initialize feature sets if server advertises MCPL capabilities
     this.registerMcplServerFeatures(config, connection);
 
+    if (deferAwareness) {
+      this.emitTrace({ type: 'module:added', moduleName: `mcpl:${config.id}` });
+      return;
+    }
+
+    const awarenessBarrier = this.installMcplDataPlaneGate();
+    this.releaseMcplDataPlaneGate(awarenessBarrier);
+    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().
+      await connection.close().catch(() => {});
+      throw error;
+    }
+
     this.emitTrace({ type: 'module:added', moduleName: `mcpl:${config.id}` });
   }
 
@@ -5629,10 +8775,12 @@ export class AgentFramework {
     });
 
     // Handle push events (Step 6)
-    connection.on('push-event', (
+    connection.on('push-event', async (
       params: PushEventParams,
       responder?: { respond: (result: unknown) => void; respondError: (code: number, message: string) => void },
     ) => {
+      const barrier = this.discordAwarenessBarrier;
+      if (barrier) await barrier.promise;
       this.pushHandler?.handlePushEvent(connection.id, params, responder as never);
     });
 
@@ -5642,6 +8790,8 @@ export class AgentFramework {
       responder?: { id: string | number; respond: (result: unknown) => void; respondError: (code: number, message: string) => void },
     ) => {
       if (this.inferenceRouter && responder) {
+        const barrier = this.discordAwarenessBarrier;
+        if (barrier) await barrier.promise;
         await this.inferenceRouter.handleInferenceRequest(connection.id, params, {
           respond: responder.respond,
           respondError: responder.respondError,
@@ -5664,10 +8814,12 @@ export class AgentFramework {
     });
 
     // Handle incoming channel messages (Step 7)
-    connection.on('channels-incoming', (
+    connection.on('channels-incoming', async (
       params: ChannelsIncomingParams,
       responder?: { respond: (result: unknown) => void },
     ) => {
+      const barrier = this.discordAwarenessBarrier;
+      if (barrier) await barrier.promise;
       this.channelRegistry?.handleIncoming(connection.id, params, responder as never);
     });
 
@@ -5678,6 +8830,8 @@ export class AgentFramework {
     ) => {
       if (!responder) return;
       try {
+        const barrier = this.discordAwarenessBarrier;
+        if (barrier) await barrier.promise;
         const result = await this.handleHostCommand(connection.id, params ?? {});
         responder.respond(result);
       } catch (error) {
@@ -5688,7 +8842,19 @@ export class AgentFramework {
 
     // Handle dynamic tool list changes (notifications/tools/list_changed)
     connection.on('tools-list-changed', () => {
+      // Pause before starting any async refresh. This listener runs
+      // synchronously in the transport line callback, so a following inbound
+      // data event cannot pass before the new barrier exists.
+      const awarenessBarrier = this.installMcplDataPlaneGate();
+      this.releaseMcplDataPlaneGate(awarenessBarrier);
       this.handleToolsListChanged(connection.id);
+      void awarenessBarrier.promise.then(() => {
+        this.completeMcplDataPlaneGate(awarenessBarrier);
+      }).catch((error) => this.failMcplDataPlaneGate(
+        awarenessBarrier,
+        'tools-list reconciliation',
+        error,
+      ));
     });
 
     // Re-establish full server registration on reconnect. The 'close' handler
@@ -5699,6 +8865,10 @@ export class AgentFramework {
     // preserved across the transient close are resumed by idempotent
     // registration. Then refresh tools (server may have different tools).
     connection.on('reconnect', (info?: { attempts?: number }) => {
+      // Install the barrier synchronously so any inbound event emitted after
+      // 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) {
@@ -5710,15 +8880,26 @@ export class AgentFramework {
           error instanceof Error ? error.message : error,
         );
       }
+      this.releaseMcplDataPlaneGate(awarenessBarrier);
       this.handleToolsListChanged(connection.id);
-      this.emitTrace({
-        type: 'mcpl:server-reconnected',
-        serverId: connection.id,
-        attempts: info?.attempts ?? 0,
-      });
-      // Mirror the module:removed emitted on 'close' so module-lifecycle
-      // consumers see the server come back, not just vanish.
-      this.emitTrace({ type: 'module:added', moduleName: `mcpl:${connection.id}` });
+      void awarenessBarrier.promise.then(() => {
+        if (
+          awarenessBarrier.requiresBarrier
+          && !this.completeMcplDataPlaneGate(awarenessBarrier)
+        ) return;
+        this.emitTrace({
+          type: 'mcpl:server-reconnected',
+          serverId: connection.id,
+          attempts: info?.attempts ?? 0,
+        });
+        // Mirror the module:removed emitted on 'close' so module-lifecycle
+        // consumers see the server come back, not just vanish.
+        this.emitTrace({ type: 'module:added', moduleName: `mcpl:${connection.id}` });
+      }).catch((error) => this.failMcplDataPlaneGate(
+        awarenessBarrier,
+        'reconnect reconciliation',
+        error,
+      ));
     });
 
     // Surface connect/reconnect failures. Before these traces existed the
@@ -5760,6 +8941,7 @@ export class AgentFramework {
     // divergence greppable instead of a silent drift into stale state.
     connection.on('orphaned-response', (info: {
       id: string | number;
+      method?: string;
       hadState: boolean;
       hadCheckpoint: boolean;
     }) => {
@@ -5767,6 +8949,7 @@ export class AgentFramework {
         type: 'mcpl:orphaned-response',
         serverId: connection.id,
         responseId: info.id,
+        method: info.method,
         hadState: info.hadState,
         hadCheckpoint: info.hadCheckpoint,
       });
@@ -6228,6 +9411,153 @@ export class AgentFramework {
     });
   }
 
+  /**
+   * Handle the synthesized `save_recent_image` tool: locate the requested
+   * image blocks in the calling agent's context (blobs re-inlined, counted
+   * back from the most recent) and write their bytes to a workspace mount
+   * via WorkspaceModule.writeBinary.
+   */
+  private dispatchSaveImageToolCall(agentName: string, call: ToolCall): void {
+    this.emitTrace({ type: 'tool:started', module: 'workspace', tool: call.name, callId: call.id, input: call.input });
+    const finish = (result: ToolResult): void => {
+      this.emitTrace({
+        type: result.isError ? 'tool:failed' : 'tool:completed',
+        module: 'workspace',
+        tool: call.name,
+        callId: call.id,
+        durationMs: 0,
+        ...(result.isError ? { error: result.error } : {}),
+      });
+      this.pushEvent({ type: 'tool-result', callId: call.id, agentName, moduleName: 'workspace', result });
+    };
+    void (async (): Promise<void> => {
+      try {
+        const workspace = this.getWorkspaceModule();
+        if (!workspace) throw new Error('save_recent_image requires a workspace module');
+        const agent = this.agents.get(agentName);
+        if (!agent) throw new Error(`Unknown agent: ${agentName}`);
+        const input = (call.input ?? {}) as { path?: unknown; index?: unknown; count?: unknown };
+        if (typeof input.path !== 'string' || input.path.length === 0) {
+          throw new Error('save_recent_image: `path` (mount-prefixed) is required');
+        }
+        const index = input.index === undefined ? 0 : Number(input.index);
+        if (!Number.isInteger(index) || index < 0) {
+          throw new Error('save_recent_image: `index` must be a non-negative integer');
+        }
+        const count = input.count === undefined ? 1 : Number(input.count);
+        const MAX_COUNT = 20;
+        if (!Number.isInteger(count) || count < 1 || count > MAX_COUNT) {
+          throw new Error(`save_recent_image: \`count\` must be an integer in 1..${MAX_COUNT}`);
+        }
+        const lastWanted = index + count - 1;
+
+        // Walk the message store tail-first in bounded windows, re-inlining
+        // blob media, until we've collected the requested range. Scanning is
+        // capped so a pathological index can't drag the whole store through
+        // blob resolution.
+        const MAX_SCAN = 500;
+        const WINDOW = 25;
+        const cm = agent.getContextManager();
+        const total = cm.getMessageCount();
+        let seen = 0;
+        let scanned = 0;
+        const found: Array<{
+          rangeOffset: number;
+          data: string;
+          mediaType: string;
+          messagesBack: number;
+        }> = [];
+        for (let end = total; end > 0 && scanned < MAX_SCAN && found.length < count; end -= WINDOW) {
+          const start = Math.max(0, end - WINDOW);
+          const { messages } = cm.getMessageWindow(start, end - start, { resolveBlobs: true });
+          scanned += end - start;
+          for (let i = messages.length - 1; i >= 0 && found.length < count; i--) {
+            const content = messages[i]?.content;
+            if (!Array.isArray(content)) continue;
+            for (let b = content.length - 1; b >= 0 && found.length < count; b--) {
+              const block = content[b] as {
+                type?: string;
+                source?: { type?: string; data?: string; mediaType?: string };
+              };
+              if (block?.type !== 'image') continue;
+              if (seen >= index && seen <= lastWanted) {
+                if (block.source?.type !== 'base64' || typeof block.source.data !== 'string') {
+                  throw new Error(
+                    `save_recent_image: image at index ${seen} is not stored inline (base64) — cannot save it`,
+                  );
+                }
+                found.push({
+                  rangeOffset: seen - index,
+                  data: block.source.data,
+                  mediaType: block.source.mediaType ?? 'image/png',
+                  messagesBack: total - (start + i),
+                });
+              }
+              seen++;
+            }
+          }
+        }
+        if (found.length === 0) {
+          throw new Error(
+            seen === 0
+              ? `save_recent_image: no images found in the most recent ${Math.min(scanned, MAX_SCAN)} messages`
+              : `save_recent_image: only ${seen} image(s) found in the most recent ${Math.min(scanned, MAX_SCAN)} messages (asked for index ${index})`,
+          );
+        }
+
+        // Single image → path as given. Range → numeric suffix before the
+        // extension ("cat.png" → "cat-0.png"), 0 = newest of the range.
+        const pathFor = (rangeOffset: number): string => {
+          if (count === 1) return input.path as string;
+          const p = input.path as string;
+          const dot = p.lastIndexOf('.');
+          const slash = p.lastIndexOf('/');
+          return dot > slash
+            ? `${p.slice(0, dot)}-${rangeOffset}${p.slice(dot)}`
+            : `${p}-${rangeOffset}`;
+        };
+        const savedFiles: Array<Record<string, unknown>> = [];
+        for (const image of found) {
+          const destination = pathFor(image.rangeOffset);
+          const bytes = Buffer.from(image.data, 'base64');
+          const result = await workspace.writeBinary(destination, bytes, image.mediaType);
+          if (!result.success) {
+            finish({
+              success: false,
+              error:
+                `save_recent_image: failed writing "${destination}": ${result.error}` +
+                (savedFiles.length > 0
+                  ? ` (already saved: ${savedFiles.map((f) => f.path).join(', ')})`
+                  : ''),
+              isError: true,
+            });
+            return;
+          }
+          savedFiles.push({
+            ...(result.data as Record<string, unknown>),
+            imageIndex: index + image.rangeOffset,
+            messagesBack: image.messagesBack,
+          });
+        }
+        finish({
+          success: true,
+          data: {
+            saved: savedFiles,
+            ...(found.length < count
+              ? { note: `only ${found.length} of ${count} requested images exist in the scanned window` }
+              : {}),
+          },
+        });
+      } catch (error) {
+        finish({
+          success: false,
+          error: error instanceof Error ? error.message : String(error),
+          isError: true,
+        });
+      }
+    })();
+  }
+
   private dispatchAgentSettingsToolCall(agentName: string, call: ToolCall): void {
     this.emitTrace({
       type: 'tool:started',
@@ -6243,11 +9573,22 @@ export class AgentFramework {
         context_budget_tokens?: unknown;
         tail_tokens?: unknown;
         transition_pace_tokens?: unknown;
+        same_round_think_text_policy?: unknown;
         settings?: unknown;
+      } & Record<string, unknown>;
+      const extensions = this.collectAgentSettingsExtensions();
+      /** Extension values merged flat alongside the core snapshot. */
+      const extGet = (): Record<string, unknown> => {
+        const out: Record<string, unknown> = {};
+        for (const ext of extensions.values()) Object.assign(out, ext.get(agentName));
+        return out;
       };
       switch (input.action) {
         case 'get':
-          result = { success: true, data: this.getAgentRuntimeSettings(agentName) };
+          result = {
+            success: true,
+            data: { ...this.getAgentRuntimeSettings(agentName), ...extGet() },
+          };
           break;
         case 'cancel':
           result = { success: true, data: this.cancelAgentRuntimeSettingsTransition(agentName) };
@@ -6261,26 +9602,101 @@ export class AgentFramework {
           if (input.transition_pace_tokens !== undefined) {
             patch.transitionPaceTokens = Number(input.transition_pace_tokens);
           }
-          result = { success: true, data: this.updateAgentRuntimeSettings(agentName, patch) };
+          if (input.same_round_think_text_policy !== undefined) {
+            patch.sameRoundThinkTextPolicy = input.same_round_think_text_policy as AgentRuntimeSettingsPatch['sameRoundThinkTextPolicy'];
+          }
+          // Route extension-owned keys to their modules; apply the core patch
+          // only when it touches core keys (an extension-only update must not
+          // disturb a converging budget transition).
+          const extResults: Record<string, unknown> = {};
+          for (const ext of extensions.values()) {
+            const slice: Record<string, unknown> = {};
+            for (const key of ext.keys) {
+              if (input[key] !== undefined) slice[key] = input[key];
+            }
+            if (Object.keys(slice).length > 0) {
+              Object.assign(extResults, ext.update(agentName, slice));
+            }
+          }
+          const coreTouched = Object.keys(patch).length > 0;
+          const core = coreTouched
+            ? this.updateAgentRuntimeSettings(agentName, patch)
+            : this.getAgentRuntimeSettings(agentName);
+          result = {
+            success: true,
+            data: {
+              ...core,
+              ...extGet(),
+              ...extResults,
+              ...(patch.sameRoundThinkTextPolicy !== undefined
+                ? {
+                    sameRoundThinkTextPolicyUpdateNote:
+                      'Stored now; applies to provider think routing and description beginning with the next inference.',
+                  }
+                : {}),
+            },
+          };
           break;
         }
         case 'reset': {
           let keys: Array<keyof AgentRuntimeSettingsPatch> | undefined;
+          const extResetKeys = new Map<AgentSettingsExtension, string[]>();
+          const resetsAllSettings = input.settings === undefined;
           if (input.settings !== undefined) {
             if (!Array.isArray(input.settings)) throw new Error('reset `settings` must be an array');
             const names: Record<string, keyof AgentRuntimeSettingsPatch> = {
               context_budget_tokens: 'contextBudgetTokens',
               tail_tokens: 'tailTokens',
               transition_pace_tokens: 'transitionPaceTokens',
+              same_round_think_text_policy: 'sameRoundThinkTextPolicy',
             };
-            keys = input.settings.map((name) => {
-              if (typeof name !== 'string' || !names[name]) {
-                throw new Error(`Unknown reset setting: ${String(name)}`);
+            keys = [];
+            for (const name of input.settings) {
+              if (typeof name === 'string' && names[name]) {
+                keys.push(names[name]);
+                continue;
               }
-              return names[name];
-            });
+              const owner = [...extensions.values()].find(
+                (ext) => typeof name === 'string' && ext.keys.includes(name),
+              );
+              if (!owner) throw new Error(`Unknown reset setting: ${String(name)}`);
+              const list = extResetKeys.get(owner) ?? [];
+              list.push(name as string);
+              extResetKeys.set(owner, list);
+            }
+            if (keys.length === 0) keys = undefined;
+          }
+          const touchedSameRoundThinkTextPolicy =
+            resetsAllSettings || keys?.includes('sameRoundThinkTextPolicy') === true;
+          const extResults: Record<string, unknown> = {};
+          if (input.settings === undefined) {
+            // Reset-all covers extensions too.
+            for (const ext of extensions.values()) {
+              if (ext.reset) Object.assign(extResults, ext.reset(agentName));
+            }
+          } else {
+            for (const [ext, list] of extResetKeys) {
+              if (ext.reset) Object.assign(extResults, ext.reset(agentName, list));
+            }
           }
-          result = { success: true, data: this.resetAgentRuntimeSettings(agentName, keys) };
+          const coreTouched = input.settings === undefined || keys !== undefined;
+          const core = coreTouched
+            ? this.resetAgentRuntimeSettings(agentName, keys)
+            : this.getAgentRuntimeSettings(agentName);
+          result = {
+            success: true,
+            data: {
+              ...core,
+              ...extGet(),
+              ...extResults,
+              ...(touchedSameRoundThinkTextPolicy
+                ? {
+                    sameRoundThinkTextPolicyUpdateNote:
+                      'Reset now; restored provider think routing and description apply beginning with the next inference.',
+                  }
+                : {}),
+            },
+          };
           break;
         }
         default: