@code-yeongyu/senpi 2026.10.18-1 → 2026.10.19

package/dist/core/extensions/handler-budget.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Host budget for extension event handlers (senpi#3650). Past `warnMs` the host reports a handler as stalled; at
+ * `timeoutMs`, or when the turn deadline releases the turn it belongs to, the host stops waiting on it and moves on
+ * (the handler keeps running detached). A value of 0 disables that limit.
+ */
+export interface ExtensionHandlerBudget {
+    readonly warnMs: number;
+    readonly timeoutMs: number;
+}
+export type ExtensionHandlerStallStage = "warn" | "timeout" | "released" | "late_failure";
+export interface ExtensionHandlerStall {
+    readonly extensionPath: string;
+    readonly event: string;
+    readonly stage: ExtensionHandlerStallStage;
+    readonly elapsedMs: number;
+    readonly timeoutMs: number;
+    readonly error?: string;
+}
+export type HandlerStopVerdict = "timed_out" | "released";
+export type BudgetedHandlerOutcome<T> = {
+    readonly kind: "settled";
+    readonly value: T;
+} | {
+    readonly kind: "failed";
+    readonly error: unknown;
+} | {
+    readonly kind: "timed_out";
+} | {
+    readonly kind: "released";
+};
+/** Waits on running handlers, tagged with the turn that owns them so a deadline releases only its own turn's waits. */
+export declare class HeldHandlerWaits {
+    private readonly releases;
+    hold(scope: number, release: () => void): () => void;
+    release(scope: number): number;
+}
+export interface HeldHandlerSlot {
+    readonly waits: HeldHandlerWaits;
+    readonly scope: () => number;
+}
+export interface BudgetedHandlerRun<T> {
+    readonly extensionPath: string;
+    readonly event: string;
+    readonly budget: ExtensionHandlerBudget;
+    readonly run: (signal: AbortSignal) => Promise<T> | T;
+    readonly onStall?: (stall: ExtensionHandlerStall) => void;
+    readonly now?: () => number;
+}
+/** One handler under the budget, with an abort signal it can observe (the `session_shutdown` path). */
+export declare function runBudgetedHandler<T>(options: BudgetedHandlerRun<T>): Promise<BudgetedHandlerOutcome<T>>;
+export type HandlerCallOutcome = {
+    readonly ok: true;
+    readonly value: unknown;
+} | {
+    readonly ok: false;
+    readonly error: unknown;
+};
+export interface BudgetedSequence<R> {
+    readonly event: string;
+    readonly length: number;
+    extensionPath(index: number): string;
+    /** Calls handler `index`; returns its result or promise, unwrapped by the sequence with a plain `await`. */
+    start(index: number): unknown;
+    /** Applies a handler's outcome; may return a promise only when it has async host work of its own. */
+    settle(index: number, outcome: HandlerCallOutcome): void | Promise<void>;
+    skip(index: number, verdict: HandlerStopVerdict, budget: ExtensionHandlerBudget): void;
+    /** Ends the walk early (for example a retired runner); the sequence then resolves with `finish()`. */
+    halted?(): boolean;
+    finish(): R;
+}
+export interface SequenceOptions {
+    readonly budget: ExtensionHandlerBudget;
+    readonly held?: HeldHandlerSlot;
+    readonly onStall?: (stall: ExtensionHandlerStall) => void;
+    readonly now?: () => number;
+}
+/**
+ * Walks an emission's handlers under the budget. A handler that settles in time is awaited exactly as a direct
+ * `await handler()` would be, so a timely emission keeps its microtask timing. A handler past its cap, or released
+ * by the turn deadline, is skipped: the walk resumes at the next handler in a new run that settles the emission,
+ * and the abandoned run stops when its handler ever returns. A failure after the host stopped waiting is reported.
+ */
+export declare function runBudgetedSequence<R>(sequence: BudgetedSequence<R>, options: SequenceOptions): Promise<R>;
+//# sourceMappingURL=handler-budget.d.ts.map

package/dist/core/extensions/handler-budget.js

@@ -0,0 +1,136 @@
+/** Waits on running handlers, tagged with the turn that owns them so a deadline releases only its own turn's waits. */
+export class HeldHandlerWaits {
+    constructor() {
+        this.releases = new Map();
+    }
+    hold(scope, release) {
+        this.releases.set(release, scope);
+        return () => this.releases.delete(release);
+    }
+    release(scope) {
+        const owned = [...this.releases].filter(([, owner]) => owner === scope).map(([release]) => release);
+        for (const release of owned) {
+            this.releases.delete(release);
+            release();
+        }
+        return owned.length;
+    }
+}
+const describeError = (error) => (error instanceof Error ? error.message : String(error));
+function watchHandler(options, stop, held) {
+    const { budget, extensionPath, event, now } = options;
+    const startedAt = now();
+    const stall = (stage) => options.onStall?.({ extensionPath, event, stage, elapsedMs: now() - startedAt, timeoutMs: budget.timeoutMs });
+    let stopped = false;
+    const end = (verdict) => {
+        if (stopped)
+            return;
+        stopped = true;
+        disarm();
+        stall(verdict === "timed_out" ? "timeout" : "released");
+        stop(verdict);
+    };
+    const warnTimer = budget.warnMs > 0 ? setTimeout(() => stall("warn"), budget.warnMs) : undefined;
+    const capTimer = budget.timeoutMs > 0 ? setTimeout(() => end("timed_out"), budget.timeoutMs) : undefined;
+    const unhold = held?.waits.hold(held.scope(), () => end("released"));
+    function disarm() {
+        clearTimeout(warnTimer);
+        clearTimeout(capTimer);
+        unhold?.();
+    }
+    return {
+        startedAt,
+        disarm: () => {
+            stopped = true;
+            disarm();
+        },
+    };
+}
+/** One handler under the budget, with an abort signal it can observe (the `session_shutdown` path). */
+export async function runBudgetedHandler(options) {
+    const controller = new AbortController();
+    // The handler outcome is captured before any race, so a late rejection after a timeout is already handled.
+    let started;
+    try {
+        started = Promise.resolve(options.run(controller.signal));
+    }
+    catch (error) {
+        started = Promise.reject(error);
+    }
+    const settled = started.then((value) => ({ kind: "settled", value }), (error) => ({ kind: "failed", error }));
+    if (options.budget.warnMs <= 0 && options.budget.timeoutMs <= 0)
+        return settled;
+    let watch;
+    const outcome = await new Promise((resolve) => {
+        watch = watchHandler({ ...options, now: options.now ?? Date.now }, (verdict) => {
+            controller.abort(new Error(`${options.event} handler ${verdict === "timed_out" ? "timed out" : "released"}`));
+            resolve({ kind: verdict });
+        });
+        void settled.then(resolve);
+    });
+    watch?.disarm();
+    return outcome;
+}
+/**
+ * Walks an emission's handlers under the budget. A handler that settles in time is awaited exactly as a direct
+ * `await handler()` would be, so a timely emission keeps its microtask timing. A handler past its cap, or released
+ * by the turn deadline, is skipped: the walk resumes at the next handler in a new run that settles the emission,
+ * and the abandoned run stops when its handler ever returns. A failure after the host stopped waiting is reported.
+ */
+export function runBudgetedSequence(sequence, options) {
+    const now = options.now ?? Date.now;
+    return new Promise((resolve, reject) => {
+        let generation = 0;
+        const run = async (from, owner) => {
+            for (let index = from; index < sequence.length; index += 1) {
+                if (owner !== generation)
+                    return;
+                if (sequence.halted?.())
+                    break;
+                const extensionPath = sequence.extensionPath(index);
+                const watchOptions = {
+                    extensionPath,
+                    event: sequence.event,
+                    budget: options.budget,
+                    onStall: options.onStall,
+                    now,
+                };
+                const watch = watchHandler(watchOptions, (verdict) => {
+                    if (owner !== generation)
+                        return;
+                    generation += 1;
+                    sequence.skip(index, verdict, options.budget);
+                    run(index + 1, generation).catch(reject);
+                }, options.held);
+                let outcome;
+                try {
+                    outcome = { ok: true, value: await sequence.start(index) };
+                }
+                catch (error) {
+                    outcome = { ok: false, error };
+                }
+                watch.disarm();
+                if (owner !== generation) {
+                    if (!outcome.ok) {
+                        options.onStall?.({
+                            extensionPath,
+                            event: sequence.event,
+                            stage: "late_failure",
+                            elapsedMs: now() - watch.startedAt,
+                            timeoutMs: options.budget.timeoutMs,
+                            error: describeError(outcome.error),
+                        });
+                    }
+                    return;
+                }
+                const settling = sequence.settle(index, outcome);
+                if (settling !== undefined)
+                    await settling;
+            }
+            if (owner === generation)
+                resolve(sequence.finish());
+        };
+        run(0, 0).catch(reject);
+    });
+}
+//# sourceMappingURL=handler-budget.js.map

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

@@ -13,6 +13,7 @@ import type { ModelRegistry } from "../model-registry.ts";
 import type { SessionManager } from "../session-manager.ts";
 import type { BuildSystemPromptOptions } from "../system-prompt.ts";
 import type { VirtualModelDefinition } from "../virtual-models.ts";
+import { type ExtensionHandlerBudget, type ExtensionHandlerStall } from "./handler-budget.ts";
 import type { AgentBeforeSettleEvent, BeforeAgentStartEvent, BeforeAgentStartEventResult, BeforeProviderHeadersEvent, BeforeProviderRequestEvent, BoundaryContextPreview, ContextEvent, ContextWithSystemEvent, EntryRenderer, EntryRendererOptions, Extension, ExtensionActions, ExtensionCommandContext, ExtensionCommandContextActions, ExtensionContext, ExtensionContextActions, ExtensionError, ExtensionEvent, ExtensionFlag, ExtensionMode, ExtensionRuntime, ExtensionShortcut, ExtensionToolContext, ExtensionUIContext, InputEvent, InputEventResult, InputSource, LoadExtensionsResult, MarkdownTransformer, MessageEndEvent, MessageRenderer, ModelSelectEvent, ModelSelectEventResult, ProjectTrustContext, ProjectTrustEvent, ProjectTrustEventResult, ProviderConfig, ProviderRequestPreparation, RegisteredMcpServerDeclaration, RegisteredTool, ReplacedSessionContext, ResolvedCommand, ResourcesDiscoverEvent, SessionBeforeCompactResult, SessionBeforeForkResult, SessionBeforeReloadResult, SessionBeforeSwitchResult, SessionBeforeTreeResult, SessionBoundaryDraft, SessionShutdownEvent, ToolCallEvent, ToolCallEventResult, ToolResultEvent, ToolResultEventResult, TurnEndEvent, UserBashEvent, UserBashEventResult } from "./types.ts";
 export declare class ExtensionRpcRequestNotFoundError extends Error {
     constructor(name: string);
@@ -122,6 +123,11 @@ export declare class ExtensionRunner {
     private modelRegistry;
     private eventBus;
     private errorListeners;
+    private eventHandlerBudget;
+    private handlerStallListener;
+    private handlerTurnScope;
+    private reportedInvalidHandlerBudget;
+    private readonly heldHandlerWaits;
     private getModel;
     private getServiceTier;
     private getEffectiveServiceTier;
@@ -226,6 +232,23 @@ export declare class ExtensionRunner {
     get isActive(): boolean;
     private assertActive;
     onError(listener: ExtensionErrorListener): () => void;
+    /**
+     * The host's budget for handlers of the queued lifecycle and boundary events, who hears their stalls, and the turn
+     * that owns a wait started now (the turn deadline releases only its own turn's waits).
+     */
+    setEventHandlerBudget(budget: () => ExtensionHandlerBudget, onStall: (stall: ExtensionHandlerStall) => void, turnScope?: () => number): void;
+    /** Stops waiting on the given turn's handlers that are still running (the turn deadline's release). */
+    releaseHeldHandlers(turn: number): number;
+    /**
+     * Resolved once per emission, before any handler starts. An invalid setting must never leave handlers unawaited,
+     * so it is reported once and the shipped defaults apply, as for `session_shutdown`.
+     */
+    private resolveEventHandlerBudget;
+    private walkHandlers;
+    private reportStoppedHandler;
+    private reportHandlerFailure;
+    /** Agent lifecycle events: every handler runs, serially, under the host budget (senpi#3650). */
+    private dispatchLifecycle;
     emitError(error: ExtensionError): void;
     hasHandlers(eventType: string): boolean;
     private getToolHookStatusMessage;

package/dist/core/extensions/runner.js

@@ -6,11 +6,12 @@ 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 { DEFAULT_SESSION_SHUTDOWN_HANDLER_TIMEOUT_MS, DEFAULT_SESSION_SHUTDOWN_HANDLER_WARN_MS, SettingsManager, } from "../settings-manager.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, SettingsManager, } from "../settings-manager.js";
 import { goalFilePath } from "./builtin/goal/persistence.js";
 import { goalStoreRef } from "./builtin/goal/store-ref.js";
 import { disableServerSearch } from "./builtin/server-search-fallback.js";
 import { dispatchContextMessages } from "./context-dispatch.js";
+import { HeldHandlerWaits, runBudgetedHandler, runBudgetedSequence, } from "./handler-budget.js";
 import { kernelToolsStorage } from "./kernel-tools-context.js";
 import { drainPendingProviderRegistrations } from "./loader.js";
 import { SessionStartTurnGate } from "./session-start-turn-gate.js";
@@ -101,6 +102,23 @@ function sanitizedToolHookStatusMessage(message) {
         .replace(/\s+/g, " ")
         .trim());
 }
+/**
+ * Agent lifecycle events the session awaits on its serial event queue before it persists a turn (senpi#3650).
+ * Their handlers observe; none may hold the queue indefinitely, so each runs under the host's event handler budget.
+ */
+const QUEUED_LIFECYCLE_EVENTS = new Set([
+    "agent_start",
+    "agent_end",
+    "agent_settled",
+    "turn_start",
+    "message_start",
+    "message_update",
+    "message_end",
+    "tool_execution_start",
+    "tool_execution_update",
+    "tool_execution_end",
+]);
+const UNBOUNDED_HANDLER_BUDGET = { warnMs: 0, timeoutMs: 0 };
 /**
  * Helper function to emit session_shutdown event to extensions.
  * Returns true if the event was emitted, false if there were no handlers.
@@ -118,6 +136,16 @@ export async function emitSessionShutdownEvent(extensionRunner, event) {
 function snapshotEventHandlers(extensions, event) {
     return extensions.map((ext) => ({ ext, handlers: ext.handlers.get(event)?.slice() ?? [] }));
 }
+/** The same snapshot as `snapshotEventHandlers`, in dispatch order, one entry per handler. */
+function flattenHandlers(extensions, event) {
+    return snapshotEventHandlers(extensions, event).flatMap(({ ext, handlers }) => handlers.map((handler) => ({ path: ext.path, handler })));
+}
+function entryAt(entries, index) {
+    const entry = entries[index];
+    if (entry === undefined)
+        throw new RangeError(`no extension handler at index ${index}`);
+    return entry;
+}
 export async function emitProjectTrustEvent(extensionsResult, event, ctx) {
     const errors = [];
     for (const { ext, handlers } of snapshotEventHandlers(extensionsResult.extensions, "project_trust")) {
@@ -203,6 +231,10 @@ export class ExtensionRunner {
     constructor(extensions, runtime, cwd, sessionManager, modelRegistry, eventBus = createEventBus()) {
         this.mode = "print";
         this.errorListeners = new Set();
+        this.eventHandlerBudget = () => UNBOUNDED_HANDLER_BUDGET;
+        this.handlerTurnScope = () => 0;
+        this.reportedInvalidHandlerBudget = false;
+        this.heldHandlerWaits = new HeldHandlerWaits();
         this.getModel = () => undefined;
         this.getServiceTier = () => undefined;
         this.getEffectiveServiceTier = () => this.getServiceTier();
@@ -676,6 +708,78 @@ export class ExtensionRunner {
         this.errorListeners.add(listener);
         return () => this.errorListeners.delete(listener);
     }
+    /**
+     * The host's budget for handlers of the queued lifecycle and boundary events, who hears their stalls, and the turn
+     * that owns a wait started now (the turn deadline releases only its own turn's waits).
+     */
+    setEventHandlerBudget(budget, onStall, turnScope = () => 0) {
+        this.eventHandlerBudget = budget;
+        this.handlerStallListener = onStall;
+        this.handlerTurnScope = turnScope;
+    }
+    /** Stops waiting on the given turn's handlers that are still running (the turn deadline's release). */
+    releaseHeldHandlers(turn) {
+        return this.heldHandlerWaits.release(turn);
+    }
+    /**
+     * Resolved once per emission, before any handler starts. An invalid setting must never leave handlers unawaited,
+     * so it is reported once and the shipped defaults apply, as for `session_shutdown`.
+     */
+    resolveEventHandlerBudget() {
+        try {
+            return this.eventHandlerBudget();
+        }
+        catch (err) {
+            if (!this.reportedInvalidHandlerBudget) {
+                this.reportedInvalidHandlerBudget = true;
+                console.warn(`Using the default extension event handler budget (warn ${DEFAULT_EXTENSION_EVENT_HANDLER_WARN_MS}ms, hard cap ${DEFAULT_EXTENSION_EVENT_HANDLER_TIMEOUT_MS}ms): ${err instanceof Error ? err.message : String(err)}`);
+            }
+            return {
+                warnMs: DEFAULT_EXTENSION_EVENT_HANDLER_WARN_MS,
+                timeoutMs: DEFAULT_EXTENSION_EVENT_HANDLER_TIMEOUT_MS,
+            };
+        }
+    }
+    walkHandlers(sequence) {
+        return runBudgetedSequence(sequence, {
+            budget: this.resolveEventHandlerBudget(),
+            held: { waits: this.heldHandlerWaits, scope: this.handlerTurnScope },
+            onStall: (stall) => this.handlerStallListener?.(stall),
+        });
+    }
+    reportStoppedHandler(extensionPath, event, verdict, budget) {
+        const error = verdict === "timed_out"
+            ? `handler timed out after ${budget.timeoutMs}ms`
+            : "handler released by the turn deadline";
+        this.emitError({ extensionPath, event, error });
+    }
+    reportHandlerFailure(extensionPath, event, err) {
+        this.emitError({
+            extensionPath,
+            event,
+            error: err instanceof Error ? err.message : String(err),
+            stack: err instanceof Error ? err.stack : undefined,
+        });
+    }
+    /** Agent lifecycle events: every handler runs, serially, under the host budget (senpi#3650). */
+    dispatchLifecycle(event) {
+        const entries = flattenHandlers(this.extensions, event.type);
+        return this.walkHandlers({
+            event: event.type,
+            length: entries.length,
+            extensionPath: (index) => entryAt(entries, index).path,
+            start: (index) => {
+                const { path, handler } = entryAt(entries, index);
+                return handler(event, this.createContext(path));
+            },
+            settle: (index, outcome) => {
+                if (!outcome.ok)
+                    this.reportHandlerFailure(entryAt(entries, index).path, event.type, outcome.error);
+            },
+            skip: (index, verdict, budget) => this.reportStoppedHandler(entryAt(entries, index).path, event.type, verdict, budget),
+            finish: () => undefined,
+        });
+    }
     emitError(error) {
         for (const listener of this.errorListeners) {
             listener(error);
@@ -1186,34 +1290,36 @@ export class ExtensionRunner {
             throw err;
         }
         let valid = true;
-        for (const { ext, handlers } of snapshotEventHandlers(this.extensions, baseEvent.type)) {
-            for (const handler of handlers) {
-                if (!this.isActive)
-                    return retired();
+        const handlers = flattenHandlers(this.extensions, baseEvent.type);
+        // Boundary handlers hold the agent loop's turn end and the run's settle, so they run under the same host budget
+        // as the lifecycle events and the turn deadline can release them (senpi#3650).
+        return this.walkHandlers({
+            event: baseEvent.type,
+            length: handlers.length,
+            extensionPath: (index) => entryAt(handlers, index).path,
+            halted: () => !this.isActive,
+            start: (index) => {
                 const event = {
                     ...baseEvent,
                     entries,
                     continue: shouldContinue,
                     context,
                 };
-                try {
-                    const handlerResult = (await handler(event, ctx));
-                    if (!this.isActive)
-                        return retired();
+                return entryAt(handlers, index).handler(event, ctx);
+            },
+            settle: async (index, outcome) => {
+                if (!this.isActive)
+                    return;
+                const { path } = entryAt(handlers, index);
+                if (outcome.ok) {
+                    const handlerResult = outcome.value;
                     if (handlerResult?.entries !== undefined)
                         entries = handlerResult.entries;
                     if (handlerResult?.continue !== undefined)
                         shouldContinue = handlerResult.continue;
                 }
-                catch (err) {
-                    if (!this.isActive)
-                        return retired();
-                    this.emitError({
-                        extensionPath: ext.path,
-                        event: baseEvent.type,
-                        error: err instanceof Error ? err.message : String(err),
-                        stack: err instanceof Error ? err.stack : undefined,
-                    });
+                else {
+                    this.reportHandlerFailure(path, baseEvent.type, outcome.error);
                 }
                 try {
                     context = await buildContext(entries);
@@ -1221,18 +1327,19 @@ export class ExtensionRunner {
                 }
                 catch (err) {
                     if (!this.isActive)
-                        return retired();
+                        return;
                     valid = false;
                     this.emitError({
-                        extensionPath: ext.path,
+                        extensionPath: path,
                         event: baseEvent.type,
                         error: `Invalid boundary entries: ${err instanceof Error ? err.message : String(err)}`,
                         stack: err instanceof Error ? err.stack : undefined,
                     });
                 }
-            }
-        }
-        return valid && this.isActive ? { entries, continue: shouldContinue, context, valid: true } : retired();
+            },
+            skip: (index, verdict, budget) => this.reportStoppedHandler(entryAt(handlers, index).path, baseEvent.type, verdict, budget),
+            finish: () => valid && this.isActive ? { entries, continue: shouldContinue, context, valid: true } : retired(),
+        });
     }
     isSessionBeforeEvent(event) {
         return (event.type === "session_before_switch" ||
@@ -1275,53 +1382,26 @@ export class ExtensionRunner {
      * exactly as before.
      */
     async runSessionShutdownHandler(extensionPath, event, handler, budget) {
-        const controller = new AbortController();
-        const startedAt = Date.now();
-        let outcome;
-        // Settle the handler through a captured outcome so a late rejection after a
-        // timeout is already handled instead of becoming an unhandled rejection.
-        const settled = Promise.resolve(handler({ ...event, signal: controller.signal }, this.createContext(extensionPath))).then(() => {
-            outcome = { ok: true };
-        }, (error) => {
-            outcome = { ok: false, error };
+        const outcome = await runBudgetedHandler({
+            extensionPath,
+            event: "session_shutdown",
+            budget,
+            run: (signal) => handler({ ...event, signal }, this.createContext(extensionPath)),
+            onStall: (stall) => {
+                if (stall.stage !== "warn")
+                    return;
+                const capNote = budget.timeoutMs > 0 ? ` (hard cap ${budget.timeoutMs}ms)` : "";
+                console.warn(`Extension ${extensionPath} is still running its session_shutdown handler after ${stall.elapsedMs}ms${capNote}.`);
+            },
         });
-        if (budget.warnMs > 0 || budget.timeoutMs > 0) {
-            let warnTimer;
-            let capTimer;
-            let timedOut = false;
-            try {
-                timedOut = await new Promise((resolve) => {
-                    if (budget.warnMs > 0) {
-                        warnTimer = setTimeout(() => {
-                            const capNote = budget.timeoutMs > 0 ? ` (hard cap ${budget.timeoutMs}ms)` : "";
-                            console.warn(`Extension ${extensionPath} is still running its session_shutdown handler after ${Date.now() - startedAt}ms${capNote}.`);
-                        }, budget.warnMs);
-                    }
-                    if (budget.timeoutMs > 0) {
-                        capTimer = setTimeout(() => resolve(true), budget.timeoutMs);
-                    }
-                    void settled.then(() => resolve(false));
-                });
-            }
-            finally {
-                clearTimeout(warnTimer);
-                clearTimeout(capTimer);
-            }
-            if (timedOut) {
-                controller.abort(new Error(`session_shutdown handler timed out after ${budget.timeoutMs}ms`));
-                this.emitError({
-                    extensionPath,
-                    event: "session_shutdown",
-                    error: `handler timed out after ${budget.timeoutMs}ms`,
-                });
-                return;
-            }
-        }
-        else {
-            await settled;
-        }
-        if (outcome && !outcome.ok) {
+        if (outcome.kind === "failed")
             throw outcome.error;
+        if (outcome.kind === "timed_out") {
+            this.emitError({
+                extensionPath,
+                event: "session_shutdown",
+                error: `handler timed out after ${budget.timeoutMs}ms`,
+            });
         }
     }
     emit(event) {
@@ -1329,14 +1409,17 @@ export class ExtensionRunner {
         // Turns requested from any session_start handler start after the last one returns (senpi#1972).
         if (event.type === "session_start")
             return this.sessionStartTurns.dispatch(() => this.dispatchEmit(event));
+        if (QUEUED_LIFECYCLE_EVENTS.has(event.type)) {
+            return this.dispatchLifecycle(event);
+        }
         return this.dispatchEmit(event);
     }
     async dispatchEmit(event) {
         let result;
-        // session_shutdown is the one host-bounded event: a hung handler must not hold
-        // Ctrl+C / quit / reload / new / resume hostage. Every other event still awaits
-        // its handlers without a cap (ask-user and approval dialogs legitimately block).
-        // The budget is resolved lazily so runners with no shutdown handler read no settings.
+        // Host-bounded events: a hung session_shutdown handler must not hold Ctrl+C / quit / reload / new / resume
+        // hostage (agent lifecycle events take `dispatchLifecycle`, senpi#3650). Every other event still awaits its
+        // handlers without a cap (ask-user and approval dialogs legitimately block).
+        // The shutdown budget is resolved lazily so runners with no shutdown handler read no settings.
         const isSessionShutdown = event.type === "session_shutdown";
         let shutdownBudget;
         for (const { ext, handlers } of snapshotEventHandlers(this.extensions, event.type)) {
@@ -1416,40 +1499,42 @@ export class ExtensionRunner {
         }
         return result;
     }
-    async emitMessageEnd(event) {
+    emitMessageEnd(event) {
         let currentMessage = event.message;
         let modified = false;
-        for (const { ext, handlers } of snapshotEventHandlers(this.extensions, "message_end")) {
-            for (const handler of handlers) {
-                try {
-                    const currentEvent = { ...event, message: currentMessage };
-                    const handlerResult = (await handler(currentEvent, this.createContext(ext.path)));
-                    if (!handlerResult?.message)
-                        continue;
-                    if (handlerResult.message.role !== currentMessage.role) {
-                        this.emitError({
-                            extensionPath: ext.path,
-                            event: "message_end",
-                            error: "message_end handlers must return a message with the same role",
-                        });
-                        continue;
-                    }
-                    currentMessage = handlerResult.message;
-                    modified = true;
+        const entries = flattenHandlers(this.extensions, "message_end");
+        return this.walkHandlers({
+            event: "message_end",
+            length: entries.length,
+            extensionPath: (index) => entryAt(entries, index).path,
+            start: (index) => {
+                const { path, handler } = entryAt(entries, index);
+                const currentEvent = { ...event, message: currentMessage };
+                return handler(currentEvent, this.createContext(path));
+            },
+            settle: (index, outcome) => {
+                const { path } = entryAt(entries, index);
+                if (!outcome.ok) {
+                    this.reportHandlerFailure(path, "message_end", outcome.error);
+                    return;
                 }
-                catch (err) {
-                    const message = err instanceof Error ? err.message : String(err);
-                    const stack = err instanceof Error ? err.stack : undefined;
+                const handlerResult = outcome.value;
+                if (!handlerResult?.message)
+                    return;
+                if (handlerResult.message.role !== currentMessage.role) {
                     this.emitError({
-                        extensionPath: ext.path,
+                        extensionPath: path,
                         event: "message_end",
-                        error: message,
-                        stack,
+                        error: "message_end handlers must return a message with the same role",
                     });
+                    return;
                 }
-            }
-        }
-        return modified ? currentMessage : undefined;
+                currentMessage = handlerResult.message;
+                modified = true;
+            },
+            skip: (index, verdict, budget) => this.reportStoppedHandler(entryAt(entries, index).path, "message_end", verdict, budget),
+            finish: () => (modified ? currentMessage : undefined),
+        });
     }
     async emitToolResult(event) {
         const currentEvent = { ...event };

package/dist/core/footer-data-provider.js

@@ -2,6 +2,7 @@ import { execFile } from "child_process";
 import { existsSync, readFileSync, statSync, unwatchFile, watchFile } from "fs";
 import { dirname, join, resolve } from "path";
 import { closeWatcher, FS_WATCH_RETRY_DELAY_MS, watchWithErrorHandler } from "../utils/fs-watch.js";
+import { isWSL } from "../utils/wsl.js";
 /**
  * Find git metadata paths by walking up from cwd.
  * Handles both regular git repos (.git is a directory) and worktrees (.git is a file).
@@ -61,7 +62,7 @@ function resolveBranchWithGitAsync(repoDir) {
     });
 }
 function isWslEnvironment() {
-    return process.platform === "linux" && !!(process.env.WSL_DISTRO_NAME || process.env.WSL_INTEROP);
+    return process.platform === "linux" && isWSL();
 }
 function isWindowsMountedRepoPath(repoDir) {
     return /^\/mnt\/[a-z](?:\/|$)/i.test(repoDir);