zigmini 0.8.0-beta.7 → 0.9.0-beta.2

package/host/omo-check/patches/omo-5.1.48-rpc-port.patch

@@ -0,0 +1,799 @@
+--- a/@code-yeongyu/senpi/dist/core/client-message-identity.d.ts
++++ b/@code-yeongyu/senpi/dist/core/client-message-identity.d.ts
+@@ -2,6 +2,7 @@ import type { ImageContent } from "@earendil-works/pi-ai";
+ import { z } from "zod";
+ import type { InputSource } from "./extensions/types.ts";
+ export declare const clientMessageIdentitySchema: z.ZodObject<{
++    clientInputId: z.ZodOptional<z.ZodString>;
+     clientMessageId: z.ZodOptional<z.ZodString>;
+     clientTurnId: z.ZodOptional<z.ZodString>;
+ }, z.core.$strip>;
+@@ -17,4 +18,4 @@ export type PreparedClientInput = ClientMessageIdentity & {
+ /** Copy only correlation metadata, never the rest of a prompt's options. */
+ export declare function clientMessageIdentity(value?: ClientMessageIdentity): ClientMessageIdentity;
+ export declare function readClientMessageIdentity(value: unknown): ClientMessageIdentity;
+-//# sourceMappingURL=client-message-identity.d.ts.map
+
++//# sourceMappingURL=client-message-identity.d.ts.map
+--- a/@code-yeongyu/senpi/dist/core/client-message-identity.js
++++ b/@code-yeongyu/senpi/dist/core/client-message-identity.js
+@@ -1,12 +1,15 @@
+ import { z } from "zod";
+ export const clientMessageIdentitySchema = z.object({
++    clientInputId: z.string().min(1).max(128).optional(),
+     clientMessageId: z.string().min(1).max(256).optional(),
+     clientTurnId: z.string().min(1).max(256).optional(),
+ });
+ /** Copy only correlation metadata, never the rest of a prompt's options. */
+ export function clientMessageIdentity(value = {}) {
++    const clientMessageId = value.clientMessageId ?? value.clientInputId;
+     return {
+-        ...(value.clientMessageId === undefined ? {} : { clientMessageId: value.clientMessageId }),
++        ...(value.clientInputId === undefined ? {} : { clientInputId: value.clientInputId }),
++        ...(clientMessageId === undefined ? {} : { clientMessageId }),
+         ...(value.clientTurnId === undefined ? {} : { clientTurnId: value.clientTurnId }),
+     };
+ }
+@@ -14,4 +17,4 @@ export function readClientMessageIdentity(value) {
+     const parsed = clientMessageIdentitySchema.safeParse(value);
+     return parsed.success ? clientMessageIdentity(parsed.data) : {};
+ }
+-//# sourceMappingURL=client-message-identity.js.map
+
++//# sourceMappingURL=client-message-identity.js.map
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/ask-user/pending.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/ask-user/pending.js
+@@ -39,7 +39,8 @@ function buildResponse(status, request, answers, comment, autoResolvedAfterMs, r
+ }
+ export function createPendingQuestion(options) {
+     const createdAtMs = options.now();
+-    const hardCapMs = options.hardCapMs ?? DEFAULT_HARD_CAP_MS;
++    // zgw: an unbounded idle timeout (required question) also has no hard cap.
++    const hardCapMs = Number.isFinite(options.idleTimeoutMs) ? (options.hardCapMs ?? DEFAULT_HARD_CAP_MS) : Infinity;
+     const hardDeadlineAtMs = createdAtMs + hardCapMs;
+     const schedule = options.setTimeout ?? ((handler, delayMs) => setTimeout(handler, delayMs));
+     const unsched = options.clearTimeout ?? clearTimeout;
+@@ -72,6 +73,8 @@ export function createPendingQuestion(options) {
+         if (terminal !== undefined)
+             return;
+         const delayMs = deadlineAtMs - options.now();
++        if (!Number.isFinite(delayMs))
++            return;
+         if (delayMs <= 0) {
+             fireTimeout();
+             return;
+@@ -131,4 +134,4 @@ export function createPendingQuestion(options) {
+         },
+     };
+ }
+-//# sourceMappingURL=pending.js.map
+
++//# sourceMappingURL=pending.js.map
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/ask-user/resume.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/ask-user/resume.js
+@@ -5,6 +5,8 @@ import { getPendingQuestions } from "./registry.js";
+ import { DEFAULT_ASK_USER_TIMEOUT_MS, toCanonical, } from "./schema.js";
+ import { deliverAnswer, startQuestion } from "./tool.js";
+ export const ASK_USER_RESUMED_ENTRY = "ask-user:resumed";
++/** zgw bug 69: a required question that was live when the host stopped; its abort result does not end it. */
++export const ASK_USER_INTERRUPTED_ENTRY = "ask-user:interrupted";
+ function isRecord(value) {
+     return typeof value === "object" && value !== null && !Array.isArray(value);
+ }
+@@ -19,6 +21,7 @@ function findDanglingQuestions(entries) {
+     const results = new Set();
+     const accepted = new Set();
+     const resumed = new Set();
++    const interrupted = new Set();
+     const settled = new Set();
+     for (const entry of entries) {
+         if (entry.type === "message" && entry.message.role === "user") {
+@@ -34,9 +37,14 @@ function findDanglingQuestions(entries) {
+         }
+         if (entry.type === "custom" && entry.customType === ASK_USER_RESUMED_ENTRY && isRecord(entry.data)) {
+             const toolCallId = entry.data.toolCallId;
+-            if (typeof toolCallId === "string")
++            // zgw bug 32: a resumed question now records its own settlement, so only a settlement or an answer
++            // frame ends it and it is resumed again after every restart. A marker without the flag predates that
++            // record (its cancellation left none), so it still ends the question.
++            if (typeof toolCallId === "string" && entry.data.settlesDurably !== true)
+                 resumed.add(toolCallId);
+         }
++        if (entry.type === "custom" && entry.customType === ASK_USER_INTERRUPTED_ENTRY && isRecord(entry.data) && typeof entry.data.toolCallId === "string")
++            interrupted.add(entry.data.toolCallId);
+         if (entry.type === "message" && entry.message.role === "toolResult") {
+             results.add(entry.message.toolCallId);
+             const details = entry.message.details;
+@@ -65,7 +73,7 @@ function findDanglingQuestions(entries) {
+                 continue;
+             const call = { toolCallId: block.id, variant, args: block.arguments };
+             const request = requestFromCall(call, DEFAULT_ASK_USER_TIMEOUT_MS);
+-            if (results.has(block.id) && (request?.waitForAnswer === true || !accepted.has(block.id)))
++            if (results.has(block.id) && !interrupted.has(block.id) && (request?.waitForAnswer === true || !accepted.has(block.id)))
+                 continue;
+             if (resumed.has(block.id))
+                 continue;
+@@ -105,6 +113,18 @@ function settleUnrestorable(pi, ctx, dangling, timeoutMs) {
+     emitAskUserClosed(pi, lost.requestId, response);
+     deliverAnswer(pi, ctx, lost, response, dangling.variant);
+ }
++/**
++ * zgw bug 69: called when the host stops (SIGTERM/SIGHUP) before the session is aborted. Each live required question
++ * is recorded as interrupted and detached, so the shutdown abort neither settles it nor hides it from the next start.
++ */
++export function interruptRequiredQuestionsForHostShutdown(sessionManager) {
++    for (const entry of getPendingQuestions(sessionManager.getSessionId())) {
++        if (!entry.request.waitForAnswer)
++            continue;
++        sessionManager.appendCustomEntry(ASK_USER_INTERRUPTED_ENTRY, { toolCallId: entry.request.requestId });
++        entry.detach();
++    }
++}
+ export async function resumeDanglingQuestion(pi, event, ctx) {
+     if (event.reason !== "resume" && event.reason !== "reload")
+         return;
+@@ -114,7 +134,7 @@ export async function resumeDanglingQuestion(pi, event, ctx) {
+         if (pending.has(dangling.toolCallId))
+             continue;
+         pending.add(dangling.toolCallId);
+-        pi.appendEntry(ASK_USER_RESUMED_ENTRY, { toolCallId: dangling.toolCallId });
++        pi.appendEntry(ASK_USER_RESUMED_ENTRY, { toolCallId: dangling.toolCallId, settlesDurably: true });
+         const request = requestFromCall(dangling, timeoutMs);
+         if (!request) {
+             settleUnrestorable(pi, ctx, dangling, timeoutMs);
+@@ -126,4 +146,4 @@ export async function resumeDanglingQuestion(pi, event, ctx) {
+         });
+     }
+ }
+-//# sourceMappingURL=resume.js.map
+
++//# sourceMappingURL=resume.js.map
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/ask-user/schema.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/ask-user/schema.js
+@@ -99,8 +99,10 @@ export function toCanonical(variant, args, options) {
+         requestId: options?.requestId ?? crypto.randomUUID(),
+         questions: args.questions.map((question, index) => parseQuestion(variant, question, index)),
+         waitForAnswer,
+-        timeoutMs: options?.timeoutMs ?? DEFAULT_ASK_USER_TIMEOUT_MS,
++        // zgw: a waiting question is a required decision; it has no idle timeout or hard cap and
++        // stays open until the user answers or cancels. Non-waiting questions keep the setting.
++        timeoutMs: waitForAnswer ? Infinity : (options?.timeoutMs ?? DEFAULT_ASK_USER_TIMEOUT_MS),
+         ...(args.required === true ? { required: true } : {}),
+     };
+ }
+-//# sourceMappingURL=schema.js.map
+
++//# sourceMappingURL=schema.js.map
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/ask-user/tool.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/ask-user/tool.js
+@@ -81,7 +81,8 @@ export function startQuestion(initialPi, initialCtx, request, signal, initialSta
+     let unregister = () => { };
+     const publish = (ownerPi, ownerCtx, response) => {
+         emitAskUserClosed(ownerPi, request.requestId, response);
+-        if (!request.waitForAnswer)
++        // zgw bug 32: a resumed question has no tool result, so record every outcome (a silent cancellation too).
++        if (!request.waitForAnswer || resuming)
+             ownerPi.appendEntry(ASK_USER_SETTLEMENT_ENTRY, {
+                 requestId: request.requestId,
+                 status: response.status,
+@@ -183,7 +184,7 @@ export function startQuestion(initialPi, initialCtx, request, signal, initialSta
+         signal: controller.signal,
+         // A resumed question delivers its answer as a user message (deliverAnswer), like an async one.
+         deliver: request.waitForAnswer && !resuming ? "tool-result" : "user-message",
+-        hardDeadlineAtMs: Date.now() + 7_200_000,
++        hardDeadlineAtMs: Number.isFinite(request.timeoutMs) ? Date.now() + 7_200_000 : Infinity,
+         getDeadlineAtMs: () => pending.deadlineAtMs,
+         onProgress: (progress) => {
+             draft = { ...draft, ...progress, answers: progress.answers ?? draft.answers };
+@@ -288,7 +289,7 @@ export function createAskUserTool(variant, pi, state) {
+         allowLazyActivation: false,
+         parameters: variant === "codex" ? CODEX_PARAMS : CLAUDE_PARAMS,
+         promptSnippet: "Ask a material question, explicitly choosing whether to wait or receive the answer later.",
+-        description: `${opener} Set ${flag} true to pause here until the user answers (the answer returns as this tool's result, or a timeout result after 30 idle minutes); set ${flag} false to keep working while the question stays open (the answer arrives later as a user message). Use it only when the answer materially changes the work; if it returns no answers, continue with best judgment instead of asking again, unless you set required true because the answer decides whether you take an action: then no answer means do not take it. Never use it for permission requests; ask those directly in your message. Unavailable to subagents.${variant === "claude" ? " Users will always be able to type a free-text answer or one comment covering everything; do not add an Other option." : ""} Call this tool directly, never from inside an eval cell (a cell that waits on the user would hold the kernel).`,
++        description: `${opener} Set ${flag} true for a required confirmation: the work pauses here until the user answers or cancels, with no timeout (the answer returns as this tool's result); never proceed on your own judgment past a required question. Set ${flag} false when the work may continue without the answer (it arrives later as a user message, or a timeout after 30 idle minutes); if such a question returns no answers, continue with best judgment instead of asking again. Use it only when the answer materially changes the work. Never use it for permission requests; ask those directly in your message. Unavailable to subagents.${variant === "claude" ? " Users will always be able to type a free-text answer or one comment covering everything; do not add an Other option." : ""} Call this tool directly, never from inside an eval cell (a cell that waits on the user would hold the kernel).`,
+         prepareArguments(args) {
+             toCanonical(variant, args);
+             return args;
+@@ -349,4 +350,4 @@ export function createAskUserTool(variant, pi, state) {
+         renderResult,
+     };
+ }
+-//# sourceMappingURL=tool.js.map
+
++//# sourceMappingURL=tool.js.map
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/permission-system/events.d.ts
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/permission-system/events.d.ts
+@@ -13,6 +13,9 @@ export type PermissionRepliedEvent = {
+     requestID: string;
+     sessionID: string;
+     reply: PermissionDecision;
++    correlationId?: string;
++    source?: "user" | "system" | "policy" | "cascade";
++    choice?: string;
+ };
+ /**
+  * Event emitter interface for permission events.
+@@ -30,7 +33,7 @@ export interface PermissionEventEmitter {
+      * @param sessionID - The session ID associated with the request
+      * @param reply - The user's reply (once, always, or reject)
+      */
+-    emitReplied(requestID: string, sessionID: string, reply: PermissionDecision): void;
++    emitReplied(requestID: string, sessionID: string, reply: PermissionDecision, evidence?: Pick<PermissionRepliedEvent, "correlationId" | "source" | "choice">): void;
+ }
+ /**
+  * Creates an event emitter that wraps pi.events for inter-extension communication.
+@@ -64,4 +67,4 @@ export declare function createLocalEventEmitter(): PermissionEventEmitter & {
+      */
+     clear(): void;
+ };
+-//# sourceMappingURL=events.d.ts.map
+
++//# sourceMappingURL=events.d.ts.map
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/permission-system/events.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/permission-system/events.js
+@@ -10,8 +10,8 @@ export function createEventEmitter(pi) {
+         emitAsked: (request) => {
+             pi.events.emit("permission_asked", request);
+         },
+-        emitReplied: (requestID, sessionID, reply) => {
+-            pi.events.emit("permission_replied", { requestID, sessionID, reply });
++        emitReplied: (requestID, sessionID, reply, evidence = {}) => {
++            pi.events.emit("permission_replied", { requestID, sessionID, reply, ...evidence });
+         },
+     };
+ }
+@@ -35,8 +35,8 @@ export function createLocalEventEmitter() {
+                 }
+             }
+         },
+-        emitReplied: (requestID, sessionID, reply) => {
+-            const event = { requestID, sessionID, reply };
++        emitReplied: (requestID, sessionID, reply, evidence = {}) => {
++            const event = { requestID, sessionID, reply, ...evidence };
+             for (const handler of repliedHandlers) {
+                 try {
+                     handler(event);
+@@ -60,4 +60,4 @@ export function createLocalEventEmitter() {
+         },
+     };
+ }
+-//# sourceMappingURL=events.js.map
+
++//# sourceMappingURL=events.js.map
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/permission-system/index.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/permission-system/index.js
+@@ -1,3 +1,4 @@
++import { randomUUID } from "node:crypto";
+ import { SettingsManager } from "../../../settings-manager.js";
+ import { extractPatchedPaths } from "../gpt-apply-patch/index.js";
+ import { decideAuto } from "./auto-policy.js";
+@@ -258,6 +259,7 @@ export default function permissionSystemExtension(pi) {
+             const request = {
+                 id: nextRequestID(),
+                 sessionID,
++                correlationId: randomUUID(),
+                 permission: permissionRequest.permission,
+                 patterns: permissionRequest.patterns,
+                 always: permissionRequest.always,
+@@ -345,4 +347,4 @@ export default function permissionSystemExtension(pi) {
+         }
+     });
+ }
+-//# sourceMappingURL=index.js.map
+
++//# sourceMappingURL=index.js.map
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/permission-system/internal-tools.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/permission-system/internal-tools.js
+@@ -2,9 +2,6 @@
+ export const INTERNAL_PERMISSION_TOOLS = new Set([
+     "todo",
+     "tool_search",
+-    "ask_user",
+-    "request_user_input",
+-    "ask_user_question",
+     "memory",
+     "monitor",
+     "create_goal",
+@@ -14,4 +11,4 @@ export const INTERNAL_PERMISSION_TOOLS = new Set([
+     "bash_resize",
+     "kill_bash",
+ ]);
+-//# sourceMappingURL=internal-tools.js.map
+
++//# sourceMappingURL=internal-tools.js.map
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/permission-system/prompt.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/permission-system/prompt.js
+@@ -14,17 +14,25 @@ export async function showPermissionPrompt(ctx, request, signal) {
+         : {};
+     if (signal !== undefined)
+         call.signal = signal;
+-    const choice = await ctx.ui.select(displayTitle, options, call);
++    const choice = await ctx.ui.select(displayTitle, options, {
++        ...call,
++        nativePermission: {
++            sessionID: request.sessionID,
++            requestID: request.id,
++            correlationId: request.correlationId,
++        },
++    });
+     if (choice === "Deny with feedback") {
+-        const feedback = await ctx.ui.input("Feedback", "Why are you denying this permission? (optional)", call);
++        const feedback = await ctx.ui.input("Feedback", "Why are you denying this permission? (optional)", { ...call, required: false });
+         return {
+             requestID: request.id,
+             reply: "reject",
+             message: feedback || undefined,
++            choice,
+         };
+     }
+     if (wider !== undefined && choice === wider.label) {
+-        return { requestID: request.id, reply: "always", always: [...wider.patterns] };
++        return { requestID: request.id, reply: "always", always: [...wider.patterns], choice };
+     }
+     const replyMap = {
+         "Allow once": "once",
+@@ -34,6 +42,7 @@ export async function showPermissionPrompt(ctx, request, signal) {
+     return {
+         requestID: request.id,
+         reply: choice ? replyMap[choice] : "reject",
++        choice,
+     };
+ }
+ function formatRequestForDisplay(request) {
+@@ -80,4 +89,4 @@ function formatRequestForDisplay(request) {
+     }
+     return parts.join("\n");
+ }
+-//# sourceMappingURL=prompt.js.map
+
++//# sourceMappingURL=prompt.js.map
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/permission-system/service.js
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/permission-system/service.js
+@@ -165,7 +165,10 @@ export class PermissionService {
+             throw new DeniedError(deniedPatterns);
+         }
+         if (!needsAsk) {
+-            this.emitter.emitReplied(info.id, info.sessionID, "allow");
++            this.emitter.emitReplied(info.id, info.sessionID, "allow", {
++                correlationId: info.correlationId,
++                source: "policy",
++            });
+             return;
+         }
+         const pendingPromise = new Promise((resolve, reject) => {
+@@ -196,7 +199,11 @@ export class PermissionService {
+         }
+         this.pending.delete(input.requestID);
+         this.pendingOptions.delete(input.requestID);
+-        this.emitter.emitReplied(existing.info.id, existing.info.sessionID, input.reply);
++        this.emitter.emitReplied(existing.info.id, existing.info.sessionID, input.reply, {
++            correlationId: existing.info.correlationId,
++            source: input.choice === undefined ? "system" : "user",
++            ...(input.choice === undefined ? {} : { choice: input.choice }),
++        });
+         if (input.reply === "reject") {
+             existing.reject(input.message ? new CorrectedError(input.message) : new RejectedError());
+             this.rejectPendingInSession(existing.info.sessionID);
+@@ -247,7 +254,10 @@ export class PermissionService {
+             }
+             this.pending.delete(requestID);
+             this.pendingOptions.delete(requestID);
+-            this.emitter.emitReplied(entry.info.id, entry.info.sessionID, "reject");
++            this.emitter.emitReplied(entry.info.id, entry.info.sessionID, "reject", {
++                correlationId: entry.info.correlationId,
++                source: "cascade",
++            });
+             entry.reject(new RejectedError());
+         }
+     }
+@@ -263,9 +273,12 @@ export class PermissionService {
+             }
+             this.pending.delete(requestID);
+             this.pendingOptions.delete(requestID);
+-            this.emitter.emitReplied(entry.info.id, entry.info.sessionID, "always");
++            this.emitter.emitReplied(entry.info.id, entry.info.sessionID, "always", {
++                correlationId: entry.info.correlationId,
++                source: "cascade",
++            });
+             entry.resolve();
+         }
+     }
+ }
+-//# sourceMappingURL=service.js.map
+
++//# sourceMappingURL=service.js.map
+--- a/@code-yeongyu/senpi/dist/core/extensions/builtin/permission-system/types.d.ts
++++ b/@code-yeongyu/senpi/dist/core/extensions/builtin/permission-system/types.d.ts
+@@ -19,6 +19,7 @@ export type PermissionDecision = Reply | "allow";
+ export type Request = {
+     id: string;
+     sessionID: string;
++    correlationId?: string;
+     permission: string;
+     patterns: string[];
+     always: string[];
+@@ -42,6 +43,8 @@ export type ReplyInput = {
+     message?: string;
+     /** With reply "always": the patterns to approve instead of the request's own (a wider scope). */
+     always?: string[];
++    /** Actual UI choice, absent for system/cancellation paths. Metadata only. */
++    choice?: string;
+ };
+ /** Error thrown when user rejects a permission request */
+ export declare class RejectedError extends Error {
+@@ -68,4 +71,4 @@ export type PendingEntry = {
+     resolve: () => void;
+     reject: (err: RejectedError | CorrectedError) => void;
+ };
+-//# sourceMappingURL=types.d.ts.map
+
++//# sourceMappingURL=types.d.ts.map
+--- a/@code-yeongyu/senpi/dist/modes/rpc/client-input-handler.js
++++ b/@code-yeongyu/senpi/dist/modes/rpc/client-input-handler.js
+@@ -8,6 +8,7 @@ import { RPC_ERROR_UNKNOWN_COMMAND } from "./rpc-types.js";
+ /** The same admission path serves classic stdio, shared sessions, and worker sessions. */
+ export async function handleClientInput(session, command, io) {
+     try {
++        command = { ...command, ...clientMessageIdentity(command) };
+         const admissions = ClientAdmissions.forSession(session);
+         let disposition;
+         let responded = false;
+@@ -128,4 +129,4 @@ export async function handleClientInput(session, command, io) {
+         });
+     }
+ }
+-//# sourceMappingURL=client-input-handler.js.map
+
++//# sourceMappingURL=client-input-handler.js.map
+--- a/@code-yeongyu/senpi/dist/modes/rpc/connection-handler.js
++++ b/@code-yeongyu/senpi/dist/modes/rpc/connection-handler.js
+@@ -322,7 +322,8 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
+                 resolve(defaultValue);
+             };
+             opts?.signal?.addEventListener("abort", onAbort, { once: true });
+-            if (opts?.timeout) {
++            // zgw: a required question degraded to dialogs has an infinite timeout; setTimeout(Infinity) fires at once.
++            if (opts?.timeout && Number.isFinite(opts.timeout)) {
+                 timeoutId = setTimeout(() => {
+                     cleanup();
+                     resolve(defaultValue);
+@@ -356,12 +357,27 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
+      * Create an extension UI context that uses the RPC protocol.
+      */
+     const createExtensionUIContext = () => ({
+-        question: (request, opts) => clientCapabilities?.includes(QUESTION_CAPABILITY)
++        // zgw (bug 151): a binding made without a connection (a handoff reopen) asks the session's live connections.
++        question: (request, opts) => clientCapabilities?.includes(QUESTION_CAPABILITY) || options.clientInfo?.sessionHasCapability?.(QUESTION_CAPABILITY)
+             ? questions.ask(request, opts)
+             : degradeQuestion(createExtensionUIContext(), request, opts),
+-        select: (title, options, opts) => createDialogPromise(opts, undefined, { method: "select", title, options, timeout: opts?.timeout, ...dialogCall(opts) }, (r) => ("cancelled" in r && r.cancelled ? undefined : "value" in r ? r.value : undefined)),
++        select: (title, options, opts) => createDialogPromise(opts, undefined, {
++            method: "select",
++            title,
++            options,
++            timeout: opts?.timeout,
++            ...dialogCall(opts),
++            nativePermission: opts?.nativePermission ?? null,
++        }, (r) => ("cancelled" in r && r.cancelled ? undefined : "value" in r ? r.value : undefined)),
+         confirm: (title, message, opts) => createDialogPromise(opts, false, { method: "confirm", title, message, timeout: opts?.timeout }, (r) => "cancelled" in r && r.cancelled ? false : "confirmed" in r ? r.confirmed : false),
+-        input: (title, placeholder, opts) => createDialogPromise(opts, undefined, { method: "input", title, placeholder, timeout: opts?.timeout, ...dialogCall(opts) }, (r) => ("cancelled" in r && r.cancelled ? undefined : "value" in r ? r.value : undefined)),
++        input: (title, placeholder, opts) => createDialogPromise(opts, undefined, {
++            method: "input",
++            title,
++            placeholder,
++            timeout: opts?.timeout,
++            ...dialogCall(opts),
++            required: opts?.required,
++        }, (r) => ("cancelled" in r && r.cancelled ? undefined : "value" in r ? r.value : undefined)),
+         notify(message, type) {
+             // Fire and forget - no response needed
+             output({
+@@ -956,6 +972,8 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
+                 await handleClientInput(session, command, { output, promptCalls });
+                 return undefined;
+             }
++            case "resume_queued_input":
++                return success(id, "resume_queued_input", session.resumeQueuedInput(command.clientInputId, command.queueEpoch));
+             case "abort":
+                 if (command.intent === "stop" && !hasRole(INTERACTIVE_USER_CAPABILITY))
+                     return error(id, "abort", "stop_requires_interactive_client: declare interactive_user with set_client_info first");
+@@ -1803,4 +1821,4 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
+         },
+     };
+ }
+-//# sourceMappingURL=connection-handler.js.map
+
++//# sourceMappingURL=connection-handler.js.map
+--- a/@code-yeongyu/senpi/dist/modes/rpc/connection-question-bridge.js
++++ b/@code-yeongyu/senpi/dist/modes/rpc/connection-question-bridge.js
+@@ -79,7 +79,9 @@ export class ConnectionQuestionBridge {
+             const arm = () => {
+                 clearTimeout(timer);
+                 frame.deadlineAtMs = Date.now() + timeout;
+-                timer = setTimeout(() => finish("timed_out"), timeout);
++                // zgw: a required question (infinite timeout) has no timer; setTimeout(Infinity) fires at once.
++                if (Number.isFinite(timeout))
++                    timer = setTimeout(() => finish("timed_out"), timeout);
+             };
+             this.pending.set(id, {
+                 frame,
+@@ -190,4 +192,4 @@ export async function degradeQuestion(ui, request, opts) {
+         unanswered,
+     };
+ }
+-//# sourceMappingURL=connection-question-bridge.js.map
+
++//# sourceMappingURL=connection-question-bridge.js.map
+--- a/@code-yeongyu/senpi/dist/modes/rpc/multi-session-host.js
++++ b/@code-yeongyu/senpi/dist/modes/rpc/multi-session-host.js
+@@ -27,7 +27,7 @@ import { attachJsonlLineReader, MAX_RPC_LINE_CHARACTERS } from "./jsonl.js";
+ import { hostGeneration, hostInstanceId, protocolIdentity } from "./protocol-identity.js";
+ import { rpcCommandShapeError } from "./rpc-input-validation.js";
+ import { computeRuntimeBuildId, RUNTIME_IDENTITY_HANDOVER_CAPABILITY } from "./runtime-build-id.js";
+-import { SessionCommandRouter } from "./session-command-router.js";
++import { markHostStopping, SessionCommandRouter } from "./session-command-router.js";
+ import { SessionEventWriter } from "./session-event-writer.js";
+ import { canonicalSessionPath } from "./session-path-key.js";
+ import { RpcSessionRegistry, RpcSessionRegistryError } from "./session-registry.js";
+@@ -556,9 +556,10 @@ function hostLog(message) {
+ function registerShutdownSignals(shutdown) {
+     for (const signal of process.platform === "win32" ? ["SIGTERM"] : ["SIGTERM", "SIGHUP"]) {
+         process.on(signal, () => {
++            markHostStopping();
+             killTrackedDetachedChildren();
+             void shutdown(signal === "SIGHUP" ? 129 : 143);
+         });
+     }
+ }
+-//# sourceMappingURL=multi-session-host.js.map
+
++//# sourceMappingURL=multi-session-host.js.map
+--- a/@code-yeongyu/senpi/dist/modes/rpc/rpc-input-validation.js
++++ b/@code-yeongyu/senpi/dist/modes/rpc/rpc-input-validation.js
+@@ -76,7 +76,17 @@ export function rpcCommandPayloadError(command) {
+     const value = command;
+     if ((value.type === "prompt" || value.type === "steer" || value.type === "follow_up") &&
+         !clientMessageIdentitySchema.safeParse(value).success) {
+-        return "clientMessageId and clientTurnId must be non-empty strings of at most 256 characters.";
++        return "clientInputId must be a non-empty string of at most 128 characters; clientMessageId and clientTurnId must be non-empty strings of at most 256 characters.";
++    }
++    if (value.type === "resume_queued_input" &&
++        (typeof value.clientInputId !== "string" ||
++            value.clientInputId.length === 0 ||
++            value.clientInputId.length > 128)) {
++        return "clientInputId must be a non-empty string of at most 128 characters.";
++    }
++    if (value.type === "resume_queued_input" &&
++        (typeof value.queueEpoch !== "string" || value.queueEpoch.length === 0 || value.queueEpoch.length > 128)) {
++        return "resume_queued_input requires a valid queueEpoch.";
+     }
+     if (value.type === "prompt" && value.toolBarrier !== undefined) {
+         const barrierError = toolBarrierSpecError(value.toolBarrier);
+@@ -281,4 +291,4 @@ export function rpcMessageLengthError(command) {
+     }
+     return `RPC ${input.type} message exceeds ${MAX_RPC_MESSAGE_CHARACTERS} characters.`;
+ }
+-//# sourceMappingURL=rpc-input-validation.js.map
+
++//# sourceMappingURL=rpc-input-validation.js.map
+--- a/@code-yeongyu/senpi/dist/modes/rpc/rpc-session-state.js
++++ b/@code-yeongyu/senpi/dist/modes/rpc/rpc-session-state.js
+@@ -33,6 +33,9 @@ export function buildRpcSessionState(session, lastAbortSource) {
+         pausedNoticeCount: session.pausedNoticeCount ?? 0,
+         holds: session.holds ?? [],
+         lifecycle: session.lifecycle,
++        clientInputIdentity: true,
++        atomicQueuedResume: true,
++        queueEpoch: session.queueEpoch,
+         pendingQuestions: sessionQuestionBridges.get(session)?.pendingQuestions(),
+         pendingDialogs: sessionDialogRequests.get(session)?.snapshot() ?? [],
+         model: session.model,
+@@ -87,4 +90,4 @@ export function buildRpcSessionState(session, lastAbortSource) {
+         scopedModels: session.scopedModels?.map((entry) => ({ ...entry })) ?? [],
+     };
+ }
+-//# sourceMappingURL=rpc-session-state.js.map
+
++//# sourceMappingURL=rpc-session-state.js.map
+--- a/@code-yeongyu/senpi/dist/modes/rpc/session-command-router.js
++++ b/@code-yeongyu/senpi/dist/modes/rpc/session-command-router.js
+@@ -4,6 +4,7 @@ import { RouterContext } from "./session-router-context.js";
+ import { beginDrain, sweepIdleSessions } from "./session-router-occupancy.js";
+ import { reopenParked } from "./session-router-open.js";
+ import { handle } from "./session-router-routing.js";
++export { markHostStopping } from "./session-router-close.js";
+ export class SessionCommandRouter {
+     constructor(...args) {
+         this.context = new RouterContext(...args);
+@@ -41,4 +42,4 @@ export class SessionCommandRouter {
+         this.context.hostMemoryView = view;
+     }
+ }
+-//# sourceMappingURL=session-command-router.js.map
+
++//# sourceMappingURL=session-command-router.js.map
+--- a/@code-yeongyu/senpi/dist/modes/rpc/session-router-close.js
++++ b/@code-yeongyu/senpi/dist/modes/rpc/session-router-close.js
+@@ -1,3 +1,8 @@
++import { interruptRequiredQuestionsForHostShutdown } from "../../core/extensions/builtin/ask-user/resume.js";
++let hostStopping = false;
++export function markHostStopping() {
++    hostStopping = true;
++}
+ import { clearHandoverParkedSession } from "./host-handover-parked.js";
+ import { RPC_ERROR_UNKNOWN_SESSION } from "./rpc-types.js";
+ import { forgetSessionOwnership, releaseOwnerAttachment } from "./session-router-attachments.js";
+@@ -91,6 +96,9 @@ export async function close(host, command) {
+  * second response or an escaped rejection.
+  */
+ export async function finalizeClose(host, sessionId, binding, terminal) {
++    const runtime = hostStopping ? host.registry.peek(sessionId)?.runtime : undefined;
++    if (runtime)
++        interruptRequiredQuestionsForHostShutdown(runtime.session.sessionManager);
+     const finalization = host.finalizations.get(sessionId) ?? createFinalization();
+     host.finalizations.set(sessionId, finalization);
+     try {
+@@ -178,4 +186,4 @@ export async function dispose(host) {
+     host.uninstallEffectSink?.();
+     host.uninstallEffectSink = undefined;
+ }
+-//# sourceMappingURL=session-router-close.js.map
+
++//# sourceMappingURL=session-router-close.js.map
+--- a/@code-yeongyu/senpi/dist/modes/rpc/session-router-open.js
++++ b/@code-yeongyu/senpi/dist/modes/rpc/session-router-open.js
+@@ -3,7 +3,24 @@ import { clearHandoverParkedSession } from "./host-handover-parked.js";
+ import { parkedOpenCommand } from "./host-handover-parked-open.js";
+ import { sessionHeldCheck } from "./session-held.js";
+ import { forgetSessionOwnership, releaseOwnedSession, releaseOwnerAttachment } from "./session-router-attachments.js";
+-import { close } from "./session-router-close.js";
++import { close, tryClaimClose } from "./session-router-close.js";
++export function sessionAdvertises(host, sessionId, capability) {
++        let attached = false;
++        for (const [connection, sessions] of host.sessionsByConnection) {
++            if (!sessions.has(sessionId) || host.releasedConnections.has(connection))
++                continue;
++            attached = true;
++            if (host.pendingCapabilities.get(connection)?.includes(capability))
++                return true;
++        }
++        if (attached)
++            return false;
++        for (const [connection, capabilities] of host.pendingCapabilities)
++            if (!host.releasedConnections.has(connection) && host.writer.hasRegisteredConnectionCapabilities(connection) && capabilities.includes(capability))
++                return true;
++        return false;
++    }
++
+ import { code, detail, error } from "./session-router-errors.js";
+ import { sweepDrain } from "./session-router-occupancy.js";
+ import { invalidSpawnedBy, validatedOpenProfile } from "./session-router-open-profile.js";
+@@ -68,6 +85,7 @@ export function reopenParked(host, entry) {
+         reply: false,
+         defaults: false,
+         contextOverlay: entry.contextOverlay,
++        releaseUnowned: true,
+     });
+ }
+ export async function open(host, command, owner, options) {
+@@ -137,6 +155,7 @@ export async function open(host, command, owner, options) {
+                         }
+                     },
+                     connectionId: () => host.writer.currentConnection(),
++                    sessionHasCapability: (capability) => sessionAdvertises(host, openedSession.sessionId, capability),
+                     relocationConnection: () => relocationConnection(host, openedSession.sessionId),
+                     deliverTo: (connection, deliver) => host.writer.withConnection(connection, deliver),
+                 },
+@@ -185,6 +204,8 @@ export async function open(host, command, owner, options) {
+             releaseOwnerAttachment(host, owner, openedSession.sessionId);
+             await releaseOwnedSession(host, openedSession.sessionId);
+         }
++        if (owner === undefined && options?.releaseUnowned === true && !host.draining && entry.retainOnDisconnect === true)
++            tryClaimClose(host, openedSession.sessionId, { drainAttachments: false, detach: true });
+         const replyState = entry.worker?.snapshot?.state ?? (entry.runtime ? buildRpcSessionState(entry.runtime.session) : undefined);
+         if (!replyState)
+             throw new Error("Session state was not created");
+@@ -227,4 +248,4 @@ export async function open(host, command, owner, options) {
+         return error(command.id, "open_session", code(cause), detail(cause));
+     }
+ }
+-//# sourceMappingURL=session-router-open.js.map
+
++//# sourceMappingURL=session-router-open.js.map
+--- a/@code-yeongyu/senpi/dist/modes/rpc/rpc-session-command-types.d.ts
++++ b/@code-yeongyu/senpi/dist/modes/rpc/rpc-session-command-types.d.ts
+@@ -16,6 +16,7 @@ export type RpcSessionCommand = {
+     sessionTitlePrompt?: string | false;
+     expandPromptTemplates?: boolean;
+     unknownCommandAsText?: boolean;
++    clientInputId?: string;
+     clientMessageId?: string;
+     clientTurnId?: string;
+     /** Arm the tool barrier for the turn this prompt starts (capability `tool_barrier`, senpi#3717). */
+@@ -77,6 +78,11 @@ export type RpcSessionCommand = {
+  * dispatched and makes a retry with the same id a replay; without it the abort behaves exactly as before.
+  */
+  | {
++    id?: string;
++    type: "resume_queued_input";
++    clientInputId: string;
++    queueEpoch: string;
++} | {
+     id?: string;
+     type: "abort";
+     effectId?: string;
+@@ -508,4 +514,4 @@ export type RpcWhenIdle = "queue" | "start";
+ export declare const STEER_WHEN_IDLE_CAPABILITY = "steer_when_idle";
+ /** Capability: `record_user_activity` reports composer draft activity (senpi#3859). */
+ export declare const USER_ACTIVITY_CAPABILITY = "user_activity";
+-//# sourceMappingURL=rpc-session-command-types.d.ts.map
+
++//# sourceMappingURL=rpc-session-command-types.d.ts.map
+--- a/@code-yeongyu/senpi/dist/modes/rpc/rpc-session-state-types.d.ts
++++ b/@code-yeongyu/senpi/dist/modes/rpc/rpc-session-state-types.d.ts
+@@ -71,6 +71,9 @@ export interface RpcSessionState {
+         sourceCounts: Record<string, number>;
+     }[];
+     lifecycle: import("../../core/session-lifecycle-types.ts").SessionLifecycle;
++    clientInputIdentity: boolean;
++    atomicQueuedResume: boolean;
++    queueEpoch: string;
+     model?: Model<any>;
+     /**
+      * Model switch held until the next compaction, or `null` when no switch is held.
+@@ -159,4 +162,4 @@ export interface RpcSessionState {
+     /** Live select, confirm, input and editor request frames, including across session replacements; [] when none. */
+     pendingDialogs?: RpcExtensionUIRequest[];
+ }
+-//# sourceMappingURL=rpc-session-state-types.d.ts.map
+
++//# sourceMappingURL=rpc-session-state-types.d.ts.map
+--- a/@code-yeongyu/senpi/dist/modes/rpc/rpc-mutation-response-types.d.ts
++++ b/@code-yeongyu/senpi/dist/modes/rpc/rpc-mutation-response-types.d.ts
+@@ -55,6 +55,14 @@ export type RpcMutationResponse = {
+         admission?: ClientMessageAdmission;
+         heldAsNotice?: boolean;
+     };
++} | {
++    id?: string;
++    type: "response";
++    command: "resume_queued_input";
++    success: true;
++    data: {
++        disposition: "stale_epoch" | "not_queued" | "busy" | "scheduled";
++    };
+ } | {
+     id?: string;
+     type: "response";
+@@ -391,4 +399,4 @@ export type RpcMutationResponse = {
+     errorCode?: string;
+     errorData?: unknown;
+ };
+-//# sourceMappingURL=rpc-mutation-response-types.d.ts.map
+
++//# sourceMappingURL=rpc-mutation-response-types.d.ts.map
+--- a/@code-yeongyu/senpi/dist/modes/rpc/rpc-question-types.d.ts
++++ b/@code-yeongyu/senpi/dist/modes/rpc/rpc-question-types.d.ts
+@@ -33,6 +33,7 @@ export type RpcExtensionUIRequest = {
+     type: "extension_ui_request";
+     id: string;
+     method: "select";
++    nativePermission?: { sessionID: string; requestID: string; correlationId: string } | null;
+     /** Permanent MCP env grant; only a grant_select presentation may answer. */
+     grantSelect?: boolean;
+     title: string;
+@@ -52,6 +53,7 @@ export type RpcExtensionUIRequest = {
+     type: "extension_ui_request";
+     id: string;
+     method: "input";
++    required?: boolean;
+     title: string;
+     placeholder?: string;
+     timeout?: number;
+@@ -155,4 +157,4 @@ export type RpcQuestionResolvedEvent = {
+     unanswered: string[];
+     deadlineAtMs?: number;
+ };
+-//# sourceMappingURL=rpc-question-types.d.ts.map
+
++//# sourceMappingURL=rpc-question-types.d.ts.map