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

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.js

@@ -2,8 +2,9 @@ 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 { 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";
@@ -330,7 +331,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 +339,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 +372,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-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-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/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/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

@@ -1644,6 +1644,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 +3426,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 +5499,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 +5926,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-1",
 	"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-1",
+		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.10.26-1",
+		"@earendil-works/pi-tui": "npm:@code-yeongyu/senpi-tui@2026.10.26-1",
 		"@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-1",
+		"@earendil-works/pi-pty": "npm:@code-yeongyu/senpi-pty@2026.10.26-1",
 		"@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};