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

package/dist/core/mcp-mrtr-presentations.js

@@ -0,0 +1,17 @@
+const presentations = new WeakMap();
+export function registerMcpMrtrPresentation(ui, signal, admit, privateForms) {
+    presentations.set(ui, { ui, signal, admit, privateForms });
+    return ui;
+}
+export function getMcpMrtrPresentation(ui) {
+    const presentation = presentations.get(ui);
+    return presentation?.signal.aborted ? undefined : presentation;
+}
+/** Preserve host identity across runner wrapping; private dialogs still use the raw host UI. */
+export function inheritMcpMrtrPresentation(source, wrapper) {
+    const presentation = getMcpMrtrPresentation(source);
+    if (presentation)
+        presentations.set(wrapper, presentation);
+    return wrapper;
+}
+//# sourceMappingURL=mcp-mrtr-presentations.js.map

package/dist/core/run-resume-turn.d.ts

@@ -2,6 +2,7 @@ import type { ImageContent } from "@earendil-works/pi-ai";
 import type { CustomMessage } from "./messages.ts";
 type Message = Pick<CustomMessage, "customType" | "content" | "display" | "details">;
 export interface RunResumePorts {
+    readonly resumeCause?: "stop" | "interrupted";
     readonly heldInputs: () => readonly {
         readonly inputId: string;
         readonly text: string;

package/dist/core/run-resume-turn.js

@@ -1,4 +1,4 @@
-import { STOP_RESUME_CUSTOM_TYPE, stopResumeDirective } from "./stop-resume-directive.js";
+import { stopResumeDirective } from "./stop-resume-directive.js";
 function partsOf(content) {
     return typeof content === "string" ? [{ type: "text", text: content }] : [...content];
 }
@@ -13,17 +13,18 @@ export async function startRunResumeTurn(ports) {
     const inputs = ports.heldInputs();
     const continues = ports.continueInputs();
     const wakes = ports.heldWakes();
+    const directive = stopResumeDirective(ports.resumeCause);
     const content = [
         ...inputs.flatMap((input) => [
             { type: "text", text: `The user wrote while the run was paused:\n${input.text}` },
             ...(input.images ?? []),
         ]),
         ...wakes.flatMap((wake) => partsOf(wake.message.content)),
-        ...partsOf(stopResumeDirective().content),
+        ...partsOf(directive.content),
     ];
     const sendSettled = Promise.withResolvers();
     const started = ports.turnStarted(sendSettled.promise);
-    const sending = ports.send({ customType: STOP_RESUME_CUSTOM_TYPE, content, display: inputs.length > 0 });
+    const sending = ports.send({ ...directive, content, display: inputs.length > 0 });
     sending.then(sendSettled.resolve, sendSettled.resolve);
     const turnId = await started;
     const delivered = (async () => {

package/dist/core/session-lifecycle-types.d.ts

@@ -22,6 +22,20 @@ export interface LifecycleHold {
     readonly kind: "session_hold" | "run_fence" | "inherited_hold" | "unattended";
     readonly since: string;
 }
+/** Why the last run stopped, for that run only (`runId`); cleared when the next lifecycle run starts. */
+export interface LifecycleStop {
+    readonly cause: "deadline" | "goal_guard" | "todo_guard" | "aborted" | "no_wake";
+    readonly runId: string;
+    readonly at: string;
+    readonly epoch: number;
+    readonly deadline?: "inactivity" | "max_runtime";
+    /** The goal guard reason exactly as `goal-continuation-stopped` recorded it. */
+    readonly guard?: string;
+    readonly todo?: "cap";
+    readonly abortSource?: "user" | "system" | "provider";
+    /** Present only when the deadline-stop entry write failed; distinct from the snapshot-level `persisted`. */
+    readonly persisted?: false;
+}
 export interface SpawnedBy {
     readonly parentSessionId: string;
     readonly rootSessionId: string;
@@ -48,6 +62,7 @@ export interface SessionLifecycle {
     readonly taskId?: string;
     readonly waitingOn?: LifecycleWaits;
     readonly holds?: readonly LifecycleHold[];
+    readonly lastStop?: LifecycleStop;
     readonly completion?: {
         readonly kind: "goal" | "run" | "agent" | "reply";
         readonly at: string;

package/dist/core/session-lifecycle.d.ts

@@ -2,8 +2,10 @@ import { type TurnEndLivenessInput } from "./extensions/builtin/goal/turn-end-li
 import type { Goal } from "./extensions/builtin/goal/types.ts";
 import { LifecycleChildren } from "./lifecycle-children.ts";
 import { LifecycleLedger, type LifecyclePersistence } from "./lifecycle-ledger.ts";
+import { type RunStopFacts } from "./lifecycle-stop.ts";
 import type { SessionActivitySnapshot } from "./session-activity.ts";
 import type { ChildLifecycleReport, HumanWait, LifecycleHold, SessionLifecycle } from "./session-lifecycle-types.ts";
+import type { TurnDeadlineKind } from "./turn-deadline.ts";
 import type { WorkCustodyRecord } from "./work-custody-record.ts";
 import { SessionWorkObligations } from "./work-obligations.ts";
 export interface LifecycleRuntimeFacts {
@@ -33,6 +35,10 @@ export declare class SessionLifecycleController {
     private ownTask;
     private evaluating;
     private deferred;
+    private stopFacts;
+    private deadlineStop;
+    /** A run that ended before this process keeps exactly the stop its record carries; none is derived for it. */
+    private readonly restoredRunId;
     constructor(options: SessionLifecycleOptions);
     get snapshot(): SessionLifecycle;
     get lastTurnInput(): TurnEndLivenessInput | undefined;
@@ -45,12 +51,22 @@ export declare class SessionLifecycleController {
     admissionSettled(): void;
     startRun(origin?: "human" | "automatic"): void;
     idle(): void;
-    goalFacts(goal: Goal | null, input?: TurnEndLivenessInput): void;
+    /** The turn deadline fired: captured before its durable write, for the run it stopped only. */
+    deadlineStopped(kind: TurnDeadlineKind, atMs: number): void;
+    /** The deadline-stop entry was refused; the captured stop says so, and the snapshot's `persisted` is untouched. */
+    deadlineStopWriteFailed(): void;
+    goalFacts(goal: Goal | null, input?: TurnEndLivenessInput, stop?: RunStopFacts): void;
     goalChanged(goal: Goal | null): void;
     reportChild(report: ChildLifecycleReport): void;
     requestSelfSettle(): import("./session-lifecycle-types.ts").SelfSettleResult;
     markRunCompleted(runId: string): void;
     recompute(): void;
     private evaluate;
+    /**
+     * Derived only from the current run's own end, bound when its agent_end was emitted: an end processed after a
+     * later run started sets nothing, and so does a fact refresh that carries no bound turn end, even when the goal
+     * collector still returns the previous run's end. An unchanged stop keeps its first `at`.
+     */
+    private lastStop;
 }
 //# sourceMappingURL=session-lifecycle.d.ts.map

package/dist/core/session-lifecycle.js

@@ -1,6 +1,7 @@
 import { effectiveWakes } from "./extensions/builtin/goal/turn-end-liveness.js";
 import { LifecycleChildren } from "./lifecycle-children.js";
 import { LifecycleLedger } from "./lifecycle-ledger.js";
+import { sameStop, stopDetail } from "./lifecycle-stop.js";
 import { lifecycleState, lifecycleTerminal } from "./session-lifecycle-reducer.js";
 import { SessionWorkObligations } from "./work-obligations.js";
 /** One event-driven reducer per session, shared by every client surface. */
@@ -21,6 +22,7 @@ export class SessionLifecycleController {
                 options.append(record);
             },
         });
+        this.restoredRunId = this.ledger.runId;
         if (this.ledger.lastTurnEnd)
             this.liveness = {
                 ...this.ledger.lastTurnEnd,
@@ -94,6 +96,8 @@ export class SessionLifecycleController {
         this.runAdmitted = false;
         this.idleBoundaryPassed = false;
         this.liveness = undefined;
+        this.stopFacts = undefined;
+        this.deadlineStop = undefined;
         const interruptedRun = this.ledger.interrupted ? this.ledger.runId : undefined;
         this.ledger.interrupted = false;
         this.ledger.startRun(origin ?? (this.pendingHuman ? "human" : "automatic"));
@@ -115,8 +119,20 @@ export class SessionLifecycleController {
         if (seq > 0 && this.ledger.snapshot.seq === seq)
             this.ledger.checkpoint();
     }
-    goalFacts(goal, input) {
+    /** The turn deadline fired: captured before its durable write, for the run it stopped only. */
+    deadlineStopped(kind, atMs) {
+        const runId = this.ledger.runId;
+        if (this.ledger.runActive && runId)
+            this.deadlineStop = { runId, kind, at: new Date(atMs).toISOString() };
+    }
+    /** The deadline-stop entry was refused; the captured stop says so, and the snapshot's `persisted` is untouched. */
+    deadlineStopWriteFailed() {
+        if (this.deadlineStop)
+            this.deadlineStop = { ...this.deadlineStop, persisted: false };
+    }
+    goalFacts(goal, input, stop) {
         this.liveness = input;
+        this.stopFacts = stop;
         if (input)
             this.ledger.lastTurnEnd = {
                 endedBy: input.endedBy,
@@ -282,6 +298,7 @@ export class SessionLifecycleController {
                 }
                 : undefined;
         const waits = { children, background, human };
+        const lastStop = this.lastStop(input, synthetic.some((wait) => wait.kind === "stalled"));
         const state = lifecycleState({
             role: this.ledger.snapshot.role,
             terminal: this.ownTask?.terminal,
@@ -296,7 +313,28 @@ export class SessionLifecycleController {
             this.ownTask?.terminal === undefined &&
             (!this.idleBoundaryPassed || active.length > 0))
             return;
-        this.ledger.update({ state, waits, holds: runtime.holds, failure });
+        this.ledger.update({ state, waits, holds: runtime.holds, failure, lastStop });
+    }
+    /**
+     * Derived only from the current run's own end, bound when its agent_end was emitted: an end processed after a
+     * later run started sets nothing, and so does a fact refresh that carries no bound turn end, even when the goal
+     * collector still returns the previous run's end. An unchanged stop keeps its first `at`.
+     */
+    lastStop(input, stalled) {
+        const existing = this.ledger.snapshot.lastStop;
+        const runId = this.ledger.runId;
+        if (!runId || runId === this.restoredRunId)
+            return existing;
+        if (this.stopFacts?.runId !== runId)
+            return existing;
+        const deadline = input && this.deadlineStop?.runId === runId ? this.deadlineStop : undefined;
+        const detail = stopDetail(input, this.stopFacts, deadline, stalled);
+        if (!detail)
+            return existing;
+        if (existing && sameStop(existing, detail))
+            return existing;
+        const { at, ...cause } = detail;
+        return { ...cause, runId, epoch: this.ledger.snapshot.epoch, at: at ?? new Date().toISOString() };
     }
 }
 //# sourceMappingURL=session-lifecycle.js.map

package/dist/core/stop-resume-directive.d.ts

@@ -1,4 +1,4 @@
 import type { CustomMessage } from "./messages.ts";
 export declare const STOP_RESUME_CUSTOM_TYPE = "session-resumed";
-export declare function stopResumeDirective(): Pick<CustomMessage, "customType" | "content" | "display">;
+export declare function stopResumeDirective(cause?: "stop" | "interrupted"): Pick<CustomMessage, "customType" | "content" | "display" | "details">;
 //# sourceMappingURL=stop-resume-directive.d.ts.map

package/dist/core/stop-resume-directive.js

@@ -2,7 +2,16 @@ export const STOP_RESUME_CUSTOM_TYPE = "session-resumed";
 const DIRECTIVE = "<system-reminder>The user stopped the previous turn and has now resumed. Tool calls that the Stop interrupted show " +
     "an aborted result; they were not re-run and their side effects may be partial. Check their effects before repeating " +
     "any of them, then continue the work.</system-reminder>";
-export function stopResumeDirective() {
+export function stopResumeDirective(cause = "stop") {
+    if (cause === "interrupted")
+        return {
+            customType: STOP_RESUME_CUSTOM_TYPE,
+            content: "<system-reminder>The previous run was interrupted and has now resumed. Interrupted tool calls may have " +
+                "partial side effects and were not re-run. Check their effects before repeating any of them, then continue " +
+                "the work.</system-reminder>",
+            display: false,
+            details: { resumeCause: cause },
+        };
     return { customType: STOP_RESUME_CUSTOM_TYPE, content: DIRECTIVE, display: false };
 }
 //# sourceMappingURL=stop-resume-directive.js.map

package/dist/main.js

@@ -1067,7 +1067,8 @@ export async function main(args, options) {
     if (appMode === "rpc" && parsed.multiSession) {
         if (options?.extensionFactories?.length)
             throw new Error("Shared RPC workers require file-backed extensions; inline factories cannot cross isolates");
-        const runtimeConfiguration = { parsed, cwd, agentDir, appMode, toolRuntime };
+        const { presenterBootstrapFd, mcpPresenterEnforcement, ...sessionArgs } = parsed;
+        const runtimeConfiguration = { parsed: sessionArgs, cwd, agentDir, appMode, toolRuntime };
         // Socket hosts (the machine-wide daemon) run every session IN this process:
         // createHostCore selects the worker registry only when a workerConfiguration
         // is passed, so withholding it is what selects the uncapped in-process registry.
@@ -1098,6 +1099,8 @@ export async function main(args, options) {
         }
         printTimings();
         await runMultiSessionHost({
+            presenterBootstrapFd,
+            mcpPresenterEnforcement,
             agentDir,
             createRuntime: createCliRuntimeFactory(runtimeConfiguration, {
                 ...(hostModelRuntime === undefined ? {} : { modelRuntime: hostModelRuntime }),
@@ -1292,6 +1295,7 @@ export async function main(args, options) {
         // mode seam: interactive startup still loads the same module before first use.
         const { InteractiveMode } = await import("./modes/interactive/interactive-mode.js");
         const interactiveMode = new InteractiveMode(runtime, {
+            mcpPresenterEnforcement: parsed.mcpPresenterEnforcement,
             migratedProviders,
             authNotices: interactiveAuthNotices(services.authStorage),
             legacyPiEditNotice: legacyPiEditStartupNotice(),

package/dist/modes/interactive/components/extension-selector.d.ts

@@ -21,6 +21,7 @@ export declare class ExtensionSelectorComponent extends Container {
     private countdown;
     private onToggleToolsExpanded;
     private maxVisibleOptions;
+    private answerSettled;
     constructor(title: string, options: string[], onSelect: (option: string) => void, onCancel: () => void, opts?: ExtensionSelectorOptions);
     private updateList;
     handleInput(keyData: string): void;

package/dist/modes/interactive/components/extension-selector.js

@@ -12,6 +12,7 @@ export class ExtensionSelectorComponent extends Container {
     constructor(title, options, onSelect, onCancel, opts) {
         super();
         this.selectedIndex = 0;
+        this.answerSettled = false;
         this.options = options;
         this.onSelectCallback = onSelect;
         this.onCancelCallback = onCancel;
@@ -67,6 +68,8 @@ export class ExtensionSelectorComponent extends Container {
         }
     }
     handleInput(keyData) {
+        if (this.answerSettled)
+            return;
         const kb = getKeybindings();
         if (kb.matches(keyData, "app.tools.expand")) {
             this.onToggleToolsExpanded?.();
@@ -89,6 +92,7 @@ export class ExtensionSelectorComponent extends Container {
         }
     }
     dispose() {
+        this.answerSettled = true;
         this.countdown?.dispose();
     }
 }

package/dist/modes/interactive/interactive-mode.d.ts

@@ -56,6 +56,8 @@ interface InteractiveUserInput {
  * Options for InteractiveMode initialization.
  */
 export interface InteractiveModeOptions {
+    /** Opt in to host-issued MCP form authority; ordinary terminal forms remain the default. */
+    mcpPresenterEnforcement?: boolean;
     /** Renderer mode for the interactive terminal. */
     uiMode?: TuiMode;
     /** Providers that were migrated to auth.json (shows warning) */
@@ -327,6 +329,8 @@ export declare class InteractiveMode {
      */
     private unsubscribeSecurityNotices?;
     private detachMcpGrantPresentation?;
+    private mcpMrtrPresentationLifetime;
+    private mcpLocalPresenter?;
     private bindCurrentSessionExtensions;
     private applyFullscreenScrollbarSetting;
     private applyRuntimeSettings;

package/dist/modes/interactive/interactive-mode.js

@@ -35,6 +35,9 @@ import { configureHttpDispatcher, formatHttpIdleTimeoutMs } from "../../core/htt
 import { KeybindingsManager } from "../../core/keybindings.js";
 import { isManualContinueSubmission } from "../../core/manual-continue.js";
 import { attachMcpGrantPresentation } from "../../core/mcp-grant-presentations.js";
+import { registerMcpMrtrPresentation } from "../../core/mcp-mrtr-presentations.js";
+import { markMcpFormPresented } from "../../core/mcp-form-types.js";
+import { registerLocalMcpPresenter } from "./mcp-local-presenter.js";
 import { createCompactionSummaryMessage, createCustomMessage } from "../../core/messages.js";
 import { defaultModelPerProvider, findExactModelReferenceMatch, resolveModelScope, resolveModelScopeFromModels, resolveModelScopeWithDiagnostics, } from "../../core/model-resolver.js";
 import { CredentialSynchronizationError } from "../../core/model-runtime.js";
@@ -688,6 +691,7 @@ export class InteractiveMode {
         this.onRightClickPaste = () => {
             void this.handleRightClickPaste();
         };
+        this.mcpMrtrPresentationLifetime = new AbortController();
         /**
          * Gracefully shutdown the agent.
          * Stops the TUI before emitting shutdown events so extension UI cleanup cannot
@@ -2010,6 +2014,9 @@ export class InteractiveMode {
         }
     }
     async bindCurrentSessionExtensions() {
+        this.mcpMrtrPresentationLifetime?.abort();
+        this.mcpMrtrPresentationLifetime = new AbortController();
+        this.mcpLocalPresenter = undefined;
         await this.sessionControlHost?.disposeActive();
         this.session.setControlEndpointHost?.(this.sessionControlHost);
         const uiContext = this.createExtensionUIContext();
@@ -2117,6 +2124,7 @@ export class InteractiveMode {
                 this.showExtensionError(error);
             },
         });
+        this.setExtensionStatus(PAUSE_STATUS_KEY, pauseFooterText(this.session));
         setRegisteredThemes(this.session.resourceLoader.getThemes().themes);
         this.setupAutocompleteProvider();
         const extensionRunner = this.session.extensionRunner;
@@ -2317,7 +2325,12 @@ export class InteractiveMode {
             return false;
         };
     }
-    async withBlockedHostDialog(id, label, show) {
+    async withBlockedHostDialog(id, label, show, opts) {
+        if (opts?.ephemeral) {
+            if (opts.signal?.aborted)
+                return undefined;
+            return await show();
+        }
         this.session.emitExtensionEvent("herdr:blocked", { active: true, label, id });
         try {
             return await show();
@@ -2845,10 +2858,11 @@ export class InteractiveMode {
         };
     }
     createExtensionUIContext() {
-        return {
-            select: (title, options, opts) => this.withBlockedHostDialog(crypto.randomUUID(), title, () => this.showExtensionSelector(title, options, opts)),
-            confirm: (title, message, opts) => this.withBlockedHostDialog(crypto.randomUUID(), title, () => this.showExtensionConfirm(title, message, opts)),
-            input: (title, placeholder, opts) => this.withBlockedHostDialog(crypto.randomUUID(), title, () => this.showExtensionInput(title, placeholder, opts)),
+        this.mcpMrtrPresentationLifetime ??= new AbortController();
+        const context = {
+            select: (title, options, opts) => this.withBlockedHostDialog(crypto.randomUUID(), title, () => this.showExtensionSelector(title, options, opts), opts),
+            confirm: async (title, message, opts) => (await this.withBlockedHostDialog(crypto.randomUUID(), title, () => this.showExtensionConfirm(title, message, opts), opts)) ?? false,
+            input: (title, placeholder, opts) => this.withBlockedHostDialog(crypto.randomUUID(), title, () => this.showExtensionInput(title, placeholder, opts), opts),
             // Async answers are delivered by the ask-user extension, not here: the
             // widget only resolves the question, so the model sees exactly one
             // framed user message no matter which surface answered.
@@ -2905,6 +2919,11 @@ export class InteractiveMode {
             getToolsExpanded: () => this.toolOutputExpanded,
             setToolsExpanded: (expanded) => this.setToolsExpanded(expanded),
         };
+        const presenterSession = this.session;
+        const privateForms = this.options?.mcpPresenterEnforcement === true
+            ? (this.mcpLocalPresenter ??= registerLocalMcpPresenter(context, presenterSession.sessionId, this.mcpMrtrPresentationLifetime.signal, () => presenterSession.admitHumanAnswer()))
+            : undefined;
+        return registerMcpMrtrPresentation(context, this.mcpMrtrPresentationLifetime.signal, undefined, privateForms);
     }
     /**
      * Show a selector for extensions.
@@ -2921,7 +2940,8 @@ export class InteractiveMode {
             };
             opts?.signal?.addEventListener("abort", onAbort, { once: true });
             this.extensionSelector = new ExtensionSelectorComponent(title, options, (option) => {
-                this.session.admitHumanAnswer();
+                if (!opts?.ephemeral || !this.options?.mcpPresenterEnforcement)
+                    this.session.admitHumanAnswer();
                 opts?.signal?.removeEventListener("abort", onAbort);
                 this.hideExtensionSelector();
                 resolve(option);
@@ -2938,7 +2958,12 @@ export class InteractiveMode {
             this.editorContainer.clear();
             this.editorContainer.addChild(this.extensionSelector);
             this.ui.setFocus(this.extensionSelector);
-            this.ui.requestRender();
+            if (opts?.ephemeral && this.options?.mcpPresenterEnforcement) {
+                this.ui.renderNow();
+                markMcpFormPresented(opts);
+            }
+            else
+                this.ui.requestRender();
         });
     }
     /**
@@ -2978,7 +3003,8 @@ export class InteractiveMode {
             };
             opts?.signal?.addEventListener("abort", onAbort, { once: true });
             this.extensionInput = new ExtensionInputComponent(title, placeholder, (value) => {
-                this.session.admitHumanAnswer();
+                if (!opts?.ephemeral || !this.options?.mcpPresenterEnforcement)
+                    this.session.admitHumanAnswer();
                 opts?.signal?.removeEventListener("abort", onAbort);
                 this.hideExtensionInput();
                 resolve(value);
@@ -5504,6 +5530,7 @@ export class InteractiveMode {
         if (this.isShuttingDown)
             return;
         this.isShuttingDown = true;
+        this.mcpMrtrPresentationLifetime?.abort();
         // Keep signal handlers registered until terminal cleanup has completed.
         // `signal-exit` checks the listener list during the same SIGTERM/SIGHUP
         // dispatch and re-sends the signal if only its own listeners remain.

package/dist/modes/interactive/mcp-local-presenter.d.ts

@@ -0,0 +1,5 @@
+import type { ExtensionUIContext } from "../../core/extensions/types.ts";
+import type { McpFormBinding } from "../../core/mcp-form-types.ts";
+/** The terminal itself is the principal; an RPC attachment never receives this handle. */
+export declare function registerLocalMcpPresenter(ui: ExtensionUIContext, sessionId: string, lifetime: AbortSignal, admit: () => void): McpFormBinding;
+//# sourceMappingURL=mcp-local-presenter.d.ts.map

package/dist/modes/interactive/mcp-local-presenter.js

@@ -0,0 +1,109 @@
+import { collectMrtrForm } from "../../core/extensions/builtin/mcp/modern/elicitation.js";
+import { queuedForm } from "../../core/extensions/builtin/mcp/modern/consent-queue.js";
+import { McpPresenterAuthority } from "../rpc/mcp-presenter-authority.js";
+/** The terminal itself is the principal; an RPC attachment never receives this handle. */
+export function registerLocalMcpPresenter(ui, sessionId, lifetime, admit) {
+    const authority = new McpPresenterAuthority();
+    const binding = authority.bind(sessionId, sessionId, admit);
+    let activeInput;
+    const drafts = new Map();
+    const sender = authority.connect("local_tui", (frame) => {
+        if (frame.type !== "mcp_form_request") {
+            drafts.get(frame.dialogId)?.abort();
+            drafts.delete(frame.dialogId);
+            return true;
+        }
+        const active = activeInput;
+        if (!active)
+            return false;
+        const { input } = active;
+        const draft = new AbortController();
+        drafts.set(frame.dialogId, draft);
+        const signal = AbortSignal.any([input.operationSignal, input.presentationSignal, lifetime, draft.signal]);
+        const { sessionId, bindingEpoch, attachmentEpoch, grantId, dialogId, dialogToken, formRevision } = frame;
+        const envelope = { sessionId, bindingEpoch, attachmentEpoch, grantId, dialogId, dialogToken, formRevision };
+        void collectMrtrForm({
+            ui,
+            signal,
+            presented: () => authority.receive(sender, { ...envelope, type: "mcp_form_presented" }),
+        }, `${frame.server.label} (${frame.server.source})`, { message: frame.message, requestedSchema: frame.schema }, signal)
+            .then((result) => {
+            if (!signal.aborted)
+                authority.receive(sender, { ...envelope, type: "mcp_form_response", ...result });
+        }, () => active.fail())
+            .finally(() => drafts.delete(frame.dialogId));
+        return true;
+    });
+    authority.attach(sender, binding);
+    const owner = authority.enroll();
+    owner.acquire(owner.register(binding, sender, { kind: "local_tui" }));
+    const dispose = () => {
+        authority.dispose();
+        for (const draft of drafts.values())
+            draft.abort();
+        drafts.clear();
+    };
+    lifetime.addEventListener("abort", dispose, { once: true });
+    const privateForms = {
+        epoch: binding.epoch,
+        signal: binding.signal,
+        capture: () => {
+            const presentation = binding.capture();
+            if (!presentation)
+                return undefined;
+            return {
+                ...presentation,
+                present: async (input) => {
+                    const deadline = performance.now() + input.deadlineMs;
+                    const timeout = new AbortController();
+                    const timer = setTimeout(() => timeout.abort(), Math.max(0, input.deadlineMs));
+                    const signal = AbortSignal.any([
+                        input.operationSignal,
+                        input.presentationSignal,
+                        presentation.signal,
+                        lifetime,
+                        timeout.signal,
+                    ]);
+                    try {
+                        return await queuedForm(binding, signal, async () => {
+                            const failure = new AbortController();
+                            const current = {
+                                input: {
+                                    ...input,
+                                    presentationSignal: AbortSignal.any([signal, failure.signal]),
+                                    deadlineMs: Math.max(0, deadline - performance.now()),
+                                },
+                                fail: () => failure.abort(),
+                            };
+                            activeInput = current;
+                            try {
+                                return await presentation.present(current.input);
+                            }
+                            finally {
+                                if (activeInput === current)
+                                    activeInput = undefined;
+                            }
+                        });
+                    }
+                    catch {
+                        return {
+                            kind: input.operationSignal.aborted || binding.signal.aborted || input.operationCurrent?.() === false
+                                ? "operation_aborted"
+                                : "processing_failure",
+                            source: "host_termination",
+                            humanAdmission: false,
+                        };
+                    }
+                    finally {
+                        clearTimeout(timer);
+                    }
+                },
+            };
+        },
+        dispose,
+    };
+    if (lifetime.aborted)
+        dispose();
+    return privateForms;
+}
+//# sourceMappingURL=mcp-local-presenter.js.map

package/dist/modes/interactive/pause-footer.d.ts

@@ -3,6 +3,11 @@ interface PauseView {
     readonly paused: boolean;
     readonly pausedNoticeCount: number;
     readonly runPaused: boolean;
+    readonly pauseView?: {
+        readonly records: readonly {
+            readonly key: string;
+        }[];
+    };
 }
 export declare function pauseFooterText(view: PauseView): string | undefined;
 export declare function resumeCommandTarget(view: PauseView): "resume_session" | "session_picker";

package/dist/modes/interactive/pause-footer.js

@@ -3,6 +3,8 @@ export function pauseFooterText(view) {
     if (!view.paused && !view.runPaused)
         return undefined;
     const held = view.pausedNoticeCount === 1 ? "1 update held" : `${view.pausedNoticeCount} updates held`;
+    if (view.pauseView?.records.some((record) => record.key === "interrupted-run"))
+        return `Interrupted · ${view.pausedNoticeCount > 0 ? `${held} · ` : ""}type to continue, /resume to resume`;
     if (view.runPaused)
         return `Run paused · ${held} · type to continue, /resume to resume the run`;
     return `Paused · ${held} · type to continue, /resume to resume`;

package/dist/modes/rpc/connection-handler.d.ts

@@ -34,6 +34,7 @@ export interface RpcConnectionOptions {
         hasCapability?: (connectionId: string, capability: string) => boolean;
     };
     bindSecurityPresentation?: (session: AgentSessionRuntime["session"], ui: ExtensionUIContext) => (() => void) | undefined;
+    bindMcpForms?: (session: AgentSessionRuntime["session"], ui: ExtensionUIContext) => (() => void) | undefined | Promise<(() => void) | undefined>;
     /** A worker's internal bridge is gated by its host's actual socket capabilities. */
     workerSecurityBridge?: boolean;
     grantDialogSettled?: (id: string) => void;

package/dist/modes/rpc/connection-handler.js

@@ -599,6 +599,8 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
         subscribeExtensionEvents();
     };
     const rebindSession = async (deferRefresh = false) => {
+        unbindMcpForms?.();
+        unbindMcpForms = undefined;
         unsubscribeSecurityNotices?.();
         unsubscribeLoadedSurfaces?.();
         unsubscribeExtensionEvents?.();
@@ -673,8 +675,10 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
         // reconstruct the session it is bound to. Installing here also drops the
         // previous session's subscription immediately instead of after the bind.
         installSessionSubscriptions();
+        const extensionUi = createExtensionUIContext();
+        unbindMcpForms = await options.bindMcpForms?.(session, extensionUi);
         const refresh = refreshLoadedSurfacesAfter(() => session.bindExtensions({
-            uiContext: createExtensionUIContext(),
+            uiContext: extensionUi,
             mode: "rpc",
             commandContextActions: {
                 waitForIdle: () => session.agent.waitForIdle(),
@@ -1752,6 +1756,7 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
         ? subscriptionLimits.subscribe((limits) => eventOutput.enqueueEvent({ type: "subscription_limits", ...limits }))
         : () => { };
     const dispose = async (disposeOptions = {}) => {
+        unbindMcpForms?.();
         grantPresentationAbort.abort();
         detachGrantPresentation?.();
         unsubscribeSecurityNotices?.();
@@ -1777,6 +1782,7 @@ export function createRpcConnectionHandler(runtimeHost, sink, options = {}) {
     };
     // Perform the initial bind synchronously-scheduled so the handler is ready
     // as soon as the caller awaits `ready`.
+    let unbindMcpForms;
     const ready = rebindSession();
     return {
         ready,

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

@@ -14,5 +14,6 @@ export declare function multiSessionHostCapabilities(options: {
     readonly warm: boolean;
     readonly toolRuntime: ToolRuntimeKind;
     readonly negotiated: readonly string[];
+    readonly mcpPresenters?: boolean;
 }): string[];
 //# sourceMappingURL=host-capabilities.d.ts.map

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

@@ -20,6 +20,7 @@ export function multiSessionHostCapabilities(options) {
     return [
         ...new Set([
             "multi_session",
+            ...(options.mcpPresenters ? ["mcp_form_presenter_v1"] : []),
             "session_lifecycle",
             "expected_host_instance",
             "attach_session",
@@ -80,7 +81,7 @@ export function multiSessionHostCapabilities(options) {
             ...(options.warm ? [WARM_CAPABILITY] : []),
             ...toolRuntimeCapabilities(options.toolRuntime),
             // The host alone says where tool work runs; a negotiated copy would make two answers.
-            ...options.negotiated.filter((capability) => !isHostOwnedToolRuntimeCapability(capability)),
+            ...options.negotiated.filter((capability) => capability !== "mcp_form_presenter_v1" && !isHostOwnedToolRuntimeCapability(capability)),
         ]),
     ];
 }