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

package/dist/core/extensions/builtin/mcp/transport-sdk.js

@@ -1,14 +1,15 @@
-import { configureMcpElicitation, mcpClientCapabilities } from "./elicitation.js";
+import { modernCredentialSnapshot } from "./modern/http-fetch.js";
+import { createMcpRequestClient } from "./modern/client.js";
 import { ProjectStdioTransport } from "./project-stdio-transport.js";
-import { loadMcpSdkClient, loadMcpSdkStdioTransport, loadMcpSdkStreamableHttpTransport } from "./sdk.lazy.js";
+import { loadMcpSdkStdioTransport, loadMcpSdkStreamableHttpTransport } from "./sdk.lazy.js";
 import { safeOn } from "./wrap.js";
-export async function materializeMcpTransport(options) {
-    const client = await buildMcpClient(options.elicitationUiProvider, options.elicitationEnabled);
+export async function materializeMcpTransport(options, protocol = {}) {
+    const client = await createMcpRequestClient(protocol, options.elicitationUiProvider, () => modernCredentialSnapshot(options.spec.authProvider?.tokens()), options.elicitationEnabled);
     if (options.spec.kind === "stdio")
-        return materializeStdio(options.spec, options, client);
+        return materializeStdio(options.spec, options, client, protocol);
     return materializeHttp(options.spec, client);
 }
-async function materializeStdio(spec, options, client) {
+async function materializeStdio(spec, options, client, protocol) {
     const { getDefaultEnvironment, StdioClientTransport } = await loadMcpSdkStdioTransport();
     const create = (current) => new StdioClientTransport({
         args: current.args,
@@ -25,7 +26,7 @@ async function materializeStdio(spec, options, client) {
         ? new ProjectStdioTransport(spec.resolveBeforeStart, create)
         : create(spec);
     trackStdioStart(transport, options.onStart);
-    pipeStderr(transport, options.logger, options.sink);
+    pipeStderr(transport, options.logger, options.sink, protocol);
     dropNullNextCursor(transport);
     return {
         client,
@@ -48,15 +49,6 @@ async function materializeHttp(spec, client) {
         transport,
     };
 }
-async function buildMcpClient(elicitationUiProvider, elicitationEnabled = true) {
-    // Elicitation capability is declared EMPTY on purpose (form mode only;
-    // Spring-AI servers reject richer shapes) and the create-handler is wired
-    // before any connect so mid-call requests never race registration.
-    const { Client: McpClient } = await loadMcpSdkClient();
-    const client = new McpClient({ name: "senpi-mcp-client", version: "0.0.0" }, { capabilities: mcpClientCapabilities(elicitationEnabled) });
-    await configureMcpElicitation(client, elicitationUiProvider, undefined, elicitationEnabled);
-    return client;
-}
 // OMP pattern: hand stdio OAuth servers the current access token via env.
 function oauthAccessTokenEnv(authProvider) {
     const accessToken = authProvider?.tokens()?.access_token;
@@ -90,26 +82,65 @@ function trackStdioStart(transport, onStart) {
         onStart();
     };
 }
-function pipeStderr(transport, logger, sink) {
+function pipeStderr(transport, logger, sink, protocol) {
     let pending = "";
+    let undecided = "";
+    let stderrEnded = false;
     const stderr = transport.stderr;
     if (stderr === undefined || stderr === null)
         return;
-    safeOn(stderr, "data", "transport.stderr.data", (chunk) => {
-        if (!Buffer.isBuffer(chunk) && typeof chunk !== "string")
-            return;
-        pending += Buffer.isBuffer(chunk) ? chunk.toString("utf8") : chunk;
+    const logLine = (line) => {
+        // Arbitrary server text may echo private messages, schemas, or answers. Keep diagnostic
+        // events and allowlisted system error codes, never untrusted payload text under enforcement.
+        const code = protocol.privateForms
+            ? line.match(/\b(?:EACCES|ENOENT|EPIPE|ECONNREFUSED|ECONNRESET|ETIMEDOUT|ENOSPC|ENOMEM|EMFILE)\b/)?.[0]
+            : undefined;
+        logger.stderr(protocol.privateForms ? `[private MCP stderr redacted]${code ? ` ${code}` : ""}` : line);
+    };
+    const append = (text) => {
+        pending += text;
         const lines = pending.split(/\r?\n/);
         pending = lines.pop() ?? "";
-        for (const line of lines) {
+        for (const line of lines)
             if (line.length > 0)
-                logger.stderr(line);
+                logLine(line);
+    };
+    protocol.resolveStdioDiagnostics = (modern) => {
+        if (!modern || protocol.privateForms) {
+            append(undecided);
+            if (stderrEnded && pending.length > 0) {
+                logLine(pending);
+                pending = "";
+            }
+        }
+        undecided = "";
+        if (modern && !protocol.privateForms)
+            pending = "";
+    };
+    safeOn(stderr, "data", "transport.stderr.data", (chunk) => {
+        if (protocol.version !== undefined && !protocol.privateForms) {
+            pending = "";
+            undecided = "";
+            return;
+        }
+        if (!Buffer.isBuffer(chunk) && typeof chunk !== "string")
+            return;
+        const text = Buffer.isBuffer(chunk) ? chunk.toString("utf8") : chunk;
+        if (!protocol.legacy && !protocol.privateForms) {
+            // Only legacy-positive negotiation may release startup diagnostics.
+            undecided += text.slice(0, Math.max(0, 512 * 1024 - undecided.length));
+            return;
         }
+        append(text);
     }, sink);
     safeOn(stderr, "end", "transport.stderr.end", () => {
-        if (pending.length > 0)
-            logger.stderr(pending);
+        stderrEnded = true;
+        if ((protocol.privateForms || (protocol.legacy && protocol.version === undefined)) && pending.length > 0)
+            logLine(pending);
         pending = "";
+        // A crashed probe is classified after EOF; only that decision may release or discard its buffer.
+        if (protocol.legacy || protocol.version !== undefined)
+            undecided = "";
     }, sink);
 }
 async function closeClientAndTransport(transport, client) {

package/dist/core/extensions/builtin/mcp/wrap.d.ts

@@ -3,6 +3,13 @@ export type { Server } from "@modelcontextprotocol/sdk/server/index.js";
 export type { CallToolResult, ListToolsResult } from "@modelcontextprotocol/sdk/types.js";
 import type { EventEmitter } from "node:events";
 import type { EventBus } from "../../../event-bus.ts";
+export interface McpClock {
+    now(): number;
+    schedule(callback: () => void, ms: number): ReturnType<typeof setTimeout>;
+    cancel(timer: ReturnType<typeof setTimeout>): void;
+}
+/** The modern operation uses one injectable monotonic clock and scheduler. */
+export declare const mcpElapsedClock: McpClock;
 type MaybePromise<T> = T | Promise<T>;
 export interface McpErrorLogger {
     error(message: string, data?: unknown): void;

package/dist/core/extensions/builtin/mcp/wrap.js

@@ -1,4 +1,10 @@
 import { redactMcpLogText } from "./log.js";
+/** The modern operation uses one injectable monotonic clock and scheduler. */
+export const mcpElapsedClock = {
+    now: () => performance.now(),
+    schedule: setTimeout,
+    cancel: clearTimeout,
+};
 export function wrapAsync(scope, fn, sink) {
     return async (...args) => {
         try {

package/dist/core/extensions/runner.js

@@ -6,6 +6,7 @@ import { getAgentDir } from "../../config.js";
 import { theme } from "../../modes/interactive/theme/theme.js";
 import { stripAnsi } from "../../utils/ansi.js";
 import { createEventBus, EXTENSION_RPC_EVENT_CHANNEL } from "../event-bus.js";
+import { inheritMcpMrtrPresentation } from "../mcp-mrtr-presentations.js";
 import { bindQuestionInput } from "../question-input.js";
 import { DEFAULT_EXTENSION_EVENT_HANDLER_TIMEOUT_MS, DEFAULT_EXTENSION_EVENT_HANDLER_WARN_MS, DEFAULT_SESSION_SHUTDOWN_HANDLER_TIMEOUT_MS, DEFAULT_SESSION_SHUTDOWN_HANDLER_WARN_MS, DEFAULT_SESSION_SHUTDOWN_QUIT_BUDGET_MS, SettingsManager, } from "../settings-manager.js";
 import { goalFilePath } from "./builtin/goal/persistence.js";
@@ -589,7 +590,7 @@ export class ExtensionRunner {
     }
     wrapUIPromptContext(ui) {
         const questionFn = ui.question;
-        return {
+        return inheritMcpMrtrPresentation(ui, {
             ...ui,
             select: (title, options, opts) => this.withUIPrompt("select", title, () => ui.select(title, options, opts)),
             confirm: (title, message, opts) => this.withUIPrompt("confirm", title, () => ui.confirm(title, message, opts)),
@@ -601,7 +602,7 @@ export class ExtensionRunner {
                     question: (request, opts) => this.withUIPrompt("question", request.questions[0]?.header, () => questionFn(request, opts), request.requestId),
                 }
                 : {}),
-        };
+        });
     }
     withUIPrompt(kind, title, run, requestId = crypto.randomUUID()) {
         const outerPrompt = this.uiPromptDepth++ === 0;

package/dist/core/extensions/types.d.ts

@@ -59,6 +59,8 @@ export type CompactionReason = "manual" | "threshold" | "overflow" | "pre_prompt
 export type CompactionRejectionCause = "cancelled-by-extension" | "external-owner" | "would-overflow" | "circuit-breaker" | "per-turn-cap" | "stale-revision";
 /** Options for extension UI dialogs. */
 export interface ExtensionUIDialogOptions {
+    /** Private local dialog: emits no generic blocked event or pending marker. Not an RPC field. */
+    ephemeral?: boolean;
     /** AbortSignal to programmatically dismiss the dialog. */
     signal?: AbortSignal;
     /** Timeout in milliseconds. Dialog auto-dismisses with live countdown display. */

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

@@ -39,6 +39,7 @@ export declare class LifecycleLedger {
         readonly waits: LifecycleWaits;
         readonly holds: readonly LifecycleHold[];
         readonly failure?: SessionLifecycle["failure"];
+        readonly lastStop?: SessionLifecycle["lastStop"];
     }): void;
     checkpoint(): void;
     /** Publishes a revision or epoch that no record carries yet, once. */

package/dist/core/lifecycle-ledger.js

@@ -80,6 +80,9 @@ export class LifecycleLedger {
     startRun(origin) {
         this.lastTurnEnd = undefined;
         this.openEpoch(origin);
+        // The previous run's stop never describes this one (senpi#3864).
+        const { lastStop: _lastStop, ...current } = this.current;
+        this.current = current;
         this.runId = crypto.randomUUID();
         this.runActive = true;
         this.admissionWriteFailed = false;
@@ -134,7 +137,7 @@ export class LifecycleLedger {
         if (input.holds.length > 0 || input.state === "failed")
             this.request = undefined;
         const terminal = input.state === "done" || input.state === "failed";
-        const { completionId: _id, completion: _completion, failure: _failure, settleDecision: _decision, ...base } = this.current;
+        const { completionId: _id, completion: _completion, failure: _failure, settleDecision: _decision, lastStop: _lastStop, ...base } = this.current;
         const now = new Date().toISOString();
         const standingRequest = this.request?.epoch === base.epoch &&
             this.request.revision === base.humanInputRevision &&
@@ -163,6 +166,7 @@ export class LifecycleLedger {
                 }
                 : {}),
             ...(input.state === "failed" && input.failure ? { failure: input.failure } : {}),
+            ...(input.lastStop ? { lastStop: input.lastStop } : {}),
             ...(input.state === "done" && standingRequest
                 ? {
                     settleDecision: this.current.settleDecision ?? { decisionId: crypto.randomUUID() },
@@ -238,7 +242,8 @@ function equivalent(previous, next) {
         previous.selfSettleEligible === next.selfSettleEligible &&
         JSON.stringify(previous.waitingOn) === JSON.stringify(next.waitingOn) &&
         JSON.stringify(previous.holds) === JSON.stringify(next.holds) &&
-        JSON.stringify(previous.failure) === JSON.stringify(next.failure));
+        JSON.stringify(previous.failure) === JSON.stringify(next.failure) &&
+        JSON.stringify(previous.lastStop) === JSON.stringify(next.lastStop));
 }
 function wireSnapshot(record) {
     const { sessionId: _sessionId, interrupted: _interrupted, completedGoalId: _goal, completedRunId: _completedRun, lastTurnEnd: _lastTurnEnd, attentionSeq: _attentionSeq, synthetic: _synthetic, epochSealed: _sealed, settleRequest: _request, runId: _runId, runActive: _runActive, ...snapshot } = record;

package/dist/core/lifecycle-record.js

@@ -1,5 +1,6 @@
 import { readHumanWait } from "./lifecycle-attention.js";
 import { readLifecycleState } from "./lifecycle-children.js";
+import { readLastStop } from "./lifecycle-stop.js";
 import { isRecord } from "./work-custody-record.js";
 /** Restore the wire snapshot and its private high-water marks from owned JSONL. */
 export function readLifecycleRecord(value) {
@@ -33,6 +34,7 @@ export function readLifecycleRecord(value) {
     const completion = readCompletion(value.completion);
     const failure = readFailure(value.failure);
     const lastTurnEnd = readTurnEnd(value.lastTurnEnd);
+    const lastStop = readLastStop(value.lastStop, value.runId);
     return {
         sessionId: value.sessionId,
         state,
@@ -63,6 +65,7 @@ export function readLifecycleRecord(value) {
         ...(completion ? { completion } : {}),
         ...(failure ? { failure } : {}),
         ...(lastTurnEnd ? { lastTurnEnd } : {}),
+        ...(lastStop ? { lastStop } : {}),
         ...(isRecord(value.settleDecision) && typeof value.settleDecision.decisionId === "string"
             ? { settleDecision: { decisionId: value.settleDecision.decisionId } }
             : {}),

package/dist/core/lifecycle-runtime-facts.js

@@ -35,6 +35,9 @@ export function readLifecycleRuntimeFacts(session) {
         });
     }
     const holds = session.holds.flatMap((hold) => {
+        // The interruption gate is a human wait, not a user Stop. Preserve unattended and real Stop precedence.
+        if (hold.kind === "session_hold" && hold.key === "interrupted-run")
+            return [];
         switch (hold.kind) {
             case "unattended":
             case "session_hold":

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

@@ -5,6 +5,7 @@ import type { ExtensionRunner } from "./extensions/runner.ts";
 import type { AgentEndEvent } from "./extensions/types.ts";
 import { SessionLifecycleController } from "./session-lifecycle.ts";
 import type { SessionLifecycleEvent } from "./session-lifecycle-types.ts";
+import type { TurnDeadlineKind } from "./turn-deadline.ts";
 interface LifecycleBindingHost {
     append(type: string, data: unknown): string;
     emit(event: SessionLifecycleEvent): void;
@@ -20,6 +21,11 @@ export declare class LifecycleSessionBinding {
     private readonly unsubscribeAdmission;
     private readonly unsubscribeGoal;
     private lastEnd;
+    /** The run each emitted agent_end belonged to, read when it was emitted, not when its queue reaches it. */
+    private readonly boundEnds;
+    private lastEndRunId;
+    /** Captured once inside the bound end's own extension-processing window, never re-scanned by a later run. */
+    private lastEndGuard;
     private refreshGeneration;
     private restored;
     private nextRunOrigin;
@@ -32,9 +38,13 @@ export declare class LifecycleSessionBinding {
     prepareRun(): void;
     get isRestored(): boolean;
     startRun(): void;
+    deadlineStopped(kind: TurnDeadlineKind, atMs: number): void;
+    deadlineStopWriteFailed(): void;
+    bindTurnEnd(end: object): void;
     consume(message: AgentMessage): string | undefined;
     consumedEntry(message: AgentMessage): string | undefined;
-    turnEnded(event: AgentEndEvent): Promise<void>;
+    /** `event` is the extension agent_end, never the session-level stamp; `end` is the core event bound at emission. */
+    turnEnded(event: AgentEndEvent, end: object, guardStartLeafId?: string | null): Promise<void>;
     refreshFacts(changedGoal?: Goal | null): Promise<void>;
     idle(): Promise<void>;
     restore(): Promise<void>;

package/dist/core/lifecycle-session-binding.js

@@ -8,11 +8,14 @@ import { readLifecycleGoal } from "./lifecycle-goal.js";
 import { lifecycleHistory } from "./lifecycle-history.js";
 import { bindLifecycleHumanInput } from "./lifecycle-human-input.js";
 import { readLifecycleRuntimeFacts } from "./lifecycle-runtime-facts.js";
+import { goalGuardAfter } from "./lifecycle-stop.js";
 import { SessionLifecycleController } from "./session-lifecycle.js";
 import { isRecord } from "./work-custody-record.js";
 /** Attaches durable lifecycle to the real session event/admission boundaries. */
 export class LifecycleSessionBinding {
     constructor(session, host) {
+        /** The run each emitted agent_end belonged to, read when it was emitted, not when its queue reaches it. */
+        this.boundEnds = new WeakMap();
         this.refreshGeneration = 0;
         this.restored = false;
         /** After dispose() nothing the controller decides is written or emitted: the session file is no longer this session's. */
@@ -44,8 +47,12 @@ export class LifecycleSessionBinding {
         });
         // A crashed receiver may have durable custody but no transcript entry yet. Recovery owns that
         // delivery already; register it before session_start can let the gateway enqueue a second carrier.
-        const deliveryEntries = session.sessionManager.reduceHistory(lifecycleDeliveryEntries);
+        const deliveries = session.sessionManager.reduceHistory(lifecycleDeliveryEntries);
         for (const record of this.controller.obligations.active) {
+            // Discover consumed work before session_start can queue another automatic turn. The later
+            // recovery pass still writes interruption/tool records, but must not be the first to close admission.
+            if (record.ticketId && (record.state === "consumed" || deliveries.has(record.ticketId)))
+                this.controller.ledger.interrupted = true;
             if (record.state !== "queued" || !record.payload || !record.ticketId)
                 continue;
             const ticketId = record.ticketId;
@@ -53,7 +60,7 @@ export class LifecycleSessionBinding {
             const deliveryId = deliveryIdOf(message);
             if (deliveryId === undefined)
                 continue;
-            if (deliveryEntries.has(ticketId))
+            if (deliveries.has(ticketId))
                 session.externalAdmission.observePersisted(message);
             else
                 session.externalAdmission.restoreQueued(deliveryId, () => 
@@ -98,10 +105,20 @@ export class LifecycleSessionBinding {
     }
     startRun() {
         this.lastEnd = undefined;
+        this.lastEndGuard = undefined;
         const origin = this.nextRunOrigin;
         this.nextRunOrigin = undefined;
         this.controller.startRun(origin);
     }
+    deadlineStopped(kind, atMs) {
+        this.controller.deadlineStopped(kind, atMs);
+    }
+    deadlineStopWriteFailed() {
+        this.controller.deadlineStopWriteFailed();
+    }
+    bindTurnEnd(end) {
+        this.boundEnds.set(end, this.controller.ledger.runId);
+    }
     consume(message) {
         return this.write(() => consumeLifecycleDelivery(this.session, this.controller, message));
     }
@@ -111,8 +128,14 @@ export class LifecycleSessionBinding {
         const ticketId = messageTicket(message);
         return ticketId ? this.session.sessionManager.reduceHistory(lifecycleDeliveryEntries).get(ticketId) : undefined;
     }
-    async turnEnded(event) {
+    /** `event` is the extension agent_end, never the session-level stamp; `end` is the core event bound at emission. */
+    async turnEnded(event, end, guardStartLeafId) {
         this.lastEnd = event;
+        this.lastEndRunId = this.boundEnds.get(end);
+        this.lastEndGuard =
+            guardStartLeafId === undefined
+                ? undefined
+                : goalGuardAfter(this.session.sessionManager.getBranch(), guardStartLeafId);
         await this.refreshFacts();
     }
     async refreshFacts(changedGoal) {
@@ -162,7 +185,15 @@ export class LifecycleSessionBinding {
                 deadlineStop: input.deadlineStop || saved.deadlineStop,
                 providerRetryAtMs: input.providerRetryAtMs ?? saved.providerRetryAtMs,
             };
-        this.controller.goalFacts(goal, input);
+        // Stop facts belong to the run that just ended in this process; a restored end carries its recorded stop.
+        const stop = this.lastEnd
+            ? {
+                runId: this.lastEndRunId,
+                guard: this.lastEndGuard,
+                todo: collected?.todoOutcome,
+            }
+            : undefined;
+        this.controller.goalFacts(goal, input, stop);
     }
     async idle() {
         await this.refreshFacts();

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

@@ -0,0 +1,41 @@
+import type { TodoOwedOutcome } from "./extensions/builtin/goal/todo-owed-backstop.ts";
+import type { TurnEndLivenessInput } from "./extensions/builtin/goal/turn-end-liveness.ts";
+import type { LifecycleStop } from "./session-lifecycle-types.ts";
+import type { TurnDeadlineKind } from "./turn-deadline.ts";
+/** Stop facts the stopping run produced itself, read from that run's own end (senpi#3864). */
+export interface RunStopFacts {
+    /** The run the turn end belonged to when its agent_end was emitted. */
+    readonly runId?: string;
+    readonly guard?: {
+        readonly reason: string;
+        readonly at: number;
+    };
+    readonly todo?: TodoOwedOutcome;
+}
+/** A deadline captured when it fired, before its durable write, for the run it stopped. */
+export interface DeadlineStopCapture {
+    readonly runId: string;
+    readonly kind: TurnDeadlineKind;
+    readonly at: string;
+    readonly persisted?: false;
+}
+type StopDetail = Omit<LifecycleStop, "runId" | "epoch" | "at"> & {
+    readonly at?: string;
+};
+/**
+ * First match wins: the run's own deadline explains its system abort, a guard explains a refused continuation, then
+ * the classified abort, and `no_wake` only for a stall no hold or guard owns. Provider failures keep the failed path.
+ */
+export declare function stopDetail(input: TurnEndLivenessInput | undefined, facts: RunStopFacts | undefined, deadline: DeadlineStopCapture | undefined, stalled: boolean): StopDetail | undefined;
+export declare function sameStop(stop: LifecycleStop, detail: StopDetail): boolean;
+/** The latest guard appended within one bound end's extension-processing window, including legacy entries. */
+export declare function goalGuardAfter(branch: readonly {
+    readonly id: string;
+    readonly type: string;
+    readonly customType?: string;
+    readonly data?: unknown;
+}[], guardStartLeafId: string | null): RunStopFacts["guard"];
+/** Malformed optional detail is dropped; it never invalidates the record that carries it. */
+export declare function readLastStop(value: unknown, runId: unknown): LifecycleStop | undefined;
+export {};
+//# sourceMappingURL=lifecycle-stop.d.ts.map

package/dist/core/lifecycle-stop.js

@@ -0,0 +1,92 @@
+import { isRecord } from "./work-custody-record.js";
+const ABORT_SOURCES = {
+    "user-abort": "user",
+    "system-abort": "system",
+    "provider-abort": "provider",
+    "unknown-abort": null,
+};
+/**
+ * First match wins: the run's own deadline explains its system abort, a guard explains a refused continuation, then
+ * the classified abort, and `no_wake` only for a stall no hold or guard owns. Provider failures keep the failed path.
+ */
+export function stopDetail(input, facts, deadline, stalled) {
+    if (input?.endedBy === "provider-error" || input?.endedBy === "policy-rejection")
+        return undefined;
+    if (deadline)
+        return {
+            cause: "deadline",
+            deadline: deadline.kind,
+            at: deadline.at,
+            ...(deadline.persisted === false ? { persisted: false } : {}),
+        };
+    if (facts?.guard)
+        return { cause: "goal_guard", guard: facts.guard.reason, at: new Date(facts.guard.at).toISOString() };
+    if (facts?.todo === "capped" || facts?.todo === "cap")
+        return { cause: "todo_guard", todo: "cap" };
+    const abortSource = input ? ABORT_SOURCES[input.endedBy] : undefined;
+    if (abortSource !== undefined)
+        return { cause: "aborted", ...(abortSource === null ? {} : { abortSource }) };
+    if (stalled && !input?.deadlineStop && !input?.budgetSpent)
+        return { cause: "no_wake" };
+    return undefined;
+}
+export function sameStop(stop, detail) {
+    return (stop.cause === detail.cause &&
+        stop.deadline === detail.deadline &&
+        stop.guard === detail.guard &&
+        stop.todo === detail.todo &&
+        stop.abortSource === detail.abortSource &&
+        stop.persisted === detail.persisted);
+}
+/** The latest guard appended within one bound end's extension-processing window, including legacy entries. */
+export function goalGuardAfter(branch, guardStartLeafId) {
+    const start = guardStartLeafId === null ? -1 : branch.findIndex((entry) => entry.id === guardStartLeafId);
+    if (guardStartLeafId !== null && start < 0)
+        return undefined;
+    for (let index = branch.length - 1; index > start; index--) {
+        const entry = branch[index];
+        if (entry?.type !== "custom" || entry.customType !== "goal-continuation-stopped" || !isRecord(entry.data))
+            continue;
+        const { reason, at } = entry.data;
+        return typeof reason === "string" && typeof at === "number" ? { reason, at } : undefined;
+    }
+    return undefined;
+}
+/** Malformed optional detail is dropped; it never invalidates the record that carries it. */
+export function readLastStop(value, runId) {
+    if (!isRecord(value) ||
+        typeof value.runId !== "string" ||
+        value.runId !== runId ||
+        typeof value.at !== "string" ||
+        typeof value.epoch !== "number")
+        return undefined;
+    const base = { runId: value.runId, at: value.at, epoch: value.epoch };
+    switch (value.cause) {
+        case "deadline":
+            return value.deadline === "inactivity" || value.deadline === "max_runtime"
+                ? {
+                    ...base,
+                    cause: value.cause,
+                    deadline: value.deadline,
+                    ...(value.persisted === false ? { persisted: false } : {}),
+                }
+                : undefined;
+        case "goal_guard":
+            return { ...base, cause: value.cause, ...(typeof value.guard === "string" ? { guard: value.guard } : {}) };
+        case "todo_guard":
+            return { ...base, cause: value.cause, todo: "cap" };
+        case "aborted":
+            return {
+                ...base,
+                cause: value.cause,
+                ...(value.abortSource === "user" || value.abortSource === "system" || value.abortSource === "provider"
+                    ? { abortSource: value.abortSource }
+                    : {}),
+            };
+        case "no_wake":
+            return { ...base, cause: value.cause };
+        default:
+            return undefined;
+    }
+}
+//# sourceMappingURL=lifecycle-stop.js.map

package/dist/core/mcp-form-types.d.ts

@@ -0,0 +1,89 @@
+import type { MrtrInputResponse } from "./extensions/builtin/mcp/modern/elicitation.ts";
+import type { ValidatedMcpFormSchema } from "./extensions/builtin/mcp/modern/form-schema.ts";
+export interface McpFormScope {
+    readonly hostInstance: string;
+    readonly durableSessionId: string;
+    readonly bindingEpoch: string;
+    readonly attachmentId: string;
+    readonly attachmentEpoch: string;
+    readonly connectionId: string;
+    readonly connectionEpoch: string;
+    readonly presenterPrincipalId: string;
+    readonly presenterGeneration: string;
+    readonly presentationBindingId: string;
+    readonly presenterKind: "desktop" | "gateway" | "local_tui";
+    readonly purpose: "mcp_form";
+}
+export interface McpFormEnvelope {
+    readonly sessionId: string;
+    readonly bindingEpoch: string;
+    readonly attachmentEpoch: string;
+    readonly grantId: string;
+    readonly dialogId: string;
+    readonly dialogToken: string;
+    readonly formRevision: string;
+}
+export interface McpFormRequest extends McpFormEnvelope {
+    readonly type: "mcp_form_request";
+    readonly server: {
+        readonly label: string;
+        readonly source: "user" | "project" | "plugin";
+    };
+    readonly message: string;
+    readonly schema: ValidatedMcpFormSchema;
+    readonly deadlineAtMs: number;
+}
+export interface McpFormResolved {
+    readonly type: "mcp_form_resolved";
+    readonly sessionId: string;
+    readonly grantId: string;
+    readonly dialogId: string;
+    readonly reason: "answered" | "declined" | "cancelled" | "processing_failed" | "operation_aborted";
+}
+export type McpFormOutcome = ({
+    readonly kind: "result";
+    readonly result: MrtrInputResponse;
+} | {
+    readonly kind: "processing_failure" | "operation_aborted";
+}) & ({
+    readonly source: "presenter_action";
+    readonly humanAdmission: true;
+} | {
+    readonly source: "host_termination";
+    readonly humanAdmission: false;
+});
+export interface McpFormInput {
+    readonly operationId: string;
+    readonly inputId: string;
+    readonly round: number;
+    readonly server: McpFormRequest["server"];
+    readonly message: string;
+    readonly schema: ValidatedMcpFormSchema;
+    readonly operationSignal: AbortSignal;
+    /** Host reads a worker-owned atomic abort fence at the terminal latch, without an IPC round trip. */
+    readonly operationCurrent?: () => boolean;
+    readonly presentationSignal: AbortSignal;
+    /** Remaining UI budget, measured by the host's monotonic clock. */
+    readonly deadlineMs: number;
+}
+export interface McpFormPresentation {
+    readonly signal: AbortSignal;
+    readonly ready: () => boolean;
+    readonly present: (input: McpFormInput) => Promise<McpFormOutcome>;
+    /** Worker-backed presenters recheck host readiness before each network attempt. */
+    readonly synchronize?: () => Promise<void>;
+}
+export interface McpFormBinding {
+    readonly epoch: string;
+    readonly signal: AbortSignal;
+    readonly capture: () => McpFormPresentation | undefined;
+    readonly dispose: () => void;
+    readonly version?: () => string | undefined;
+    readonly subscribe?: (listener: () => void) => () => void;
+}
+export declare function bindMcpFormPresented(options: object, callback: (() => void) | undefined): void;
+export declare function markMcpFormPresented(options: object | undefined): void;
+/** An enforced binding is part of the host-issued presenter identity, not a UI capability declaration. */
+export declare function bindPrivateMcpForms(ui: object, binding: McpFormBinding): void;
+export declare function privateMcpForms(ui: object): McpFormBinding | undefined;
+//# sourceMappingURL=mcp-form-types.d.ts.map

package/dist/core/mcp-form-types.js

@@ -0,0 +1,23 @@
+import { getMcpMrtrPresentation, registerMcpMrtrPresentation } from "./mcp-mrtr-presentations.js";
+const presentedCallbacks = new WeakMap();
+export function bindMcpFormPresented(options, callback) {
+    if (callback)
+        presentedCallbacks.set(options, callback);
+    else
+        presentedCallbacks.delete(options);
+}
+export function markMcpFormPresented(options) {
+    if (!options)
+        return;
+    const callback = presentedCallbacks.get(options);
+    presentedCallbacks.delete(options);
+    callback?.();
+}
+/** An enforced binding is part of the host-issued presenter identity, not a UI capability declaration. */
+export function bindPrivateMcpForms(ui, binding) {
+    registerMcpMrtrPresentation(ui, binding.signal, undefined, binding);
+}
+export function privateMcpForms(ui) {
+    return getMcpMrtrPresentation(ui)?.privateForms;
+}
+//# sourceMappingURL=mcp-form-types.js.map

package/dist/core/mcp-mrtr-presentations.d.ts

@@ -0,0 +1,15 @@
+import type { ExtensionUIContext } from "./extensions/types.ts";
+import type { McpFormBinding } from "./mcp-form-types.ts";
+/** Local host references only. RPC capabilities and serialized UI objects cannot enter this registry. */
+export interface McpMrtrPresentation {
+    readonly ui: Pick<ExtensionUIContext, "select" | "input">;
+    readonly signal: AbortSignal;
+    readonly admit?: () => void;
+    readonly presented?: () => void;
+    readonly privateForms?: McpFormBinding;
+}
+export declare function registerMcpMrtrPresentation(ui: ExtensionUIContext, signal: AbortSignal, admit?: () => void, privateForms?: McpFormBinding): ExtensionUIContext;
+export declare function getMcpMrtrPresentation(ui: object): McpMrtrPresentation | undefined;
+/** Preserve host identity across runner wrapping; private dialogs still use the raw host UI. */
+export declare function inheritMcpMrtrPresentation(source: ExtensionUIContext, wrapper: ExtensionUIContext): ExtensionUIContext;
+//# sourceMappingURL=mcp-mrtr-presentations.d.ts.map