@animalabs/connectome-host 0.3.7 → 0.3.8

package/src/modules/mcpl-admin-module.ts

@@ -114,16 +114,6 @@ export class McplAdminModule implements Module {
             token: { type: 'string', description: 'Bearer token for WebSocket auth.' },
             toolPrefix: { type: 'string', description: 'Tool namespace prefix. Default: mcpl--<id>.' },
             reconnect: { type: 'boolean', description: 'Auto-reconnect on transport failure (default false). Note: does NOT respawn a crashed child — use mcpl_restart for that.' },
-            channelSubscription: {
-              type: 'string',
-              enum: ['auto', 'manual'],
-              description: "Channel auto-open policy: 'auto' (default) opens every channel the server registers; 'manual' opens none. For an allow-list, use channelAllowlist instead.",
-            },
-            channelAllowlist: {
-              type: 'array',
-              items: { type: 'string' },
-              description: 'Allow-list of channel ids to auto-open (overrides channelSubscription).',
-            },
             enabledFeatureSets: { type: 'array', items: { type: 'string' } },
             disabledFeatureSets: { type: 'array', items: { type: 'string' } },
             enabledTools: { type: 'array', items: { type: 'string' }, description: 'Tool allow-list (bare names, * wildcard).' },
@@ -263,11 +253,6 @@ export class McplAdminModule implements Module {
     if (typeof input.token === 'string') entry.token = input.token;
     if (typeof input.toolPrefix === 'string') entry.toolPrefix = input.toolPrefix;
     if (typeof input.reconnect === 'boolean') entry.reconnect = input.reconnect;
-    if (Array.isArray(input.channelAllowlist)) {
-      entry.channelSubscription = input.channelAllowlist.map(String);
-    } else if (input.channelSubscription === 'auto' || input.channelSubscription === 'manual') {
-      entry.channelSubscription = input.channelSubscription;
-    }
     if (Array.isArray(input.enabledFeatureSets)) entry.enabledFeatureSets = input.enabledFeatureSets.map(String);
     if (Array.isArray(input.disabledFeatureSets)) entry.disabledFeatureSets = input.disabledFeatureSets.map(String);
     if (Array.isArray(input.enabledTools)) entry.enabledTools = input.enabledTools.map(String);

package/src/modules/settings-module.ts

@@ -3,10 +3,11 @@
  * itself. State persists to chronicle via ModuleContext (`setState`/`getState`)
  * so changes survive restarts.
  *
- * First domain: **reasoning** (Anthropic extended thinking). Tools:
- *   - reasoning_status                    → show current state
- *   - reasoning_enable {budgetTokens?}    → turn on with optional budget
- *   - reasoning_disable                   → turn off
+ * First domain: **reasoning** (Anthropic extended thinking), surfaced to the
+ * agent as `agent_settings` fields (reasoning_enabled /
+ * reasoning_budget_tokens) via the framework's settings-extension hook —
+ * NOT as standalone tools (the former reasoning_status/enable/disable trio
+ * was tool bloat for one boolean + number).
  *
  * The host's adapter wrapper (LoggingAnthropicAdapter) reads `getReasoning()`
  * on each call and injects `thinking: {type:'enabled', budget_tokens: N}` into
@@ -69,75 +70,98 @@ export class SettingsModule implements Module {
     return { ...this.state.reasoning };
   }
 
+  /** No standalone tools — reasoning controls live inside the framework's
+   *  `agent_settings` tool via getAgentSettingsExtension() below. The three
+   *  former reasoning_* tools were pure tool bloat for one boolean + number. */
   getTools(): ToolDefinition[] {
-    return [
-      {
-        name: 'reasoning_status',
-        description:
-          'Show whether extended thinking (reasoning) is currently enabled and the token budget.',
-        inputSchema: { type: 'object', properties: {} },
-      },
-      {
-        name: 'reasoning_enable',
-        description:
-          'Enable extended thinking (reasoning) on your subsequent inference calls. ' +
-          'Optional budgetTokens in tokens (default: current value, initially 8192; min 1024).',
-        inputSchema: {
-          type: 'object',
-          properties: {
-            budgetTokens: {
-              type: 'number',
-              description: 'Token budget for thinking blocks (min 1024).',
-            },
-          },
-        },
-      },
-      {
-        name: 'reasoning_disable',
-        description:
-          'Disable extended thinking (reasoning). Subsequent inference calls will not request thinking blocks.',
-        inputSchema: { type: 'object', properties: {} },
-      },
-    ];
+    return [];
   }
 
   async handleToolCall(call: ToolCall): Promise<ToolResult> {
-    const input = (call.input ?? {}) as Record<string, unknown>;
-    switch (call.name) {
-      case 'reasoning_status':
-        return ok(this.reasoningStatusText());
-      case 'reasoning_enable': {
-        const budget =
-          typeof input.budgetTokens === 'number'
-            ? Math.max(1024, Math.round(input.budgetTokens))
-            : this.state.reasoning.budgetTokens;
-        this.state.reasoning = { enabled: true, budgetTokens: budget };
+    return {
+      success: false,
+      error:
+        `Unknown tool: ${call.name}. Reasoning controls moved into agent_settings ` +
+        `(fields reasoning_enabled / reasoning_budget_tokens).`,
+      isError: true,
+    };
+  }
+
+  /**
+   * Declare reasoning as an agent_settings extension: the framework merges
+   * these fields into the agent_settings tool and routes get/update/reset for
+   * them back here. Framework versions predating the hook simply never call
+   * this — in that case reasoning is temporarily not agent-tunable (the
+   * adapter still honors persisted state).
+   */
+  getAgentSettingsExtension(): {
+    properties: Record<string, unknown>;
+    keys: string[];
+    get(agentName: string): Record<string, unknown>;
+    update(agentName: string, patch: Record<string, unknown>): Record<string, unknown>;
+    reset(agentName: string, keys?: string[]): Record<string, unknown>;
+  } {
+    return {
+      properties: {
+        reasoning_enabled: {
+          type: 'boolean',
+          description:
+            'Extended thinking (reasoning) on subsequent inference calls.',
+        },
+        reasoning_budget_tokens: {
+          type: 'number',
+          description: 'Token budget for thinking blocks (min 1024).',
+        },
+      },
+      keys: ['reasoning_enabled', 'reasoning_budget_tokens'],
+      get: () => this.reasoningSettingsView(),
+      update: (_agentName, patch) => {
+        const next = { ...this.state.reasoning };
+        if (patch.reasoning_enabled !== undefined) {
+          if (typeof patch.reasoning_enabled !== 'boolean') {
+            throw new Error('reasoning_enabled must be a boolean');
+          }
+          next.enabled = patch.reasoning_enabled;
+        }
+        if (patch.reasoning_budget_tokens !== undefined) {
+          const budget = Number(patch.reasoning_budget_tokens);
+          if (!Number.isFinite(budget)) {
+            throw new Error('reasoning_budget_tokens must be a number');
+          }
+          next.budgetTokens = Math.max(1024, Math.round(budget));
+        }
+        this.state.reasoning = next;
         this.ctx?.setState(this.state);
-        return ok('Reasoning enabled. ' + this.reasoningStatusText());
-      }
-      case 'reasoning_disable':
-        this.state.reasoning = { ...this.state.reasoning, enabled: false };
+        return this.reasoningSettingsView();
+      },
+      reset: (_agentName, keys) => {
+        const all = !keys || keys.length === 0;
+        if (all || keys?.includes('reasoning_enabled')) {
+          this.state.reasoning.enabled = DEFAULTS.reasoning.enabled;
+        }
+        if (all || keys?.includes('reasoning_budget_tokens')) {
+          this.state.reasoning.budgetTokens = DEFAULTS.reasoning.budgetTokens;
+        }
         this.ctx?.setState(this.state);
-        return ok('Reasoning disabled. ' + this.reasoningStatusText());
-      default:
-        return { success: false, error: `Unknown tool: ${call.name}`, isError: true };
-    }
+        return this.reasoningSettingsView();
+      },
+    };
+  }
+
+  /** The extension's wire view of reasoning state (flat agent_settings keys). */
+  private reasoningSettingsView(): Record<string, unknown> {
+    return {
+      reasoning_enabled: this.state.reasoning.enabled,
+      reasoning_budget_tokens: this.state.reasoning.budgetTokens,
+    };
   }
 
   async onProcess(_event: ProcessEvent, _state: ProcessState): Promise<EventResponse> {
     return {};
   }
 
-  private reasoningStatusText(): string {
-    const r = this.state.reasoning;
-    return `reasoning=${r.enabled ? 'ENABLED' : 'disabled'}, budgetTokens=${r.budgetTokens}`;
-  }
 }
 
 function clone<T>(x: T): T {
   return JSON.parse(JSON.stringify(x)) as T;
 }
-
-function ok(message: string): ToolResult {
-  return { success: true, data: { message }, isError: false };
-}

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

@@ -1,5 +1,5 @@
 /**
- * SubscriptionGcModule — auto-unsubscribe noisy ambient Discord channels.
+ * SubscriptionGcModule — auto-close noisy ordinary channel traffic.
  *
  * Problem: a subscribed channel delivers ambient (non-mention, non-DM) messages
  * into the agent's context whether or not the agent ever acts on them. A busy
@@ -12,7 +12,7 @@
  *     the agent saw every subscribed channel in that context (compressed if
  *     large; nothing is dropped), so the slate is clean.
  *   - The instant a channel's since-last-activation count crosses its limit, it
- *     is auto-unsubscribed via the surface's `unsubscribe_channel` tool. This
+ *     is auto-closed via the host's generic `channel_close` tool. This
  *     bounds any one channel's context pollution to ~limit characters.
  *
  * Everything is durable across restarts: counters + per-channel overrides
@@ -36,15 +36,15 @@ import type {
 } from '@animalabs/agent-framework';
 
 export interface SubscriptionGcConfig {
-  /** Default ambient-character budget per channel before auto-unsubscribe. */
+  /** Default ambient-character budget per channel before auto-close. */
   defaultLimitChars?: number;
   /** MCPL server id that owns subscriptions (default 'discord'). */
   serverId?: string;
-  /** Tool-name prefix for that server (default `mcpl--<serverId>`). */
+  /** @deprecated Lifecycle tools are host-generic; retained for config compatibility. */
   toolPrefix?: string;
 }
 
-/** `'off'` pins a channel (never auto-unsubscribe); a number overrides the
+/** `'off'` pins a channel (never auto-close); a number overrides the
  *  default limit; absence falls back to the default. */
 type LimitOverride = number | 'off';
 
@@ -66,7 +66,6 @@ export class SubscriptionGcModule implements Module {
 
   private readonly defaultLimitChars: number;
   private readonly serverId: string;
-  private readonly toolPrefix: string;
 
   private state: GcState = { overrides: {}, counters: {} };
 
@@ -76,7 +75,6 @@ export class SubscriptionGcModule implements Module {
         ? Math.round(config.defaultLimitChars)
         : 20000;
     this.serverId = config.serverId ?? 'discord';
-    this.toolPrefix = config.toolPrefix ?? `mcpl--${this.serverId}`;
   }
 
   async start(ctx: ModuleContext): Promise<void> {
@@ -121,9 +119,9 @@ export class SubscriptionGcModule implements Module {
         description:
           'Set how many characters of ambient (non-mention, non-DM) traffic a ' +
           'subscribed channel may emit between your activations before it is ' +
-          'auto-unsubscribed. `limit` is a number of characters, "default" to ' +
+          'auto-closed. `limit` is a number of characters, "default" to ' +
           `use the global default (${this.defaultLimitChars}), or "off" to ` +
-          'never auto-unsubscribe this channel.',
+          'never auto-close this channel.',
         inputSchema: {
           type: 'object',
           properties: {
@@ -139,7 +137,7 @@ export class SubscriptionGcModule implements Module {
       {
         name: 'list_channel_idle_limits',
         description:
-          'Show the auto-unsubscribe configuration: the global default limit, ' +
+          'Show the auto-close configuration: the global default limit, ' +
           'per-channel overrides, and the current since-last-activation ambient ' +
           'character counts per channel.',
         inputSchema: { type: 'object', properties: {} },
@@ -169,7 +167,7 @@ export class SubscriptionGcModule implements Module {
           desc = `default (${this.defaultLimitChars})`;
         } else if (limit === 'off') {
           this.state.overrides[channelId] = 'off';
-          desc = 'off (never auto-unsubscribe)';
+          desc = 'off (never auto-close)';
         } else if (Number.isFinite(numeric) && numeric > 0) {
           this.state.overrides[channelId] = Math.round(numeric);
           desc = `${Math.round(numeric)} characters`;
@@ -207,14 +205,14 @@ export class SubscriptionGcModule implements Module {
     const next = (this.state.counters[channelId] ?? 0) + chars;
 
     if (limit !== Infinity && next > limit) {
-      // Cross the threshold → unsubscribe and clear the counter.
+      // Cross the threshold → close and clear the counter.
       delete this.state.counters[channelId];
       this.persistNow();
       const result = await this.ctx
         ?.callTool({
           id: `gc-unsub-${this.callSeq++}`,
-          name: `${this.toolPrefix}--unsubscribe_channel`,
-          input: { channelId },
+          name: 'channel_close',
+          input: { channelId, serverId: this.serverId },
         })
         .catch((err: unknown) => ({
           success: false,
@@ -231,18 +229,17 @@ export class SubscriptionGcModule implements Module {
                 {
                   type: 'text',
                   text:
-                    `[subscription-gc] Auto-unsubscribed from channel ${channelId}: it emitted ` +
+                    `[subscription-gc] Auto-closed channel ${channelId}: it emitted ` +
                     `over ${limit} characters of ambient traffic since your last activation without ` +
-                    `engagement. Mentions and DMs there still reach you. Resubscribe with ` +
-                    `${this.toolPrefix}--subscribe_channel, raise/disable its limit with ` +
-                    `set_channel_idle_limit, or check what you're missing with ${this.toolPrefix}--channel_missed.`,
+                    `engagement. Direct addresses there still reach you. Reopen with channel_open, ` +
+                    `or raise/disable its limit with set_channel_idle_limit.`,
                 },
               ],
             },
           ],
         };
       }
-      // Unsubscribe failed — keep the channel counted so we retry on the next
+      // Close failed — keep the channel counted so we retry on the next
       // ambient message rather than silently giving up.
       this.state.counters[channelId] = next;
       this.persistNow();
@@ -270,7 +267,7 @@ export class SubscriptionGcModule implements Module {
       if (event.serverId !== this.serverId) return null;
       const origin = (event.origin ?? {}) as Record<string, unknown>;
       if (origin.isMention || origin.isDM) return null;
-      const channelId = origin.channelId;
+      const channelId = origin.mcplChannelId ?? origin.channelId;
       if (typeof channelId !== 'string' || channelId.length === 0) return null;
       return { channelId, chars: textLen(event.content) };
     }

package/src/modules/web-ui-module.ts

@@ -983,8 +983,14 @@ export class WebUiModule implements Module {
       // `new WebSocket(...)` the way they do on fetch, so without an
       // explicit check, any tab the operator opens could connect here.
       if (!this.checkOrigin(req)) return new Response('Forbidden', { status: 403 });
-      const basicOk = this.checkAuth(req);
-      // Without basic auth the upgrade is allowed only when observer grants
+      // Full authority = basic auth OR a full session cookie (minted by
+      // /auth/basic). The cookie path exists because browsers reliably send
+      // cookies on WS upgrades but Chrome does NOT send cached basic-auth
+      // credentials — without it, password sign-in bounced back to the
+      // observer gate in a loop.
+      const wsSession = sharedServer!.observerSessions.lookup(sessionTokenFromRequest(req));
+      const basicOk = this.checkAuth(req) || (wsSession?.full ?? false);
+      // Without full auth the upgrade is allowed only when observer grants
       // exist — and then NOTHING is sent until a signed observer-hello
       // verifies (in-band auth; see onWsOpen/onWsMessage).
       if (!basicOk && !observersActive) return this.unauthorized();
@@ -1002,19 +1008,29 @@ export class WebUiModule implements Module {
     // when observers are active the static app shell is public — it carries
     // no data, and key-only devices must be able to load the SPA to
     // authenticate at all.
-    const basicOk = this.checkAuth(req);
-    const sessionScopes = basicOk
-      ? null
-      : sharedServer!.observerSessions.lookup(sessionTokenFromRequest(req));
+    const session = sharedServer!.observerSessions.lookup(sessionTokenFromRequest(req));
+    const basicOk = this.checkAuth(req) || (session?.full ?? false);
+    const sessionScopes = basicOk ? null : session?.scopes ?? null;
     const httpAllowed = (scope: ObserverScope): boolean =>
       basicOk || (sessionScopes?.has(scope) ?? false);
     // /auth/basic: deliberate basic-auth challenge point. fetch() never
     // triggers the browser's native credential prompt, but a top-level
     // navigation here does — the SPA's "sign in with password" fallback for
-    // devices without an observer grant. Once credentials are cached for
-    // the realm, the WS upgrade carries them and the client is 'full'.
+    // devices without an observer grant. On success it mints a FULL session
+    // cookie: the subsequent WS upgrade authenticates via that cookie
+    // (browsers send cookies on upgrades; Chrome does not send cached basic
+    // credentials, which used to loop users back to the gate).
     if (url.pathname === '/auth/basic') {
-      if (basicOk) return new Response(null, { status: 302, headers: { location: '/' } });
+      if (basicOk) {
+        const token = sharedServer!.observerSessions.mint(new Set(), { full: true });
+        return new Response(null, {
+          status: 302,
+          headers: {
+            location: '/',
+            'set-cookie': `fkm_obs=${token}; Path=/; HttpOnly; SameSite=Lax; Max-Age=${12 * 3600}`,
+          },
+        });
+      }
       return this.unauthorized();
     }
     const isStatic = !url.pathname.startsWith('/debug/')
@@ -1077,7 +1093,44 @@ export class WebUiModule implements Module {
       if (typeof fw.healthSnapshot !== 'function') {
         return Response.json({ error: 'framework lacks healthSnapshot()' }, { status: 501 });
       }
-      return Response.json(fw.healthSnapshot());
+      const snapshot = fw.healthSnapshot();
+      // Compression quarantine is a guaranteed-eventual-outage state (raw
+      // spans accumulate until the picker cannot fit the window). Surface it
+      // here so the fleet hub and connectome-doctor can alarm on it — it
+      // must never be observable only in agent.log.
+      try {
+        const quarantine: Record<string, unknown> = {};
+        for (const agent of app.framework.getAllAgents()) {
+          const strategy = (agent.getContextManager() as unknown as {
+            getStrategy?: () => { getCompressionQuarantineStatus?: () => unknown };
+          }).getStrategy?.();
+          const status = strategy?.getCompressionQuarantineStatus?.();
+          if (status) quarantine[(agent as unknown as { name: string }).name] = status;
+        }
+        (snapshot as Record<string, unknown>).compressionQuarantine = quarantine;
+      } catch {
+        // Health reads never throw.
+      }
+      // Per-agent runtime settings (context budget, tail, transition pace +
+      // convergence state) — the same numbers `agent_settings get` returns,
+      // exposed externally so the fleet hub / connectome-doctor can watch
+      // budget convergence without an agent turn.
+      try {
+        const fw2 = app.framework as unknown as {
+          getAgentRuntimeSettings?: (name: string) => unknown;
+        };
+        if (typeof fw2.getAgentRuntimeSettings === 'function') {
+          const settings: Record<string, unknown> = {};
+          for (const agent of app.framework.getAllAgents()) {
+            const name = (agent as unknown as { name: string }).name;
+            settings[name] = fw2.getAgentRuntimeSettings(name);
+          }
+          (snapshot as Record<string, unknown>).runtimeSettings = settings;
+        }
+      } catch {
+        // Health reads never throw.
+      }
+      return Response.json(snapshot);
     }
 
     // Workspace file passthrough: /files/<mount>/<path...>

package/src/modules/web-ui-observers.ts

@@ -210,23 +210,36 @@ export class ObserverRegistry {
 
 const SESSION_TTL_MS = 12 * 60 * 60_000;
 
+export interface ObserverSession {
+  scopes: Set<ObserverScope>;
+  /**
+   * Full sessions carry OPERATOR authority (equivalent to basic auth): the
+   * WS upgrade treats the connection as a full client, not a read-only
+   * observer. Minted only by /auth/basic after a successful password
+   * challenge. Exists because browsers reliably attach cookies to WebSocket
+   * upgrades but (Chrome, notably) do NOT attach cached basic-auth
+   * credentials — without this, password sign-in loops back to the gate.
+   */
+  full: boolean;
+}
+
 export class ObserverSessions {
-  private sessions = new Map<string, { scopes: Set<ObserverScope>; expiresAt: number }>();
+  private sessions = new Map<string, ObserverSession & { expiresAt: number }>();
 
-  mint(scopes: Set<ObserverScope>): string {
-    // Opportunistic sweep — the map stays tiny (one entry per WS auth).
+  mint(scopes: Set<ObserverScope>, opts?: { full?: boolean }): string {
+    // Opportunistic sweep — the map stays tiny (one entry per auth event).
     const now = Date.now();
     for (const [t, s] of this.sessions) if (s.expiresAt < now) this.sessions.delete(t);
     const token = randomBytes(32).toString('hex');
-    this.sessions.set(token, { scopes, expiresAt: now + SESSION_TTL_MS });
+    this.sessions.set(token, { scopes, full: opts?.full ?? false, expiresAt: now + SESSION_TTL_MS });
     return token;
   }
 
-  lookup(token: string | null | undefined): Set<ObserverScope> | null {
+  lookup(token: string | null | undefined): ObserverSession | null {
     if (!token) return null;
     const s = this.sessions.get(token);
     if (!s || s.expiresAt < Date.now()) return null;
-    return s.scopes;
+    return { scopes: s.scopes, full: s.full };
   }
 }
 

package/src/recipe.ts

@@ -35,6 +35,13 @@ export interface RecipeStrategy {
   // for what the recipe loader accepts under `agent.strategy`.
   enforceBudget?: boolean;
   maxSpeculativeL1s?: number;
+  /** Number of coverage-equivalent recall curves to try after the canonical
+   * autobiographical compression request is explicitly refused. Zero disables
+   * fallback while retaining the canonical attempt. */
+  compressionRefusalCurveFallbacks?: number;
+  /** Complete provider-request admission ceiling for compression fallbacks,
+   * including the output reserve. */
+  compressionContextBudgetTokens?: number;
   positionedRecallPairs?: boolean;
   recallHeaderTemplate?: string;
   targetChunkTokens?: number;
@@ -93,6 +100,11 @@ export interface RecipeAgent {
   /** Prompt-cache TTL ('5m' | '1h') forwarded to the provider. Defaults to
    *  '1h'; set '5m' explicitly for high-frequency, sub-5-minute workloads. */
   cacheTtl?: '5m' | '1h';
+  /**
+   * Same-round routing policy for ordinary text emitted beside think().
+   * Omitted preserves the compatibility carry-forward in Agent Framework.
+   */
+  sameRoundThinkTextPolicy?: 'public' | 'private';
   strategy?: RecipeStrategy;
   /**
    * Native extended thinking. When `enabled: true`, the agent's API requests
@@ -108,6 +120,7 @@ export interface RecipeAgent {
   responses?: {
     reasoningEffort?: 'none' | 'low' | 'medium' | 'high' | 'xhigh' | 'max';
     reasoningContext?: 'current_turn' | 'all_turns';
+    serviceTier?: string;
     compactThreshold?: number;
   };
   /**
@@ -119,6 +132,11 @@ export interface RecipeAgent {
     autoRewind?: boolean;
     maxRewinds?: number;
     announceHumanTurns?: boolean;
+    primarySummaryFallback?: {
+      enabled?: boolean;
+      maxNewSummaries?: number;
+      requestBudgetTokens?: number;
+    };
   };
 }
 
@@ -154,9 +172,8 @@ export interface RecipeMcpServer {
   /** Ceiling for the exponential reconnect backoff. Default: 5 minutes. */
   reconnectMaxIntervalMs?: number;
   /**
-   * Channel auto-open policy. 'auto' (default) opens everything the server
-   * registers; 'manual' opens nothing (agent calls channel_open as needed);
-   * a string[] is an allow-list of channel ids.
+   * @deprecated One-time migration input for legacy recipes. Runtime channel
+   * desired state is Chronicle-backed and changed with channel_open/close.
    */
   channelSubscription?: 'auto' | 'manual' | string[];
   /**
@@ -716,6 +733,9 @@ export function validateRecipe(raw: unknown): Recipe {
     if (responses.reasoningContext !== undefined && responses.reasoningContext !== 'current_turn' && responses.reasoningContext !== 'all_turns') {
       throw new Error(`Invalid agent.responses.reasoningContext ${JSON.stringify(responses.reasoningContext)}.`);
     }
+    if (responses.serviceTier !== undefined && (typeof responses.serviceTier !== 'string' || !responses.serviceTier.trim())) {
+      throw new Error('Recipe agent.responses.serviceTier must be a non-empty string.');
+    }
     if (responses.compactThreshold !== undefined &&
         (typeof responses.compactThreshold !== 'number' || responses.compactThreshold <= 0)) {
       throw new Error('Recipe agent.responses.compactThreshold must be a positive number.');
@@ -733,6 +753,16 @@ export function validateRecipe(raw: unknown): Recipe {
   }
   agent.cacheTtl ??= '1h';
 
+  if (
+    agent.sameRoundThinkTextPolicy !== undefined &&
+    agent.sameRoundThinkTextPolicy !== 'public' &&
+    agent.sameRoundThinkTextPolicy !== 'private'
+  ) {
+    throw new Error(
+      `Recipe agent.sameRoundThinkTextPolicy must be 'public' or 'private', got ${JSON.stringify(agent.sameRoundThinkTextPolicy)}.`,
+    );
+  }
+
   // Validate agent.thinking if present. Catches typos and constraint
   // violations (notably max_tokens > budget_tokens) at recipe-load time
   // rather than as a 400 from Anthropic at first inference.
@@ -770,6 +800,58 @@ export function validateRecipe(raw: unknown): Recipe {
         `Invalid strategy type "${strategy.type}". Must be "autobiographical", "passthrough", or "frontdesk".`,
       );
     }
+    if (
+      strategy.compressionRefusalCurveFallbacks !== undefined
+      && (
+        typeof strategy.compressionRefusalCurveFallbacks !== 'number'
+        || !Number.isSafeInteger(strategy.compressionRefusalCurveFallbacks)
+        || strategy.compressionRefusalCurveFallbacks < 0
+      )
+    ) {
+      throw new Error('Recipe agent.strategy.compressionRefusalCurveFallbacks must be a non-negative safe integer.');
+    }
+    if (
+      strategy.compressionContextBudgetTokens !== undefined
+      && (
+        typeof strategy.compressionContextBudgetTokens !== 'number'
+        || !Number.isSafeInteger(strategy.compressionContextBudgetTokens)
+        || strategy.compressionContextBudgetTokens <= 0
+      )
+    ) {
+      throw new Error('Recipe agent.strategy.compressionContextBudgetTokens must be a positive safe integer.');
+    }
+  }
+
+  const refusalHandling = agent.refusalHandling as Record<string, unknown> | undefined;
+  const primarySummaryFallback = refusalHandling?.primarySummaryFallback;
+  if (primarySummaryFallback !== undefined) {
+    if (!primarySummaryFallback || typeof primarySummaryFallback !== 'object' || Array.isArray(primarySummaryFallback)) {
+      throw new Error('Recipe agent.refusalHandling.primarySummaryFallback must be an object.');
+    }
+    const fallback = primarySummaryFallback as Record<string, unknown>;
+    if (fallback.enabled !== undefined && typeof fallback.enabled !== 'boolean') {
+      throw new Error('Recipe agent.refusalHandling.primarySummaryFallback.enabled must be a boolean.');
+    }
+    if (
+      fallback.maxNewSummaries !== undefined &&
+      (
+        typeof fallback.maxNewSummaries !== 'number' ||
+        !Number.isSafeInteger(fallback.maxNewSummaries) ||
+        fallback.maxNewSummaries < 0
+      )
+    ) {
+      throw new Error('Recipe agent.refusalHandling.primarySummaryFallback.maxNewSummaries must be a non-negative safe integer.');
+    }
+    if (
+      fallback.requestBudgetTokens !== undefined &&
+      (
+        typeof fallback.requestBudgetTokens !== 'number' ||
+        !Number.isSafeInteger(fallback.requestBudgetTokens) ||
+        fallback.requestBudgetTokens <= 0
+      )
+    ) {
+      throw new Error('Recipe agent.refusalHandling.primarySummaryFallback.requestBudgetTokens must be a positive safe integer.');
+    }
   }
 
   // Validate mcpServers entries if present

package/src/state/agent-tree-reducer.ts

@@ -202,10 +202,13 @@ const EVENT_HANDLERS: Record<string, EventHandler> = {
     node.lastEventAt = ts;
   },
 
-  // inference:exhausted = budget exhaustion / stream-side cancel / reboot-
+  // inference:exhausted = retries exhausted / genuine stream cancel / reboot-
   // induced. Postmortem 2026-05-28 P1 #3: not strictly a fault — flip both
   // fields to the dedicated 'cancelled' terminal state so the renderer can
-  // distinguish "stopped on purpose" from "errored out".
+  // distinguish "stopped on purpose" from "errored out". (AF PR #55 / ≥ 0.6.5
+  // stopped emitting this for endTurn and context-budget restarts — those are
+  // no longer terminal at all — but user cancels and reboots still land here,
+  // and older AF still sends the endTurn-trailing one.)
   'inference:exhausted': (r, e, ts) => {
     if (!e.agentName) return;
     const node = r._ensureNode(e.agentName);
@@ -236,9 +239,20 @@ const EVENT_HANDLERS: Record<string, EventHandler> = {
     r._ensureNode(e.agentName).lastEventAt = ts;
   },
 
+  // endTurn tool result: the agent deliberately ended its turn — a successful
+  // terminal, same family as inference:completed. This event must be terminal
+  // in its own right: agent-framework PR #55 (≥ 0.6.5) settles endTurn from
+  // the state machine and no longer follows it with the spurious
+  // inference:exhausted that used to flip these nodes to 'cancelled'. On
+  // older AF the trailing exhausted still arrives and (harmlessly)
+  // re-terminates the node as cancelled one event later.
   'inference:turn_ended': (r, e, ts) => {
     if (!e.agentName) return;
-    r._ensureNode(e.agentName).lastEventAt = ts;
+    const node = r._ensureNode(e.agentName);
+    node.phase = 'done';
+    node.status = 'completed';
+    node.completedAt = ts;
+    node.lastEventAt = ts;
   },
 
   'tool:started': (r, e, ts) => {