@code-yeongyu/senpi 2026.10.25-2 → 2026.10.25-4

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

@@ -1,6 +1,7 @@
 import { ConfigReferenceError } from "@earendil-works/pi-ai/utils/config-reference";
 import { getAgentDir } from "../../../../config.js";
 import { redactResolvedReferenceData } from "../../../config-reference-redaction.js";
+import { getMcpMrtrPresentation } from "../../../mcp-mrtr-presentations.js";
 import { getToolSearchService, getToolSearchServiceForExtension, resetToolSearchServiceForTests, ToolSearchService, } from "../tool-search/service.js";
 import { mcpCredentialIdentity } from "./auth/catalog-identity.js";
 import { resolveAuthMode } from "./auth/context.js";
@@ -13,6 +14,8 @@ import { HostMcpRegistry } from "./host-registry.js";
 import { refreshMcpInstructionsForSession } from "./instructions.js";
 import { createMcpLogger } from "./log.js";
 import { prepareProjectSkillServer } from "./project-skill-policy.js";
+import { createMcpRequestOrigin } from "./request-origin.js";
+import { McpMrtrError } from "./modern/errors.js";
 import { reconnectMcpNow } from "./reconnect.js";
 import { createMcpSessionConnection, disposeEntryConnection } from "./service-connection.js";
 import { getMcpServiceExposureStatus } from "./service-exposure.js";
@@ -181,8 +184,12 @@ export class McpService {
         };
         const previous = this.#bindings.get(pi);
         // A session-owned service serves exactly one session: a new attach takes over its binding.
-        if (!this.#servesManySessions)
+        previous?.lifetime.abort();
+        if (!this.#servesManySessions) {
+            for (const binding of this.#bindings.values())
+                binding.lifetime.abort();
             this.#bindings.clear();
+        }
         let fallbackToolSearch;
         let holdsProcessFallback = false;
         const sessionToolSearch = getToolSearchServiceForExtension(pi);
@@ -205,6 +212,8 @@ export class McpService {
             }
         }
         const binding = {
+            lifetime: new AbortController(),
+            presentation: owner.context.ui === undefined ? undefined : getMcpMrtrPresentation(owner.context.ui),
             pi,
             fallbackToolSearch,
             holdsProcessFallback,
@@ -224,8 +233,10 @@ export class McpService {
     #liveBindings() {
         for (const [pi, binding] of this.#bindings) {
             // A disposed session retires its own tool-search service; its binding goes with it.
-            if (getToolSearchServiceForExtension(binding.pi)?.isDisposed === true)
+            if (getToolSearchServiceForExtension(binding.pi)?.isDisposed === true) {
+                binding.lifetime.abort();
                 this.#bindings.delete(pi);
+            }
         }
         return [...this.#bindings.values()];
     }
@@ -240,6 +251,7 @@ export class McpService {
      */
     async releaseSession(pi, disposeReason) {
         const released = this.#bindings.get(pi);
+        released?.lifetime.abort();
         this.#bindings.delete(pi);
         if (disposeReason !== undefined)
             this.#releasedSessions.add(pi);
@@ -386,7 +398,7 @@ export class McpService {
                 ? await prepareProjectSkillServer(name, decl, {
                     context: binding.context,
                     options: binding.options,
-                    ui: () => this.getMcpElicitationUi(),
+                    ui: this.#elicitationProviderFor(binding),
                     notice: (identity, names) => {
                         // An untrusted project keeps the skill's references literal (senpi#2345); keep that fix in
                         // the one notice instead of a generic withheld line (senpi#3796).
@@ -527,6 +539,8 @@ export class McpService {
         this.#disposed = true;
         this.#disposeCount += 1;
         this.#lastDisposeReason = reason;
+        for (const binding of this.#bindings.values())
+            binding.lifetime.abort();
         this.#bindings.clear();
         this.#sessionContext = null;
         this.#config = null;
@@ -711,7 +725,7 @@ export class McpService {
                 session: options,
                 elicitationEnabled: declarer.context.mode !== "print" && declarer.context.mode !== "json",
                 cwd: declarer.context.cwd,
-                ui: () => this.getMcpElicitationUi(),
+                ui: this.#elicitationProviderFor(declarer),
                 artifacts: this.#outputArtifacts,
                 shouldReconnect: (current) => !this.#disposed &&
                     this.#entryForName(name) === current &&
@@ -813,6 +827,8 @@ export class McpService {
             onRegistered: (entry, identity) => binding.registeredIdentities.set(entry.key, identity),
             contextRequired: binding.context.mode !== undefined,
             sessionManager: binding.context.sessionManager,
+            requestOrigin: (entry) => this.#requestOrigin(binding, entry),
+            bindPresentation: (ui) => this.bindMcpMrtrPresentation(binding.pi, ui),
             // A new attach of this session replaces its binding (and with it its config); a peer's attach does not.
             isCurrent: (entry) => !this.#disposed &&
                 this.#bindings.get(binding.pi) === binding &&
@@ -955,9 +971,68 @@ export class McpService {
     setMcpElicitationUiProvider(provider) {
         this.#elicitationUiProvider = provider;
     }
+    bindMcpMrtrPresentation(pi, ui) {
+        const binding = this.#bindings.get(pi);
+        const presentation = getMcpMrtrPresentation(ui);
+        if (binding && presentation)
+            binding.presentation = presentation;
+    }
+    #requestOrigin(binding, entry) {
+        const source = binding.config.servers[entry.name]?.source;
+        return createMcpRequestOrigin({
+            binding,
+            connection: entry.connection,
+            signal: AbortSignal.any([binding.lifetime.signal, entry.connection.requestLifetimeSignal]),
+            presentation: binding.presentation,
+            privateFormsEnforced: binding.presentation?.privateForms !== undefined,
+            privateForm: binding.presentation?.privateForms?.capture(),
+            serverLabel: entry.name,
+            serverSource: source === "project" || source === "claude"
+                ? "project"
+                : source === "skill" || source === "extension"
+                    ? "plugin"
+                    : "user",
+            isCurrent: () => !this.#disposed &&
+                !binding.lifetime.signal.aborted &&
+                this.#bindings.get(binding.pi) === binding &&
+                [...this.#connections.values()].includes(entry) &&
+                declares(binding.config, entry.name, entry.configHash) &&
+                entry.isCurrent?.() !== false &&
+                entry.credentialsCurrent?.() !== false,
+            resolveAuthority: async (signal) => {
+                if (await entry.generationChanged?.())
+                    throw new McpMrtrError("MCP_MRTR_CONTEXT_CHANGED");
+                // Same observed-revocation boundary as ordinary MCP requests. Never prompts for a new grant.
+                return await entry.connection.projectPolicy?.resolve(signal, false);
+            },
+        });
+    }
     getMcpElicitationUi() {
         return this.#elicitationUiProvider?.();
     }
+    #elicitationProviderFor(owner) {
+        // Connections outlive their first declarer's extension context. Capture its host-owned
+        // references while it is live; readiness must never read a released session's ctx.ui.
+        const binding = [...this.#bindings.values()].find((candidate) => candidate === owner);
+        const ui = owner.context.ui;
+        const privateBinding = () => {
+            // Keep observing presentation replacements on the binding, not just its initial grant.
+            const presentation = binding
+                ? binding.presentation
+                : ui === undefined
+                    ? undefined
+                    : getMcpMrtrPresentation(ui);
+            return presentation?.privateForms;
+        };
+        return Object.assign(() => this.getMcpElicitationUi(), {
+            enforced: () => privateBinding() !== undefined,
+            subscribe: (listener) => privateBinding()?.subscribe?.(listener) ?? (() => { }),
+            eligible: () => {
+                const binding = privateBinding();
+                return binding === undefined || binding.capture()?.ready() === true;
+            },
+        });
+    }
     isMcpPromptCommandRegistered(name) {
         return this.#promptCommandNames.has(name);
     }

package/dist/core/extensions/builtin/mcp/shared-connection.js

@@ -9,6 +9,8 @@ import { safeInterval, safeTimer } from "./wrap.js";
 /** Owns one SDK handler set, reconnect loop, cache writer and aggregate lifetime. */
 export class SharedMcpConnection {
     #calls;
+    #readinessListeners;
+    #readinessSubscriptions;
     #options;
     #onDispose;
     #idleTimeoutMin;
@@ -22,6 +24,8 @@ export class SharedMcpConnection {
     constructor(options, onDispose) {
         this.leases = new Set();
         this.#calls = new Map();
+        this.#readinessListeners = new Set();
+        this.#readinessSubscriptions = new Map();
         this.#cacheGeneration = -1;
         this.#disposed = false;
         this.#inFlight = 0;
@@ -64,13 +68,30 @@ export class SharedMcpConnection {
                     },
                 },
             logger,
-            elicitationUiProvider: () => {
+            elicitationUiProvider: Object.assign(() => {
                 // SDK server requests carry no originating tool-call id.
                 const owners = [...this.#calls.keys()];
                 return owners.length === 1 && this.leases.has(owners[0])
                     ? owners[0].options.elicitationUiProvider?.()
                     : undefined;
-            },
+            }, {
+                enforced: () => [...this.leases].some((lease) => lease.options.elicitationUiProvider?.enforced?.()),
+                subscribe: (listener) => {
+                    this.#readinessListeners.add(listener);
+                    return () => {
+                        this.#readinessListeners.delete(listener);
+                    };
+                },
+                eligible: () => {
+                    const leases = [...this.leases];
+                    const eligible = (lease) => lease.options.elicitationEnabled !== false &&
+                        lease.options.elicitationUiProvider?.eligible?.() !== false;
+                    // Any ready owner permits negotiation; per-operation authority still selects the holder.
+                    if (leases.some((lease) => lease.options.elicitationUiProvider?.enforced?.()))
+                        return leases.some(eligible);
+                    return leases.length > 0 && leases.every(eligible);
+                },
+            }),
         });
         this.connection.onToolsChanged(() => {
             this.#catalog = undefined;
@@ -112,6 +133,14 @@ export class SharedMcpConnection {
         this.#clearIdle();
         const lease = new SharedMcpLease(this, options, owner, key);
         this.leases.add(lease);
+        const unsubscribe = options.elicitationUiProvider?.subscribe?.(() => {
+            for (const listener of this.#readinessListeners)
+                listener();
+        });
+        if (unsubscribe)
+            this.#readinessSubscriptions.set(lease, unsubscribe);
+        for (const listener of this.#readinessListeners)
+            listener();
         this.#idleTimeoutMin = Math.max(...[...this.leases].map((item) => item.options.config.idleTimeoutMin));
         this.#refreshKeepAlive();
         return lease;
@@ -154,6 +183,11 @@ export class SharedMcpConnection {
         // Capture the last attached policy before removing the final owner.
         this.#idleTimeoutMin = Math.max(...[...this.leases].map((item) => item.options.config.idleTimeoutMin));
         this.leases.delete(lease);
+        this.#readinessSubscriptions.get(lease)?.();
+        this.#readinessSubscriptions.delete(lease);
+        if (this.leases.size > 0)
+            for (const listener of this.#readinessListeners)
+                listener();
         this.#refreshKeepAlive();
         this.#armIdle();
     }

package/dist/core/extensions/builtin/mcp/shared-lease.d.ts

@@ -9,6 +9,7 @@ export declare class SharedMcpLease extends ServerConnection {
     readonly key: string;
     readonly options: ServerConnectionOptions;
     readonly shared: SharedMcpConnection;
+    get requestLifetimeSignal(): AbortSignal;
     constructor(shared: SharedMcpConnection, options: ServerConnectionOptions, owner: object, key: string);
     get state(): import("./connection-types.ts").ServerConnectionState;
     get generation(): number;

package/dist/core/extensions/builtin/mcp/shared-lease.js

@@ -1,5 +1,6 @@
 import { ServerConnection } from "./connection.js";
 import { ConnectError } from "./errors.js";
+import { registerMcpClientAlias } from "./request-origin.js";
 const requestMethods = new Set([
     "request",
     "listTools",
@@ -19,6 +20,10 @@ export class SharedMcpLease extends ServerConnection {
     #unsubscribeTools;
     #stateSubscriptions = new Set();
     #released = false;
+    #requestLifetime = new AbortController();
+    get requestLifetimeSignal() {
+        return this.#requestLifetime.signal;
+    }
     #localGeneration = 0;
     #client;
     #physicalClient;
@@ -63,6 +68,7 @@ export class SharedMcpLease extends ServerConnection {
                     return typeof value === "function" ? value.bind(target) : value;
                 },
             });
+            registerMcpClientAlias(this.#client, physical);
         }
         if (this.#client === undefined)
             throw new ConnectError("MCP client unavailable", { phase: "client" });
@@ -79,6 +85,8 @@ export class SharedMcpLease extends ServerConnection {
     }
     async bumpGeneration() {
         this.#assertAttached();
+        this.#requestLifetime.abort();
+        this.#requestLifetime = new AbortController();
         this.#localGeneration++;
         this.#refreshCatalog = true;
         // Re-list only this owner's catalog; never interrupt another owner's call.
@@ -128,6 +136,7 @@ export class SharedMcpLease extends ServerConnection {
         if (this.#released)
             return;
         this.#released = true;
+        this.#requestLifetime.abort();
         this.#unsubscribeTools();
         for (const off of this.#stateSubscriptions)
             off();

package/dist/core/extensions/builtin/mcp/transport-sdk.d.ts

@@ -11,8 +11,9 @@
 import type { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
 import type { McpOAuthProvider } from "./auth/oauth-provider.ts";
-import { type McpElicitationUiProvider } from "./elicitation.ts";
+import type { McpElicitationUiProvider } from "./elicitation.ts";
 import type { McpLogger } from "./log.ts";
+import type { ModernProtocolState } from "./modern/request.ts";
 import { type McpAsyncErrorSink } from "./wrap.ts";
 export type McpStdioTransportSpec = {
     readonly projectPolicy?: boolean;
@@ -48,5 +49,5 @@ export interface MaterializeMcpTransportOptions {
     /** Invoked once the stdio child has started, so the caller can capture its pid. */
     readonly onStart: () => void;
 }
-export declare function materializeMcpTransport(options: MaterializeMcpTransportOptions): Promise<McpMaterializedTransport>;
+export declare function materializeMcpTransport(options: MaterializeMcpTransportOptions, protocol?: ModernProtocolState): Promise<McpMaterializedTransport>;
 //# sourceMappingURL=transport-sdk.d.ts.map

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-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>;