@code-yeongyu/senpi 2026.10.25-1 → 2026.10.25-3

package/dist/modes/rpc/host-ensure-start.js

@@ -17,6 +17,7 @@ import { pollProtocolInfo } from "./host-readiness.js";
 import { initialHostEnvironment } from "./host-spawn-environment.js";
 import { hostLaunchProfile } from "./protocol-identity.js";
 import { createSocketSecret, socketSecretPath } from "./socket-transport.js";
+import { relayPresenterBootstrap } from "./mcp-presenter-bootstrap.js";
 export const DEFAULT_READINESS_TIMEOUT_MS = 10_000;
 export { DEFAULT_STOP_TIMEOUT_MS };
 /**
@@ -55,11 +56,13 @@ export async function startHost(paths, socket, options, generation = 0) {
     let child;
     let exitedEarly;
     let childExit;
+    let presenterEnrollment;
     try {
         const supervisorArgs = [
             "--socket",
             socket,
             ...(options.owner ? ["--owner-fd", String(OWNER_WATCH_FD)] : []),
+            ...(options.presenterBootstrap ? ["--mcp-presenter-fd", "4"] : []),
             ...(options.hostArgs ?? []),
         ];
         const launch = testOptions?.spawn ?? testOptions?.launch?.(supervisorArgs) ?? defaultHostLaunch(supervisorArgs);
@@ -73,8 +76,14 @@ export async function startHost(paths, socket, options, generation = 0) {
                 instanceId,
                 generation,
             }),
-            stdio: options.owner ? ["ignore", "ignore", stderr.fd, "pipe"] : ["ignore", "ignore", stderr.fd],
+            stdio: options.presenterBootstrap
+                ? ["ignore", "ignore", stderr.fd, options.owner ? "pipe" : "ignore", "pipe"]
+                : options.owner
+                    ? ["ignore", "ignore", stderr.fd, "pipe"]
+                    : ["ignore", "ignore", stderr.fd],
         });
+        if (options.presenterBootstrap)
+            presenterEnrollment = relayPresenterBootstrap(options.presenterBootstrap, child);
         childExit = new Promise((resolveExit) => {
             child.once("exit", (code, signal) => {
                 exitedEarly = { code, signal };
@@ -140,8 +149,10 @@ export async function startHost(paths, socket, options, generation = 0) {
     }
     const readinessTimeoutMs = testOptions?.readinessTimeoutMs ?? DEFAULT_READINESS_TIMEOUT_MS;
     const result = await pollProtocolInfo(socket, readinessTimeoutMs, isCompatible, childExit);
-    if (result.ready)
+    if (result.ready) {
+        await presenterEnrollment;
         return { pid: pidFile.pid, socket, reused: false, release: result.hold.release };
+    }
     await testOptions?.beforeReadinessTeardown?.();
     // Teardown runs for the diagnostic's sake, so it must never replace it: a stop failure here
     // (unreadable identity, a host that outlives SIGKILL) would otherwise propagate instead of the

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

@@ -1,5 +1,6 @@
 /** The options and result of `ensureHost`, kept apart so the ensure's helpers can name them without a cycle. */
 import type { HostLifecyclePolicyInput } from "./host-lifecycle.ts";
+import type { Duplex } from "node:stream";
 /**
  * What an ensure may do to a host that is already running.
  *
@@ -10,6 +11,7 @@ import type { HostLifecyclePolicyInput } from "./host-lifecycle.ts";
  */
 export type HostUpgradePolicy = "never" | "if-engine-differs";
 export interface EnsureHostOptions {
+    readonly presenterBootstrap?: Duplex;
     readonly socket: string;
     readonly agentDir?: string;
     readonly keyRoot?: string;

package/dist/modes/rpc/host-ensure.js

@@ -205,6 +205,7 @@ async function upgradeGeneration(paths, socket, options, attachedPid) {
         socket,
         agentDir: options.agentDir ?? getAgentDir(),
         hostArgs: options.hostArgs ?? [],
+        presenterBootstrap: options.presenterBootstrap,
         ...(options.env ? { env: options.env } : {}),
         ...(options.policy ? { policy: options.policy } : {}),
         _test: {

package/dist/modes/rpc/host-handoff.d.ts

@@ -1,3 +1,4 @@
+import type { Duplex } from "node:stream";
 import type { HostLifecyclePolicyInput } from "./host-lifecycle.ts";
 /**
  * The longest a handoff holds the ensure lock: its probe of the running host, the two session counts
@@ -5,6 +6,7 @@ import type { HostLifecyclePolicyInput } from "./host-lifecycle.ts";
  */
 export declare const HANDOFF_LOCK_HOLD_MS: number;
 export interface HandoffHostOptions {
+    readonly presenterBootstrap?: Duplex;
     readonly socket: string;
     readonly agentDir?: string;
     /** Extra CLI arguments the successor's host child is launched with (provider pinning, extensions). */

package/dist/modes/rpc/host-handover-wire.d.ts

@@ -9,6 +9,7 @@
 import type { HandoverAnswer, HandoverOutcome, HandoverView, IdleHandoverRequest } from "./host-idle-handover.ts";
 import type { RpcResponse } from "./rpc-types.ts";
 import type { RpcSessionRegistry } from "./session-registry.ts";
+import type { Duplex } from "node:stream";
 export declare const BEGIN_HANDOVER_COMMAND = "begin_handover";
 export declare function parseBeginHandover(record: Readonly<Record<string, unknown>>): IdleHandoverRequest | string;
 export declare function beginHandoverResponse(id: unknown, answer: HandoverAnswer | string): Record<string, unknown>;
@@ -37,5 +38,6 @@ export declare function performIdleHandover(context: {
     readonly request: IdleHandoverRequest;
     readonly socket: string;
     readonly agentDir: string;
+    readonly presenterBootstrap?: Duplex;
 }): Promise<HandoverOutcome>;
 //# sourceMappingURL=host-handover-wire.d.ts.map

package/dist/modes/rpc/host-handover-wire.js

@@ -120,6 +120,7 @@ export async function performIdleHandover(context) {
         env[name] = null;
     Object.assign(env, request.env);
     const result = await handoffHost({
+        presenterBootstrap: context.presenterBootstrap,
         socket,
         agentDir,
         hostArgs: request.hostArgs,

package/dist/modes/rpc/host-lifecycle-launch.d.ts

@@ -6,6 +6,7 @@
 import { type ChildProcess } from "node:child_process";
 import type { SocketFileIdentity } from "./socket-ownership.ts";
 export interface SupervisorLaunch {
+    readonly presenterBootstrapFd?: number;
     readonly socket: string;
     readonly hostArgs: readonly string[];
     /** Optional runtime command used by rebranded/bundled callers. */

package/dist/modes/rpc/host-lifecycle-launch.js

@@ -56,10 +56,16 @@ export function parseSupervisorArgs(argv) {
     let childArgs;
     let agentDir;
     let ownerFd;
+    let presenterBootstrapFd;
     let bindSocket;
     let replaceIdentity;
     for (let index = 0; index < argv.length; index++) {
         const arg = argv[index];
+        if (arg === "--mcp-presenter-fd" && argv[index + 1] === "4") {
+            presenterBootstrapFd = 4;
+            index++;
+            continue;
+        }
         if (arg === "--owner-fd" && index + 1 < argv.length) {
             ownerFd = Number(argv[++index]);
             if (!Number.isSafeInteger(ownerFd) || ownerFd < 3)
@@ -101,7 +107,19 @@ export function parseSupervisorArgs(argv) {
     }
     return socket === undefined
         ? undefined
-        : { socket, hostArgs, childCommand, childArgs, agentDir, ownerFd, bindSocket, replaceIdentity };
+        : ownerFd === presenterBootstrapFd && ownerFd !== undefined
+            ? undefined
+            : {
+                socket,
+                hostArgs,
+                childCommand,
+                childArgs,
+                agentDir,
+                ownerFd,
+                bindSocket,
+                replaceIdentity,
+                presenterBootstrapFd,
+            };
 }
 export const OWNER_WATCH_FD = 3;
 // Strongly retain the write end until that supervisor exits, but never keep the caller alive.
@@ -188,6 +206,10 @@ export const HOST_CHILD_WATCH_FD = 3;
 export function spawnHostChild(options) {
     const { launch, internalSocket, internal, internalSecret, publicSocket } = options;
     const childLaunch = spawnableChildLaunch(resolveHostChildLaunch(launch, internalSocket));
+    // A shell wrapper cannot prove preservation of the private inherited handle.
+    const bootstrap = launch.presenterBootstrapFd !== undefined && !childLaunch.shell;
+    if (bootstrap)
+        childLaunch.args.push("--mcp-presenter-fd", "4");
     const child = spawn(childLaunch.command, childLaunch.args, {
         env: {
             ...process.env,
@@ -210,13 +232,32 @@ export function spawnHostChild(options) {
         // Slot 3 is the lifetime pipe: "pipe" gives the child a read end it can
         // wait on and keeps the write end owned by this process alone.
         shell: childLaunch.shell,
-        stdio: [process.platform === "win32" ? "ignore" : "pipe", "ignore", "inherit", "pipe"],
+        stdio: [
+            process.platform === "win32" ? "ignore" : "pipe",
+            "ignore",
+            "inherit",
+            "pipe",
+            ...(bootstrap ? ["pipe"] : []),
+        ],
         // The supervisor is spawned detached, so on win32 it owns no console. A
         // console-subsystem child started from it would allocate a fresh one,
         // which Windows Terminal renders as an empty window that takes focus.
         // CREATE_NO_WINDOW gives the child a console with no window instead.
         windowsHide: true,
     });
+    if (launch.presenterBootstrapFd !== undefined) {
+        const fd = launch.presenterBootstrapFd;
+        // The opt-in helper stays outside the supervisor's fixed startup import budget.
+        void import("./mcp-presenter-bootstrap.js")
+            .then(({ presenterBootstrapStream, relayPresenterBootstrap }) => {
+            const upstream = presenterBootstrapStream(fd);
+            if (upstream && bootstrap)
+                return relayPresenterBootstrap(upstream, child);
+            upstream?.destroy();
+            child.stdio[4]?.destroy();
+        })
+            .catch(() => child.stdio[4]?.destroy());
+    }
     if (options.internalKey) {
         child.stdin?.on("error", () => { });
         // One write only. Keep its write end alive until this supervisor exits.

package/dist/modes/rpc/host-reservations.js

@@ -22,7 +22,7 @@
 import { createHash } from "node:crypto";
 import { mkdir, readdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { join } from "node:path";
-import { processIsLive, processStartTimeMs, readProcessStartTime, sameProcessStartMs, } from "../../utils/process-identity.js";
+import { processIsLive, processIsRunning, processStartTimeMs, readProcessStartTime, sameProcessStartMs, } from "../../utils/process-identity.js";
 import { createHostDaemonPaths, generationPaths, HOST_DAEMON_DIR_ENV, hostDaemonDirectoryPaths, } from "./host-daemon-paths.js";
 import { parseJson, readFileOrUndefined } from "./host-daemon-state.js";
 import { generationHeartbeatStopped } from "./host-stalled-evidence.js";
@@ -280,7 +280,8 @@ export async function claimOwnerIsLive(owner) {
  * different start time. `unproven`: the pid runs but no start time was recorded or none can be read.
  */
 export async function claimOwnerIdentity(owner) {
-    if (!processIsLive(owner.pid))
+    // An exited, unreaped owner (state Z) makes no more writes: the claim is gone (senpi#4119).
+    if (!processIsRunning(owner.pid))
         return "gone";
     const recorded = owner.processStartTime === null ? undefined : processStartTimeMs(owner.processStartTime);
     if (recorded === undefined) {

package/dist/modes/rpc/host-runner.d.ts

@@ -5,6 +5,7 @@ import type { ResolvedHostLaunchSpec } from "./host-launch-spec.ts";
 import { type HostOutcome } from "./host-outcome.ts";
 import type { HostStopGeneration } from "./host-stop-generation.ts";
 export { HOST_EXIT_ERROR, HOST_EXIT_FALLBACK, HOST_EXIT_OK, HOST_EXIT_REFUSED, HOST_EXIT_USAGE, type HostOutcome, } from "./host-outcome.ts";
+import type { Duplex } from "node:stream";
 /** Which daemon a request is about: the endpoint, and the agent directory holding its state. */
 export interface HostTarget {
     readonly socket: string;
@@ -50,5 +51,6 @@ export type HostRequest = {
 };
 export declare function runHostRequest(request: HostRequest, options?: {
     readonly keyRoot?: string;
+    readonly presenterBootstrap?: Duplex;
 }): Promise<HostOutcome>;
 //# sourceMappingURL=host-runner.d.ts.map

package/dist/modes/rpc/host-runner.js

@@ -37,9 +37,9 @@ import { hostRequestKeyRoot } from "./host-request-key-root.js";
 import { withRpcKeyRoot } from "./rpc-auth-client.js";
 const PROBE_TIMEOUT_MS = 10_000;
 export async function runHostRequest(request, options = {}) {
-    return withRpcKeyRoot(hostRequestKeyRoot(request, options.keyRoot), () => runHostRequestInKeyRoot(request));
+    return withRpcKeyRoot(hostRequestKeyRoot(request, options.keyRoot), () => runHostRequestInKeyRoot(request, options.presenterBootstrap));
 }
-async function runHostRequestInKeyRoot(request) {
+async function runHostRequestInKeyRoot(request, presenterBootstrap) {
     if (request.action === "ensure" || request.action === "handoff" || request.action === "stop") {
         const { socket, agentDir } = request.target;
         if ((await endpointKindOfSocket(socket, agentDir)) === "tui") {
@@ -48,7 +48,7 @@ async function runHostRequestInKeyRoot(request) {
     }
     switch (request.action) {
         case "ensure":
-            return ensureOutcome(request.target, request.spec, request.policy);
+            return ensureOutcome(request.target, request.spec, request.policy, presenterBootstrap);
         case "status":
             return request.all === true
                 ? statusAllOutcome(request.target, request.includeWorkers)
@@ -57,7 +57,7 @@ async function runHostRequestInKeyRoot(request) {
             return stopOutcome(request);
         case "handoff":
             return request.handover === undefined
-                ? handoffOutcome(request.target, request.spec)
+                ? handoffOutcome(request.target, request.spec, presenterBootstrap)
                 : idleHandoverOutcome(request.target, request.spec, request.handover);
         case "shard_path":
             return shardPathOutcome(request.kind, request.owner, request.root);
@@ -70,7 +70,7 @@ async function runHostRequestInKeyRoot(request) {
             return assertNever(request);
     }
 }
-async function ensureOutcome(target, spec, policy) {
+async function ensureOutcome(target, spec, policy, presenterBootstrap) {
     const before = await probeProtocolInfo(target.socket, PROBE_TIMEOUT_MS);
     if (policy === "fallback") {
         // `fallback` is the caller saying it can live without a host. The decision is made HERE
@@ -84,6 +84,7 @@ async function ensureOutcome(target, spec, policy) {
     try {
         ensured = await ensureHost({
             socket: target.socket,
+            presenterBootstrap,
             agentDir: target.agentDir,
             hostArgs: spec.hostArgs,
             env: daemonEnvOverrides(process.env, spec.env),
@@ -181,10 +182,11 @@ async function stopOutcome(request) {
         },
     };
 }
-async function handoffOutcome(target, spec) {
+async function handoffOutcome(target, spec, presenterBootstrap) {
     const before = await probeProtocolInfo(target.socket, PROBE_TIMEOUT_MS);
     const result = await handoffHost({
         socket: target.socket,
+        presenterBootstrap,
         agentDir: target.agentDir,
         hostArgs: spec.hostArgs,
         env: daemonEnvOverrides(process.env, spec.env),

package/dist/modes/rpc/host-stalled-evidence.js

@@ -132,7 +132,8 @@ export async function hostChildAlive(generation) {
     if (!processIsLive(pid))
         return false;
     const observed = await readProcessIdentity(pid, process.platform, 1_000, processIsLive, "UTC");
-    if (!processIsLive(pid))
+    // `absent` includes an exited, unreaped child (state Z), read in the same async snapshot (senpi#4119).
+    if (observed.kind === "absent" || !processIsLive(pid))
         return false;
     const recordedMs = typeof record?.processStartTime === "string" ? processStartTimeMs(record.processStartTime) : undefined;
     const observedMs = observed.kind === "present" ? processStartTimeMs(observed.identity) : undefined;

package/dist/modes/rpc/host-successor.js

@@ -28,6 +28,7 @@ import { defaultHostLaunch, PINNED_HOST_CLIENT_CAPABILITIES } from "./host-launc
 import { DEFAULT_HOST_IDLE_EXIT_MS } from "./host-lifecycle.js";
 import { keepOwnerPipe, OWNER_WATCH_FD } from "./host-lifecycle-launch.js";
 import { probeProtocolInfo } from "./host-probe.js";
+import { relayPresenterBootstrap } from "./mcp-presenter-bootstrap.js";
 import { successorHostEnvironment } from "./host-spawn-environment.js";
 import { signalGeneration } from "./host-stop.js";
 import { hostLaunchProfile } from "./protocol-identity.js";
@@ -81,6 +82,7 @@ export async function startSuccessor(context) {
             "--replace",
             `${replaced.dev}:${replaced.ino}`,
             ...(inheritOwnerPipe ? ["--owner-fd", String(OWNER_WATCH_FD)] : []),
+            ...(options.presenterBootstrap ? ["--mcp-presenter-fd", "4"] : []),
             ...(options.hostArgs ?? []),
         ];
         const launch = (options._test?.launch ?? options.launch)?.(argv) ?? defaultHostLaunch(argv);
@@ -96,8 +98,15 @@ export async function startSuccessor(context) {
                 generation,
                 instanceId,
             }),
-            stdio: inheritOwnerPipe ? ["ignore", "ignore", stderr.fd, "pipe"] : ["ignore", "ignore", stderr.fd],
+            stdio: options.presenterBootstrap
+                ? ["ignore", "ignore", stderr.fd, inheritOwnerPipe ? "pipe" : "ignore", "pipe"]
+                : inheritOwnerPipe
+                    ? ["ignore", "ignore", stderr.fd, "pipe"]
+                    : ["ignore", "ignore", stderr.fd],
         });
+        const presenterEnrollment = options.presenterBootstrap
+            ? relayPresenterBootstrap(options.presenterBootstrap, spawned)
+            : undefined;
         child = spawned;
         exited = new Promise((resolve) => spawned.once("exit", () => resolve()));
         await stderr.close();
@@ -135,6 +144,7 @@ export async function startSuccessor(context) {
         // clients reach is still the predecessor, and the pointer has to name whoever owns the socket.
         await options._test?.beforeRegistration?.();
         await writeHostRegistration(paths, { ...registration, ...successorBuild(answer) });
+        await presenterEnrollment;
         child.unref();
         // The successor owns the socket now: the predecessor may drain. SIGUSR1 is sent only here,
         // to a pid the record proved and a host that advertised it can survive the signal. A

package/dist/modes/rpc/mcp-form-dialog.d.ts

@@ -0,0 +1,45 @@
+import type { McpFormInput, McpFormOutcome, McpFormRequest, McpFormResolved } from "../../core/mcp-form-types.ts";
+export interface McpFormClock {
+    now(): number;
+    schedule(callback: () => void, delay: number): object;
+    cancel(timer: object): void;
+}
+export declare const mcpFormClock: McpFormClock;
+type Termination = "presentation_lost" | "presentation_timeout" | "operation_aborted";
+export type McpPresenterReply = {
+    readonly ok: true;
+    readonly form?: McpFormRequest;
+} | {
+    readonly error: "presenter_not_authorized" | "invalid_form_response" | "form_stale" | "form_expired";
+};
+/** One private entry. Lifecycle closures retain this object even after its grant is removed. */
+export declare class McpFormDialog {
+    readonly result: Promise<McpFormOutcome>;
+    readonly deadline: number;
+    private stage;
+    private request;
+    private readonly token;
+    private readonly cleanups;
+    private resolve;
+    private readonly input;
+    private readonly context;
+    constructor(input: McpFormInput, context: {
+        readonly clock: McpFormClock;
+        readonly envelope: Omit<McpFormRequest, "type" | "server" | "message" | "schema" | "deadlineAtMs" | "dialogToken">;
+        readonly current: () => boolean;
+        readonly remove: () => void;
+        readonly admit: () => void;
+        readonly send: (frame: McpFormRequest | McpFormResolved) => boolean;
+    });
+    start(): void;
+    sync(): McpFormRequest | undefined;
+    matches(token: string, revision: string): boolean;
+    presented(): McpPresenterReply;
+    respond(action: string, content: unknown): McpPresenterReply;
+    /** Internal-only: never called with a cause or entry reference decoded from RPC. */
+    terminate(cause: Termination): void;
+    private live;
+    private commit;
+}
+export {};
+//# sourceMappingURL=mcp-form-dialog.d.ts.map

package/dist/modes/rpc/mcp-form-dialog.js

@@ -0,0 +1,159 @@
+import { randomBytes, timingSafeEqual } from "node:crypto";
+import { validMcpFormContent } from "../../core/extensions/builtin/mcp/modern/form-schema.js";
+export const mcpFormClock = {
+    now: () => performance.now(),
+    schedule: (callback, delay) => setTimeout(callback, delay),
+    cancel: (timer) => {
+        if ("close" in timer && typeof timer.close === "function")
+            timer.close();
+    },
+};
+/** One private entry. Lifecycle closures retain this object even after its grant is removed. */
+export class McpFormDialog {
+    constructor(input, context) {
+        this.stage = "prepared";
+        this.token = randomBytes(32);
+        this.cleanups = [];
+        this.resolve = () => { };
+        this.input = input;
+        this.context = context;
+        this.deadline = context.clock.now() + Math.max(0, input.deadlineMs);
+        this.result = new Promise((resolve) => {
+            this.resolve = resolve;
+        });
+        this.request = {
+            ...context.envelope,
+            type: "mcp_form_request",
+            dialogToken: this.token.toString("hex"),
+            server: structuredClone(input.server),
+            message: input.message,
+            schema: structuredClone(input.schema),
+            deadlineAtMs: Date.now() + Math.max(0, input.deadlineMs),
+        };
+    }
+    start() {
+        const watch = (signal, cause) => {
+            const stop = () => this.terminate(cause);
+            signal.addEventListener("abort", stop, { once: true });
+            this.cleanups.push(() => signal.removeEventListener("abort", stop));
+            if (signal.aborted)
+                stop();
+        };
+        watch(this.input.operationSignal, "operation_aborted");
+        watch(this.input.presentationSignal, "presentation_lost");
+        if (this.stage === "settled") {
+            for (const cleanup of this.cleanups.splice(0))
+                cleanup();
+            return;
+        }
+        const timer = this.context.clock.schedule(() => this.terminate("presentation_timeout"), this.input.deadlineMs);
+        this.cleanups.push(() => this.context.clock.cancel(timer));
+        if (!this.context.current() || !this.request || !this.context.send(this.request))
+            this.terminate("presentation_lost");
+    }
+    sync() {
+        if (!this.live())
+            return undefined;
+        return this.request === undefined ? undefined : structuredClone(this.request);
+    }
+    matches(token, revision) {
+        return (this.request?.formRevision === revision &&
+            /^[a-f0-9]{64}$/.test(token) &&
+            timingSafeEqual(this.token, Buffer.from(token, "hex")));
+    }
+    presented() {
+        if (!this.live())
+            return { error: "form_expired" };
+        this.stage = "presented";
+        return { ok: true };
+    }
+    respond(action, content) {
+        if (!this.live())
+            return { error: "form_expired" };
+        if (this.stage !== "presented" || !this.request)
+            return { error: "invalid_form_response" };
+        let result;
+        switch (action) {
+            case "accept":
+                if (!validMcpFormContent(this.request.schema, content) ||
+                    Buffer.byteLength(JSON.stringify(content)) > 1024 * 1024)
+                    return { error: "invalid_form_response" };
+                result = { action, content: structuredClone(content) };
+                break;
+            case "decline":
+            case "cancel":
+                if (content !== undefined)
+                    return { error: "invalid_form_response" };
+                result = { action };
+                break;
+            default:
+                return { error: "invalid_form_response" };
+        }
+        if (!this.live())
+            return { error: "form_expired" };
+        this.commit({ kind: "result", result, source: "presenter_action", humanAdmission: true });
+        return { ok: true };
+    }
+    /** Internal-only: never called with a cause or entry reference decoded from RPC. */
+    terminate(cause) {
+        const provenance = { source: "host_termination", humanAdmission: false };
+        if (cause === "operation_aborted" ||
+            this.input.operationSignal.aborted ||
+            this.input.operationCurrent?.() === false) {
+            this.commit({ kind: "operation_aborted", ...provenance });
+        }
+        else if (this.stage === "presented") {
+            this.commit({ kind: "result", result: { action: "cancel" }, ...provenance });
+        }
+        else {
+            this.commit({ kind: "processing_failure", ...provenance });
+        }
+    }
+    live() {
+        if (this.stage === "settled")
+            return false;
+        if (this.input.operationSignal.aborted || this.input.operationCurrent?.() === false) {
+            this.terminate("operation_aborted");
+            return false;
+        }
+        if (this.context.clock.now() >= this.deadline || !this.context.current()) {
+            this.terminate("presentation_timeout");
+            return false;
+        }
+        return true;
+    }
+    commit(outcome) {
+        if (this.stage === "settled")
+            return;
+        this.stage = "settled";
+        const request = this.request;
+        this.request = undefined;
+        this.token.fill(0);
+        this.context.remove();
+        for (const cleanup of this.cleanups.splice(0))
+            cleanup();
+        // No callback, promise resolution or admission precedes the synchronous terminal claim.
+        if (outcome.humanAdmission)
+            this.context.admit();
+        this.resolve(outcome);
+        if (request && this.context.current()) {
+            const reason = outcome.kind === "result"
+                ? outcome.result.action === "accept"
+                    ? "answered"
+                    : outcome.result.action === "decline"
+                        ? "declined"
+                        : "cancelled"
+                : outcome.kind === "operation_aborted"
+                    ? "operation_aborted"
+                    : "processing_failed";
+            this.context.send({
+                type: "mcp_form_resolved",
+                sessionId: request.sessionId,
+                grantId: request.grantId,
+                dialogId: request.dialogId,
+                reason,
+            });
+        }
+    }
+}
+//# sourceMappingURL=mcp-form-dialog.js.map

package/dist/modes/rpc/mcp-form-worker.d.ts

@@ -0,0 +1,14 @@
+import type { HostToSessionWorker, SessionWorkerToHost } from "./session-worker-protocol.ts";
+/** Private worker messages never pass through WorkerEventWriter.enqueue or a snapshot. */
+export declare class McpFormWorker {
+    private readonly send;
+    private readonly binds;
+    private readonly ready;
+    private readonly settlements;
+    private readonly bindings;
+    private readonly entries;
+    constructor(send: (message: SessionWorkerToHost) => void);
+    bind(durableId: string, ui: object, admit: () => void): Promise<() => void>;
+    receive(message: HostToSessionWorker): boolean;
+}
+//# sourceMappingURL=mcp-form-worker.d.ts.map