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

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

@@ -0,0 +1,778 @@
+--- 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 { 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 @@
+ /** 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 @@
+     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 @@
+ }
+ 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 @@
+         if (terminal !== undefined)
+             return;
+         const delayMs = deadlineAtMs - options.now();
++        if (!Number.isFinite(delayMs))
++            return;
+         if (delayMs <= 0) {
+             fireTimeout();
+             return;
+@@ -131,4 +134,4 @@
+         },
+     };
+ }
+-//# 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 { 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 @@
+     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 @@
+         }
+         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 @@
+                 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 @@
+     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 @@
+         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 @@
+         });
+     }
+ }
+-//# 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 @@
+         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
+@@ -78,7 +78,8 @@
+     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,
+@@ -175,7 +176,7 @@
+         timeout: request.timeoutMs,
+         signal: controller.signal,
+         deliver: request.waitForAnswer ? "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 };
+@@ -268,7 +269,7 @@
+         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;
+@@ -327,4 +328,4 @@
+         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 @@
+     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 @@
+      * @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 @@
+      */
+     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 @@
+         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 @@
+                 }
+             }
+         },
+-        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 @@
+         },
+     };
+ }
+-//# 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 @@
+             const request = {
+                 id: nextRequestID(),
+                 sessionID,
++                correlationId: randomUUID(),
+                 permission: permissionRequest.permission,
+                 patterns: permissionRequest.patterns,
+                 always: permissionRequest.always,
+@@ -345,4 +347,4 @@
+         }
+     });
+ }
+-//# 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 @@
+     "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 @@
+         : {};
+     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 @@
+     return {
+         requestID: request.id,
+         reply: choice ? replyMap[choice] : "reject",
++        choice,
+     };
+ }
+ function formatRequestForDisplay(request) {
+@@ -80,4 +89,4 @@
+     }
+     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 @@
+             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 @@
+         }
+         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 @@
+             }
+             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 @@
+             }
+             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 Request = {
+     id: string;
+     sessionID: string;
++    correlationId?: string;
+     permission: string;
+     patterns: string[];
+     always: string[];
+@@ -42,6 +43,8 @@
+     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 @@
+     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 @@
+ /** 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;
+@@ -123,4 +124,4 @@
+         });
+     }
+ }
+-//# 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
+@@ -310,7 +310,8 @@
+                 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);
+@@ -331,12 +332,27 @@
+      * 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({
+@@ -870,6 +886,8 @@
+                 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");
+@@ -1673,4 +1691,4 @@
+         },
+     };
+ }
+-//# 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
+@@ -76,7 +76,9 @@
+             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,
+@@ -174,4 +176,4 @@
+         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
+@@ -26,7 +26,7 @@
+ 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";
+@@ -585,9 +585,10 @@
+ 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
+@@ -75,8 +75,18 @@
+     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 === "dequeue_message" || value.type === "edit_queued_message") &&
+         !(typeof value.queuedId === "string" && value.queuedId.length > 0 && value.queuedId.length <= 256)) {
+         return "queuedId must be a non-empty string of at most 256 characters; read it from get_state or queue_update.";
+@@ -269,4 +279,4 @@
+     }
+     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
+@@ -32,6 +32,9 @@
+         paused: session.paused ?? false,
+         pausedNoticeCount: session.pausedNoticeCount ?? 0,
+         holds: session.holds ?? [],
++        clientInputIdentity: true,
++        atomicQueuedResume: true,
++        queueEpoch: session.queueEpoch,
+         pendingQuestions: sessionQuestionBridges.get(session)?.pendingQuestions(),
+         pendingDialogs: sessionDialogRequests.get(session)?.snapshot() ?? [],
+         model: session.model,
+@@ -82,4 +85,4 @@
+         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/rpc-types.d.ts
++++ b/@code-yeongyu/senpi/dist/modes/rpc/rpc-types.d.ts
+@@ -44,6 +44,7 @@
+     sessionTitlePrompt?: string | false;
+     expandPromptTemplates?: boolean;
+     unknownCommandAsText?: boolean;
++    clientInputId?: string;
+     clientMessageId?: string;
+     clientTurnId?: string;
+ } | {
+@@ -97,6 +98,11 @@
+  * 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;
+@@ -917,6 +923,9 @@
+         data?: unknown;
+         sourceCounts: Record<string, number>;
+     }[];
++    clientInputIdentity: boolean;
++    atomicQueuedResume: boolean;
++    queueEpoch: string;
+     model?: Model<any>;
+     /**
+      * Model switch held until the next compaction, or `null` when no switch is held.
+@@ -1215,6 +1224,14 @@
+ } | {
+     id?: string;
+     type: "response";
++    command: "resume_queued_input";
++    success: true;
++    data: {
++        disposition: "stale_epoch" | "not_queued" | "busy" | "scheduled";
++    };
++} | {
++    id?: string;
++    type: "response";
+     command: "follow_up";
+     success: true;
+     data?: ClientMessageIdentity & {
+@@ -1868,6 +1885,11 @@
+     type: "extension_ui_request";
+     id: string;
+     method: "select";
++    nativePermission?: {
++        sessionID: string;
++        requestID: string;
++        correlationId: string;
++    } | null;
+     title: string;
+     options: string[];
+     timeout?: number;
+@@ -1885,6 +1907,7 @@
+     type: "extension_ui_request";
+     id: string;
+     method: "input";
++    required?: boolean;
+     title: string;
+     placeholder?: string;
+     timeout?: number;
+@@ -2193,4 +2216,4 @@
+     to: string;
+     reason: string;
+ }
+-//# sourceMappingURL=rpc-types.d.ts.map
+
++//# sourceMappingURL=rpc-types.d.ts.map
+--- a/@code-yeongyu/senpi/dist/modes/rpc/session-command-router.js
++++ b/@code-yeongyu/senpi/dist/modes/rpc/session-command-router.js
+@@ -1,6 +1,7 @@
+ import { VERSION } from "../../config.js";
+ import { subscriptionLimits } from "../../core/subscription-limits/limit-store.js";
+ import { detachConnection } from "./connection-detach.js";
++import { interruptRequiredQuestionsForHostShutdown } from "../../core/extensions/builtin/ask-user/resume.js";
+ import { buildRpcSessionState } from "./connection-handler.js";
+ import { CONNECTION_ROLE_FIXED, ConnectionRoles, roleConnection } from "./connection-roles.js";
+ import { answerEffectFromTranscript } from "./effect-commands.js";
+@@ -26,6 +27,12 @@
+ import { selectSweepEvictions } from "./session-sweep.js";
+ import { unloadSession } from "./session-unload.js";
+ import { liveToolMediaScope, toolMediaPersister } from "./tool-media-store.js";
++// zgw bug 69: set once the host received its stop signal (SIGTERM/SIGHUP); a close after that is the host stopping,
++// not the user or the agent.
++let hostStopping = false;
++export function markHostStopping() {
++    hostStopping = true;
++}
+ /** How often a draining host re-checks whether the work it is waiting for has settled. */
+ const DRAIN_SWEEP_MS = 50;
+ function error(id, command, code, data) {
+@@ -666,6 +673,27 @@
+             if (opens.size === 0)
+                 this.opensByConnection.delete(owner);
+         });
++    }
++    /**
++     * zgw (bug 151): whether the session's clients advertised a capability, read when it is needed. A binding keeps the
++     * capabilities of the connection that opened it, and a handoff reopen has none. Attached live connections decide;
++     * with none attached, any live connection that advertised it does, since a question frame is replayed on attach.
++     */
++    sessionAdvertises(sessionId, capability) {
++        let attached = false;
++        for (const [connection, sessions] of this.sessionsByConnection) {
++            if (!sessions.has(sessionId) || this.releasedConnections.has(connection))
++                continue;
++            attached = true;
++            if (this.pendingCapabilities.get(connection)?.includes(capability))
++                return true;
++        }
++        if (attached)
++            return false;
++        for (const [connection, capabilities] of this.pendingCapabilities)
++            if (!this.releasedConnections.has(connection) && this.writer.hasRegisteredConnectionCapabilities(connection) && capabilities.includes(capability))
++                return true;
++        return false;
+     }
+     /**
+      * The successor's reopen of a handoff-parked session: the same open as an `open_session`, with no
+@@ -677,8 +705,19 @@
+             reply: false,
+             defaults: false,
+             contextOverlay: entry.contextOverlay,
++            releaseUnowned: true,
+         });
+     }
++    /**
++     * zgw (rotation after a handoff): the registry counts one attachment for every open, and an owner-less reopen has no
++     * connection that could ever release it, so a later close by the real owner left the session open. Release it as a
++     * detach: a retained entry stays open at zero attachments, exactly as when its last client leaves.
++     */
++    releaseUnownedReopen(sessionId) {
++        if (this.draining || this.registry.peek(sessionId)?.retainOnDisconnect !== true)
++            return false;
++        return this.tryClaimClose(sessionId, { drainAttachments: false, detach: true }) !== undefined;
++    }
+     async open(command, owner, options) {
+         // A parked session's reopen replays what its park recorded; a field it left empty stays empty
+         // rather than taking THIS host's default (senpi#3376 review).
+@@ -796,6 +835,7 @@
+                             }
+                         },
+                         connectionId: () => this.writer.currentConnection(),
++                        sessionHasCapability: (capability) => this.sessionAdvertises(openedSession.sessionId, capability),
+                     },
+                 }));
+                 if (entry.worker)
+@@ -842,6 +882,8 @@
+                 this.releaseOwnerAttachment(owner, openedSession.sessionId);
+                 await this.releaseOwnedSession(openedSession.sessionId);
+             }
++            if (owner === undefined && options?.releaseUnowned === true)
++                this.releaseUnownedReopen(openedSession.sessionId);
+             const replyState = entry.worker?.snapshot?.state ?? (entry.runtime ? buildRpcSessionState(entry.runtime.session) : undefined);
+             if (!replyState)
+                 throw new Error("Session state was not created");
+@@ -1107,6 +1149,10 @@
+      * second response or an escaped rejection.
+      */
+     async finalizeClose(sessionId, binding, terminal) {
++        // zgw bug 69: before the binding drops its UI requests, keep live required questions resumable.
++        const runtime = hostStopping ? this.registry.peek(sessionId)?.runtime : undefined;
++        if (runtime)
++            interruptRequiredQuestionsForHostShutdown(runtime.session.sessionManager);
+         const finalization = this.finalizations.get(sessionId) ?? this.createFinalization();
+         this.finalizations.set(sessionId, finalization);
+         try {
+@@ -1159,4 +1205,4 @@
+             : `${RPC_ERROR_OPEN_FAILED}: ${cause.message}`;
+     }
+ }
+-//# sourceMappingURL=session-command-router.js.map
+
++//# sourceMappingURL=session-command-router.js.map