@code-yeongyu/senpi 2026.11.15-2 → 2026.11.15-3

package/dist/core/extensions/builtin/anthropic-subscription/limit-recheck.js

@@ -0,0 +1,55 @@
+import { subscriptionLimits } from "../../../subscription-limits/limit-store.js";
+import { currentPersonTurn } from "../../../turn-origin.js";
+/**
+ * One allowance per account on an admitted person's turn (senpi#6727). Its identity follows the actual message,
+ * not a predicted end event: a fresh run drops it even when the previous retry was cancelled or blocked.
+ */
+export function registerLimitRecheck(pi) {
+    let sessionManager;
+    let turn;
+    let attempted;
+    const reset = () => {
+        sessionManager = undefined;
+        turn = undefined;
+        attempted = undefined;
+    };
+    pi.on("agent_start", (_event, ctx) => {
+        sessionManager = ctx.sessionManager;
+    });
+    pi.on("session_start", reset);
+    return {
+        accounts: () => {
+            const activeTurn = sessionManager === undefined ? undefined : currentPersonTurn(sessionManager);
+            if (activeTurn !== turn) {
+                turn = activeTurn;
+                attempted = turn === undefined ? undefined : new Set();
+            }
+            return attempted;
+        },
+        reset,
+    };
+}
+/** A rate-limit block with no successful usage reading newer than the block. Errors are not usage evidence. */
+export function unverifiedLimitBlock(account, now) {
+    if (account.blockReason !== "rate_limit" || (account.blockedUntil ?? 0) <= now)
+        return false;
+    const limits = subscriptionLimits
+        .snapshot()
+        .find((entry) => entry.provider === "anthropic-subscription" && entry.account === account.name);
+    return (account.blockedAt === undefined ||
+        limits === undefined ||
+        limits.windows.length === 0 ||
+        Date.parse(limits.reportedAt) <= account.blockedAt);
+}
+/** The selection view alone is opened. Persistent state and model-specific blocks remain authoritative. */
+export function recheckSelection(accounts, attempted, now) {
+    if (attempted === undefined)
+        return accounts;
+    return accounts.map((account) => {
+        if (attempted.has(account.name) || !unverifiedLimitBlock(account, now))
+            return account;
+        const { blockReason: _reason, blockedUntil: _until, blockedAt: _at, ...available } = account;
+        return available;
+    });
+}
+//# sourceMappingURL=limit-recheck.js.map

package/dist/core/extensions/builtin/anthropic-subscription/session-stream.d.ts

@@ -7,6 +7,7 @@ export type ResidentSessionStreamInput = {
     model: Model<Api>;
     context: Context;
     streamOptions: SimpleStreamOptions;
+    recheckedAccounts?: Set<string>;
     providerSettings: AnthropicSubscriptionProviderSettings;
     pinnedAccount?: string;
     buildOptions: Parameters<typeof queryWithAuthLane>[0]["buildOptions"];

package/dist/core/extensions/builtin/anthropic-subscription/session-stream.js

@@ -209,6 +209,7 @@ function residentAuthLaneMessages(input) {
         prompt: "",
         query: getSdkBoundary().query,
         providerSettings: input.providerSettings,
+        recheckedAccounts: input.recheckedAccounts,
         env: input.streamOptions.env,
         signal: input.streamOptions.signal,
         sessionId: input.streamOptions.affinitySessionId ?? input.streamOptions.sessionId,

package/dist/core/extensions/builtin/anthropic-subscription/stream-guidance.js

@@ -13,9 +13,11 @@ export function withAuthGuidance(error, message, ran, now = Date.now()) {
             ? allAccountsBlockedGuidance(error.soonestUnblockAt, error.blockReason, error.accounts)
             : singleAccountUnavailableGuidance(error.unavailableAccount, error.soonestUnblockAt, error.blockReason);
         // The model-limit sentence is how the fallback chain learns the limit binds this model only (senpi#5007).
+        // A pool that recovers on its own names its soonest retry, so the session's retry waits for it instead of
+        // spending its budget on local refusals that cannot change before then (senpi#6727).
         return error.limitedModel === undefined
-            ? guidance
-            : `${modelLimitSentence(error, error.limitedModel, now)}\n${guidance}${retryAfterMarker(error, now)}`;
+            ? `${guidance}${retryAfterMarker(error.rateLimitedUntil, now)}`
+            : `${modelLimitSentence(error, error.limitedModel, now)}\n${guidance}${retryAfterMarker(error.soonestUnblockAt, now)}`;
     }
     const kind = classifySdkError(error).kind;
     const account = errorAccountContext(error instanceof ClassifiedSdkError ? error.original : error);
@@ -31,7 +33,9 @@ export function withAuthGuidance(error, message, ran, now = Date.now()) {
     const pool = error instanceof ClassifiedSdkError ? error.poolState : undefined;
     const poolGuidance = pool && exhaustedPoolGuidance(pool.soonestUnblockAt, pool.accounts);
     const hints = [guidance, versionGuidance, poolGuidance].filter((hint) => hint !== undefined);
-    return hints.length > 0 ? `${message}\n${hints.join("\n")}` : message;
+    const text = hints.length > 0 ? `${message}\n${hints.join("\n")}` : message;
+    // The last account's failure left no account to try: the next one is free at the pool's soonest retry (senpi#6727).
+    return `${text}${retryAfterMarker(pool?.rateLimitedUntil, now)}`;
 }
 /**
  * Names the limit, the model and its reset as relative prose, the form `usageLimitResetMs` (the
@@ -49,8 +53,7 @@ function modelLimitSentence(error, model, now) {
     return `${subject} hit the usage limit for model ${model}; it resets in ${Math.floor(minutes / 60)} hours ${minutes % 60} minutes, at ${new Date(until).toISOString()}.`;
 }
 /** The session's retry-delay reader only takes the marker at the very end of the text. */
-function retryAfterMarker(error, now) {
-    const until = error.soonestUnblockAt;
+function retryAfterMarker(until, now) {
     return until === undefined || !Number.isFinite(until) ? "" : ` (retry-after-ms: ${Math.max(0, until - now)})`;
 }
 //# sourceMappingURL=stream-guidance.js.map

package/dist/core/extensions/builtin/anthropic-subscription/stream.d.ts

@@ -1,4 +1,4 @@
 import { type Api, type AssistantMessageEventStream, type Context, type Model, type SimpleStreamOptions } from "@earendil-works/pi-ai";
 export declare const NATIVE_COMPACTION_WHILE_SENPI_OWNS = "Claude Code compacted this session natively although senpi owns compaction on this lane (compactionOwner: \"senpi\"); the turn was stopped so only one side compacts. Run /compact, or set anthropicSubscriptionProvider.compactionOwner to \"sdk\" to let Claude Code compact.";
-export declare function streamAnthropicSubscription(model: Model<Api>, context: Context, options?: SimpleStreamOptions): AssistantMessageEventStream;
+export declare function streamAnthropicSubscription(model: Model<Api>, context: Context, options?: SimpleStreamOptions, recheckedAccounts?: Set<string>): AssistantMessageEventStream;
 //# sourceMappingURL=stream.d.ts.map

package/dist/core/extensions/builtin/anthropic-subscription/stream.js

@@ -27,7 +27,7 @@ import { emptyOutput, errorMessage, mapStopReason, updateUsage } from "./stream-
 import { toolWatch } from "./tool-watch.js";
 import { resolveSdkTools } from "./tools.js";
 export const NATIVE_COMPACTION_WHILE_SENPI_OWNS = 'Claude Code compacted this session natively although senpi owns compaction on this lane (compactionOwner: "senpi"); the turn was stopped so only one side compacts. Run /compact, or set anthropicSubscriptionProvider.compactionOwner to "sdk" to let Claude Code compact.';
-export function streamAnthropicSubscription(model, context, options) {
+export function streamAnthropicSubscription(model, context, options, recheckedAccounts) {
     const stream = createAssistantMessageEventStream();
     void (async () => {
         const output = emptyOutput(model);
@@ -166,6 +166,7 @@ export function streamAnthropicSubscription(model, context, options) {
                     model,
                     context,
                     streamOptions: options,
+                    recheckedAccounts,
                     providerSettings,
                     pinnedAccount: getSessionClaudeAccountPin(options.sessionId),
                     buildOptions,
@@ -193,6 +194,7 @@ export function streamAnthropicSubscription(model, context, options) {
                     onAttemptStart,
                     providerSettings,
                     env: options?.env,
+                    recheckedAccounts,
                     signal: options?.signal,
                     sessionId: affinityKey,
                     model: model.id,

package/dist/core/extensions/builtin/terminal/extension-state.js

@@ -118,6 +118,20 @@ export function bundleSinks(pi, state) {
         },
     };
 }
+/** A background session belongs to the turn that started it, so interrupting that turn with `background: "stop"` stops it. */
+function recordRunJob(state, id, description) {
+    const bundle = state.bundle;
+    if (bundle === null)
+        return;
+    const release = withTerminalContext(() => state.ctx?.registerRunBackgroundJob?.({
+        kind: "bash",
+        id,
+        description,
+        stop: (turnId) => bundle.stopForInterrupt(id, turnId),
+    }), () => { });
+    if (release !== undefined)
+        bundle.trackRunJob(id, release);
+}
 export function buildToolContext(pi, state) {
     const requireBundle = () => {
         // Lazily create a bundle so the tools work even when invoked directly (e.g. via the
@@ -170,6 +184,7 @@ export function buildToolContext(pi, state) {
                 ...(command === undefined ? {} : { command }),
                 ...(autoReapMinutes === undefined ? {} : { autoReapMinutes }),
             });
+            recordRunJob(state, id, description);
             const runtime = state.bundle?.manager.get(id);
             if (runtime) {
                 const key = withTerminalContext(() => sessionKeyOf(state.ctx), () => { });

package/dist/core/extensions/builtin/terminal/notify.d.ts

@@ -14,7 +14,7 @@ export interface TerminalNotifierDeps {
         details?: unknown;
     }, options: {
         triggerTurn: boolean;
-        deliverAs: "steer" | "followUp";
+        deliverAs: "steer" | "followUp" | "nextTurn";
     }) => void;
     readonly getContext: () => ExtensionContext | undefined;
     readonly getMode: () => NotifyMode;
@@ -24,6 +24,7 @@ export declare const NOTICE_TAIL_MAX_CHARS = 2000;
 export interface TerminalNotificationDelivery {
     readonly send: (content: string, options?: {
         readonly forceWake?: boolean;
+        readonly nextTurn?: boolean;
         readonly details?: unknown;
     }) => void;
 }

package/dist/core/extensions/builtin/terminal/notify.js

@@ -21,10 +21,12 @@ export function getTerminalNotificationDelivery(deps, customType = TERMINAL_NOTI
             content,
             display: false,
             ...(options?.details === undefined ? {} : { details: options.details }),
-        }, {
-            triggerTurn: true,
-            deliverAs: mode === "wake" || options?.forceWake === true ? "steer" : "followUp",
-        }),
+        }, options?.nextTurn === true
+            ? { triggerTurn: false, deliverAs: "nextTurn" }
+            : {
+                triggerTurn: true,
+                deliverAs: mode === "wake" || options?.forceWake === true ? "steer" : "followUp",
+            }),
     };
 }
 function minutes(count) {
@@ -69,7 +71,11 @@ function buildNotice(id, runtime, trustText) {
         tailSection = `\nFinal output:\n${shown}${note}`;
     }
     const trustSection = trustText === undefined ? "" : `\n${trustText}`;
-    return `<system-reminder>Background terminal session ${id} finished: ${status}${codeText}.${reapText}${tailSection}${trustSection}</system-reminder>`;
+    const interrupted = runtime.stoppedByInterrupt;
+    const ended = interrupted === undefined
+        ? `finished: ${status}${codeText}.`
+        : `was stopped when turn ${interrupted.turnId} was interrupted (${status}${codeText}).`;
+    return `<system-reminder>Background terminal session ${id} ${ended}${reapText}${tailSection}${trustSection}</system-reminder>`;
 }
 /**
  * Notifies an interactive agent once when a background session completes.
@@ -108,7 +114,10 @@ export class TerminalNotifier {
             exitCode: runtime.exitResult?.exitCode ?? null,
             output: runtime.fullOutput(),
         });
-        delivery.send(buildNotice(id, runtime, annotation?.text), annotation === undefined ? undefined : { details: { trust: annotation.trust } });
+        delivery.send(buildNotice(id, runtime, annotation?.text), {
+            ...(runtime.stoppedByInterrupt === undefined ? {} : { nextTurn: true }),
+            ...(annotation === undefined ? {} : { details: { trust: annotation.trust } }),
+        });
     }
 }
 //# sourceMappingURL=notify.js.map

package/dist/core/extensions/builtin/terminal/session-bundle.d.ts

@@ -32,9 +32,13 @@ export declare class TerminalSessionBundle {
     park(): void;
     backgroundSnapshot(): readonly WakeSourceStateItem[];
     notifyBackgroundStart(id: string, description: string, startedAtMs?: number, details?: BackgroundStartDetails): void;
+    /** Hold the release of the run job `id` was recorded as; its exit drops it. */
+    trackRunJob(id: string, release: () => void): void;
+    /** Stop a session the interrupted turn `turnId` started; its exit notice then reaches the next turn without waking. */
+    stopForInterrupt(id: string, turnId: string): Promise<void>;
     /** The auto-reap's stop did not end a session still on the schedule: one notice; its age notices go on. */
     notifyBackgroundReapFailed(id: string, autoReapMinutes: number, reason: string): void;
-    notifyBackgroundExit(id: string, runtime: TerminalExitView): void;
+    notifyBackgroundExit(id: string, exited: TerminalExitView): void;
     teardown(): Promise<void>;
 }
 /** Park a bundle across a reload; at most one parked bundle per session, older ones torn down. */

package/dist/core/extensions/builtin/terminal/session-bundle.js

@@ -19,6 +19,9 @@ export class TerminalSessionBundle {
     #ages = new BackgroundAgeSchedule((event) => this.#dispatchAge(event));
     /** Age events that came due while parked: only the newest per session is worth delivering. */
     #parkedAges = new Map();
+    /** Background sessions an interrupted turn's stop ended, by the turn id: their exit notice does not wake. */
+    #interruptStops = new Map();
+    #runJobReleases = new Map();
     #torndown = false;
     constructor(options) {
         this.manager = new TerminalManager(options);
@@ -71,6 +74,24 @@ export class TerminalSessionBundle {
         this.#ages.add({ id, description, startedAtMs, ...details });
         this.#sinks?.onBackgroundState(this.backgroundSnapshot());
     }
+    /** Hold the release of the run job `id` was recorded as; its exit drops it. */
+    trackRunJob(id, release) {
+        if (this.#torndown)
+            return release();
+        this.#runJobReleases.set(id, release);
+    }
+    /** Stop a session the interrupted turn `turnId` started; its exit notice then reaches the next turn without waking. */
+    async stopForInterrupt(id, turnId) {
+        const runtime = this.manager.get(id);
+        if (runtime === null)
+            throw new Error(`${id} runs on the session's tool child, which this stop does not reach`);
+        this.#interruptStops.set(id, turnId);
+        const stopped = await this.manager.stop(id);
+        if (stopped && runtime.exited)
+            return;
+        this.#interruptStops.delete(id);
+        throw new Error(`${id} was still running after the stop (TERM, then KILL)`);
+    }
     /** The auto-reap's stop did not end a session still on the schedule: one notice; its age notices go on. */
     notifyBackgroundReapFailed(id, autoReapMinutes, reason) {
         if (this.#torndown)
@@ -81,9 +102,14 @@ export class TerminalSessionBundle {
         const event = backgroundAgeEvent("reap_failed", { ...subject, autoReapMinutes }, Date.now());
         this.#dispatchAge({ ...event, reason });
     }
-    notifyBackgroundExit(id, runtime) {
+    notifyBackgroundExit(id, exited) {
         if (this.#torndown)
             return;
+        this.#runJobReleases.get(id)?.();
+        this.#runJobReleases.delete(id);
+        const interruptedTurn = this.#interruptStops.get(id);
+        this.#interruptStops.delete(id);
+        const runtime = interruptedTurn === undefined ? exited : stoppedByInterruptView(exited, interruptedTurn);
         const subject = this.#ages.remove(id);
         this.#parkedAges.delete(id);
         if (subject && runtime.autoReapedAfterMinutes !== undefined) {
@@ -107,6 +133,10 @@ export class TerminalSessionBundle {
         this.#parkedExits.clear();
         this.#ages.dispose();
         this.#parkedAges.clear();
+        for (const release of this.#runJobReleases.values())
+            release();
+        this.#runJobReleases.clear();
+        this.#interruptStops.clear();
         this.monitors.dispose();
         if (this.#backgrounds.size > 0) {
             this.#backgrounds.clear();
@@ -137,6 +167,16 @@ export class TerminalSessionBundle {
             this.#parkedMonitorEvents.shift();
     }
 }
+function stoppedByInterruptView(runtime, turnId) {
+    return {
+        exitResult: runtime.exitResult,
+        ...(runtime.autoReapedAfterMinutes === undefined
+            ? {}
+            : { autoReapedAfterMinutes: runtime.autoReapedAfterMinutes }),
+        stoppedByInterrupt: { turnId },
+        fullOutput: () => runtime.fullOutput(),
+    };
+}
 const parkedBundles = new Map();
 /** Park a bundle across a reload; at most one parked bundle per session, older ones torn down. */
 export async function parkBundle(sessionKey, bundle) {

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

@@ -64,6 +64,10 @@ 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;
+    /** Set when `interrupt { background: "stop" }` on turn `turnId` stopped the session: its notice does not wake. */
+    readonly stoppedByInterrupt?: {
+        readonly turnId: string;
+    };
     fullOutput(): string;
 }
 export interface TerminalLaunchBarrier {

package/dist/core/extensions/loader.js

@@ -843,6 +843,11 @@ function createExtensionAPI(extension, runtime, cwd, eventBus, session) {
             if (state !== "loading")
                 return;
             runtime.assertActive();
+            // Checked before anything is applied: another extension may have registered a device machine while this load's
+            // registration was staged (from an event fired during this factory). The load then fails whole, nothing half-applied.
+            if (deviceMachineStaged && runtime.deviceMachine !== undefined) {
+                throw new DeviceMachineConflictError(runtime.deviceMachine.extensionPath, extension.path);
+            }
             for (const [name, value] of pendingFlagValues) {
                 if (!runtime.flagValues.has(name))
                     runtime.flagValues.set(name, value);

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

@@ -169,6 +169,7 @@ export declare class ExtensionRunner {
     private engineTurnsHeldFn;
     private noteHeldWakeFn;
     private pauseActions;
+    private registerRunBackgroundJobFn;
     private questionInput;
     private personAnswerPending;
     private isProjectTrustedFn;

package/dist/core/extensions/runner.js

@@ -534,6 +534,7 @@ export class ExtensionRunner {
             fenceRun: contextActions.fenceRun,
             releaseRunFence: contextActions.releaseRunFence,
         };
+        this.registerRunBackgroundJobFn = contextActions.registerRunBackgroundJob;
         this.questionInput = contextActions.questionInput;
         this.isProjectTrustedFn = contextActions.isProjectTrusted;
         this.getSignalFn = contextActions.getSignal;
@@ -1345,6 +1346,10 @@ export class ExtensionRunner {
                 runner.assertActive();
                 runner.pauseActions.releaseRunFence?.(runRef);
             },
+            registerRunBackgroundJob: (job) => {
+                runner.assertActive();
+                return runner.registerRunBackgroundJobFn?.(job) ?? (() => { });
+            },
             isProjectTrusted: () => {
                 runner.assertActive();
                 return runner.isProjectTrustedFn();

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

@@ -55,6 +55,7 @@ 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";
+import type { RunBackgroundJob } from "../run-background-jobs.ts";
 export type { ExecOptions, ExecResult } from "../exec.ts";
 export type { AppKeybinding, KeybindingsManager } from "../keybindings.ts";
 export type { BuildSystemPromptOptions, NormalizedBuildSystemPromptOptions } from "../system-prompt.ts";
@@ -483,6 +484,11 @@ export interface ExtensionContext {
         kind: "dag" | "task" | "workpool" | "team";
         id: string;
     }): void;
+    /**
+     * Record a background job the running turn started, so `interrupt { background: "stop" }` on that turn stops it.
+     * Outside a turn nothing is recorded. The returned release drops the job once it ended on its own.
+     */
+    registerRunBackgroundJob?(job: RunBackgroundJob): () => void;
     /** Whether project-local trust is active for this context. */
     isProjectTrusted(): boolean;
     /** The current abort signal, or undefined when the agent is not streaming. */
@@ -2956,6 +2962,7 @@ export interface ExtensionContextActions {
         kind: "dag" | "task" | "workpool" | "team";
         id: string;
     }) => void;
+    registerRunBackgroundJob?: (job: RunBackgroundJob) => () => void;
     /** Internal delivery for a human-settled builtin question, never exposed on ExtensionAPI. */
     questionInput?: () => void;
     isProjectTrusted: () => boolean;

package/dist/core/run-background-jobs.d.ts

@@ -0,0 +1,33 @@
+/**
+ * The background jobs each turn started (a bash command run with `run_in_background` or one that auto-detached),
+ * keyed by the turn id (`turn_epoch`) that was running when the job became background. `interrupt { background:
+ * "stop" }` stops the jobs of the turn it interrupted, so nothing that turn left running wakes the session later.
+ * A job leaves the registry when it ends on its own (`release`) or once it is stopped.
+ */
+/** A job the turn started; `stop` ends it without waking the session and rejects with the reason it could not. */
+export interface RunBackgroundJob {
+    readonly kind: "bash";
+    readonly id: string;
+    readonly description?: string;
+    stop(turnId: string): Promise<void>;
+}
+export interface StoppedRunBackgroundJob {
+    readonly kind: RunBackgroundJob["kind"];
+    readonly id: string;
+    readonly description?: string;
+}
+export interface FailedRunBackgroundJob extends StoppedRunBackgroundJob {
+    readonly reason: string;
+}
+/** What `interrupt { background: "stop" }` stopped, and each job it could not stop with the reason. */
+export interface RunBackgroundStopOutcome {
+    readonly stopped: readonly StoppedRunBackgroundJob[];
+    readonly failed: readonly FailedRunBackgroundJob[];
+}
+export declare class RunBackgroundJobs {
+    #private;
+    /** Record `job` under `turnId`; the returned release drops it once it ended on its own. */
+    register(turnId: string, job: RunBackgroundJob): () => void;
+    stop(turnId: string): Promise<RunBackgroundStopOutcome>;
+}
+//# sourceMappingURL=run-background-jobs.d.ts.map

package/dist/core/run-background-jobs.js

@@ -0,0 +1,47 @@
+/**
+ * The background jobs each turn started (a bash command run with `run_in_background` or one that auto-detached),
+ * keyed by the turn id (`turn_epoch`) that was running when the job became background. `interrupt { background:
+ * "stop" }` stops the jobs of the turn it interrupted, so nothing that turn left running wakes the session later.
+ * A job leaves the registry when it ends on its own (`release`) or once it is stopped.
+ */
+function named(job) {
+    return { kind: job.kind, id: job.id, ...(job.description === undefined ? {} : { description: job.description }) };
+}
+export class RunBackgroundJobs {
+    #byTurn = new Map();
+    /** Record `job` under `turnId`; the returned release drops it once it ended on its own. */
+    register(turnId, job) {
+        let jobs = this.#byTurn.get(turnId);
+        if (jobs === undefined) {
+            jobs = new Set();
+            this.#byTurn.set(turnId, jobs);
+        }
+        jobs.add(job);
+        return () => this.#drop(turnId, job);
+    }
+    async stop(turnId) {
+        const jobs = [...(this.#byTurn.get(turnId) ?? [])];
+        this.#byTurn.delete(turnId);
+        const stopped = [];
+        const failed = [];
+        for (const job of jobs) {
+            try {
+                await job.stop(turnId);
+                stopped.push(named(job));
+            }
+            catch (error) {
+                failed.push({ ...named(job), reason: error instanceof Error ? error.message : String(error) });
+            }
+        }
+        return { stopped, failed };
+    }
+    #drop(turnId, job) {
+        const jobs = this.#byTurn.get(turnId);
+        if (jobs === undefined)
+            return;
+        jobs.delete(job);
+        if (jobs.size === 0)
+            this.#byTurn.delete(turnId);
+    }
+}
+//# sourceMappingURL=run-background-jobs.js.map

package/dist/core/tools/bash-core.d.ts

@@ -0,0 +1,50 @@
+import type { ExecShell } from "../../../vendor/senpi-machine-ops/index.js";
+import type { AgentTool } from "@earendil-works/pi-agent-core";
+import type { ShellTrust } from "../../engine-trust/shell-trust.ts";
+import type { ToolDefinition } from "../extensions/types.ts";
+import { type BashSpawnHook, type BashToolDetails, bashSchema, type ShellToolConfig } from "./bash-schema.ts";
+import { type OutputSpillFactory } from "./output-accumulator-core.ts";
+import { type BashOperations } from "./shell-operations.ts";
+import type { ToolMachine } from "./tool-machine.ts";
+/** Annotates a failed command's result with the engine trust status; undefined leaves the result as is. */
+export type ShellTrustAnnotator = (result: {
+    exitCode: number;
+    output: string;
+}) => {
+    text: string | undefined;
+    trust: ShellTrust;
+} | undefined;
+export interface ShellToolCoreOptions {
+    /** Runs the policy gate once per call. */
+    machine: ToolMachine;
+    /** Where the command runs. */
+    operations: BashOperations;
+    /** Where output past the display limits is kept; the path appears in the model's truncation notice. */
+    outputSpill: OutputSpillFactory;
+    /** The base environment before the session's `PI_*` values. Default: empty. */
+    shellEnv?: () => NodeJS.ProcessEnv;
+    /** Default: no annotation. */
+    annotateTrust?: ShellTrustAnnotator;
+    /** Redact credential-shaped output before streaming or spilling. Default: false. */
+    redactSecretsInOutput?: boolean;
+    /** Command prefix prepended to every command (for example shell setup commands) */
+    commandPrefix?: string;
+    /** Expose current Pi session metadata as PI_* environment variables. Default: true */
+    exposeSessionEnvironment?: boolean;
+    /** Hook to adjust command, cwd, or env before execution */
+    spawnHook?: BashSpawnHook;
+}
+/** A shell tool's model-facing definition and execution, without renderers: the shared core of bash and powershell. */
+export declare function createShellToolCore(cwd: string, config: ShellToolConfig, options: ShellToolCoreOptions): ToolDefinition<typeof bashSchema, BashToolDetails | undefined>;
+export interface CoreBashToolOptions extends Omit<ShellToolCoreOptions, "operations" | "outputSpill" | "annotateTrust" | "shellEnv"> {
+    /** Where the command runs. Default: `process.exec` on `machine`, in `shell`. */
+    operations?: BashOperations;
+    /** The shell for the default operations. Default: the machine's own (`/bin/sh -c` on POSIX). */
+    shell?: ExecShell;
+    /** Default: a file under `/tmp` on `machine` (see `createMachineOutputSpill`). */
+    outputSpill?: OutputSpillFactory;
+}
+/** The bash tool for a host whose only effect channel is `machine`. */
+export declare function createCoreBashToolDefinition(cwd: string, options: CoreBashToolOptions): ToolDefinition<typeof bashSchema, BashToolDetails | undefined>;
+export declare function createCoreBashTool(cwd: string, options: CoreBashToolOptions): AgentTool<typeof bashSchema>;
+//# sourceMappingURL=bash-core.d.ts.map