@code-yeongyu/senpi 2026.10.25-4 → 2026.10.26-2

package/dist/modes/rpc/json-normal-value.js

@@ -0,0 +1,100 @@
+import { isBigIntObject, isBooleanObject, isNumberObject, isStringObject } from "node:util/types";
+/** JSON.stringify's value semantics, without serializing or parsing a record. */
+export function normalizeJsonValue(input) {
+    const ancestors = new Set();
+    let changed = false;
+    const visit = (input, key) => {
+        let value = input;
+        if ((typeof value === "object" && value !== null) || typeof value === "function" || typeof value === "bigint") {
+            const toJSON = value.toJSON;
+            if (typeof toJSON === "function") {
+                value = toJSON.call(value, key);
+                changed = true;
+            }
+        }
+        if (typeof value === "object" && value !== null) {
+            if (isNumberObject(value)) {
+                value = +value;
+                changed = true;
+            }
+            else if (isStringObject(value)) {
+                value = String(value);
+                changed = true;
+            }
+            else if (isBooleanObject(value)) {
+                value = Boolean.prototype.valueOf.call(value);
+                changed = true;
+            }
+            else if (isBigIntObject(value)) {
+                throw new TypeError("Do not know how to serialize a BigInt");
+            }
+        }
+        if (typeof value === "bigint")
+            throw new TypeError("Do not know how to serialize a BigInt");
+        if (typeof value === "number") {
+            const normalized = Number.isFinite(value) ? (Object.is(value, -0) ? 0 : value) : null;
+            if (!Object.is(normalized, value))
+                changed = true;
+            return normalized;
+        }
+        if (typeof value === "undefined" || typeof value === "function" || typeof value === "symbol") {
+            changed = true;
+            return undefined;
+        }
+        if (typeof value !== "object" || value === null)
+            return value;
+        if (ancestors.has(value))
+            throw new TypeError("Converting circular structure to JSON");
+        ancestors.add(value);
+        try {
+            // A non-callable toJSON getter must not be read again by later serialization.
+            if ("toJSON" in value)
+                changed = true;
+            if (Array.isArray(value)) {
+                const array = [];
+                const length = value.length;
+                for (let index = 0; index < length; index++) {
+                    const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+                    if (!descriptor || descriptor.get)
+                        changed = true;
+                    array.push(visit(value[index], String(index)) ?? null);
+                }
+                return array;
+            }
+            const result = {};
+            const names = Object.keys(value);
+            if (Object.getPrototypeOf(value) !== Object.prototype || Reflect.ownKeys(value).length !== names.length)
+                changed = true;
+            for (const name of names) {
+                if (Object.getOwnPropertyDescriptor(value, name)?.get)
+                    changed = true;
+                const child = visit(value[name], name);
+                if (child !== undefined)
+                    Object.defineProperty(result, name, {
+                        value: child,
+                        enumerable: true,
+                        configurable: true,
+                        writable: true,
+                    });
+            }
+            return result;
+        }
+        finally {
+            ancestors.delete(value);
+        }
+    };
+    let value;
+    try {
+        value = visit(input, "");
+    }
+    catch (error) {
+        // The recursive walk overflows the stack before native JSON does; let native JSON decide.
+        if (!(error instanceof RangeError))
+            throw error;
+        return { value: JSON.parse(JSON.stringify(input)), changed: true };
+    }
+    if (value === undefined)
+        throw new SyntaxError("JSON input has no representation");
+    return { value, changed };
+}
+//# sourceMappingURL=json-normal-value.js.map

package/dist/modes/rpc/mcp-presenter-bootstrap.js

@@ -11,6 +11,11 @@ export function presenterBootstrapStream(fd) {
         const stat = fstatSync(fd);
         if (!stat.isSocket() && !stat.isFIFO())
             return undefined;
+        // Node's fs read blocks a worker until peer EOF, even after destroy(), and process.exit()
+        // joins that worker. A socket handle can cancel the pending read after enrollment.
+        // Bun does not support inherited net.Socket fds; it retains the file-stream adapter below.
+        if (stat.isSocket() && !process.versions.bun)
+            return new Socket({ fd, readable: true, writable: true });
     }
     catch {
         // Bootstrap is optional authority, never a reason to terminate the shared host.

package/dist/modes/rpc/media-placeholders.d.ts

@@ -11,17 +11,18 @@
  * `SessionEventWriter.enqueue`.
  *
  * Two hard rules:
- * - Type-gate FIRST. `message_update` is the hot path (one record per token) and must
- *   never be walked.
+ * - Type-gate the media walk. JSON-value normalization is shared with writer
+ *   acceptance; media projection itself never walks `message_update` partials.
  * - Copy-on-write. Responses hand out live agent state by reference
  *   (`success(id, "get_messages", { messages: session.messages })`), so the input graph
- *   is never mutated and unchanged sub-trees keep their identity. When nothing changed
+ *   is never mutated and unchanged JSON sub-trees keep their identity. When nothing changed
  *   the SAME record reference comes back, which lets the caller reuse the line it
  *   already serialized.
  *
  * User-authored images (`prompt.images`) stay intact: they are bounded by the client
  * that sent them; the fan-out hazard is tool output.
  */
+type RpcRecord = Record<string, unknown>;
 /** Why a host could not keep a tool image on disk for the client to read. */
 export type MediaUnavailableReason = "image_too_large" | "session_limit" | "storage_error";
 /** Where a persisted image lives (absolute), or why there is no file. */
@@ -61,6 +62,8 @@ export interface ImageRefBlock {
  * omitting it.
  */
 export declare function base64ByteLength(data: string): number;
+/** True when this record type can carry a tool result at all (cheap gate). */
+export declare function carriesMedia(record: RpcRecord): boolean;
 /**
  * Replace inline tool-result images with `image_ref` placeholders.
  *
@@ -68,4 +71,7 @@ export declare function base64ByteLength(data: string): number;
  * serialization entirely.
  */
 export declare function omitInlineMedia<T extends object>(record: T, persist?: MediaPersister): T;
+/** `omitInlineMedia` for a value that is already JSON-normal: type gate first, no normalization walk. */
+export declare function omitNormalInlineMedia<T extends object>(record: T, persist?: MediaPersister): T;
+export {};
 //# sourceMappingURL=media-placeholders.d.ts.map

package/dist/modes/rpc/media-placeholders.js

@@ -11,17 +11,18 @@
  * `SessionEventWriter.enqueue`.
  *
  * Two hard rules:
- * - Type-gate FIRST. `message_update` is the hot path (one record per token) and must
- *   never be walked.
+ * - Type-gate the media walk. JSON-value normalization is shared with writer
+ *   acceptance; media projection itself never walks `message_update` partials.
  * - Copy-on-write. Responses hand out live agent state by reference
  *   (`success(id, "get_messages", { messages: session.messages })`), so the input graph
- *   is never mutated and unchanged sub-trees keep their identity. When nothing changed
+ *   is never mutated and unchanged JSON sub-trees keep their identity. When nothing changed
  *   the SAME record reference comes back, which lets the caller reuse the line it
  *   already serialized.
  *
  * User-authored images (`prompt.images`) stay intact: they are bounded by the client
  * that sent them; the fan-out hazard is tool output.
  */
+import { normalizeJsonValue } from "./json-normal-value.js";
 /** Record types that can carry a tool result somewhere in their payload. */
 const MEDIA_BEARING_RECORD_TYPES = new Set([
     "tool_execution_end",
@@ -128,7 +129,7 @@ function omitToolExecutionEndImages(record, persist) {
     return omitted === result.content ? record : { ...record, result: { ...result, content: omitted } };
 }
 /** True when this record type can carry a tool result at all (cheap gate). */
-function carriesMedia(record) {
+export function carriesMedia(record) {
     if (typeof record.type !== "string")
         return false;
     if (MEDIA_BEARING_RECORD_TYPES.has(record.type))
@@ -144,6 +145,13 @@ function carriesMedia(record) {
  * serialization entirely.
  */
 export function omitInlineMedia(record, persist) {
+    const { value, changed } = normalizeJsonValue(record);
+    if (!changed)
+        return omitNormalInlineMedia(record, persist);
+    return omitNormalInlineMedia(value, persist);
+}
+/** `omitInlineMedia` for a value that is already JSON-normal: type gate first, no normalization walk. */
+export function omitNormalInlineMedia(record, persist) {
     const typed = record;
     if (!carriesMedia(typed))
         return record;

package/dist/modes/rpc/rpc-host-command-types.d.ts

@@ -192,6 +192,8 @@ export type RpcCommand = RpcAttachmentCommand | (RpcSessionCommand & {
      * caused the transition (default: true for `childrenOf`, false otherwise).
      */
     effects?: boolean;
+    /** Observe dialog registration and settlement without receiving command replies. */
+    dialogs?: boolean;
     /** Also deliver these content record types of matched sessions (default `"none"`); opt-in, never an attachment. */
     mirror?: "none" | "all" | string[];
     /** Mark the request activity-neutral for the supervisor's idle exit, as on `list_sessions`. */

package/dist/modes/rpc/rpc-question-types.d.ts

@@ -116,6 +116,7 @@ export type RpcExtensionUIResponseFrame = {
     type: "extension_ui_response";
     id: string;
     uiRequestId?: string;
+    answerId?: string;
 };
 export type RpcExtensionUIResponse = (RpcExtensionUIResponseFrame & {
     value: string;

package/dist/modes/rpc/rpc-read-response-types.d.ts

@@ -10,7 +10,14 @@ import type { EffectStatus } from "./effect-record.ts";
 import type { RpcSlashCommand } from "./rpc-command-surface.ts";
 import type { RpcEvalCell, RpcEvalCellSnapshot } from "./rpc-result-types.ts";
 import type { RpcAuthProvider, RpcLoadedExtension, RpcLoadedMcpServer, RpcProviderAccount, RpcSessionState } from "./rpc-session-state-types.ts";
+import type { RpcSnapshot } from "./snapshot-types.ts";
 export type RpcReadResponse = {
+    id?: string;
+    type: "response";
+    command: "get_snapshot";
+    success: true;
+    data: RpcSnapshot;
+} | {
     id?: string;
     type: "response";
     command: "get_state";

package/dist/modes/rpc/rpc-session-command-types.d.ts

@@ -182,6 +182,12 @@ export type RpcSessionCommand = {
 } | {
     id?: string;
     type: "get_state";
+} | {
+    id?: string;
+    type: "get_snapshot";
+    tail?: number;
+    maxBytes?: number;
+    observe?: boolean;
 } | {
     id?: string;
     type: "request_self_settle";

package/dist/modes/rpc/rpc-session-state-types.d.ts

@@ -9,6 +9,7 @@ import type { SessionEntry, UsageTotals } from "../../core/session-manager.ts";
 import type { ThinkingLevelSource } from "../../core/session-thinking-memory.ts";
 import type { SourceInfo } from "../../core/source-info.ts";
 import type { RpcExtensionUIRequest, RpcQuestionUiRequest } from "./rpc-question-types.ts";
+import type { UiAnswerReceipt } from "./ui-answer-ledger.ts";
 /** One provider row for the /login and /logout selectors. */
 export interface RpcAuthProvider {
     /** Provider id (e.g. "anthropic", "openai"). */
@@ -61,6 +62,8 @@ export interface RpcSessionModelEntry {
     serviceTier?: ServiceTier;
 }
 export interface RpcSessionState {
+    /** Latest 64 UI-answer receipts in this session generation, oldest first. */
+    answeredUiRequests?: UiAnswerReceipt[];
     paused: boolean;
     pausedNoticeCount: number;
     holds: {

package/dist/modes/rpc/rpc-session-state.js

@@ -7,6 +7,7 @@ import { sanitizeProviderDiagnostic } from "@earendil-works/pi-ai";
 import { ProjectTrustStore } from "../../core/trust-manager.js";
 import { clientFacingIdentity } from "./client-admission-record.js";
 import { sessionQuestionBridges } from "./connection-question-bridge.js";
+import { sessionUiAnswerLedger } from "./ui-answer-ledger.js";
 import { sessionDialogRequests } from "./session-extension-ui-requests.js";
 /**
  * Project one session into the wire state shape.
@@ -29,6 +30,7 @@ export function buildRpcSessionState(session, lastAbortSource) {
     const projectTrusted = new ProjectTrustStore(session.agentDir).get(cwd) === true;
     const lastProviderDiagnostic = sanitizeProviderDiagnostic(session.agent.state.providerDiagnostic);
     return {
+        answeredUiRequests: sessionUiAnswerLedger(session).snapshot(),
         paused: session.paused ?? false,
         pausedNoticeCount: session.pausedNoticeCount ?? 0,
         holds: session.holds ?? [],

package/dist/modes/rpc/rpc-types.d.ts

@@ -1,4 +1,5 @@
 /** Public RPC protocol surface. Definitions are grouped by responsibility. */
+export type { RpcSnapshot, RpcSnapshotMarker, RpcUiRequestEvent } from "./snapshot-types.ts";
 export type { SessionContext, SessionKind } from "../../core/extensions/types.ts";
 export type { RpcCommandInvocationEvent } from "./rpc-command-invocation.ts";
 export type { RpcCommandsChangedEvent, RpcSlashCommand } from "./rpc-command-surface.ts";

package/dist/modes/rpc/security-presentations.js

@@ -109,7 +109,8 @@ export class RpcSecurityPresentations {
         if (pending.connection !== connection ||
             (connection !== undefined && !this.fanout.connectionHas(connection, "grant_select")))
             return false;
-        state?.grants.delete(requestId);
+        // The entry stays until the worker reports the grant settled (settleGrant): a frame the worker
+        // refuses leaves the grant pending, and it must stay answerable only by its recipient.
         return true;
     }
     settleGrant(sessionId, requestId) {

package/dist/modes/rpc/session-attachment-gate.js

@@ -13,6 +13,7 @@ export const ATTACH_GATE_EXEMPT = new Set([
     "reclaim_session",
     "get_effect_status",
     "get_state",
+    "get_snapshot",
     "get_messages",
     "get_entries",
     "get_tree",

package/dist/modes/rpc/session-binding.js

@@ -1,6 +1,7 @@
 import { bindToProviderScope, runWithProviderScope } from "@earendil-works/pi-ai/node/provider-scope";
 import { createRpcConnectionHandler, } from "./connection-handler.js";
 import { createToolAttributionSpans } from "./session-attribution.js";
+import { structuredLaneEnabled } from "./structured-session-records.js";
 /**
  * Creates the extension UI bridge and subscriptions within the entry's provider
  * scope. The classic handler remains the single source of command semantics.
@@ -14,14 +15,9 @@ export async function createRpcSessionBinding(sessionId, entry, writer, requestC
     // session is inside is what the loop-lag watchdog blames for a stall. The record
     // stream already carries that transition; no extra subscription is needed.
     const toolSpans = createToolAttributionSpans(sessionId);
-    const enqueueRecords = (chunk) => {
-        for (const line of chunk.split("\n")) {
-            if (!line)
-                continue;
-            const record = JSON.parse(line);
-            toolSpans.observe(record);
-            writer.enqueue(sessionId, record);
-        }
+    const enqueueRecord = (record) => {
+        toolSpans.observe(record);
+        writer.enqueue(sessionId, record);
     };
     // Attachments share one entry, so resolve the host from the live runtime. In
     // particular, switch_session must use the entry's replacement-aware method
@@ -48,16 +44,34 @@ export async function createRpcSessionBinding(sessionId, entry, writer, requestC
     // an unawaited prompt (senpi#2871).
     let droppedAfterClose = false;
     const handler = await runWithProviderScope(entry.scope, async () => {
-        const writeInScope = bindToProviderScope(enqueueRecords);
+        const writeInScope = bindToProviderScope(enqueueRecord);
+        const dropAfterClose = () => {
+            if (!droppedAfterClose)
+                process.stderr.write(`senpi rpc host: dropped a record for closed session ${sessionId} at ${new Date().toISOString()}\n`);
+            droppedAfterClose = true;
+        };
+        const writeRecord = (record) => {
+            if (entry.scope.state === "closed")
+                return dropAfterClose();
+            writeInScope(record);
+        };
+        const writeStructuredInScope = bindToProviderScope((record) => writer.structuredLanes.accept(sessionId, record));
         const taggedSink = {
-            writeRaw: (chunk) => {
-                if (entry.scope.state === "closed") {
-                    if (!droppedAfterClose)
-                        process.stderr.write(`senpi rpc host: dropped a record for closed session ${sessionId} at ${new Date().toISOString()}\n`);
-                    droppedAfterClose = true;
-                    return;
+            writeRecord,
+            ...(structuredLaneEnabled()
+                ? {
+                    writeStructured: (record) => {
+                        if (entry.scope.state !== "closed")
+                            writeStructuredInScope(record);
+                    },
                 }
-                writeInScope(chunk);
+                : {}),
+            // A late raw reply after the scope closed is dropped like any record (senpi#2871); while the scope is
+            // open, records arrive only through writeRecord, so a raw write is a wiring bug.
+            writeRaw: () => {
+                if (entry.scope.state === "closed")
+                    return dropAfterClose();
+                throw new Error("Shared session bindings deliver records through writeRecord, never writeRaw");
             },
             waitForBackpressure: bindToProviderScope(async () => { }),
         };
@@ -65,7 +79,6 @@ export async function createRpcSessionBinding(sessionId, entry, writer, requestC
             sessionId,
             shutdownHandler: bindToProviderScope(requestClose),
             disposeRuntime: false,
-            eventFlushScheduler: (flush) => flush(),
             publishLoadedSurfacesChanged: (previous, digest) => {
                 if (entry.scope.state !== "closed")
                     writer.publishLoadedSurfacesChanged(sessionId, previous, digest);

package/dist/modes/rpc/session-command-activity.js

@@ -1,6 +1,7 @@
 /** Whether the command itself refreshes activity, apart from attached-client keepalives. */
 const observations = new Set([
     "get_state",
+    "get_snapshot",
     "get_effect_status",
     "get_pending_inputs",
     "get_messages",

package/dist/modes/rpc/session-event-fanout.d.ts

@@ -50,7 +50,7 @@ export declare class SessionEventFanout {
     pendingQuestionCount(sessionId: string): number;
     /** Deliver one line to the connections attached to a session, never to the rest of the fanout. */
     deliverToSession(sessionId: string, line: string): void;
-    rememberSnapshot(sessionId: string, value: Record<string, unknown>, line: string, placeholderLine?: string, source?: Record<string, unknown>): void;
+    rememberSnapshot(sessionId: string, value: Record<string, unknown>, line: string, placeholderLine?: string): void;
     forgetSession(sessionId: string): void;
     private replaySnapshot;
     private resyncSnapshot;

package/dist/modes/rpc/session-event-fanout.js

@@ -1,6 +1,6 @@
 import { MEDIA_PLACEHOLDERS_CAPABILITY } from "./custom-capability.js";
 import { serializeJsonLine } from "./jsonl.js";
-import { omitInlineMedia } from "./media-placeholders.js";
+import { carriesMedia, omitNormalInlineMedia } from "./media-placeholders.js";
 import { SocketEventSinkActor } from "./socket-event-fanout.js";
 import { EVENT_RESYNC_CAPABILITY } from "./socket-peer-recovery.js";
 const BROADCAST_LIFECYCLE_RECORDS = new Set([
@@ -15,9 +15,11 @@ const BROADCAST_LIFECYCLE_RECORDS = new Set([
 function snapshotPlaceholderLine(record) {
     if (record.placeholderLine !== undefined)
         return record.placeholderLine;
-    const redacted = record.source === undefined ? undefined : omitInlineMedia(record.source);
-    record.placeholderLine =
-        redacted === undefined || redacted === record.source ? record.line : serializeJsonLine(redacted);
+    if (!record.mayCarryMedia)
+        return record.line;
+    const source = JSON.parse(record.line);
+    const redacted = omitNormalInlineMedia(source);
+    record.placeholderLine = redacted === source ? record.line : serializeJsonLine(redacted);
     return record.placeholderLine;
 }
 export class SessionEventFanout {
@@ -147,13 +149,20 @@ export class SessionEventFanout {
             if (this.connectionSessions.get(id)?.has(sessionId))
                 actor.enqueue(line);
     }
-    rememberSnapshot(sessionId, value, line, placeholderLine, source) {
+    rememberSnapshot(sessionId, value, line, placeholderLine) {
+        const record = {
+            line,
+            placeholderLine,
+            hasMessage: value.message != null,
+            mayCarryMedia: carriesMedia(value),
+        };
         if (value.type === "session_lifecycle") {
-            this.lifecycleSnapshots.set(sessionId, { line, placeholderLine, source });
+            this.lifecycleSnapshots.set(sessionId, record);
             return;
         }
         if (value.type === "extension_ui_request" && value.method === "question" && typeof value.id === "string") {
             const pending = this.pendingQuestions.get(sessionId) ?? new Map();
+            // Writer acceptance already detached and JSON-normalized the frame.
             pending.set(value.id, { ...value });
             this.pendingQuestions.set(sessionId, pending);
             return;
@@ -169,7 +178,6 @@ export class SessionEventFanout {
             return;
         }
         const event = value.assistantMessageEvent;
-        const record = { line, placeholderLine, source };
         if (value.type === "message_start" || (value.type === "message_update" && event?.type === "text_start")) {
             this.sessionSnapshots.set(sessionId, [record]);
         }
@@ -200,7 +208,7 @@ export class SessionEventFanout {
         const current = this.connectionSessions.get(id) ?? new Set();
         return [...new Set([...attached, ...current])].map((sessionId) => {
             const records = this.sessionSnapshots.get(sessionId) ?? [];
-            const latest = records.findLast((record) => record.source?.message != null);
+            const latest = records.findLast((record) => record.hasMessage);
             // The producer may mutate its partial object after emission. The serialized
             // record, not that object, fixes the recovery cut before later deltas enqueue.
             const frozen = latest === undefined ? undefined : JSON.parse(latest.line);
@@ -211,7 +219,7 @@ export class SessionEventFanout {
                 message: typeof frozen === "object" && frozen !== null && "message" in frozen ? frozen.message : null,
                 ...(!current.has(sessionId) ? { closed: true } : {}),
             };
-            return placeholders ? omitInlineMedia(record) : record;
+            return placeholders ? omitNormalInlineMedia(record) : record;
         });
     }
 }

package/dist/modes/rpc/session-event-writer.d.ts

@@ -2,6 +2,7 @@ import type { ExtensionUIContext, SessionKind } from "../../core/extensions/type
 import { type McpFormBinding } from "../../core/mcp-form-types.ts";
 import { McpPresenterAuthority, type McpPresenterConnection } from "./mcp-presenter-authority.ts";
 import type { SecurityNoticeSnapshot, SecurityNoticeState } from "../../core/security-notices.ts";
+import { SessionStructuredLanes } from "./session-structured-lanes.ts";
 import { type MediaPersister } from "./media-placeholders.ts";
 import type { RpcHostLifecycleEvent, RpcOpenQueuedEvent, RpcSessionClosedEvent, RpcSessionClosedReason, RpcSessionParkedEvent } from "./rpc-types.ts";
 import { type SessionEventWriterConnection } from "./session-event-fanout.ts";
@@ -23,6 +24,7 @@ export declare const MAX_SHARED_STDIO_QUEUE_RECORDS = 4096;
  * scheduling boundary and violate D9.
  */
 export declare class SessionEventWriter {
+    readonly structuredLanes: SessionStructuredLanes;
     private presenterAuthority?;
     private readonly presenterConnections;
     private readonly presenterBindings;

package/dist/modes/rpc/session-event-writer.js

@@ -2,8 +2,10 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import { bindPrivateMcpForms } from "../../core/mcp-form-types.js";
 import { McpPresenterAuthority } from "./mcp-presenter-authority.js";
 import { MEDIA_PLACEHOLDERS_CAPABILITY } from "./custom-capability.js";
+import { normalizeJsonValue } from "./json-normal-value.js";
+import { SessionStructuredLanes } from "./session-structured-lanes.js";
 import { serializeJsonLine } from "./jsonl.js";
-import { omitInlineMedia } from "./media-placeholders.js";
+import { omitNormalInlineMedia } from "./media-placeholders.js";
 import { RpcSecurityPresentations } from "./security-presentations.js";
 import { SessionEventFanout } from "./session-event-fanout.js";
 import { SessionOpenTurns } from "./session-open-turns.js";
@@ -140,6 +142,7 @@ export class SessionEventWriter {
         return this.reservedCloseBytes;
     }
     constructor(writeRaw, waitOrSchedule, scheduleFlush) {
+        this.structuredLanes = new SessionStructuredLanes();
         this.presenterConnections = new Map();
         this.presenterBindings = new Map();
         this.records = new SessionRecordAccounting();
@@ -330,7 +333,7 @@ export class SessionEventWriter {
         if (this.sealedSessions.has(sessionId))
             return false;
         const targetId = this.connectionContext.getStore();
-        const record = value;
+        const record = normalizeJsonValue(value).value;
         const isTargeted = record.type === "response" ||
             record.type === "bash_execution_update" ||
             // Relocation records belong to the one connection that offers it (session-relocation-channel.ts).
@@ -338,8 +341,22 @@ export class SessionEventWriter {
             record.type === "relocation_due" ||
             (record.type === "extension_ui_request" &&
                 ["select", "confirm", "input", "editor"].includes(String(record.method)));
-        const tagged = { ...value, sessionId };
+        const tagged = { ...record, sessionId };
         const line = serializeJsonLine(tagged);
+        // Observation records are per-subscription opt-ins on the subscriber's own actor FIFO: never attachments,
+        // the attach replay, response broadcast, or the stdio lane, which cannot subscribe.
+        if (record.type === "snapshot_marker" ||
+            record.type === "ui_request_pending" ||
+            record.type === "ui_request_settled") {
+            const targets = record.type === "snapshot_marker"
+                ? this.status.mirrorTargets(sessionId, "snapshot_marker").filter((id) => id === targetId)
+                : this.status.dialogTargets(sessionId);
+            for (const target of targets)
+                this.fanout.get(target)?.actor.enqueue(line);
+            if (targets.length > 0)
+                this.requestFlush();
+            return true;
+        }
         if (this.fanout.isEmpty() && this.exceedsStdioCapacity(line)) {
             this.closeSession(sessionId, {
                 type: "response",
@@ -357,10 +374,12 @@ export class SessionEventWriter {
         // A record is only walked and re-serialized when a target asked for placeholders;
         // otherwise this is byte-for-byte today's path, with serializeJsonLine called once.
         const hasPlaceholderTarget = targets.some((target) => this.fanout.connectionHas(target, MEDIA_PLACEHOLDERS_CAPABILITY));
-        const redacted = hasPlaceholderTarget ? omitInlineMedia(tagged, this.mediaPersisters.get(sessionId)) : tagged;
+        const redacted = hasPlaceholderTarget
+            ? omitNormalInlineMedia(tagged, this.mediaPersisters.get(sessionId))
+            : tagged;
         const placeholderLine = redacted === tagged ? undefined : serializeJsonLine(redacted);
         if (!isTargeted)
-            this.fanout.rememberSnapshot(sessionId, tagged, line, placeholderLine, tagged);
+            this.fanout.rememberSnapshot(sessionId, tagged, line, placeholderLine);
         for (const target of targets) {
             if (target !== undefined && !this.fanout.get(target))
                 continue;

package/dist/modes/rpc/session-extension-ui-requests.d.ts

@@ -1,3 +1,4 @@
+import type { UiRequestChange } from "./snapshot-types.ts";
 import type { RpcExtensionUIRequest, RpcExtensionUIResponse } from "./rpc-types.ts";
 type PendingRequest = {
     resolve: (value: RpcExtensionUIResponse) => void;
@@ -9,7 +10,7 @@ export declare const sessionDialogRequests: WeakMap<object, SessionExtensionUiRe
 export declare class SessionExtensionUiRequests {
     private readonly pending;
     private readonly changed;
-    constructor(changed?: () => void);
+    constructor(changed?: (change?: UiRequestChange) => void);
     set(id: string, request: PendingRequest): void;
     delete(id: string): void;
     snapshot(): RpcExtensionUIRequest[];

package/dist/modes/rpc/session-extension-ui-requests.js

@@ -7,11 +7,13 @@ export class SessionExtensionUiRequests {
     }
     set(id, request) {
         this.pending.set(id, request);
-        this.changed?.();
+        this.changed?.(request.frame
+            ? { type: "ui_request_pending", uiRequestId: id, method: request.frame.method, request: request.frame }
+            : undefined);
     }
     delete(id) {
-        this.pending.delete(id);
-        this.changed?.();
+        if (this.pending.delete(id))
+            this.changed?.({ type: "ui_request_settled", uiRequestId: id, disposition: "cancelled" });
     }
     snapshot() {
         return [...this.pending.values()].flatMap((request) => (request.frame ? [request.frame] : []));
@@ -22,22 +24,25 @@ export class SessionExtensionUiRequests {
             return false;
         beforeAnswer?.();
         this.pending.delete(response.id);
-        this.changed?.();
+        this.changed?.({
+            type: "ui_request_settled",
+            uiRequestId: response.id,
+            disposition: "cancelled" in response ? "cancelled" : "answered",
+        });
         request.resolve(response);
         return true;
     }
     cancelAll() {
-        for (const [id, request] of this.pending)
+        for (const [id, request] of this.pending) {
+            this.delete(id);
             request.resolve({ type: "extension_ui_response", id, cancelled: true });
-        this.pending.clear();
-        this.changed?.();
+        }
     }
     close() {
-        for (const request of this.pending.values()) {
+        for (const [id, request] of this.pending) {
+            this.delete(id);
             request.reject(new Error("Extension UI request cancelled: session closed"));
         }
-        this.pending.clear();
-        this.changed?.();
     }
 }
 //# sourceMappingURL=session-extension-ui-requests.js.map

package/dist/modes/rpc/session-held.js

@@ -9,6 +9,7 @@ import { RpcSessionRegistryError } from "./session-registry-types.js";
 // a read or a control needed to finish/cancel an already-admitted turn.
 const READ_ONLY_OR_CONTROL = new Set([
     "get_state",
+    "get_snapshot",
     "get_effect_status",
     "get_pending_inputs",
     "get_steering_messages",

package/dist/modes/rpc/session-record-stream.d.ts

@@ -7,7 +7,7 @@
  * reads the same records from either.
  */
 import type { AgentAbortSource } from "../../core/agent-abort-provenance.ts";
-import type { AgentSession } from "../../core/agent-session.ts";
-/** Subscribes `output` to the session's records; returns the unsubscribe. */
-export declare function subscribeSessionRecords(session: AgentSession, output: (record: object) => void, onAbortSource?: (source: AgentAbortSource) => void): () => void;
+import type { AgentSession, AgentSessionEventListener } from "../../core/agent-session.ts";
+/** Subscribes `output` to the session's records (from `source`, by default `session.subscribe`); returns the unsubscribe. */
+export declare function subscribeSessionRecords(session: AgentSession, output: (record: object) => void, onAbortSource?: (source: AgentAbortSource) => void, source?: (listener: AgentSessionEventListener) => () => void): () => void;
 //# sourceMappingURL=session-record-stream.d.ts.map