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

package/dist/modes/rpc/session-record-stream.js

@@ -1,10 +1,10 @@
 import { clientFacingIdentity } from "./client-admission-record.js";
 import { ClientAdmissions } from "./client-admissions.js";
 import { ClientMessageEvents } from "./client-message-events.js";
-/** Subscribes `output` to the session's records; returns the unsubscribe. */
-export function subscribeSessionRecords(session, output, onAbortSource = () => { }) {
+/** Subscribes `output` to the session's records (from `source`, by default `session.subscribe`); returns the unsubscribe. */
+export function subscribeSessionRecords(session, output, onAbortSource = () => { }, source = (listener) => session.subscribe(listener)) {
     const correlatedEvents = new ClientMessageEvents(output, () => ClientAdmissions.forSession(session).hasIdentities);
-    return session.subscribe((event) => {
+    return source((event) => {
         if (event.type === "session_lifecycle") {
             // The connection adds the routing handle; classic stdio has no envelope.
             const { sessionId: _sessionId, ...record } = event;

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

@@ -67,7 +67,8 @@ export declare class SessionStatusStream {
     publishEffect(sessionId: string, status: EffectStatus): void;
     seal(sessionId: string, terminal: SessionStatusTerminal, cause: SessionStatusCause, by: SessionStatusActor): void;
     forget(sessionId: string): void;
-    mirrorTargets(sessionId: string, recordType: string): readonly string[];
+    dialogTargets(sessionId: string): readonly string[];
+    mirrorTargets(sessionId: string, recordType: string, dialogs?: boolean): readonly string[];
     matchingConnections(sessionId: string): ReadonlyMap<string, boolean>;
     /** The live view, falling back to the last one seen once the registry has dropped a sealed entry. */
     private currentView;

package/dist/modes/rpc/session-status-stream.js

@@ -171,8 +171,14 @@ export class SessionStatusStream {
         this.lastViews.delete(sessionId);
         this.lastChanges.delete(sessionId);
     }
-    mirrorTargets(sessionId, recordType) {
-        const subscriptions = [...this.pendings.values(), ...this.subscriptions.values()].filter((subscription) => mirrorsRecord(subscription.options.mirror, recordType));
+    dialogTargets(sessionId) {
+        return this.mirrorTargets(sessionId, "ui_request_pending", true);
+    }
+    mirrorTargets(sessionId, recordType, dialogs = false) {
+        const subscriptions = [...this.pendings.values(), ...this.subscriptions.values()].filter((subscription) => (dialogs ? subscription.options.dialogs === true : true) &&
+            (recordType === "snapshot_marker" || dialogs
+                ? subscription.options.mirror.kind !== "none"
+                : mirrorsRecord(subscription.options.mirror, recordType)));
         if (subscriptions.length === 0)
             return [];
         const entry = this.source?.entryView(sessionId) ?? this.lastViews.get(sessionId)?.entry;

package/dist/modes/rpc/session-status-subscriptions.d.ts

@@ -29,6 +29,7 @@ export interface SubscriptionOptions {
     readonly includeContext: boolean;
     readonly mirror: MirrorSelection;
     readonly effects: boolean;
+    readonly dialogs?: boolean;
 }
 export interface SubscriptionRefusal {
     readonly reason: string;
@@ -36,7 +37,7 @@ export interface SubscriptionRefusal {
 }
 export declare function parseSubscription(request: Readonly<Pick<Extract<RpcCommand, {
     type: "subscribe_sessions";
-}>, "sessions" | "mirror" | "include_workers" | "include_context" | "effects">>): {
+}>, "sessions" | "mirror" | "include_workers" | "include_context" | "effects" | "dialogs">>): {
     readonly options: SubscriptionOptions;
 } | {
     readonly refusal: SubscriptionRefusal;

package/dist/modes/rpc/session-status-subscriptions.js

@@ -59,12 +59,16 @@ export function parseSubscription(request) {
     const includeContext = optionalBoolean(request.include_context, "include_context");
     if (typeof includeContext === "object")
         return { refusal: includeContext };
+    const dialogs = optionalBoolean(request.dialogs, "dialogs");
+    if (typeof dialogs === "object")
+        return { refusal: dialogs };
     const effects = optionalBoolean(request.effects, "effects");
     if (typeof effects === "object")
         return { refusal: effects };
     return {
         options: {
             selector: selector.selector,
+            dialogs: dialogs ?? false,
             // A childrenOf subscription exists to watch machine-driven children, which open as workers.
             includeWorkers: includeWorkers ?? selector.selector.kind === "childrenOf",
             includeContext: includeContext ?? false,

package/dist/modes/rpc/session-structured-lanes.d.ts

@@ -0,0 +1,12 @@
+type StructuredReceiver = (record: object) => void;
+/**
+ * Per-session receivers of the internal structured lane (senpi#4272): the host-side owner of seeded records and
+ * block controls (S03/S04) registers here. Legacy sockets, stdout and the replay snapshot never read it.
+ */
+export declare class SessionStructuredLanes {
+    private readonly receivers;
+    observe(sessionId: string, receiver: StructuredReceiver): () => void;
+    accept(sessionId: string, record: object): void;
+}
+export {};
+//# sourceMappingURL=session-structured-lanes.d.ts.map

package/dist/modes/rpc/session-structured-lanes.js

@@ -0,0 +1,24 @@
+/**
+ * Per-session receivers of the internal structured lane (senpi#4272): the host-side owner of seeded records and
+ * block controls (S03/S04) registers here. Legacy sockets, stdout and the replay snapshot never read it.
+ */
+export class SessionStructuredLanes {
+    constructor() {
+        this.receivers = new Map();
+    }
+    observe(sessionId, receiver) {
+        const receivers = this.receivers.get(sessionId) ?? new Set();
+        receivers.add(receiver);
+        this.receivers.set(sessionId, receivers);
+        return () => {
+            receivers.delete(receiver);
+            if (receivers.size === 0 && this.receivers.get(sessionId) === receivers)
+                this.receivers.delete(sessionId);
+        };
+    }
+    accept(sessionId, record) {
+        for (const receiver of [...(this.receivers.get(sessionId) ?? [])])
+            receiver(record);
+    }
+}
+//# sourceMappingURL=session-structured-lanes.js.map

package/dist/modes/rpc/session-worker-client.js

@@ -5,6 +5,7 @@ import { ownProcessStartedAtMs } from "../../core/extensions/builtin/terminal/pr
 import { isSecurityNoticeState } from "../../core/security-notices.js";
 import { createWebViewBroker } from "../../core/webview/webview-broker.js";
 import { roleConnection } from "./connection-roles.js";
+import { answeredUiRequestId } from "./extension-ui-response.js";
 import { subscriptionLimits } from "../../core/subscription-limits/limit-store.js";
 import { SessionWorkerRequests } from "./session-worker-requests.js";
 import { acknowledge, acknowledgeGrant } from "./session-worker-signals.js";
@@ -125,11 +126,11 @@ export class SessionWorkerClient {
                 if (writer.handleMcpForm(command))
                     return;
                 const connection = writer.currentConnection();
-                if ("type" in command &&
-                    command.type === "extension_ui_response" &&
-                    "id" in command &&
-                    typeof command.id === "string" &&
-                    writer.acceptWorkerGrantResponse(sessionId, command.id, connection) === false)
+                const grantAnswer = "type" in command && command.type === "extension_ui_response"
+                    ? answeredUiRequestId(command)
+                    : undefined;
+                if (grantAnswer !== undefined &&
+                    writer.acceptWorkerGrantResponse(sessionId, grantAnswer, connection) === false)
                     return;
                 await this.request({
                     type: "command",

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

@@ -76,7 +76,8 @@ class WorkerEventWriter extends SessionEventWriter {
         }));
     }
     enqueue(_sessionId, record) {
-        if (Buffer.byteLength(JSON.stringify(record)) > SESSION_WORKER_LIMITS.outputBytes)
+        const line = JSON.stringify(record);
+        if (Buffer.byteLength(line) > SESSION_WORKER_LIMITS.outputBytes)
             failWorker("session_worker_output_limit");
         const session = entry?.runtime?.session;
         if (!session)
@@ -97,7 +98,9 @@ class WorkerEventWriter extends SessionEventWriter {
             failWorker("session_worker_snapshot_limit");
         exchange((signal) => ({
             type: "output",
-            record,
+            // Keep one JSON-normal transfer format, including toJSON and non-cloneable fields.
+            // S12 replaces this whole-record serialization with compact records and permits.
+            record: JSON.parse(line),
             connection: this.currentConnection(),
             signal,
             activity,

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

@@ -0,0 +1,29 @@
+import type { SessionEntry } from "../../core/session-manager.ts";
+import type { RpcExtensionUIRequest } from "./rpc-question-types.ts";
+import type { RpcSessionState } from "./rpc-session-state-types.ts";
+export type RpcSnapshot = {
+    readonly state: RpcSessionState;
+    readonly entries: SessionEntry[];
+    readonly next_before: string | null;
+    readonly history_truncated: boolean;
+    readonly markerId: string;
+};
+export type RpcSnapshotMarker = {
+    readonly type: "snapshot_marker";
+    readonly sessionId: string;
+    readonly markerId: string;
+};
+export type UiRequestChange = {
+    readonly type: "ui_request_pending";
+    readonly uiRequestId: string;
+    readonly method: RpcExtensionUIRequest["method"];
+    readonly request: RpcExtensionUIRequest;
+} | {
+    readonly type: "ui_request_settled";
+    readonly uiRequestId: string;
+    readonly disposition: "answered" | "cancelled";
+};
+export type RpcUiRequestEvent = UiRequestChange & {
+    readonly sessionId: string;
+};
+//# sourceMappingURL=snapshot-types.d.ts.map

package/dist/modes/rpc/snapshot-types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=snapshot-types.js.map

package/dist/modes/rpc/structured-session-records.d.ts

@@ -0,0 +1,12 @@
+import type { AgentSession } from "../../core/agent-session.ts";
+/**
+ * The engine-socket compact-updates rollout flag (`<brand>_ENGINE_SOCKET_COMPACT_UPDATES`), explicit-true only.
+ * Off, no session holds a structured subscription and every destination keeps its existing bytes.
+ */
+export declare function structuredLaneEnabled(): boolean;
+/**
+ * The session's internal structured lane, correlated like its legacy records: seeded `toJsonEvent` projections of
+ * every session event plus the three block controls, in session order. Never a legacy destination.
+ */
+export declare function subscribeStructuredSessionRecords(session: AgentSession, output: (record: object) => void): () => void;
+//# sourceMappingURL=structured-session-records.d.ts.map

package/dist/modes/rpc/structured-session-records.js

@@ -0,0 +1,88 @@
+import { getAssistantCapture } from "@earendil-works/pi-ai";
+import { envValue } from "../../core/brand.js";
+import { toJsonEvent } from "../json-event.js";
+import { subscribeSessionRecords } from "./session-record-stream.js";
+/**
+ * The engine-socket compact-updates rollout flag (`<brand>_ENGINE_SOCKET_COMPACT_UPDATES`), explicit-true only.
+ * Off, no session holds a structured subscription and every destination keeps its existing bytes.
+ */
+export function structuredLaneEnabled() {
+    const value = envValue("ENGINE_SOCKET_COMPACT_UPDATES");
+    return value === "1" || value === "true";
+}
+const SEEDS = { blockSeeds: 1 };
+/**
+ * Admits a block's records only after its own seed or insert reached this subscriber, so a subscriber that attached
+ * mid-message gets no seed, delta or control for that message, never a wrong one. A started block whose next record
+ * has no capture, or that has no accepted end when the message ends, is invalid: its later records are dropped and
+ * the assistant `message_end` names it in `invalidatedBlocks`, so a reader rebuilds it from the terminal message.
+ * A terminal that rewrote blocks from `rewrittenFrom` on invalidates every block at or above that index, and a
+ * `message_end` with no interpretable terminal capture (cancel, idle timeout) invalidates every block of the message.
+ * Blocks are addressed by the capture's own index (`capture.contentIndex ?? event.contentIndex`), never a drifted public one.
+ */
+class SeededBlockGate {
+    accept(record) {
+        if (record.type === "message_block_state" || record.type === "message_block_metadata")
+            return this.control(record, record.type === "message_block_state" ? record.phase : undefined);
+        if (record.type === "message_tool_arguments_reset")
+            return this.control(record);
+        if (record.type === "message_start" && record.message.role === "assistant") {
+            const seeded = toJsonEvent(record, SEEDS);
+            this.blocks = seeded && new Map();
+            return seeded;
+        }
+        if (record.type === "message_end" && record.message.role === "assistant")
+            return this.end(record);
+        if (record.type !== "message_update")
+            return toJsonEvent(record, SEEDS);
+        if (!this.blocks)
+            return undefined;
+        const seeded = toJsonEvent(record, SEEDS);
+        const update = record.assistantMessageEvent;
+        if (!("contentIndex" in update))
+            return seeded;
+        const index = getAssistantCapture(record)?.contentIndex ?? update.contentIndex;
+        const starts = update.type === "text_start" || update.type === "thinking_start" || update.type === "toolcall_start";
+        if (!starts && this.blocks.get(index) !== "open")
+            return undefined;
+        const ends = update.type === "text_end" || update.type === "thinking_end" || update.type === "toolcall_end";
+        this.blocks.set(index, seeded ? (ends ? "ended" : "open") : "invalid");
+        return seeded;
+    }
+    control(record, phase) {
+        const state = this.blocks?.get(record.contentIndex);
+        if (!this.blocks || state === "invalid")
+            return undefined;
+        if (phase === "insert")
+            this.blocks.set(record.contentIndex, "open");
+        else if (state === undefined || (phase === "end" && state !== "open"))
+            return undefined;
+        else if (phase === "end")
+            this.blocks.set(record.contentIndex, "ended");
+        return record;
+    }
+    end(record) {
+        const capture = getAssistantCapture(record);
+        const rewrittenFrom = capture?.message === undefined ? 0 : (capture.rewrittenFrom ?? Number.POSITIVE_INFINITY);
+        const invalidatedBlocks = [...(this.blocks ?? [])].flatMap(([index, state]) => state === "ended" && index < rewrittenFrom ? [] : [index]);
+        this.blocks = undefined;
+        const seeded = toJsonEvent(record, SEEDS) ?? record;
+        return invalidatedBlocks.length === 0
+            ? seeded
+            : { ...seeded, invalidatedBlocks: invalidatedBlocks.sort((a, b) => a - b) };
+    }
+}
+/**
+ * The session's internal structured lane, correlated like its legacy records: seeded `toJsonEvent` projections of
+ * every session event plus the three block controls, in session order. Never a legacy destination.
+ */
+export function subscribeStructuredSessionRecords(session, output) {
+    const gate = new SeededBlockGate();
+    return subscribeSessionRecords(session, output, undefined, (listener) => session.subscribeStructured((record) => {
+        const accepted = gate.accept(record);
+        // Correlation reads only `type`, `role` and outer fields, which seeded records and controls keep.
+        if (accepted)
+            listener(accepted);
+    }));
+}
+//# sourceMappingURL=structured-session-records.js.map

package/dist/modes/rpc/ui-answer-ledger.d.ts

@@ -0,0 +1,13 @@
+/** Session-generation receipts: deliberately never persisted to the transcript. */
+export type UiAnswerReceipt = {
+    readonly uiRequestId: string;
+    readonly answerId?: string;
+};
+export declare class UiAnswerLedger {
+    private readonly answers;
+    lookup(uiRequestId: string, answerId: string | undefined): "replay" | "already_answered" | undefined;
+    record(uiRequestId: string, answerId: string | undefined): void;
+    snapshot(): UiAnswerReceipt[];
+}
+export declare function sessionUiAnswerLedger(session: object): UiAnswerLedger;
+//# sourceMappingURL=ui-answer-ledger.d.ts.map

package/dist/modes/rpc/ui-answer-ledger.js

@@ -0,0 +1,34 @@
+export class UiAnswerLedger {
+    constructor() {
+        this.answers = new Map();
+    }
+    lookup(uiRequestId, answerId) {
+        const receipt = this.answers.get(uiRequestId);
+        if (!receipt)
+            return undefined;
+        return answerId !== undefined && answerId === receipt.answerId ? "replay" : "already_answered";
+    }
+    record(uiRequestId, answerId) {
+        if (this.answers.has(uiRequestId))
+            return;
+        this.answers.set(uiRequestId, { uiRequestId, ...(answerId === undefined ? {} : { answerId }) });
+        if (this.answers.size > 1024) {
+            const oldest = this.answers.keys().next();
+            if (!oldest.done)
+                this.answers.delete(oldest.value);
+        }
+    }
+    snapshot() {
+        return [...this.answers.values()].slice(-64).map((receipt) => ({ ...receipt }));
+    }
+}
+const ledgers = new WeakMap();
+export function sessionUiAnswerLedger(session) {
+    let ledger = ledgers.get(session);
+    if (!ledger) {
+        ledger = new UiAnswerLedger();
+        ledgers.set(session, ledger);
+    }
+    return ledger;
+}
+//# sourceMappingURL=ui-answer-ledger.js.map

package/dist/senpi

@@ -10,7 +10,7 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
 import "./valid-cwd.js";
 import "./internal-role.js";
 import { spawn, spawnSync } from "node:child_process";
-import { existsSync, realpathSync } from "node:fs";
+import { existsSync, fstatSync, realpathSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { processBunRuntimeOptions, resolveBunReexec } from "./bun-runtime.js";
@@ -20,6 +20,24 @@ import { APP_NAME, DISPLAY_VERSION, findNodePackageDir, getAgentDir, getInstallP
 import { hasInheritedInspectorOption, releaseInheritedInspectorForChild } from "./inspector-policy.js";
 import { prepareRuntimeSnapshot } from "./runtime-snapshot/enter.js";
 import { handleBootstrapSelfUpdate } from "./self-update-bootstrap.js";
+/** Only a presenter-enabled launch may carry its reserved private channel through CLI re-execution. */
+function reexecStdio() {
+    const argv = process.argv.slice(2);
+    const presenter = argv.indexOf("--mcp-presenter-fd");
+    if (presenter < 0 || argv[presenter + 1] !== "4")
+        return "inherit";
+    try {
+        const stat = fstatSync(4);
+        if (!stat.isSocket() && !stat.isFIFO())
+            return "inherit";
+    }
+    catch {
+        return "inherit";
+    }
+    const owner = argv.indexOf("--owner-fd");
+    const lifetime = (owner >= 0 && argv[owner + 1] === "3") || process.env.SENPI_RPC_HOST_WATCH_FD === "3";
+    return ["inherit", "inherit", "inherit", lifetime ? 3 : "ignore", 4];
+}
 // Upstream's `cli/setup.ts` helper is deliberately not used here: this launcher only decides the
 // runtime and process structure, and `cli-main.ts` performs the equivalent process/title/env/http
 // setup for both entry paths (Node launcher and the Bun binary).
@@ -52,7 +70,7 @@ function reexecUnderBunIfNeeded() {
         return false;
     }
     const result = spawnSync(decision.bunPath, [scriptRealPath, ...process.argv.slice(2)], {
-        stdio: "inherit",
+        stdio: reexecStdio(),
         windowsHide: true,
     });
     if (result.signal) {
@@ -125,7 +143,7 @@ async function spawnFullCli() {
     return await new Promise((resolve, reject) => {
         const child = spawn(process.execPath, [...process.execArgv, fullCliPath, ...args], {
             env: childEnvironment,
-            stdio: "inherit",
+            stdio: reexecStdio(),
         });
         child.on("error", (error) => {
             reject(error);

package/docs/extensions.md

@@ -2170,7 +2170,13 @@ session-notice identity. Restart redelivers unconsumed queued messages once, but
 never replays a consumed result or reruns an interrupted tool.
 
 `pi.lifecycle.reportChild({ taskId, childSessionId, runEpoch, generation, state,
-waitingOn?, terminal? })` persists runner-owned child state. Stale epoch/generation
+label?, since?, waitingOn?, terminal? })` persists runner-owned child state. `label`
+is a producer-authored name and `since` is the child's own state-entry time (ISO);
+an unparseable `since` is dropped. `waitingOn` takes the `SessionLifecycle.waitingOn`
+shape described in [RPC session lifecycle](rpc.md#session-lifecycle), named lists
+included; its counts stay authoritative and the child's human waits are not kept.
+A nonterminal report appears in the parent's `waitingOn.childReports` as
+`{ taskId, childSessionId, runEpoch, state, label?, since? }`. Stale epoch/generation
 pairs are ignored; a higher `runEpoch` clears the old terminal status. Terminal
 values are `completed`, `error`, `lost`, `interrupted`, and `cancelled`. Child UI
 requests remain automatically answered by their runners, not routed to a person.

package/docs/mcp.md

@@ -386,6 +386,26 @@ above.
 
 ## Resources and prompts
 
+MCP 2026-07-28 tool schemas use JSON Schema 2020-12 by default. Explicit
+2020-12 declarations are supported; other dialect declarations produce
+`MCP_SCHEMA_UNSUPPORTED_DIALECT`. Tool discovery, the disk cache, and MCP
+exposure retain the full schema, including `$defs`, `$ref` siblings, and
+`additionalProperties`. Boolean roots use an equivalent `allOf` container
+at the object-shaped model-tool API boundary.
+
+Modern structured results may be any JSON value, including `null`, `false`,
+and `0`. Successful results with an `outputSchema` must contain conforming
+`structuredContent`; execution-error results are exempt. Validation never
+coerces values, inserts defaults, removes properties, or fetches references
+from the network. Unresolved references are rejected. Schemas are bounded
+to 64 nesting levels and 16,384 JSON nodes; `format` is an annotation.
+
+Object-only model providers may require a lossy schema adaptation in the AI
+provider layer. That wire adaptation does not change MCP's source schema
+or the arguments sent to the server: modern calls validate the model's
+arguments without coercion. Legacy connections retain the SDK's existing
+schema validation and compatibility conversion.
+
 - `mcp_list_resources` / `mcp_read_resource` register automatically when a
   connected server lists resources.
 - Mention `@mcp:<server>/<uri>` in your prompt to inline a resource's content

package/docs/rpc.md

@@ -145,8 +145,23 @@ The shared `SessionLifecycle` type is exported by `@code-yeongyu/senpi`:
 - `seq`, `epoch`, `epochOrigin` (`human` or `automatic`), `humanInputRevision`,
   `selfSettleEligible`, `restoring`, `persisted`, `runPaused`, and `since` (ISO time).
 - `role` (`root` or `child`), `rootSessionId`, and optional `parentSessionId` and `taskId`.
-- Optional `waitingOn`: `{ children, background, human }`. Background entries carry
-  `source`, `activeCount`, and optional `retryAtMs`. Human entries carry `kind`,
+- Optional `waitingOn`: `{ children, background, human, childSources?, childReports?, childReportsOmitted? }`.
+  `children` and each source's `activeCount` are the authoritative counts; every named list below is
+  supplemental and may be incomplete, so never derive a count from a list's length. `children` is the
+  larger of the nonterminal child reports and the summed `childSources` counts.
+  Background entries carry `source`, `activeCount`, optional `items`, optional `omittedItems`, and
+  optional `retryAtMs`. `childSources` entries carry `source`, `activeCount`, optional `items`, and
+  optional `omittedItems`. Each item is `{ id, label?, startedAt? }` (`startedAt` is ISO time), taken
+  from the producer's `wake_source_state` snapshot: its `items`, or the legacy `monitors` list when
+  `items` is missing or null. Terminal monitors are named by their stable `mon_` id. Each list is a
+  snapshot: entries whose `id` is not a non-blank string are dropped, duplicates collapse to one entry
+  per `id`, the list is sorted by `id`, and at most 32 entries are kept. `omittedItems` is the
+  producer's own omitted count plus any valid items cut at 32; it is not `activeCount` minus the list
+  length. Invalid detail drops only the detail, never the count.
+  `childReports` lists nonterminal reports from `reportChild` as
+  `{ taskId, childSessionId, runEpoch, state, label?, since? }`, excluding reports about the session
+  itself, sorted by `taskId` and capped at 32; `childReportsOmitted` counts the reports cut by that cap.
+  Human entries carry `kind`,
   `originSessionId`, `requestId`, `revision`, `since`, and optional child identity/label.
   Human kinds are `question`, `approval`, `goal_blocked`, `goal_paused`, `stalled`,
   and `interrupted_run`; attention remains visible even when a hold wins precedence.
@@ -1644,6 +1659,7 @@ A multi-session host advertising the capability `session_status` pushes one `ses
 - `include_context`: carry each session's published `context` on its records; default `false`.
 - `mirror`: `"none"` (default), `"all"` or an array of record types (`["message_update", "tool_execution_start"]`). The matched sessions' records of those types are also delivered to this connection. Mirroring is an explicit opt-in open to every subscriber of the host (the socket is per user, mode 0600): it is not an attachment and does not keep a session alive. Worker content is mirrored only with `include_workers: true`.
 - `effects`: also deliver `effect_status` receipts of matched sessions; default `true` for `childrenOf`, `false` otherwise. Each `effect_status` is enqueued after the record that caused the transition and shares the subscription's `seq`.
+- `dialogs`: with capability `dialog_observer`, also deliver the `ui_request_pending` and `ui_request_settled` records of matched sessions; default `false`. It takes effect only together with a `mirror` selection, stays observing, and grants no answering authority (see "UI-answer receipts and dialog observation").
 
 Response:
 
@@ -3425,6 +3441,14 @@ If an extension cancelled:
 
 ### State
 
+#### get_snapshot
+
+Atomic snapshot cursor (capability `snapshot_cursor`). Subscribe with `mirror` before taking a snapshot to cut the live record stream at a source-issued cursor rather than at response arrival. Terminal control endpoints support the same command.
+
+`get_snapshot {sessionId, tail?, maxBytes?, observe?: true}` returns `{state, entries, next_before, history_truncated, markerId}`. `state` uses the existing `get_state` projection, including `pendingDialogs` and `pendingQuestions`. `entries` is the newest tail, in chronological order. `tail` defaults to 100 and accepts non-negative integers; `maxBytes` defaults to 8 MiB and accepts positive integers, capped at 48 MiB. The byte bound applies to serialized history entries. An entry that does not fit ends the tail; it is never silently skipped. `history_truncated` reports omitted history; `next_before` is the oldest returned entry's id when older history remains, otherwise null (also null when no entry fits).
+
+State capture, history capture, and enqueueing `{type: "snapshot_marker", sessionId, markerId}` are one synchronous operation. The marker goes only to the requesting connection, only when a matching subscription has `mirror` enabled (including a list of selected record types). Other subscribers never receive that marker. Apply the snapshot and then records after its marker; a post-marker record can arrive **before** the correlated response. A reader without a mirrored subscription receives the snapshot response but no marker record. `observe: true` does not attach or refresh activity.
+
 #### get_state
 
 Get current session state.
@@ -5490,6 +5514,22 @@ With enforcement, only the authority's winning whole-form action admits once.
 The host advertises `mcp_form_presenter_v1` only when enforcement is enabled;
 the capability reports protocol support, not authority to present or answer a form.
 
+The public `host ensure` and `host handoff` commands accept the same deployment option,
+separately from `--launch-spec`. Add `--mcp-presenter-fd 4` with a live inherited duplex
+channel to enroll the launch owner of a new host. The runtime-selecting CLI re-exec,
+supervisor and host child preserve that channel. The option alone enables enforcement,
+not a presenter; fd 4 alone does not enable enforcement.
+
+An enforcing predecessor keeps enforcement in its successor, including when an older
+handoff caller omits the option. Conditional `handoff --when idle` carries the non-secret
+`mcp_presenter_enforcement` boolean in `begin_handover`, independently of the launch
+specification and environment. It uses only the existing authenticated owner's channel
+for fresh successor enrollment; the CLI cannot enroll itself into the predecessor.
+Reuse and already-current handover answers report the serving host's actual capabilities.
+Neither a successful CLI exit nor an equal `runtimeBuildId` proves enforcement or
+enrollment. A deployment requesting enforcement against an unenforced existing host must
+coordinate a replacement, not force-restart another owner's busy host.
+
 The native launch owner enrolls an Ed25519 public key through an inherited private
 bootstrap channel. Descriptor 4 is reserved for this channel; descriptor 3 remains
 the separate owner-lifetime channel. Enrollment and management proofs sign the
@@ -5901,6 +5941,25 @@ Dismiss any dialog method. The extension receives `undefined` (for select/input/
 {"type": "extension_ui_response", "id": "uuid-3", "cancelled": true}
 ```
 
+### UI-answer receipts and dialog observation
+
+With capability `ui_answer_ledger`, `extension_ui_response` accepts an optional `answerId` string of 1-256 characters. The response preserves the frame's correlation `id` and adds `disposition`:
+
+- `applied`: success; the pending request was settled once.
+- `replay`: success; this `(uiRequestId, answerId)` pair was already applied, with no repeated delivery.
+- `already_answered`: failure; the request was already settled with a different answer id.
+- `unknown`: failure; no pending request or receipt exists (`unknown_extension_ui_request`).
+
+A malformed answer (for example `invalid_answer_id` or `question_incomplete`) is refused without a `disposition` and leaves its request pending. A single-session stdio connection still ignores an unnamed response that matches no request; a named response always gets a reply.
+
+`get_state.answeredUiRequests` contains the latest 64 receipts, oldest first, as `{uiRequestId, answerId?}`. Receipts are session-local and memory-only, retained for that session's life in the host generation. The ledger evicts FIFO beyond 1,024 requests; replay does not extend retention. Omitting `answerId` keeps the short-form answer contract but provides no named replay identity. A restart, unloaded session, or evicted receipt is not proof of non-execution.
+
+With capability `dialog_observer`, `subscribe_sessions` accepts `dialogs?: boolean` (default false). A matching `dialogs: true` subscription must also enable `mirror`. It receives these new records on its connection FIFO:
+
+`{type: "ui_request_pending", sessionId, uiRequestId, method, request}` when a dialog or question is registered, with its original request frame; `{type: "ui_request_settled", sessionId, uiRequestId, disposition: "answered" | "cancelled"}` when it settles. Timeout and lifecycle teardown count as cancellation. The feed survives the command connection's departure while the session remains loaded. A dialog already present in the snapshot is not emitted again.
+
+The subscription remains observing: it creates no attachment and carries no correlated `response` records. The original select, confirm, input, and editor `extension_ui_request` records remain targeted, not mirrored. Use a separate attached command connection for answers; dialog observation grants no answering authority.
+
 ## Error Handling
 
 Failed commands return a response with `success: false`:

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi",
-	"version": "2026.10.25-4",
+	"version": "2026.10.26-2",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"piConfig": {
@@ -71,10 +71,11 @@
 	},
 	"dependencies": {
 		"@earendil-works/chord": "0.99.1",
-		"@earendil-works/pi-agent-core": "npm:@code-yeongyu/senpi-agent-core@2026.10.25-4",
-		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.10.25-4",
-		"@earendil-works/pi-tui": "npm:@code-yeongyu/senpi-tui@2026.10.25-4",
+		"@earendil-works/pi-agent-core": "npm:@code-yeongyu/senpi-agent-core@2026.10.26-2",
+		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.10.26-2",
+		"@earendil-works/pi-tui": "npm:@code-yeongyu/senpi-tui@2026.10.26-2",
 		"@silvia-odwyer/photon-node": "0.3.4",
+		"ajv": "8.20.0",
 		"chalk": "6.0.0",
 		"cross-spawn": "7.0.6",
 		"diff": "9.0.0",
@@ -92,8 +93,8 @@
 		"yaml": "2.9.1",
 		"@anthropic-ai/claude-agent-sdk": "0.3.306",
 		"@anthropic-ai/sdk": "0.127.0",
-		"@code-yeongyu/senpi-codemode": "2026.10.25-4",
-		"@earendil-works/pi-pty": "npm:@code-yeongyu/senpi-pty@2026.10.25-4",
+		"@code-yeongyu/senpi-codemode": "2026.10.26-2",
+		"@earendil-works/pi-pty": "npm:@code-yeongyu/senpi-pty@2026.10.26-2",
 		"@modelcontextprotocol/sdk": "1.32.1",
 		"@mozilla/readability": "0.6.0",
 		"linkedom": "0.18.13",

package/dist/bundle/chunks/azure-openai-responses-7I45DI72.js

@@ -1,2 +0,0 @@
-import { createRequire as __piCreateRequire } from "node:module"; const require = __piCreateRequire(import.meta.url); { const __piWorkerThreads = require("node:worker_threads"); if (typeof __piWorkerThreads.markAsUncloneable !== "function") { __piWorkerThreads.markAsUncloneable = () => {}; } }
-import{AzureOpenAI}from"./chunk-CD2HJK4C.js";import{getPiUserAgent}from"./chunk-QTG7MY2X.js";import{buildBaseOptions}from"./chunk-GSSD3R5X.js";import{retryProviderRequest}from"./chunk-EDOW5W5H.js";import{deriveOpenAIPromptCacheKey}from"./chunk-3BTN337S.js";import{formatProviderError,normalizeProviderError}from"./chunk-TAV6QZFM.js";import"./chunk-PELNNWGO.js";import{convertResponsesMessages,convertResponsesTools,processResponsesStream}from"./chunk-E4LBKOZG.js";import"./chunk-GVSBCJFI.js";import"./chunk-HK46JMSC.js";import{createGrammarToolInputProperties}from"./chunk-4P7WARQZ.js";import"./chunk-WDTJ6JKE.js";import{getProviderEnvValue}from"./chunk-5ROMKDLK.js";import"./chunk-3W47LTXQ.js";import{clampThinkingLevel,getDeclaredTools,resolveTranscript,resolveTranscriptTools,supportsMax}from"./chunk-6AOVUTUR.js";import"./chunk-45SZOLCU.js";import{AssistantMessageEventStream}from"./chunk-DMI55M2N.js";import{headersToRecord}from"./chunk-PJ34QVL5.js";import"./chunk-IKOFCODM.js";var DEFAULT_AZURE_API_VERSION="v1",AZURE_TOOL_CALL_PROVIDERS=new Set(["openai","chatgpt-subscription","opencode","azure-openai-responses"]),OPENAI_RESPONSES_MIN_OUTPUT_TOKENS=16;function parseDeploymentNameMap(value){let map=new Map;if(!value)return map;for(let entry of value.split(",")){let trimmed=entry.trim();if(!trimmed)continue;let[modelId,deploymentName]=trimmed.split("=",2);!modelId||!deploymentName||map.set(modelId.trim(),deploymentName.trim())}return map}function resolveDeploymentName(model,options){return options?.azureDeploymentName?options.azureDeploymentName:parseDeploymentNameMap(getProviderEnvValue("AZURE_OPENAI_DEPLOYMENT_NAME_MAP",options?.env)).get(model.id)||model.id}function formatAzureOpenAIError(error){return formatProviderError(normalizeProviderError(error),"Azure OpenAI API error")}var stream=(model,context,options)=>{let stream2=new AssistantMessageEventStream,normalizedContext=resolveTranscript(context,model.compat?.supportsMidConvoSystemMessages);return(async()=>{let deploymentName=resolveDeploymentName(model,options),output={role:"assistant",content:[],api:"azure-openai-responses",provider:model.provider,model:model.id,usage:{input:0,output:0,cacheRead:0,cacheWrite:0,totalTokens:0,cost:{input:0,output:0,cacheRead:0,cacheWrite:0,total:0}},stopReason:"pending",timestamp:Date.now()};try{let apiKey=options?.apiKey;if(!apiKey)throw new Error(`No API key for provider: ${model.provider}`);let client=createClient(model,apiKey,options),grammarToolInputProperties=createGrammarToolInputProperties(getDeclaredTools(normalizedContext.messages),model.compat?.supportsOpenAIGrammarTools??!1),params=buildParams(model,normalizedContext,options,deploymentName,grammarToolInputProperties),nextParams=await options?.onPayload?.(params,model);nextParams!==void 0&&(params=nextParams);let requestOptions={...options?.signal?{signal:options.signal}:{},...options?.timeoutMs!==void 0?{timeout:options.timeoutMs}:{},maxRetries:0},{data:openaiStream,response}=await retryProviderRequest(()=>client.responses.create(params,requestOptions).withResponse(),{maxRetries:options?.maxRetries,maxRetryDelayMs:options?.maxRetryDelayMs,signal:options?.signal});if(await options?.onResponse?.({status:response.status,headers:headersToRecord(response.headers)},model),stream2.push({type:"start",partial:output}),await processResponsesStream(openaiStream,output,stream2,model,{onProviderStreamEvent:options?.onProviderStreamEvent,grammarToolInputProperties}),options?.signal?.aborted)throw new Error("Request was aborted");if(output.stopReason==="pending")throw new Error("Azure OpenAI Responses stream ended without a stop reason");if(output.stopReason==="aborted"||output.stopReason==="error")throw new Error(output.errorMessage||"An unknown error occurred");stream2.push({type:"done",reason:output.stopReason,message:output}),stream2.end()}catch(error){for(let block of output.content)delete block.index,delete block.partialJson,delete block.customInput;output.stopReason=options?.signal?.aborted?"aborted":"error",output.errorMessage=formatAzureOpenAIError(error),stream2.push({type:"error",reason:output.stopReason,error:output}),stream2.end()}})(),stream2},streamSimple=(model,context,options)=>{let apiKey=options?.apiKey;if(!apiKey)throw new Error(`No API key for provider: ${model.provider}`);let base={...buildBaseOptions(model,context,options,apiKey),toolChoice:options?.toolChoice},clampedReasoning=options?.reasoning?clampThinkingLevel(model,options.reasoning):void 0,reasoningEffort=clampedReasoning==="off"?void 0:clampedReasoning==="max"&&supportsMax(model)?"max":clampedReasoning==="max"?"high":clampedReasoning;return stream(model,context,{...base,reasoningEffort})};function normalizeAzureBaseUrl(baseUrl){let trimmed=baseUrl.trim().replace(/\/+$/,""),url;try{url=new URL(trimmed)}catch{throw new Error(`Invalid Azure OpenAI base URL: ${baseUrl}`)}let isAzureHost=url.hostname.endsWith(".openai.azure.com")||url.hostname.endsWith(".cognitiveservices.azure.com")||url.hostname.endsWith(".ai.azure.com"),normalizedPath=url.pathname.replace(/\/+$/,"");return isAzureHost&&(normalizedPath===""||normalizedPath==="/"||normalizedPath==="/openai"||normalizedPath==="/openai/v1/responses")&&(url.pathname="/openai/v1",url.search=""),url.toString().replace(/\/+$/,"")}function buildDefaultBaseUrl(resourceName){return`https://${resourceName}.openai.azure.com/openai/v1`}function resolveAzureConfig(model,options){let apiVersion=options?.azureApiVersion||getProviderEnvValue("AZURE_OPENAI_API_VERSION",options?.env)||DEFAULT_AZURE_API_VERSION,baseUrl=options?.azureBaseUrl?.trim()||getProviderEnvValue("AZURE_OPENAI_BASE_URL",options?.env)?.trim()||void 0,resourceName=options?.azureResourceName||getProviderEnvValue("AZURE_OPENAI_RESOURCE_NAME",options?.env),resolvedBaseUrl=baseUrl;if(!resolvedBaseUrl&&resourceName&&(resolvedBaseUrl=buildDefaultBaseUrl(resourceName)),!resolvedBaseUrl&&model.baseUrl&&(resolvedBaseUrl=model.baseUrl),!resolvedBaseUrl)throw new Error("Azure OpenAI base URL is required. Set AZURE_OPENAI_BASE_URL or AZURE_OPENAI_RESOURCE_NAME, or pass azureBaseUrl, azureResourceName, or model.baseUrl.");return{baseUrl:normalizeAzureBaseUrl(resolvedBaseUrl),apiVersion}}function createClient(model,apiKey,options){let headers={"User-Agent":getPiUserAgent(),...model.headers};options?.headers&&Object.assign(headers,options.headers);let{baseUrl,apiVersion}=resolveAzureConfig(model,options);return new AzureOpenAI({apiKey,apiVersion,dangerouslyAllowBrowser:!0,fetch:options?.fetch,defaultHeaders:headers,baseURL:baseUrl})}function buildParams(model,context,options,deploymentName,grammarToolInputProperties=createGrammarToolInputProperties(getDeclaredTools(context.messages),model.compat?.supportsOpenAIGrammarTools??!1)){let requestedReasoningEffort=options?.reasoningEffort??(options?.reasoningSummary?"medium":void 0),mappedReasoningEffort=requestedReasoningEffort===void 0?void 0:model.thinkingLevelMap?.[requestedReasoningEffort],reasoningEffort=mappedReasoningEffort===void 0?requestedReasoningEffort:mappedReasoningEffort,reasoningRequested=reasoningEffort!=null,reasoningUnavailable=reasoningEffort===null,supportsAdditionalTools=model.compat?.supportsAdditionalTools??!1,supportsToolSearch=model.compat?.supportsToolSearch??!1,transcriptTools=resolveTranscriptTools(context.messages,supportsAdditionalTools||supportsToolSearch),messages=convertResponsesMessages(model,context,AZURE_TOOL_CALL_PROVIDERS,{grammarToolInputProperties,supportsMidConvoSystemMessages:model.compat?.supportsMidConvoSystemMessages??!1,supportsAdditionalTools,supportsToolSearch,toolOptions:{supportsStrictMode:model.compat?.supportsStrictMode??!0,supportsOpenAIGrammarTools:model.compat?.supportsOpenAIGrammarTools??!1}}),params={model:deploymentName,input:messages,stream:!0,...(options?.cacheRetention??model.cacheRetention)==="none"?{}:{prompt_cache_key:deriveOpenAIPromptCacheKey(model.id,context)},store:!1};return options?.maxTokens&&(params.max_output_tokens=Math.max(options.maxTokens,OPENAI_RESPONSES_MIN_OUTPUT_TOKENS)),options?.temperature!==void 0&&(params.temperature=options?.temperature),transcriptTools.requestTools.length>0&&(params.tools=convertResponsesTools(transcriptTools.requestTools,{supportsStrictMode:model.compat?.supportsStrictMode??!0,supportsOpenAIGrammarTools:model.compat?.supportsOpenAIGrammarTools??!1})),options?.toolChoice!==void 0&&(params.tool_choice=options.toolChoice),model.reasoning&&(reasoningRequested?(params.reasoning={effort:reasoningEffort,...options?.reasoningSummary===null?{}:{summary:options?.reasoningSummary||"auto"}},params.include=["reasoning.encrypted_content"]):!reasoningUnavailable&&model.thinkingLevelMap?.off!==null&&(params.reasoning={effort:model.thinkingLevelMap?.off??"none"})),Object.assign(params,model.samplingParams,options?.samplingParams),params}export{stream,streamSimple};

package/dist/bundle/chunks/chunk-DMI55M2N.js

@@ -1,2 +0,0 @@
-import { createRequire as __piCreateRequire } from "node:module"; const require = __piCreateRequire(import.meta.url); { const __piWorkerThreads = require("node:worker_threads"); if (typeof __piWorkerThreads.markAsUncloneable !== "function") { __piWorkerThreads.markAsUncloneable = () => {}; } }
-var FifoQueue=class{constructor(){this.incoming=[],this.outgoing=[]}get length(){return this.incoming.length+this.outgoing.length}enqueue(value){this.incoming.push(value)}dequeue(){if(this.outgoing.length===0)for(;this.incoming.length>0;)this.outgoing.push(this.incoming.pop());return this.outgoing.pop()}},EventStream=class{#queue;#queueHead;#failed;#error;#localWorkDepth;constructor(isComplete,extractResult){this.#queue=[],this.#queueHead=0,this.waiting=new FifoQueue,this.done=!1,this.#failed=!1,this.#localWorkDepth=0,this.isComplete=isComplete,this.extractResult=extractResult,this.finalResultPromise=new Promise((resolve,reject)=>{this.resolveFinalResult=resolve,this.rejectFinalResult=reject}),this.finalResultPromise.catch(()=>{})}get queue(){return this.#queue.slice(this.#queueHead)}#enqueue(event){this.#queue.push(event)}#dequeue(){let event=this.#queue[this.#queueHead];if(event===void 0)throw new Error("EventStream queue underflow");return this.#queueHead++,this.#queueHead>1024&&this.#queueHead*2>=this.#queue.length&&(this.#queue=this.#queue.slice(this.#queueHead),this.#queueHead=0),event}push(event){if(this.done)return;this.isComplete(event)&&(this.done=!0,this.resolveFinalResult(this.extractResult(event)));let waiter=this.waiting.dequeue();waiter?waiter.resolve({value:event,done:!1}):this.#enqueue(event)}end(result){for(this.done=!0,result!==void 0&&this.resolveFinalResult(result);this.waiting.length>0;){let waiter=this.waiting.dequeue();waiter&&waiter.resolve({value:void 0,done:!0})}}fail(error){if(!this.done)for(this.done=!0,this.#failed=!0,this.#error=error,this.rejectFinalResult(error);this.waiting.length>0;){let waiter=this.waiting.dequeue();waiter&&waiter.reject(error)}}[Symbol.asyncIterator](){return{next:()=>this.#queueHead<this.#queue.length?Promise.resolve({value:this.#dequeue(),done:!1}):this.#failed?Promise.reject(this.#error):this.done?Promise.resolve({value:void 0,done:!0}):new Promise((resolve,reject)=>this.waiting.enqueue({resolve,reject}))}}result(){return this.finalResultPromise}async trackLocalWork(work){this.#localWorkDepth++;try{return await work}finally{this.#localWorkDepth--}}hasPendingLocalWork(){return this.#localWorkDepth>0}},AssistantMessageEventStream=class extends EventStream{constructor(){super(event=>event.type==="done"||event.type==="error",event=>{if(event.type==="done")return event.message;if(event.type==="error")return event.error;throw new Error("Unexpected event type for final result")})}};function createAssistantMessageEventStream(){return new AssistantMessageEventStream}function formatThrownValue(value){return value instanceof Error?value.message||value.name:typeof value=="string"?value:String(value)}function extractDiagnosticError(error){if(!(error instanceof Error))return{name:"ThrownValue",message:formatThrownValue(error)};let code=error.code;return{name:error.name||void 0,message:error.message||error.name,stack:error.stack,code:typeof code=="string"||typeof code=="number"?code:void 0}}function createAssistantMessageDiagnostic(type,error,details){return{type,timestamp:Date.now(),error:extractDiagnosticError(error),details}}function appendAssistantMessageDiagnostic(message,diagnostic){message.diagnostics=[...message.diagnostics??[],diagnostic]}export{EventStream,AssistantMessageEventStream,createAssistantMessageEventStream,formatThrownValue,extractDiagnosticError,createAssistantMessageDiagnostic,appendAssistantMessageDiagnostic};