agents 0.24.0 → 0.26.0

package/dist/{connector-CkQD4MK3.d.ts → connector-Cl-VqPmA.d.ts}

@@ -6,7 +6,7 @@ import {
   PassEndStatus
 } from "@cloudflare/codemode";
 
-//#region src/browser/cdp-session.d.ts
+//#region src/browser/cdp-connection.d.ts
 interface DebugEntry {
   at: string;
   type: string;
@@ -19,20 +19,41 @@ interface CdpSendOptions {
 interface CdpAttachOptions {
   timeoutMs?: number;
 }
+/** Construction options for {@link CdpConnection}. */
+interface CdpConnectionOptions {
+  /** Default per-command timeout. Defaults to 10 seconds. */
+  timeoutMs?: number;
+  /**
+   * Invoked exactly once when the session reaches a terminal state — an
+   * explicit `close()`, peer closure, or a socket error.
+   */
+  onClose?: () => void;
+  /** Browser Run session id, when connected to a session-scoped browser. */
+  sessionId?: string;
+  /** Invoked on every CDP command sent — an activity signal for idle tracking. */
+  onActivity?: () => void;
+}
 /**
- * A CDP session over an open WebSocket. Manages command correlation,
- * timeouts, target sessions, and a debug event ring buffer.
+ * One Chrome DevTools Protocol connection over an open WebSocket. Manages
+ * command correlation, timeouts, per-tab CDP sessions, and a debug event
+ * ring buffer.
  *
  * Used host-side (not in the sandbox) — the sandbox calls into this
  * via DynamicWorkerExecutor's ToolDispatcher RPC.
  */
-declare class CdpSession {
+declare class CdpConnection {
   #private;
   readonly sessionId?: string;
+  constructor(socket: WebSocket, options?: CdpConnectionOptions);
+  /**
+   * @deprecated Pass a {@link CdpConnectionOptions} object instead —
+   * `new CdpConnection(socket, { timeoutMs, onClose, sessionId })`. The
+   * positional form will be removed.
+   */
   constructor(
     socket: WebSocket,
-    defaultTimeoutMs?: number,
-    dispose?: () => void,
+    timeoutMs?: number,
+    onClose?: () => void,
     sessionId?: string
   );
   send(
@@ -60,7 +81,11 @@ declare function connectUrl(
     timeoutMs?: number;
     headers?: Record<string, string>;
   }
-): Promise<CdpSession>;
+): Promise<CdpConnection>;
+/** @deprecated Renamed to {@link CdpConnection}. */
+declare const CdpSession: typeof CdpConnection;
+/** @deprecated Renamed to {@link CdpConnection}. */
+type CdpSession = CdpConnection;
 //#endregion
 //#region src/browser/browser-run.d.ts
 /**
@@ -71,6 +96,23 @@ declare function connectUrl(
 interface BrowserBinding {
   fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
 }
+/**
+ * Browser Run [hostname guardrails](https://developers.cloudflare.com/browser-run/features/guardrails/):
+ * restrict which hostnames the session's HTTP/HTTPS requests may reach. Fixed
+ * at session launch for every connection to the session, including Live View.
+ * Omitted entirely, the platform default applies: all hostnames are allowed.
+ * Not supported by Kitesurf.
+ */
+interface BrowserSessionGuardrails {
+  /**
+   * Hostname patterns the browser may request — bare hostnames only (no
+   * protocol, port, or path). `*.example.com` matches subdomains; add
+   * `example.com` separately to allow the apex.
+   */
+  allowedDomains?: string[];
+  /** Named Cloudflare-maintained domain sets, e.g. `"common-cdns"`. */
+  allowedDomainSets?: string[];
+}
 interface BrowserTargetInfo {
   id: string;
   type?: string;
@@ -85,7 +127,10 @@ interface BrowserSessionInfo {
   targets?: BrowserTargetInfo[];
   webSocketDebuggerUrl?: string;
 }
-interface ConnectBrowserOptions {
+/** {@link connectBrowser} options for the default Chromium engine. */
+interface ConnectChromiumBrowserOptions {
+  /** Select the browser engine. Defaults to Chromium. */
+  browser?: "chromium";
   timeoutMs?: number;
   keepAliveMs?: number;
   includeTargets?: boolean;
@@ -96,12 +141,24 @@ interface ConnectBrowserOptions {
    * {@link getBrowserRecording}.
    */
   recording?: boolean;
-  /**
-   * Select the browser engine. Defaults to Chromium. Use `"kitesurf"` for
-   * Cloudflare's connection-scoped, agent-first browser engine.
-   */
-  browser?: "kitesurf";
 }
+/**
+ * {@link connectBrowser} options for Kitesurf, Cloudflare's connection-scoped,
+ * agent-first browser engine. A Kitesurf browser lives and dies with its
+ * WebSocket, so the Chromium-only options (`keepAliveMs`, `includeTargets`,
+ * `recording`) do not exist on this arm.
+ */
+interface ConnectKitesurfBrowserOptions {
+  browser: "kitesurf";
+  timeoutMs?: number;
+}
+/**
+ * Engine-discriminated {@link connectBrowser} options: selecting
+ * `browser: "kitesurf"` removes the Chromium-only options at the type level.
+ */
+type ConnectBrowserOptions =
+  | ConnectChromiumBrowserOptions
+  | ConnectKitesurfBrowserOptions;
 /** An rrweb session recording for a closed Browser Run session. */
 interface BrowserRecording {
   sessionId: string;
@@ -123,6 +180,7 @@ declare function createBrowserSession(
     keepAliveMs?: number;
     includeTargets?: boolean;
     recording?: boolean;
+    guardrails?: BrowserSessionGuardrails;
   }
 ): Promise<BrowserSessionInfo>;
 declare function listBrowserTargets(
@@ -139,7 +197,7 @@ declare function deleteBrowserSession(
 declare function connectBrowser(
   browser: BrowserBinding,
   options?: number | ConnectBrowserOptions
-): Promise<CdpSession>;
+): Promise<CdpConnection>;
 /**
  * Fetch a Browser Run [session recording](https://developers.cloudflare.com/browser-run/features/session-recording/)
  * by session id, via the Browser Rendering REST API.
@@ -159,14 +217,135 @@ declare function getBrowserRecording(options: {
   sessionId: string /** Override for testing; defaults to the global `fetch`. */;
   fetchImpl?: typeof fetch;
 }): Promise<BrowserRecording>;
+interface ConnectBrowserSessionOptions {
+  timeoutMs?: number;
+  /**
+   * Invoked once when the returned {@link CdpConnection} reaches a terminal
+   * state — an explicit `close()`, peer closure, or a socket error. The
+   * session itself is never deleted on close — pass an `onClose` that
+   * deletes it for one-shot (create-and-close) semantics.
+   */
+  onClose?: () => void;
+  /**
+   * Invoked on every CDP command sent over the returned {@link CdpConnection} —
+   * an activity signal for idle tracking. Keep it cheap and synchronous;
+   * throttle any I/O it triggers.
+   */
+  onActivity?: () => void;
+}
 /**
  * Connect to an existing Browser Rendering session without deleting it on close.
  */
+declare function connectBrowserSession(
+  browser: BrowserBinding,
+  sessionId: string,
+  options?: ConnectBrowserSessionOptions
+): Promise<CdpConnection>;
+/**
+ * @deprecated Pass `{ timeoutMs }` instead of a bare number — the numeric
+ * form will be removed.
+ */
 declare function connectBrowserSession(
   browser: BrowserBinding,
   sessionId: string,
   timeoutMs?: number
-): Promise<CdpSession>;
+): Promise<CdpConnection>;
+//#endregion
+//#region src/browser/live-view.d.ts
+/**
+ * Live View rendering mode (the `mode` query param the hosted UI at
+ * `live.browser.run` understands):
+ *
+ * - `"tab"` — a standalone, interactive page view (best for handing control
+ *   to a human).
+ * - `"devtools"` — the full DevTools inspector panel (Elements, Console,
+ *   Network, …).
+ *
+ * Omit it to use whatever mode the binding's `devtoolsFrontendUrl` defaults
+ * to.
+ */
+type LiveViewMode = "tab" | "devtools";
+/** A single tab's Live View URL. */
+interface BrowserLiveViewUrl {
+  /** Open this in a browser to watch/control the tab in real time. */
+  url: string;
+  /** CDP target (tab) id the URL points at. */
+  targetId: string;
+  /** Milliseconds the URL stays valid from when it was generated (~5 min). */
+  expiresInMs: number;
+}
+interface BrowserLiveViewTarget {
+  targetId: string;
+  /** Embeddable Live View URL (the `devtoolsFrontendUrl`) for this tab. */
+  url: string;
+  /** The page the tab is currently showing (e.g. `https://example.com`). */
+  pageUrl?: string;
+  title?: string;
+  type?: string;
+}
+/** Live View URLs for every tab in a session. */
+interface BrowserLiveView {
+  sessionId: string;
+  targets: BrowserLiveViewTarget[];
+  /** Milliseconds the URLs stay valid from when they were generated (~5 min). */
+  expiresInMs: number;
+}
+//#endregion
+//#region src/browser/session-store.d.ts
+type MaybePromise<T> = T | Promise<T>;
+interface StoredBrowserSession {
+  sessionId: string;
+  createdAt: number;
+  updatedAt: number;
+  /**
+   * Set when a sweep closed this entry's Browser Run session but kept the
+   * entry as a tombstone, so a later resume of the owning execution fails
+   * loudly instead of silently continuing in a fresh browser.
+   */
+  closedAt?: number;
+  /**
+   * Named browsers only: the tab (CDP `targetId`) the agent last worked in,
+   * so `sessionId: "active"` in a later execution lands on the same page.
+   * CDP session ids die with each connection; target ids live as long as
+   * the tab.
+   */
+  activeTargetId?: string;
+}
+interface BrowserSessionLock {
+  release(): MaybePromise<void>;
+}
+interface BrowserSessionStore {
+  /**
+   * Acquire an exclusive lock for this session key. The lock must serialize
+   * all holders using the same key. Held only around storage reads/writes —
+   * never across Browser Rendering network calls.
+   */
+  acquireLock(key: string): MaybePromise<BrowserSessionLock>;
+  get(key: string): MaybePromise<StoredBrowserSession | undefined>;
+  set(key: string, session: StoredBrowserSession): MaybePromise<void>;
+  delete(key: string): MaybePromise<void>;
+  /**
+   * List stored sessions by key prefix. Optional — used by sweeps to find
+   * orphaned per-execution sessions; without it only the shared session key
+   * is swept.
+   */
+  list?(prefix: string): MaybePromise<Map<string, StoredBrowserSession>>;
+}
+declare class DurableBrowserSessionStore implements BrowserSessionStore {
+  #private;
+  private readonly storage;
+  constructor(storage: DurableObjectStorage);
+  acquireLock(key: string): Promise<BrowserSessionLock>;
+  get(key: string): Promise<StoredBrowserSession | undefined>;
+  set(key: string, session: StoredBrowserSession): Promise<void>;
+  delete(key: string): Promise<void>;
+  list(prefix: string): Promise<Map<string, StoredBrowserSession>>;
+}
+/**
+ * Default idle window used by {@link BrowserConnector.sweep} for the shared
+ * (reuse/promoted) session entry.
+ */
+declare const DEFAULT_SWEEP_IDLE_MS: number;
 //#endregion
 //#region src/browser/quick-actions.d.ts
 /**
@@ -365,55 +544,6 @@ declare function browserPdf(
   input: QuickActionPage
 ): Promise<QuickActionBinary>;
 //#endregion
-//#region src/browser/session-manager.d.ts
-type MaybePromise<T> = T | Promise<T>;
-interface StoredBrowserSession {
-  sessionId: string;
-  createdAt: number;
-  updatedAt: number;
-  /**
-   * Set when a sweep closed this entry's Browser Run session but kept the
-   * entry as a tombstone, so a later resume of the owning execution fails
-   * loudly instead of silently continuing in a fresh browser.
-   */
-  closedAt?: number;
-}
-interface BrowserSessionLock {
-  release(): MaybePromise<void>;
-}
-interface BrowserSessionStore {
-  /**
-   * Acquire an exclusive lock for this session key. The lock must serialize
-   * all holders using the same key. Held only around storage reads/writes —
-   * never across Browser Rendering network calls.
-   */
-  acquireLock(key: string): MaybePromise<BrowserSessionLock>;
-  get(key: string): MaybePromise<StoredBrowserSession | undefined>;
-  set(key: string, session: StoredBrowserSession): MaybePromise<void>;
-  delete(key: string): MaybePromise<void>;
-  /**
-   * List stored sessions by key prefix. Optional — used by sweeps to find
-   * orphaned per-execution sessions; without it only the shared session key
-   * is swept.
-   */
-  list?(prefix: string): MaybePromise<Map<string, StoredBrowserSession>>;
-}
-declare class DurableBrowserSessionStore implements BrowserSessionStore {
-  #private;
-  private readonly storage;
-  constructor(storage: DurableObjectStorage);
-  acquireLock(key: string): Promise<BrowserSessionLock>;
-  get(key: string): Promise<StoredBrowserSession | undefined>;
-  set(key: string, session: StoredBrowserSession): Promise<void>;
-  delete(key: string): Promise<void>;
-  list(prefix: string): Promise<Map<string, StoredBrowserSession>>;
-}
-/**
- * Default idle window used by {@link BrowserConnector.sweep} for the shared
- * (reuse/promoted) session entry.
- */
-declare const DEFAULT_SWEEP_IDLE_MS: number;
-//#endregion
 //#region src/browser/connector.d.ts
 /** Browser session lifecycle for the connector (binding-backed only). */
 interface BrowserConnectorSessionOptions {
@@ -496,44 +626,6 @@ interface BrowserConnectorSweepResult {
     sessionId: string;
   }>;
 }
-/**
- * Live View rendering mode (the `mode` query param the hosted UI at
- * `live.browser.run` understands):
- *
- * - `"tab"` — a standalone, interactive page view (best for handing control
- *   to a human).
- * - `"devtools"` — the full DevTools inspector panel (Elements, Console,
- *   Network, …).
- *
- * Omit it to use whatever mode the binding's `devtoolsFrontendUrl` defaults
- * to.
- */
-type LiveViewMode = "tab" | "devtools";
-/** A single tab's Live View URL. */
-interface BrowserLiveViewUrl {
-  /** Open this in a browser to watch/control the tab in real time. */
-  url: string;
-  /** CDP target (tab) id the URL points at. */
-  targetId: string;
-  /** Milliseconds the URL stays valid from when it was generated (~5 min). */
-  expiresInMs: number;
-}
-interface BrowserLiveViewTarget {
-  targetId: string;
-  /** Embeddable Live View URL (the `devtoolsFrontendUrl`) for this tab. */
-  url: string;
-  /** The page the tab is currently showing (e.g. `https://example.com`). */
-  pageUrl?: string;
-  title?: string;
-  type?: string;
-}
-/** Live View URLs for every tab in a (shared) session. */
-interface BrowserLiveView {
-  sessionId: string;
-  targets: BrowserLiveViewTarget[];
-  /** Milliseconds the URLs stay valid from when they were generated (~5 min). */
-  expiresInMs: number;
-}
 /**
  * Default idle window before {@link BrowserConnector.sweep} reclaims a
  * per-execution session. Matches the codemode runtime's default paused TTL
@@ -621,56 +713,62 @@ declare class BrowserConnector extends CodemodeConnector {
 }
 //#endregion
 export {
-  browserMarkdown as A,
-  BrowserTargetInfo as B,
-  QuickActionScrapeInput as C,
-  browserContent as D,
-  QuickActionSnapshot as E,
-  runQuickAction as F,
-  deleteBrowserSession as G,
-  connectBrowser as H,
+  CdpConnection as $,
+  DurableBrowserSessionStore as A,
+  BrowserSessionInfo as B,
+  browserScrape as C,
+  BrowserSessionLock as D,
+  runQuickAction as E,
+  LiveViewMode as F,
+  ConnectKitesurfBrowserOptions as G,
+  ConnectBrowserOptions as H,
   BrowserBinding as I,
-  CdpAttachOptions as J,
-  getBrowserRecording as K,
+  createBrowserSession as J,
+  connectBrowser as K,
   BrowserRecording as L,
-  browserScrape as M,
-  browserScreenshot as N,
-  browserExtract as O,
-  browserSnapshot as P,
+  BrowserLiveView as M,
+  BrowserLiveViewTarget as N,
+  BrowserSessionStore as O,
+  BrowserLiveViewUrl as P,
+  CdpAttachOptions as Q,
   BrowserRenderingError as R,
-  QuickActionPage as S,
-  QuickActionScreenshotInput as T,
-  connectBrowserSession as U,
-  ConnectBrowserOptions as V,
-  createBrowserSession as W,
-  CdpSession as X,
-  CdpSendOptions as Y,
-  connectUrl as Z,
-  QuickActionBinary as _,
+  browserPdf as S,
+  browserSnapshot as T,
+  ConnectBrowserSessionOptions as U,
+  BrowserTargetInfo as V,
+  ConnectChromiumBrowserOptions as W,
+  getBrowserRecording as X,
+  deleteBrowserSession as Y,
+  listBrowserTargets as Z,
+  QuickActionSnapshot as _,
   BrowserConnectorSweepResult as a,
-  QuickActionExtractInput as b,
-  BrowserLiveViewUrl as c,
-  BrowserSessionLock as d,
-  BrowserSessionStore as f,
-  QuickAction as g,
-  StoredBrowserSession as h,
+  browserLinks as b,
+  QuickActionBinary as c,
+  QuickActionExtractInput as d,
+  CdpConnectionOptions as et,
+  QuickActionInput as f,
+  QuickActionScreenshotInput as g,
+  QuickActionScrapeResult as h,
   BrowserConnectorSweepOptions as i,
-  browserPdf as j,
-  browserLinks as k,
-  DEFAULT_EXEC_SWEEP_IDLE_MS as l,
-  DurableBrowserSessionStore as m,
+  StoredBrowserSession as j,
+  DEFAULT_SWEEP_IDLE_MS as k,
+  QuickActionBinding as l,
+  QuickActionScrapeInput as m,
   BrowserConnectorOptions as n,
-  BrowserLiveView as o,
-  DEFAULT_SWEEP_IDLE_MS as p,
-  listBrowserTargets as q,
+  CdpSession as nt,
+  DEFAULT_EXEC_SWEEP_IDLE_MS as o,
+  QuickActionPage as p,
+  connectBrowserSession as q,
   BrowserConnectorSessionOptions as r,
-  BrowserLiveViewTarget as s,
+  connectUrl as rt,
+  QuickAction as s,
   BrowserConnector as t,
-  LiveViewMode as u,
-  QuickActionBinding as v,
-  QuickActionScrapeResult as w,
-  QuickActionInput as x,
-  QuickActionCommonOptions as y,
-  BrowserSessionInfo as z
+  CdpSendOptions as tt,
+  QuickActionCommonOptions as u,
+  browserContent as v,
+  browserScreenshot as w,
+  browserMarkdown as x,
+  browserExtract as y,
+  BrowserSessionGuardrails as z
 };
-//# sourceMappingURL=connector-CkQD4MK3.d.ts.map
+//# sourceMappingURL=connector-Cl-VqPmA.d.ts.map

package/dist/context/index.d.ts

@@ -94,6 +94,22 @@ interface ContextConfig {
    *  - SearchProvider (get+search+set?) → searchable via search_context
    *  If omitted, auto-wired to writable SQLite when using builder. */
   provider?: ContextProvider | WritableContextProvider | SearchProvider;
+  /**
+   * What the model sees when this block's value moves on after the system
+   * prompt was frozen.
+   *
+   * - `"wait"` (default): nothing, until `refreshSystemPrompt()` rebuilds
+   *   the prompt.
+   * - `"remind"`: `reminder()` re-reads the block and, while it differs from
+   *   the frozen prompt, returns its current value for the host to send
+   *   after the cached prefix. The frozen prompt, and the provider's prefix
+   *   cache, stay intact until `refreshSystemPrompt()` promotes the value.
+   *   The block renders in the prompt even when empty.
+   *
+   * A change is any difference in what the provider returns, so return only
+   * what should count: a date rather than a timestamp.
+   */
+  whenChanged?: "wait" | "remind";
 }
 /**
  * A loaded context block with computed token count.
@@ -140,6 +156,7 @@ declare class ContextBlocks {
   load(): Promise<void>;
   /** Initialize a block's provider and read its current content. */
   private loadBlock;
+  private readBlock;
   /**
    * Dynamically register a new context block after initialization.
    * Used by extensions to contribute context at runtime.
@@ -192,6 +209,18 @@ declare class ContextBlocks {
    * persist it. Use this after block content has changed.
    */
   refreshSystemPrompt(): Promise<string>;
+  /**
+   * Current values of the `whenChanged: "remind"` blocks that no longer
+   * match the frozen prompt, rendered for the host to send after the cached
+   * prefix: at the end of the conversation, not in the system prompt. `null`
+   * when nothing has changed or nothing is frozen yet.
+   *
+   * Each call re-reads those blocks from their providers. The comparison is
+   * against the frozen prompt itself, so it holds across restarts, and a
+   * reminder keeps appearing on every call until `refreshSystemPrompt()`
+   * folds the value in.
+   */
+  reminder(): Promise<string | null>;
   /**
    * AI tools for context blocks.
    *

package/dist/context/index.js

@@ -104,6 +104,39 @@ function contextEntryKey(metadataTitle, content) {
 	if (metadataTitle?.trim()) return slugify(metadataTitle) || `entry-${stableHash(metadataTitle)}`;
 	return `${slugify(content) || "entry"}-${stableHash(content)}`;
 }
+const SECTION_RULE = "═".repeat(46);
+const REMINDER_PREAMBLE = "These context blocks changed after the system prompt was written. Their current values below replace the ones in the system prompt.";
+/**
+* Empty readonly blocks are left out of the prompt. Writable and searchable
+* blocks always render so the model knows which tools can address them.
+* Remind blocks always render so `promptRendersBlock` can match them exactly:
+* an absent section cannot be told apart from another label's by prefix.
+*/
+function rendersInPrompt(block, remind) {
+	return !!block.content || block.writable || block.isSearchable || remind;
+}
+function renderSection(block) {
+	let header = block.label.toUpperCase();
+	if (block.description) header += ` (${block.description})`;
+	if (block.maxTokens) {
+		const pct = Math.round(block.tokens / block.maxTokens * 100);
+		header += ` [${pct}% — ${block.tokens}/${block.maxTokens} tokens]`;
+	}
+	if (block.isSearchable) header += " [searchable]";
+	else if (!block.writable) header += " [readonly]";
+	else header += " [writable]";
+	return `${SECTION_RULE}\n${header}\n${SECTION_RULE}\n${block.content}`;
+}
+/**
+* Whether `prompt` renders `block` exactly as it stands now. Sections are
+* joined by a blank line and each opens with a rule, so padding the prompt
+* with a blank line in front and a rule behind lets one containment test
+* pin both ends of a section: content that only grew or shrank at the
+* edges does not pass for unchanged.
+*/
+function promptRendersBlock(prompt, block) {
+	return `\n\n${prompt}\n\n${SECTION_RULE}\n`.includes(`\n\n${renderSection(block)}\n\n${SECTION_RULE}\n`);
+}
 /**
 * Check if a provider is writable (has a `set` method).
 */
@@ -148,8 +181,11 @@ var ContextBlocks = class {
 	}
 	/** Initialize a block's provider and read its current content. */
 	async loadBlock(config) {
+		config.provider?.init?.(config.label);
+		return this.readBlock(config);
+	}
+	async readBlock(config) {
 		const provider = config.provider;
-		provider?.init?.(config.label);
 		const content = provider ? await provider.get() ?? "" : "";
 		const searchable = isSearchProvider(provider);
 		return {
@@ -262,22 +298,8 @@ var ContextBlocks = class {
 		return this.setBlock(label, existing.content + (needsSep ? "\n" : "") + content);
 	}
 	renderPrompt() {
-		const parts = [];
-		const sep = "═".repeat(46);
-		for (const block of this.blocks.values()) {
-			if (!block.content && !block.writable && !block.isSearchable) continue;
-			let header = block.label.toUpperCase();
-			if (block.description) header += ` (${block.description})`;
-			if (block.maxTokens) {
-				const pct = Math.round(block.tokens / block.maxTokens * 100);
-				header += ` [${pct}% — ${block.tokens}/${block.maxTokens} tokens]`;
-			}
-			if (block.isSearchable) header += " [searchable]";
-			else if (!block.writable) header += " [readonly]";
-			else header += " [writable]";
-			parts.push(`${sep}\n${header}\n${sep}\n${block.content}`);
-		}
-		return parts.join("\n\n");
+		const remind = new Set(this.configs.filter((config) => config.whenChanged === "remind").map((config) => config.label));
+		return Array.from(this.blocks.values()).filter((block) => rendersInPrompt(block, remind.has(block.label))).map(renderSection).join("\n\n");
 	}
 	/**
 	* The frozen system prompt. The first call renders the blocks and stores
@@ -308,6 +330,31 @@ var ContextBlocks = class {
 		return this.snapshot;
 	}
 	/**
+	* Current values of the `whenChanged: "remind"` blocks that no longer
+	* match the frozen prompt, rendered for the host to send after the cached
+	* prefix: at the end of the conversation, not in the system prompt. `null`
+	* when nothing has changed or nothing is frozen yet.
+	*
+	* Each call re-reads those blocks from their providers. The comparison is
+	* against the frozen prompt itself, so it holds across restarts, and a
+	* reminder keeps appearing on every call until `refreshSystemPrompt()`
+	* folds the value in.
+	*/
+	async reminder() {
+		if (!this.loaded) await this.load();
+		const frozen = this.promptStore ? await this.promptStore.get() ?? this.snapshot : this.snapshot;
+		if (frozen === null) return null;
+		const sections = [];
+		for (const config of this.configs) {
+			if (config.whenChanged !== "remind") continue;
+			const block = await this.readBlock(config);
+			this.blocks.set(config.label, block);
+			if (!promptRendersBlock(frozen, block)) sections.push(renderSection(block));
+		}
+		if (sections.length === 0) return null;
+		return [REMINDER_PREAMBLE, ...sections].join("\n\n");
+	}
+	/**
 	* AI tools for context blocks.
 	*
 	* Auto-wired based on provider capabilities: