@code-yeongyu/senpi 2026.11.6-2 → 2026.11.9

package/dist/core/extensions/builtin/terminal/tools/bash.d.ts

@@ -6,6 +6,7 @@ export declare const ptyBashSchema: Type.TObject<{
     timeout: Type.TOptional<Type.TNumber>;
     description: Type.TOptional<Type.TString>;
     run_in_background: Type.TOptional<Type.TBoolean>;
+    auto_reap_minutes: Type.TOptional<Type.TNumber>;
     cols: Type.TOptional<Type.TNumber>;
     rows: Type.TOptional<Type.TNumber>;
 }>;
@@ -50,10 +51,11 @@ export declare function createPtyBashTool(ctx: TerminalToolContext): {
         timeout: Type.TOptional<Type.TNumber>;
         description: Type.TOptional<Type.TString>;
         run_in_background: Type.TOptional<Type.TBoolean>;
+        auto_reap_minutes: Type.TOptional<Type.TNumber>;
         cols: Type.TOptional<Type.TNumber>;
         rows: Type.TOptional<Type.TNumber>;
     }>;
-    execute(_toolCallId: string, input: PtyBashInput, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback, execCtx?: SessionEnvSource): Promise<TerminalToolResult>;
+    execute(toolCallId: string, input: PtyBashInput, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback, execCtx?: SessionEnvSource): Promise<TerminalToolResult>;
 };
 export {};
 //# sourceMappingURL=bash.d.ts.map

package/dist/core/extensions/builtin/terminal/tools/bash.js

@@ -1,8 +1,12 @@
 import { Type } from "typebox";
+import { getAgentDir } from "../../../../../config.js";
 import { annotateShellTrust } from "../../../../../engine-trust/shell-trust.js";
+import { createSessionLogger } from "../../../../session-log.js";
+import { stallThresholdMs, watchForStall } from "../../../../stall-warning.js";
 import { formatTerminalToolOutput } from "../output-format.js";
 import { BACKGROUND_START_GRACE_MS, DEFAULT_COLS, DEFAULT_ROWS, FOREGROUND_ENV_OVERRIDES, KILLED_SESSION_EXIT_GRACE_MS, TERMINAL_BASH_TOOL, } from "../shared.js";
 import { errorResult, noticedResult, textResult, } from "./context.js";
+import { backgroundStart, trackBackgroundSession } from "./background-auto-reap.js";
 import { createForegroundDetachGate } from "./foreground-detach.js";
 import { resolveForegroundWindowSeconds, SLEEP_WAIT_WINDOW_SECONDS } from "./foreground-window.js";
 import { classifySleepWait } from "./sleep-wait.js";
@@ -16,6 +20,9 @@ export const ptyBashSchema = Type.Object({
     run_in_background: Type.Optional(Type.Boolean({
         description: "Run as a persistent background session: returns a bash_id immediately (read with bash_output, steer with bash_input, stop with kill_bash). A plain & job dies with the call's PTY hangup (native backend), and nohup at best leaves an untracked orphan (no bash_id, no log) that the call's timeout still group-kills. This flag is the only reliable way a job outlives the call.",
     })),
+    auto_reap_minutes: Type.Optional(Type.Number({
+        description: "Background sessions only: stop this session (TERM, then KILL to its process group) once it has run this many minutes. Defaults to the terminal.backgroundAutoReapMinutes setting, which is off; 0 turns it off for this call.",
+    })),
     cols: Type.Optional(Type.Number({ description: "PTY width in columns (default 120)." })),
     rows: Type.Optional(Type.Number({ description: "PTY height in rows (default 40)." })),
 });
@@ -76,6 +83,32 @@ export function createThrottledEmitter(emit, throttleMs = BASH_UPDATE_THROTTLE_M
         },
     };
 }
+let defaultSessionLogger;
+/**
+ * Spawn, logging once if the spawn outlives the call's own timeout (capped at the stall threshold). The call's
+ * kill timer and detach gate are armed only after spawn returns, so a spawn that never returns is otherwise
+ * silent (senpi#6189). The spawn itself is awaited exactly as before.
+ */
+async function spawnReportingStall(ctx, request, toolCallId, execCtx) {
+    const thresholdMs = stallThresholdMs(request.timeoutMs === undefined ? undefined : request.timeoutMs / 1000);
+    const watch = watchForStall(thresholdMs, (elapsedMs) => {
+        const logger = ctx.sessionLogger ?? (defaultSessionLogger ??= createSessionLogger(getAgentDir()));
+        const sessionId = (execCtx ?? ctx.getSessionContext?.())?.sessionManager?.getSessionId();
+        logger.warn("bash_spawn_stalled", {
+            toolCallId,
+            toolName: TERMINAL_BASH_TOOL,
+            ...(sessionId === undefined ? {} : { sessionId }),
+            thresholdMs,
+            elapsedMs,
+        });
+    });
+    try {
+        return await spawnCommandSession(sessionSpawnContext(ctx), request);
+    }
+    finally {
+        watch.stop();
+    }
+}
 function sessionSpawnContext(ctx) {
     return {
         ...ctx,
@@ -198,18 +231,18 @@ function scheduleDetachedSweep(ctx, id, runtime, timeoutMs, startedAt) {
             void ctx.manager.stop(id).catch(() => { });
     }, remainingMs);
 }
-async function runForeground(ctx, input, cols, rows, signal, cwd, onUpdate, execCtx) {
+async function runForeground(ctx, input, cols, rows, signal, cwd, onUpdate, toolCallId, execCtx) {
     if (signal?.aborted)
         return errorResult("Command aborted");
     const timeoutMs = input.timeout !== undefined ? Math.trunc(input.timeout * 1000) : undefined;
-    const { id, runtime } = await spawnCommandSession(sessionSpawnContext(ctx), {
+    const { id, runtime } = await spawnReportingStall(ctx, {
         command: input.command,
         cols,
         rows,
         timeoutMs,
         cwd,
         envOverrides: { ...sessionEnvOverrides(ctx, execCtx), ...FOREGROUND_ENV_OVERRIDES },
-    });
+    }, toolCallId, execCtx);
     const startedAt = Date.now();
     const activity = `running ${input.command.slice(0, 80)}`;
     const emitOutputUpdate = () => {
@@ -277,9 +310,7 @@ async function runForeground(ctx, input, cols, rows, signal, cwd, onUpdate, exec
     }
     if (outcome === "detached") {
         scheduleDetachedSweep(ctx, id, runtime, timeoutMs, startedAt);
-        ctx.onBackgroundStart?.(id, input.description ?? input.command, startedAt, input.command);
-        if (ctx.onBackgroundExit)
-            runtime.session.onExit(() => ctx.onBackgroundExit?.(id, runtime));
+        trackBackgroundSession(ctx, id, runtime, backgroundStart(input, ctx.backgroundAutoReapMinutes, startedAt));
         const delta = runtime.readDelta();
         const partialOutput = formatTerminalToolOutput(delta.text).text || "(no output yet)";
         const timeoutNote = input.timeout !== undefined && Number.isFinite(input.timeout)
@@ -334,19 +365,17 @@ async function runForeground(ctx, input, cols, rows, signal, cwd, onUpdate, exec
         },
     });
 }
-async function runBackground(ctx, input, cols, rows, cwd, execCtx) {
+async function runBackground(ctx, input, cols, rows, cwd, toolCallId, execCtx) {
     // Background sessions are NEVER killed by `timeout` (bash-timeout injects a default into
     // every bash call); they live until exit or kill_bash, so no timeoutMs is passed.
-    const { id, runtime } = await spawnCommandSession(sessionSpawnContext(ctx), {
+    const { id, runtime } = await spawnReportingStall(ctx, {
         command: input.command,
         cols,
         rows,
         cwd,
         envOverrides: sessionEnvOverrides(ctx, execCtx),
-    });
-    ctx.onBackgroundStart?.(id, input.description ?? input.command, Date.now(), input.command);
-    if (ctx.onBackgroundExit)
-        runtime.session.onExit(() => ctx.onBackgroundExit?.(id, runtime));
+    }, toolCallId, execCtx);
+    trackBackgroundSession(ctx, id, runtime, backgroundStart(input, ctx.backgroundAutoReapMinutes, Date.now()));
     // Capture any output the command emits within a short grace window (or its exit).
     await Promise.race([delay(BACKGROUND_START_GRACE_MS), runtime.session.waitExit()]);
     const early = formatTerminalToolOutput(runtime.readDelta().text).text;
@@ -368,13 +397,13 @@ export function createPtyBashTool(ctx) {
         promptGuidelines: ["PI_* env vars = current model + session details."],
         fullPromptGuidelines: ["You can inspect PI_* environment variables for current model and session details."],
         parameters: ptyBashSchema,
-        async execute(_toolCallId, input, signal, onUpdate, execCtx) {
+        async execute(toolCallId, input, signal, onUpdate, execCtx) {
             const cols = resolveDimension(input.cols, ctx.defaultCols || DEFAULT_COLS);
             const rows = resolveDimension(input.rows, ctx.defaultRows || DEFAULT_ROWS);
             const cwd = execCtx?.cwd;
             if (input.run_in_background)
-                return runBackground(ctx, input, cols, rows, cwd, execCtx);
-            return runForeground(ctx, input, cols, rows, signal, cwd, onUpdate, execCtx);
+                return runBackground(ctx, input, cols, rows, cwd, toolCallId, execCtx);
+            return runForeground(ctx, input, cols, rows, signal, cwd, onUpdate, toolCallId, execCtx);
         },
     };
 }

package/dist/core/extensions/builtin/terminal/tools/child-placement.d.ts

@@ -27,11 +27,19 @@ export type TerminalBackgroundWake = {
     readonly id: string;
     readonly description: string;
     readonly startedAtMs: number;
+    readonly command?: string;
+    readonly autoReapMinutes?: number;
 } | {
     readonly event: "background_exit";
     readonly id: string;
     readonly exit: TerminalExitView["exitResult"];
     readonly output: string;
+    readonly autoReapedAfterMinutes?: number;
+} | {
+    readonly event: "background_reap_failed";
+    readonly id: string;
+    readonly autoReapMinutes: number;
+    readonly reason: string;
 };
 export declare function lostSessionResult(id: string, generation: number): AgentToolResult<unknown>;
 export declare function terminalChildJob(ctx: TerminalToolContext, kind: (typeof TERMINAL_CHILD_JOB_KINDS)[keyof typeof TERMINAL_CHILD_JOB_KINDS]): ToolChildJob;

package/dist/core/extensions/builtin/terminal/tools/child-placement.js

@@ -25,6 +25,9 @@ function childGenerationOf(id) {
     const generation = CHILD_SESSION_ID.exec(id)?.[1];
     return generation === undefined ? undefined : Number(generation);
 }
+function optionalMinutes(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 1 ? Math.trunc(value) : undefined;
+}
 function parseBackgroundWake(value) {
     if (typeof value !== "object" || value === null)
         return undefined;
@@ -37,19 +40,46 @@ function parseBackgroundWake(value) {
         const startedAtMs = Reflect.get(value, "startedAtMs");
         if (typeof description !== "string" || typeof startedAtMs !== "number")
             return undefined;
-        return { event, id, description, startedAtMs };
+        const command = Reflect.get(value, "command");
+        const autoReapMinutes = optionalMinutes(Reflect.get(value, "autoReapMinutes"));
+        return {
+            event,
+            id,
+            description,
+            startedAtMs,
+            ...(typeof command === "string" ? { command } : {}),
+            ...(autoReapMinutes === undefined ? {} : { autoReapMinutes }),
+        };
+    }
+    if (event === "background_reap_failed") {
+        const autoReapMinutes = optionalMinutes(Reflect.get(value, "autoReapMinutes"));
+        const reason = Reflect.get(value, "reason");
+        if (autoReapMinutes === undefined || typeof reason !== "string")
+            return undefined;
+        return { event, id, autoReapMinutes, reason };
     }
     if (event === "background_exit") {
         const output = Reflect.get(value, "output");
         const exit = Reflect.get(value, "exit");
         if (typeof output !== "string" || (exit !== null && typeof exit !== "object"))
             return undefined;
-        return { event, id, exit: exit, output };
+        const autoReapedAfterMinutes = optionalMinutes(Reflect.get(value, "autoReapedAfterMinutes"));
+        return {
+            event,
+            id,
+            exit: exit,
+            output,
+            ...(autoReapedAfterMinutes === undefined ? {} : { autoReapedAfterMinutes }),
+        };
     }
     return undefined;
 }
-function exitView(exit, output) {
-    return { exitResult: exit, fullOutput: () => output };
+function exitView(exit, output, autoReapedAfterMinutes) {
+    return {
+        exitResult: exit,
+        fullOutput: () => output,
+        ...(autoReapedAfterMinutes === undefined ? {} : { autoReapedAfterMinutes }),
+    };
 }
 function bashIdOf(value) {
     if (typeof value !== "object" || value === null)
@@ -106,6 +136,9 @@ export function terminalChildJob(ctx, kind) {
                 defaultRows: ctx.defaultRows,
                 redactSecretsInOutput: ctx.redactSecretsInOutput === true,
                 ...(ctx.timeoutAction === undefined ? {} : { timeoutAction: ctx.timeoutAction }),
+                ...(ctx.backgroundAutoReapMinutes === undefined
+                    ? {}
+                    : { backgroundAutoReapMinutes: ctx.backgroundAutoReapMinutes }),
             };
         },
     };
@@ -124,11 +157,15 @@ function backgroundRelay(ctx) {
                 return;
             if (wake.event === "background_start") {
                 running.set(wake.id, generation);
-                ctx.onBackgroundStart?.(wake.id, wake.description, wake.startedAtMs);
+                ctx.onBackgroundStart?.(wake.id, wake.description, wake.startedAtMs, wake.command, wake.autoReapMinutes);
+                return;
+            }
+            if (wake.event === "background_reap_failed") {
+                ctx.onBackgroundReapFailed?.(wake.id, wake.autoReapMinutes, wake.reason);
                 return;
             }
             running.delete(wake.id);
-            ctx.onBackgroundExit?.(wake.id, exitView(wake.exit, wake.output));
+            ctx.onBackgroundExit?.(wake.id, exitView(wake.exit, wake.output, wake.autoReapedAfterMinutes));
         },
         childExited: (generation) => {
             for (const [id, startedOn] of running) {

package/dist/core/extensions/builtin/terminal/tools/context.d.ts

@@ -2,6 +2,7 @@ import type { TextContent } from "@earendil-works/pi-ai";
 import type { TerminalSessionExit } from "@earendil-works/pi-pty";
 import type { TerminalManager } from "../manager.ts";
 import type { MonitorEvent, MonitorRegistry } from "../monitor-registry.ts";
+import type { SessionLogger } from "../../../../session-log.ts";
 import type { TimeoutAction } from "../settings.ts";
 /** Shared dependencies handed to every terminal tool factory. */
 export interface TerminalToolContext {
@@ -16,6 +17,8 @@ export interface TerminalToolContext {
     readonly timeoutAction?: TimeoutAction;
     /** Resolved `terminal.maxDurableMonitors`; omitted contexts admit any number of persistent monitors. */
     readonly maxDurableMonitors?: number | "unlimited";
+    /** Resolved `terminal.backgroundAutoReapMinutes`: background sessions are stopped at this age; unset means never. */
+    readonly backgroundAutoReapMinutes?: number | undefined;
     /** Resolve the environment for spawned sessions (mirrors core bash `getShellEnv`). */
     readonly getEnv: () => NodeJS.ProcessEnv;
     /**
@@ -23,12 +26,17 @@ export interface TerminalToolContext {
      * expose PI_* session metadata to spawned commands like the core bash tool does.
      */
     readonly getSessionContext?: () => import("../../../types.ts").ExtensionContext | undefined;
-    /** Registers a session when it transitions to background liveness; `command` is what it runs, when known. */
-    readonly onBackgroundStart?: (id: string, description: string, startedAtMs: number, command?: string) => void;
+    /**
+     * Registers a session when it transitions to background liveness; `command` is what it runs, when known, and
+     * `autoReapMinutes` the age at which the opt-in auto-reap stops it.
+     */
+    readonly onBackgroundStart?: (id: string, description: string, startedAtMs: number, command?: string, autoReapMinutes?: number) => void;
     /** A person or the model wrote to a session's stdin (`bash_input`): it is interactive from now on. */
     readonly onSessionInput?: (id: string) => void;
     /** Notified when a background session exits, so the notify layer can wake the agent. */
     readonly onBackgroundExit?: (id: string, runtime: TerminalExitView) => void;
+    /** The opt-in auto-reap's one stop at `autoReapMinutes` did not end the session, for `reason`; it keeps running. */
+    readonly onBackgroundReapFailed?: (id: string, autoReapMinutes: number, reason: string) => void;
     /** Session-scoped monitor state, sharing the terminal manager's bash-id namespace. */
     readonly monitorRegistry?: MonitorRegistry;
     /** Receives filtered monitor line and terminal-summary events. */
@@ -48,10 +56,14 @@ export interface TerminalToolContext {
      * the server and only then lets the command run. Absent on the in-process path, which spawns exactly as before.
      */
     readonly launchBarrier?: TerminalLaunchBarrier;
+    /** Where a stalled spawn is reported (senpi#6189); defaults to the agent directory's session log. */
+    readonly sessionLogger?: Pick<SessionLogger, "warn">;
 }
 /** What a background exit notice reads: on the tool child it is a summary the child sent, not the live session. */
 export interface TerminalExitView {
     readonly exitResult: Pick<TerminalSessionExit, "exitCode" | "signal" | "cancelled" | "timedOut"> | null;
+    /** Set when the opt-in auto-reap stopped the session at this age (senpi#6201). */
+    readonly autoReapedAfterMinutes?: number;
     fullOutput(): string;
 }
 export interface TerminalLaunchBarrier {

package/dist/core/extensions/bun-extension-importer.js

@@ -14,6 +14,7 @@ import { fileURLToPath, pathToFileURL } from "node:url";
 import { parse } from "es-module-lexer/js";
 import { isCommonJsFile, isEsmByPackageType, parseImportClause, rewriteCommonJsImport, } from "./bun-extension-commonjs.js";
 import { ExtensionSourceError } from "./bun-extension-error.js";
+import { loadSynchronously } from "./bun-extension-load-turns.js";
 import { createPreparedSourceCache } from "./bun-extension-prepared-cache.js";
 import { ExtensionGenerationDisposedError, extensionNamespace, registerExtensionGraph, runtimeModulePath, } from "./bun-extension-registry.js";
 import { hasUseStrictDirective, strictDirectiveModuleSource } from "./bun-extension-strict-directive.js";
@@ -181,7 +182,7 @@ export function createBunExtensionImporter(virtualModules, builtinRedirects = {}
             const evaluating = commonJsModules.get(id);
             if (evaluating !== undefined)
                 return evaluating.exports;
-            const result = nativeRequire(id);
+            const result = loadSynchronously(() => nativeRequire(id));
             return commonJs.has(id) ? result.default : result;
         },
         evaluateCommonJs(filename, body) {
@@ -240,7 +241,7 @@ export function createBunExtensionImporter(virtualModules, builtinRedirects = {}
             // A package directory loads through its main or index file, as a native import does.
             const entry = statSync(absolute).isDirectory() ? realpathSync(Bun.resolveSync(absolute, absolute)) : absolute;
             const { id } = fileTarget(entry);
-            const module = await import(__rewriteRelativeImportExtension(id));
+            const module = await registration.holdDuring(import(__rewriteRelativeImportExtension(id)));
             const factory = module.default;
             if (typeof factory !== "function")
                 return factory;
@@ -255,7 +256,7 @@ export function createBunExtensionImporter(virtualModules, builtinRedirects = {}
         async importNamespace(path) {
             assertActive();
             const { id } = fileTarget(realpathSync(resolve(path)));
-            return import(__rewriteRelativeImportExtension(id));
+            return registration.holdDuring(import(__rewriteRelativeImportExtension(id)));
         },
         // Capture identity from the transpiler input, never from a later disk snapshot.
         compiledSources() {

package/dist/core/extensions/bun-extension-load-turns.d.ts

@@ -0,0 +1,4 @@
+export declare function loadInTurn<T>(load: () => T): T | Promise<T>;
+/** Runs `require` so every module it loads is served synchronously, as a CommonJS require needs. */
+export declare function loadSynchronously<T>(require: () => T): T;
+//# sourceMappingURL=bun-extension-load-turns.d.ts.map

package/dist/core/extensions/bun-extension-load-turns.js

@@ -0,0 +1,45 @@
+/**
+ * One extension module per event-loop turn (senpi#6199). Bun fetches the whole static graph of an `import()` inside
+ * one microtask drain, so a synchronous `onLoad` holds the loop for every module of the graph: a host compiling an
+ * extension (its boot load, a warm, an open) answered no socket until the last one. During an import each load waits
+ * for its own turn instead; a synchronous `require()` cannot take a promise, so its loads still run at once.
+ */
+const queued = [];
+let draining = false;
+let synchronousDepth = 0;
+function drainOne() {
+    queued.shift()?.();
+    if (queued.length > 0)
+        setImmediate(drainOne);
+    else
+        draining = false;
+}
+export function loadInTurn(load) {
+    if (synchronousDepth > 0)
+        return load();
+    return new Promise((resolve, reject) => {
+        queued.push(() => {
+            try {
+                resolve(load());
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+        if (draining)
+            return;
+        draining = true;
+        setImmediate(drainOne);
+    });
+}
+/** Runs `require` so every module it loads is served synchronously, as a CommonJS require needs. */
+export function loadSynchronously(require) {
+    synchronousDepth++;
+    try {
+        return require();
+    }
+    finally {
+        synchronousDepth--;
+    }
+}
+//# sourceMappingURL=bun-extension-load-turns.js.map

package/dist/core/extensions/bun-extension-registry.d.ts

@@ -29,6 +29,7 @@ export declare class ExtensionGenerationDisposedError extends Error {
 }
 export declare function registerExtensionGraph(graph: ExtensionGraph, virtualModules: Readonly<Record<string, Readonly<Record<string, unknown>>>>): {
     generation: string;
+    holdDuring<T>(pending: Promise<T>): Promise<T>;
     dispose(): void;
 };
 /** Internal lifecycle diagnostics, shared by regression and compiled probes. */

package/dist/core/extensions/bun-extension-registry.js

@@ -1,6 +1,7 @@
 import { existsSync } from "node:fs";
 import { dirname, isAbsolute } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
+import { loadInTurn } from "./bun-extension-load-turns.js";
 import { publishRuntimeMetadata } from "./extension-runtime-module.js";
 // esbuild reads an import() only when its second argument is fully static, and these
 // attributes are whatever the extension wrote. The call stays dynamic either way, so
@@ -33,6 +34,10 @@ function splitModuleId(id) {
 }
 const graphs = new Map();
 const collected = new FinalizationRegistry((generation) => graphs.delete(generation));
+// Bun serves an import()'s modules one loop turn at a time (senpi#6199) and its loader keeps no reference to the graph
+// serving them: a graph whose importer was already dropped was collected between two loads and failed the import as
+// disposed (senpi#6208). A graph is held strongly while any import it serves is in flight.
+const importing = new Map();
 let nextGeneration = 0;
 let installed = false;
 let pluginRegistrations = 0;
@@ -129,7 +134,7 @@ function installRegistry(virtualModules) {
                     const parsed = splitModuleId(path);
                     if (parsed === undefined)
                         throw new ExtensionModuleIdError(path);
-                    return graphFor(parsed.generation).load(parsed.filename);
+                    return loadInTurn(() => graphFor(parsed.generation).load(parsed.filename));
                 });
                 installed = true;
             },
@@ -143,6 +148,19 @@ export function registerExtensionGraph(graph, virtualModules) {
     collected.register(graph, generation, graph);
     return {
         generation,
+        async holdDuring(pending) {
+            importing.set(graph, (importing.get(graph) ?? 0) + 1);
+            try {
+                return await pending;
+            }
+            finally {
+                const remaining = (importing.get(graph) ?? 1) - 1;
+                if (remaining === 0)
+                    importing.delete(graph);
+                else
+                    importing.set(graph, remaining);
+            }
+        },
         dispose() {
             graphs.delete(generation);
             collected.unregister(graph);

package/dist/core/extensions/loader.js

@@ -53,6 +53,7 @@ import { cachedExtensionFactory, extensionModuleImporter, rememberExtensionFacto
 import { kernelToolInvokerStorage } from "./kernel-tools-context.js";
 import { createLifecycleApi } from "./lifecycle-api.js";
 import { withProviderLoginStart } from "./provider-login-start.js";
+import { createSessionDialogApi } from "./session-dialog-api.js";
 import { StaleExtensionContextError } from "./stale-context-error.js";
 import { DEFAULT_EXTENSION_SESSION_PROFILE, EMPTY_SESSION_CONTEXT } from "./types.js";
 function sessionProfile(options) {
@@ -573,6 +574,10 @@ function createExtensionAPI(extension, runtime, cwd, eventBus, session) {
             }
             return readPermissionPreset(sessionManager);
         },
+        sessionDialog: createSessionDialogApi(() => {
+            assertActive();
+            return runtime.createContext().ui;
+        }),
         getSubscriptionLimits() {
             assertActive();
             return subscriptionLimits.snapshot();

package/dist/core/extensions/session-control-types.d.ts

@@ -45,6 +45,15 @@ export type SessionControlSender = {
     readonly platform: string;
     readonly author?: string;
 };
+/**
+ * The remote device a delivery's RPC connection speaks for, stamped by the engine from the connection it arrived on
+ * (senpi#6233). It is never taken from a caller's record or an extension's input, so it is the one provenance on a
+ * delivery that a remote caller cannot write.
+ */
+export interface SessionControlRemoteOrigin {
+    readonly deviceId: string;
+    readonly deviceName?: string;
+}
 export interface AdmitExternalMessageInput {
     readonly delivery_id: string;
     readonly text: string;
@@ -154,7 +163,13 @@ export interface SessionControlDeliveryDetails {
     readonly deliverAs: ExternalDeliverAs;
     readonly sender?: SessionControlSender;
     readonly display_text?: string;
+    /** Engine-stamped: the remote device the admitting connection speaks for. */
+    readonly remote_origin?: SessionControlRemoteOrigin;
+    /** Engine-stamped: the thread-chain hop count the delivery was admitted at. */
+    readonly chain_count?: number;
 }
+/** The engine-stamped remote device a delivery's `details` names, when it names a well-formed one. */
+export declare function sessionControlRemoteOriginOf(details: unknown): SessionControlRemoteOrigin | undefined;
 /** The sender a delivery's `details` names, when it names a well-formed one. */
 export declare function sessionControlSenderOf(details: unknown): SessionControlSender | undefined;
 /** Whether a custom-message `details` value proves it came through session-control admission. */

package/dist/core/extensions/session-control-types.js

@@ -11,6 +11,17 @@
 export { RELOCATION_TOOL_NAMES } from "../session-relocation.js";
 /** `customType` of the transcript entry an admitted delivery becomes. */
 export const SESSION_CONTROL_DELIVERY_TYPE = "session_control_delivery";
+/** The engine-stamped remote device a delivery's `details` names, when it names a well-formed one. */
+export function sessionControlRemoteOriginOf(details) {
+    if (!isSessionControlDeliveryDetails(details) || typeof details.remote_origin !== "object")
+        return undefined;
+    const origin = { ...details.remote_origin };
+    if (typeof origin.deviceId !== "string" || origin.deviceId === "")
+        return undefined;
+    return typeof origin.deviceName === "string" && origin.deviceName !== ""
+        ? { deviceId: origin.deviceId, deviceName: origin.deviceName }
+        : { deviceId: origin.deviceId };
+}
 /** The sender a delivery's `details` names, when it names a well-formed one. */
 export function sessionControlSenderOf(details) {
     if (!isSessionControlDeliveryDetails(details) || typeof details.sender !== "object" || details.sender === null)

package/dist/core/extensions/session-dialog-api.d.ts

@@ -0,0 +1,5 @@
+import type { ExtensionUIContext } from "./types.ts";
+/** Dialogs addressed to every client attached to the session (`pi.sessionDialog`). */
+export type SessionDialogApi = Pick<ExtensionUIContext, "select" | "confirm" | "input" | "editor">;
+export declare function createSessionDialogApi(currentUI: () => ExtensionUIContext): SessionDialogApi;
+//# sourceMappingURL=session-dialog-api.d.ts.map

package/dist/core/extensions/session-dialog-api.js

@@ -0,0 +1,13 @@
+const toSession = (opts) => ({
+    ...opts,
+    audience: "session",
+});
+export function createSessionDialogApi(currentUI) {
+    return {
+        select: (title, options, opts) => currentUI().select(title, options, toSession(opts)),
+        confirm: (title, message, opts) => currentUI().confirm(title, message, toSession(opts)),
+        input: (title, placeholder, opts) => currentUI().input(title, placeholder, toSession(opts)),
+        editor: (title, prefill, opts) => currentUI().editor(title, prefill, toSession(opts)),
+    };
+}
+//# sourceMappingURL=session-dialog-api.js.map

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

@@ -51,6 +51,7 @@ import type { PermissionPresetName } from "./builtin/permission-system/types.ts"
 import type { EvalHandleHost } from "./eval-handle-host.ts";
 import type { ExtensionKernelTools } from "./kernel-tools-context.ts";
 import type { SessionControlActions, SessionControlWakeEvent } from "./session-control-types.ts";
+import type { SessionDialogApi } from "./session-dialog-api.ts";
 import type { UserActivityKind } from "./user-activity.ts";
 export type { ExecOptions, ExecResult } from "../exec.ts";
 export type { AppKeybinding, KeybindingsManager } from "../keybindings.ts";
@@ -72,6 +73,11 @@ export interface ExtensionUIDialogOptions {
     toolCallId?: string;
     /** Set with `toolCallId` when another tool (for example a codemode script) issued that call. */
     parentToolCallId?: string;
+    /**
+     * `session`: address the dialog to every client attached to the session instead of the connection whose command
+     * is running, so a prompt raised after that command returned still reaches someone who can answer. RPC field.
+     */
+    audience?: "session";
 }
 /** A guarded private single-line input; callers on older hosts must check capabilities first. */
 export interface ExtensionUIInputOptions extends ExtensionUIDialogOptions {
@@ -247,7 +253,7 @@ export interface ExtensionUIContext {
     /** Get the current text from the core input editor. */
     getEditorText(): string;
     /** Show a multi-line editor for text editing. */
-    editor(title: string, prefill?: string): Promise<string | undefined>;
+    editor(title: string, prefill?: string, opts?: ExtensionUIDialogOptions): Promise<string | undefined>;
     /** Stack additional autocomplete behavior on top of the built-in provider. */
     addAutocompleteProvider(factory: AutocompleteProviderFactory): void;
     /**
@@ -2245,6 +2251,13 @@ export interface ExtensionAPI {
      * permission system is not running for the session, its setup failed, or the session is not bound yet.
      */
     getPermissionPreset(): PermissionPresetName | undefined;
+    /**
+     * Dialogs addressed to every client attached to this session, not only to the connection whose command is
+     * running: a prompt raised after that command returned (a background child's permission request a task runner
+     * forwards) still reaches someone who can answer. The first answer wins. Secret inputs stay with the raising
+     * connection. In the terminal UI they show like any dialog.
+     */
+    sessionDialog: SessionDialogApi;
     /**
      * Every subscription account's latest limit windows: the records `get_subscription_limits` serves, fed by
      * the engine's usage poll and by turns (senpi#3684). An account nothing has reported for is absent.

package/dist/core/external-admission.d.ts

@@ -13,8 +13,10 @@
  * a file that still refuses writes.
  */
 import type { AgentMessage } from "@earendil-works/pi-agent-core";
-import { type AdmissionHoldReason, type AdmitExternalMessageInput, type AdmittedDeliveries, type ExternalAdmissionResult, type ExternalDeliverAs, type SessionAdmissionGate, type SessionControlDeliveryDetails } from "./extensions/session-control-types.ts";
+import { type AdmissionHoldReason, type AdmitExternalMessageInput, type AdmittedDeliveries, type ExternalAdmissionResult, type ExternalDeliverAs, type SessionAdmissionGate, type SessionControlDeliveryDetails, type SessionControlRemoteOrigin } from "./extensions/session-control-types.ts";
 import type { CustomMessage } from "./messages.ts";
+import type { HistoryReducer } from "./session-history-reduce.ts";
+import { type InputTurnMark } from "./turn-origin.ts";
 export type SessionControlDeliveryMessage = CustomMessage<SessionControlDeliveryDetails>;
 export interface ExternalAdmissionPort {
     /** A run is active, or a prompt has claimed its start: new input queues behind it. */
@@ -28,6 +30,16 @@ export interface EditorHoldState {
     readonly hold_reason?: AdmissionHoldReason;
     readonly revision: number;
 }
+/**
+ * What the engine itself adds to a delivery an RPC connection admits (senpi#6233): the remote device that connection
+ * speaks for, the thread-chain hop it was admitted at, and the origin mark its turn takes. `pi.session` never passes
+ * one, so neither an extension nor a caller's record can write these.
+ */
+export interface DeliveryStamp {
+    readonly remoteOrigin?: SessionControlRemoteOrigin;
+    readonly chainCount?: number;
+    readonly turnMark?: InputTurnMark;
+}
 export declare class ExternalAdmission {
     private turnEpochValue;
     private readonly pending;
@@ -70,7 +82,7 @@ export declare class ExternalAdmission {
     /** Undoes `close` when the hand-over it was closed for did not happen. */
     reopen(): void;
     gate(): SessionAdmissionGate;
-    admit(input: AdmitExternalMessageInput): ExternalAdmissionResult;
+    admit(input: AdmitExternalMessageInput, stamp?: DeliveryStamp): ExternalAdmissionResult;
     list(): AdmittedDeliveries;
     /** A message's transcript entry was written: the file takes writes; a delivery's own entry makes it emitted. */
     observePersisted(message: AgentMessage): void;
@@ -96,5 +108,7 @@ export interface InputHold {
     /** The submission ended without being accepted (it threw, was cancelled, or never submitted). */
     end(): void;
 }
+/** Every delivery id the transcript holds an entry for: what answers for the process-lifetime ledger after a restart. */
+export declare const writtenDeliveryIds: HistoryReducer<Set<string>>;
 export declare function deliveryIdOf(message: AgentMessage): string | undefined;
 //# sourceMappingURL=external-admission.d.ts.map