@timurproko/a1 0.1.8-dev.457 → 0.1.8-dev.465

package/dist/integrations/pi/engine/compaction-progress.js

@@ -0,0 +1,96 @@
+/** Expected summary size for a first compaction, when no previous summary on the branch can serve as the estimate. */
+export const DEFAULT_EXPECTED_COMPACTION_SUMMARY_CHARS = 4000;
+/** The percent shown while a compaction is still running never reaches this value. */
+const MAX_RUNNING_PERCENT = 99;
+/**
+ * Observes the summarization stream of a compaction through the session agent's public stream
+ * function and reports an estimated integer percent. Pi never iterates that stream itself (it
+ * reads only its final result), so the observer iterates it in the background between
+ * `begin()` and `end()` and returns the same stream object to Pi. Outside that window the
+ * wrapper is a pass-through. Returns null when the agent exposes no callable stream function,
+ * in which case compaction proceeds without progress.
+ */
+export function observeCompactionProgress(session, onProgress) {
+    const agent = session.agent;
+    if (agent === undefined || typeof agent.streamFunction !== "function")
+        return null;
+    const original = agent.streamFunction;
+    let active = false;
+    let disposed = false;
+    let generation = 0;
+    let streamed = 0;
+    let expected = DEFAULT_EXPECTED_COMPACTION_SUMMARY_CHARS;
+    let reported = null;
+    const report = () => {
+        const percent = Math.min(MAX_RUNNING_PERCENT, Math.floor((100 * streamed) / expected));
+        if (percent === reported)
+            return;
+        reported = percent;
+        onProgress(percent);
+    };
+    const wrapped = async (model, context, options) => {
+        const stream = await original(model, context, options);
+        if (!active || disposed)
+            return stream;
+        const observed = generation;
+        void (async () => {
+            report();
+            // Invariant: observation never affects the request; a stream that cannot be iterated ends observation only.
+            try {
+                for await (const event of stream) {
+                    if (observed !== generation || !active)
+                        return;
+                    if (event.type === "text_delta") {
+                        streamed += event.delta.length;
+                        report();
+                    }
+                }
+            }
+            catch {
+                return;
+            }
+        })();
+        return stream;
+    };
+    agent.streamFunction = wrapped;
+    return {
+        begin() {
+            generation += 1;
+            streamed = 0;
+            reported = null;
+            expected = latestCompactionSummaryLength(session) ?? DEFAULT_EXPECTED_COMPACTION_SUMMARY_CHARS;
+            active = true;
+        },
+        end() {
+            active = false;
+            generation += 1;
+        },
+        dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            active = false;
+            generation += 1;
+            if (agent.streamFunction === wrapped)
+                agent.streamFunction = original;
+        },
+    };
+}
+function latestCompactionSummaryLength(session) {
+    let entries;
+    try {
+        entries = session.sessionManager?.getBranch?.() ?? [];
+    }
+    catch {
+        return null;
+    }
+    for (let index = entries.length - 1; index >= 0; index -= 1) {
+        const entry = entries[index];
+        if (typeof entry !== "object" || entry === null)
+            continue;
+        const { type, summary } = entry;
+        if (type === "compaction" && typeof summary === "string" && summary.length > 0)
+            return summary.length;
+    }
+    return null;
+}

package/dist/integrations/pi/engine/conformance.d.ts

@@ -6,7 +6,7 @@ export interface PiCapabilityConformanceResult {
 export declare const REQUIRED_PI_CAPABILITY_OPERATIONS: Readonly<{
     readonly "public-exports": readonly ["services.create", "session.create", "runtime.create"];
     readonly "session-lifecycle": readonly ["session.new", "session.resume", "session.rebind", "session.dispose"];
-    readonly "commands-events": readonly ["prompt", "steer", "followUp", "abort", "compact", "setModel", "setThinkingLevel", "subscribe", "dispose"];
+    readonly "commands-events": readonly ["prompt", "steer", "followUp", "clearQueue", "abort", "compact", "setModel", "setThinkingLevel", "subscribe", "dispose"];
     readonly "models-authentication": readonly ["models.list", "models.refresh", "models.completeSimple", "auth.status", "auth.login", "auth.logout", "auth.cancel"];
     readonly settings: readonly ["settings.read", "settings.write", "settings.flush"];
     readonly "resources-extensions": readonly ["resources.discover", "extensions.inline", "extensions.bind", "extensions.reload", "renderers.invoke"];

package/dist/integrations/pi/engine/conformance.js

@@ -8,7 +8,7 @@ import { createWindowsNulCleanupExtension } from "./windows-filesystem-hygiene.j
 export const REQUIRED_PI_CAPABILITY_OPERATIONS = Object.freeze({
     "public-exports": ["services.create", "session.create", "runtime.create"],
     "session-lifecycle": ["session.new", "session.resume", "session.rebind", "session.dispose"],
-    "commands-events": ["prompt", "steer", "followUp", "abort", "compact", "setModel", "setThinkingLevel", "subscribe", "dispose"],
+    "commands-events": ["prompt", "steer", "followUp", "clearQueue", "abort", "compact", "setModel", "setThinkingLevel", "subscribe", "dispose"],
     "models-authentication": ["models.list", "models.refresh", "models.completeSimple", "auth.status", "auth.login", "auth.logout", "auth.cancel"],
     settings: ["settings.read", "settings.write", "settings.flush"],
     "resources-extensions": ["resources.discover", "extensions.inline", "extensions.bind", "extensions.reload", "renderers.invoke"],
@@ -85,7 +85,7 @@ export async function runPiUpgradeConformance() {
             });
             const session = created.session;
             sessionId = session.sessionId;
-            requireMethods(session, "session commands", ["prompt", "steer", "followUp", "abort", "compact", "setModel", "setThinkingLevel", "subscribe", "dispose"]);
+            requireMethods(session, "session commands", ["prompt", "steer", "followUp", "clearQueue", "abort", "compact", "setModel", "setThinkingLevel", "subscribe", "dispose"]);
             requireMethods(services.modelRuntime, "models/authentication", ["getModels", "getModel", "completeSimple", "checkAuth", "login", "logout", "refresh"]);
             requireMethods(services.settingsManager, "settings", ["getGlobalSettings", "getProjectSettings", "flush"]);
             requireMethods(services.resourceLoader, "resources/extensions", ["getExtensions", "getSkills", "getPrompts", "getThemes", "reload"]);
@@ -96,7 +96,7 @@ export async function runPiUpgradeConformance() {
         catch (error) {
             throw new PiUpgradeConformanceError("session", error);
         }
-        const commandSurface = ["prompt", "steer", "followUp", "abort", "compact", "setModel", "setThinkingLevel", "subscribe", "dispose"];
+        const commandSurface = ["prompt", "steer", "followUp", "clearQueue", "abort", "compact", "setModel", "setThinkingLevel", "subscribe", "dispose"];
         const capabilities = Object.entries(REQUIRED_PI_CAPABILITY_OPERATIONS)
             .map(([capabilityName, operations]) => capability(capabilityName, operations));
         validatePiCapabilityResults(VERSION, capabilities);

package/dist/integrations/pi/engine/session-integration.d.ts

@@ -1,24 +1,33 @@
 import type { AgentSession, AgentSessionEvent, PromptOptions } from "../startup-public.js";
 import { type AgentCommandOutcome, type AgentEvent } from "../../../contracts/agent-engine/index.js";
+type PiPromptImages = NonNullable<PromptOptions["images"]>;
 export interface PiDocumentedSessionCommands {
     readonly isStreaming: AgentSession["isStreaming"];
     readonly isRetrying: AgentSession["isRetrying"];
     readonly isCompacting: AgentSession["isCompacting"];
     prompt(text: string, options?: Parameters<AgentSession["prompt"]>[1]): Promise<void>;
-    steer(text: string): Promise<void>;
-    followUp(text: string): Promise<void>;
+    steer(text: string, images?: PiPromptImages): Promise<void>;
+    followUp(text: string, images?: PiPromptImages): Promise<void>;
     abort(): Promise<void>;
     abortRetry(): void;
     abortCompaction(): void;
     compact(customInstructions?: Parameters<AgentSession["compact"]>[0]): Promise<unknown>;
+    clearQueue(): {
+        readonly steering: readonly string[];
+        readonly followUp: readonly string[];
+    };
     executeBash?(command: string, onChunk: unknown, options: {
         readonly excludeFromContext: boolean;
     }): Promise<unknown>;
+    /** Optional: extension commands cannot be queued, so they run immediately during compaction as in pinned Pi. */
+    readonly extensionRunner?: {
+        getCommand(name: string): unknown;
+    } | undefined;
 }
 export type PiSessionCommand = {
     readonly type: "prompt" | "steer" | "follow-up";
     readonly text: string;
-    readonly images?: NonNullable<PromptOptions["images"]>;
+    readonly images?: PiPromptImages;
 } | {
     readonly type: "abort" | "retry" | "compact";
 } | {
@@ -37,9 +46,22 @@ export declare class PiSessionCommandIntegration {
     private readonly session;
     constructor(session: PiDocumentedSessionCommands);
     execute(command: PiSessionCommand): Promise<PiSessionCommandResult>;
+    /**
+     * Delivers the messages queued during a manual compaction. The session is idle when a manual
+     * compaction ends, so nothing would consume the queue: the first message starts one run
+     * through the ordinary prompt path with its mode, and the rest are re-queued for that run,
+     * whose initial poll injects them in order. Automatic compaction needs no delivery: its
+     * continuing run or pending prompt consumes the queue itself. The run is not awaited; when
+     * the start is refused before the message is accepted, the queue is restored and the error
+     * reported through `onFailure`.
+     */
+    deliverQueuedAfterCompaction(onFailure: (error: unknown) => void): Promise<void>;
+    /** Forgets the attachments kept for queued messages; the queue itself was cleared by the caller. */
+    forgetQueuedImages(): void;
 }
 export interface PiOrderedEventIntegration {
     dispose(): void;
 }
 export declare function subscribeToPiSessionEvents(session: Pick<AgentSession, "subscribe">, sessionId: string, emit: (event: AgentEvent) => void, malformed: (diagnostic: string) => void): PiOrderedEventIntegration;
 export declare function convertPiSessionEvent(event: AgentSessionEvent, sessionId: string, sequence: number): AgentEvent | null;
+export {};

package/dist/integrations/pi/engine/session-integration.js

@@ -3,6 +3,9 @@ import { AGENT_ENGINE_CONTRACT_VERSION, } from "../../../contracts/agent-engine/
 export class PiSessionCommandIntegration {
     session;
     #lastPrompt = null;
+    // Rationale: Pi's queue restore returns text only, so the attachments of messages queued
+    // during compaction are kept here until the queue is delivered or cleared.
+    #queuedImages = [];
     constructor(session) {
         this.session = session;
     }
@@ -18,22 +21,24 @@ export class PiSessionCommandIntegration {
                     });
                 return { outcome: "completed" };
             case "steer":
+            case "follow-up": {
                 this.#lastPrompt = command.text;
+                const mode = command.type === "steer" ? "steer" : "followUp";
+                if (this.session.isCompacting && !this.#isExtensionCommand(command.text)) {
+                    // Compatibility: match interactive Pi: prompt() refuses input during manual compaction,
+                    // while the engine queue accepts it at any time and delivers it when compaction ends.
+                    await this.#queue(mode, command.text, command.images);
+                    return { outcome: "completed" };
+                }
                 // Compatibility: match interactive Pi: prompt() owns template/extension expansion and
                 // turns the accepted steering message into the visible user row while
                 // later messages remain in the pending queue.
                 await this.session.prompt(command.text, {
-                    streamingBehavior: "steer",
-                    ...(command.images === undefined ? {} : { images: [...command.images] }),
-                });
-                return { outcome: "completed" };
-            case "follow-up":
-                this.#lastPrompt = command.text;
-                await this.session.prompt(command.text, {
-                    streamingBehavior: "followUp",
+                    streamingBehavior: mode,
                     ...(command.images === undefined ? {} : { images: [...command.images] }),
                 });
                 return { outcome: "completed" };
+            }
             case "abort":
                 if (this.session.isRetrying)
                     this.session.abortRetry();
@@ -61,6 +66,86 @@ export class PiSessionCommandIntegration {
             }
         }
     }
+    /**
+     * Delivers the messages queued during a manual compaction. The session is idle when a manual
+     * compaction ends, so nothing would consume the queue: the first message starts one run
+     * through the ordinary prompt path with its mode, and the rest are re-queued for that run,
+     * whose initial poll injects them in order. Automatic compaction needs no delivery: its
+     * continuing run or pending prompt consumes the queue itself. The run is not awaited; when
+     * the start is refused before the message is accepted, the queue is restored and the error
+     * reported through `onFailure`.
+     */
+    async deliverQueuedAfterCompaction(onFailure) {
+        if (this.session.isStreaming || this.session.isCompacting)
+            return;
+        const { steering, followUp } = this.session.clearQueue();
+        const queued = [
+            ...steering.map(text => ({ mode: "steer", text, images: this.#takeImages(text) })),
+            ...followUp.map(text => ({ mode: "followUp", text, images: this.#takeImages(text) })),
+        ];
+        this.#queuedImages = [];
+        const [first, ...rest] = queued;
+        if (first === undefined)
+            return;
+        this.#lastPrompt = first.text;
+        let accepted = false;
+        const started = this.session.prompt(first.text, {
+            streamingBehavior: first.mode,
+            preflightResult: success => { accepted = success; },
+            ...(first.images === undefined ? {} : { images: [...first.images] }),
+        });
+        for (const item of rest)
+            await this.#queue(item.mode, item.text, item.images);
+        started.catch(async (error) => {
+            // Security: a run that reached the provider is never resent; only a refused start restores.
+            try {
+                if (!accepted)
+                    await this.#restoreQueue(queued);
+            }
+            finally {
+                onFailure(error);
+            }
+        }).catch(() => undefined);
+    }
+    /** Forgets the attachments kept for queued messages; the queue itself was cleared by the caller. */
+    forgetQueuedImages() {
+        this.#queuedImages = [];
+    }
+    // Rationale: the rest were re-queued before the refused start surfaced, so the queue is rebuilt
+    // in the original order; anything queued in between keeps its place after it.
+    async #restoreQueue(queued) {
+        const { steering, followUp } = this.session.clearQueue();
+        const restored = new Set(queued.map(item => item.text));
+        const extra = [
+            ...steering.filter(text => !restored.has(text)).map(text => ({ mode: "steer", text, images: this.#takeImages(text) })),
+            ...followUp.filter(text => !restored.has(text)).map(text => ({ mode: "followUp", text, images: this.#takeImages(text) })),
+        ];
+        this.#queuedImages = [];
+        for (const item of [...queued, ...extra])
+            await this.#queue(item.mode, item.text, item.images);
+    }
+    async #queue(mode, text, images) {
+        if (images !== undefined && images.length > 0)
+            this.#queuedImages.push({ text, images: [...images] });
+        if (mode === "steer")
+            await this.session.steer(text, images === undefined ? undefined : [...images]);
+        else
+            await this.session.followUp(text, images === undefined ? undefined : [...images]);
+    }
+    #takeImages(text) {
+        const index = this.#queuedImages.findIndex(item => item.text === text);
+        if (index === -1)
+            return undefined;
+        const [item] = this.#queuedImages.splice(index, 1);
+        return item?.images;
+    }
+    #isExtensionCommand(text) {
+        if (!text.startsWith("/"))
+            return false;
+        const spaceIndex = text.indexOf(" ");
+        const name = spaceIndex === -1 ? text.slice(1) : text.slice(1, spaceIndex);
+        return this.session.extensionRunner?.getCommand(name) !== undefined;
+    }
 }
 export function subscribeToPiSessionEvents(session, sessionId, emit, malformed) {
     let sequence = 0;

package/dist/integrations/pi/session-ui/session-shell-root.js

@@ -103,6 +103,7 @@ export class OwnedUiSessionShellRoot {
         });
         this.resources = createPiShellLoadedResources(startup.resources ?? [], startup.expanded ?? false);
         this.#status = createPiShellStatus(view, progressStatusText, handlers);
+        this.#status.setProgressPresentation(this.#customViewport ? "custom-viewport" : "pinned");
         this.#footer = createPiShellFooter(this.#viewWithExtensionStatuses(view), cwd, this.#customViewport ? "a1" : "pi");
         this.#queued = createPiQueuedInputStatus(view.editor.queuedSubmissions, this.#customViewport ? "custom-viewport" : "pinned");
         this.editor = createPiShellEditor({

package/dist/integrations/pi/session-ui/session-shell.js

@@ -66,7 +66,6 @@ export class OwnedUiSessionShell {
     #showImages = true;
     #imageWidthCells = 80;
     #fullscreenExitOutput = "transcript";
-    #compactionQueue = [];
     #waitingImages = new Map();
     #lastClearTime = 0;
     #lastEscapeTime = 0;
@@ -494,8 +493,6 @@ export class OwnedUiSessionShell {
                     model: event.model,
                 });
             }
-            if (view.lifecycle === "ready" && this.#compactionQueue.length > 0)
-                void this.#flushCompactionQueue();
             if (event.type === "session-lifecycle" && event.lifecycle === "stopped")
                 this.#settleStoppedLifecycle();
         });
@@ -642,18 +639,8 @@ export class OwnedUiSessionShell {
                 }
             }
         }
-        if (this.view().status.workingMessage?.startsWith("Compacting") === true) {
-            this.#rememberInput(displayInput, "steer");
-            this.#compactionQueue.push({
-                text: input,
-                draft: displayInput,
-                type: "steer",
-                ...(prepared.images.length === 0 ? {} : { images: prepared.images }),
-            });
-            this.root.appendWorkflowResult({ command: "compact", outcome: "completed", message: `Queued during compaction: ${input}` });
-            this.runtime.requestRender();
-            return { outcome: "completed", diagnostic: null };
-        }
+        // Compatibility: match interactive Pi: input during compaction is queued steering; the engine
+        // shows it in the pending rows and delivers it when compaction ends.
         const type = this.view().lifecycle === "busy" ? "steer" : "prompt";
         this.#rememberInput(displayInput, type);
         this.root.resumeViewportFollowing();
@@ -772,15 +759,6 @@ export class OwnedUiSessionShell {
         if (this.root.editor.getText() === draft)
             this.root.editor.setText("");
         this.root.resumeViewportFollowing();
-        if (this.view().status.workingMessage?.startsWith("Compacting") === true) {
-            this.#compactionQueue.push({
-                text,
-                draft: displayInput,
-                type: "follow-up",
-                ...(prepared.images.length === 0 ? {} : { images: prepared.images }),
-            });
-            return { outcome: "completed", diagnostic: null };
-        }
         return this.#execute({
             type: "follow-up",
             correlationId: this.#correlation("follow-up"),
@@ -790,9 +768,8 @@ export class OwnedUiSessionShell {
         }, displayInput);
     }
     restoreQueuedInput() {
-        const queued = [...this.#waitingImages.keys(), ...this.backend.clearQueuedWorkflows(), ...this.#compactionQueue.map(item => item.draft)];
+        const queued = [...this.#waitingImages.keys(), ...this.backend.clearQueuedWorkflows()];
         this.#cancelWaitingImages();
-        this.#compactionQueue = [];
         if (queued.length === 0)
             return;
         this.root.editor.setText(queued.join("\n"));
@@ -1394,6 +1371,10 @@ export class OwnedUiSessionShell {
         attempt(() => this.#unsubscribe());
         attempt(() => this.#dialogHandle?.hide());
         attempt(() => this.#extensionBridge.dispose());
+        // Invariant: from here to the leave nothing but the outro paints. A throttled frame the
+        // renderer still has queued would otherwise land during the stop-time input drain and
+        // flash the prompt and footer, whether or not an effect plays.
+        attempt(() => this.#freezeQuitPresentation());
         await this.#playQuitOutro(outroFrame);
         // Invariant: terminal restoration precedes any potentially stalled backend teardown. The
         // fullscreen leave preserves the screen: the pinned runtime never dumps its final document
@@ -1415,8 +1396,8 @@ export class OwnedUiSessionShell {
         if (!this.runtime.active || this.runtime.mode !== "fullscreen")
             return null;
         try {
-            const { effect, durationMs } = outro.snapshot();
-            if (effect === "off")
+            const { enabled, effect, durationMs } = outro.snapshot();
+            if (!enabled)
                 return null;
             const viewport = this.runtime.viewport();
             return { rows: this.#damageTerminal.presentedRows(), columns: viewport.columns, height: viewport.rows, settings: { effect, durationMs } };
@@ -1425,6 +1406,11 @@ export class OwnedUiSessionShell {
             return null;
         }
     }
+    #freezeQuitPresentation() {
+        if (!this.#customViewport || !this.runtime.active || this.runtime.mode !== "fullscreen")
+            return;
+        this.runtime.freezePresentation();
+    }
     // Rationale: any failure here only skips the effect; restoration always follows.
     async #playQuitOutro(capture) {
         const outro = this.#quitOutro;
@@ -1436,7 +1422,6 @@ export class OwnedUiSessionShell {
             const frame = captureQuitOutroFrame(capture.rows, capture.columns, capture.height);
             if (frame === null || !this.runtime.active)
                 return;
-            this.runtime.freezePresentation();
             await playQuitOutro(frame, capture.settings.effect, capture.settings.durationMs, {
                 write: data => this.runtime.writeControl(data),
                 ...(outro.now === undefined ? {} : { now: outro.now }),
@@ -1765,19 +1750,6 @@ export class OwnedUiSessionShell {
         this.root.setInputSurface(null);
         this.runtime.requestRender();
     }
-    async #flushCompactionQueue() {
-        const queued = this.#compactionQueue;
-        this.#compactionQueue = [];
-        for (const item of queued) {
-            await this.#execute({
-                type: item.type,
-                correlationId: this.#correlation(`compaction-${item.type}`),
-                sessionId: this.backend.sessionId,
-                text: item.text,
-                ...(item.images === undefined ? {} : { images: item.images }),
-            }, item.draft);
-        }
-    }
     async #execute(command, draft) {
         if (draft === undefined)
             return this.backend.execute(command);

package/dist/native/darwin-arm64/manifest.json

@@ -5,7 +5,7 @@
   "platform": "darwin",
   "architecture": "arm64",
   "capability": "supported",
-  "builtAt": "2026-09-17T10:19:32.993Z",
+  "builtAt": "2026-09-17T17:09:52.350Z",
   "artifact": {
     "filename": "process-guardian",
     "sha256": "9db1726bbe3fc2e8292f2ead1e7e9d0fd4d7d0dc9217b372582bf354b0f565dc",

package/dist/native/linux-x64/manifest.json

@@ -5,7 +5,7 @@
   "platform": "linux",
   "architecture": "x64",
   "capability": "supported",
-  "builtAt": "2026-09-17T10:19:33.794Z",
+  "builtAt": "2026-09-17T17:09:48.434Z",
   "artifact": {
     "filename": "process-guardian",
     "sha256": "d8cda6b0c7cb36c0cc41e90802aceebf6c02eaebbc08a83d7d963d2e918dbd7a",

package/dist/native/win32-x64/manifest.json

@@ -5,10 +5,10 @@
   "platform": "win32",
   "architecture": "x64",
   "capability": "supported",
-  "builtAt": "2026-09-17T10:20:20.745Z",
+  "builtAt": "2026-09-17T17:10:27.708Z",
   "artifact": {
     "filename": "process-guardian.exe",
-    "sha256": "049f0659bfe5d506a900d07e219c6a96480e8495dede8375c7ea5f9e5dc1990d",
+    "sha256": "7f414d3e5005949040b86ae78a4f73375ac5773c6ad9f6a3b3f22e7d9f7d5b11",
     "size": 177664
   },
   "provenance": {

package/dist/ui/components/list-view.js

@@ -29,14 +29,13 @@ export function renderListRow(row, state, valueColumn, width, theme) {
         ? `${theme.fg("accent", cursor)}${theme.fg("accent", labelPadded)}`
         : `${cursor}${theme.plain(labelPadded)}`;
     const gap = Math.max(2, valueColumn - displayWidth(leftRaw));
-    // Compatibility: pinned SettingsList gives the selected label and value the same accent
-    // role. Pointer hover may brighten an unselected value without changing the
-    // keyboard selection.
+    // Rationale: a declared difference from pinned SettingsList, which paints the selected
+    // value in the accent too. Here only the cursor and label carry the selection; the
+    // value reads the same on every row, and pointer hover brightens it without moving
+    // the keyboard selection.
     const valueHovered = state.hovered && state.region !== "label";
     const stepper = row.stepper !== undefined && valueHovered;
-    const value = state.selected
-        ? theme.fg("accent", row.value)
-        : valueHovered ? theme.plain(row.value) : theme.fg("muted", row.value);
+    const value = valueHovered ? theme.plain(row.value) : theme.fg("muted", row.value);
     const minus = stepper
         ? row.stepper?.lower === true
             ? state.region === "minus" ? theme.plain("- ") : theme.fg("dim", "- ")

package/dist/ui/components/surface.d.ts

@@ -1,12 +1,17 @@
-import { type ScrollbarGeometry } from "./scrollbar.js";
+import { type ScrollbarGeometry, type ScrollbarPresentation } from "./scrollbar.js";
 import type { UiTheme } from "./theme.js";
 /** Columns the rail occupies: its own, plus the gap before it. */
 export declare const RAIL_COLUMNS = 2;
 export interface RailOptions {
     /** Rows at the top the rail does not run beside, such as a sticky header. */
     readonly topInset?: number;
+    /** How the rail shows. Absent draws the thin rail whenever the content overflows. */
+    readonly presentation?: ScrollbarPresentation;
 }
-/** Draws the rail beside each row, padding the rows to a common width first. */
+/**
+ * Draws the rail beside each row, padding the rows to a common width first.
+ * A presentation that reserves no space returns the rows untouched.
+ */
 export declare function withScrollbarRail(lines: readonly string[], geometry: ScrollbarGeometry | null, contentWidth: number, theme: UiTheme, options?: RailOptions): readonly string[];
 /**
  * What a list shows instead of rows: a mark and a line, both quiet, sitting in

package/dist/ui/components/surface.js

@@ -3,13 +3,23 @@ import { displayWidth } from "./text.js";
 // Rationale: shared list chrome belongs here rather than in individual screens.
 /** Columns the rail occupies: its own, plus the gap before it. */
 export const RAIL_COLUMNS = 2;
-/** Draws the rail beside each row, padding the rows to a common width first. */
+/**
+ * Draws the rail beside each row, padding the rows to a common width first.
+ * A presentation that reserves no space returns the rows untouched.
+ */
 export function withScrollbarRail(lines, geometry, contentWidth, theme, options = {}) {
     const inset = options.topInset ?? 0;
+    const presentation = options.presentation
+        ?? { visible: geometry !== null, reservesSpace: true, trackGlyph: "│", thumbGlyph: "│" };
+    if (!presentation.reservesSpace)
+        return lines;
+    const drawn = presentation.visible && geometry !== null;
     return lines.map((line, offset) => {
-        const cell = offset < inset || geometry === null
+        const cell = offset < inset || !drawn
             ? " "
-            : isThumbRow(geometry, offset - inset) ? theme.fg("accent", "│") : theme.fg("dim", "│");
+            : isThumbRow(geometry, offset - inset)
+                ? theme.fg("accent", presentation.thumbGlyph)
+                : theme.fg("dim", presentation.trackGlyph);
         return `${pad(line, contentWidth)} ${cell}`;
     });
 }

package/dist/ui/settings/declarations.d.ts

@@ -1,4 +1,4 @@
-export declare const OWNED_UI_SETTINGS_VERSION = 5;
+export declare const OWNED_UI_SETTINGS_VERSION = 6;
 export type OwnedUiSettingValue = string | number | boolean;
 export type OwnedUiSettingApplication = "live" | "restart";
 export interface OwnedUiSettingDeclaration {

package/dist/ui/settings/declarations.js

@@ -1,11 +1,22 @@
-export const OWNED_UI_SETTINGS_VERSION = 5;
+export const OWNED_UI_SETTINGS_VERSION = 6;
 const MAX_ID_LENGTH = 64;
 const ID_PATTERN = /^[a-z][a-z0-9]*(?:[A-Z][a-z0-9]*)*$/;
+/** Declared first so the settings screen opens on it; sections follow first-declaration order. */
+const GENERIC_SECTION = Object.freeze({ id: "generic", title: "Generic" });
 const SCROLL_SECTION = Object.freeze({ id: "scroll", title: "Scroll" });
 const QUIT_SECTION = Object.freeze({ id: "quit", title: "Quit" });
 /** Playback lengths the quit outro offers, in milliseconds. */
 export const QUIT_EFFECT_DURATIONS_MS = Object.freeze(Array.from({ length: 18 }, (_, index) => 300 + index * 100));
 export const OWNED_UI_SETTING_DECLARATIONS = Object.freeze([
+    Object.freeze({
+        id: "quitAnimation",
+        label: "Exit animation",
+        section: GENERIC_SECTION,
+        description: "Play the quit effect when the session quits. Off returns to the terminal immediately.",
+        application: "live",
+        defaultValue: true,
+        allowedValues: Object.freeze([true, false]),
+    }),
     Object.freeze({
         id: "scrollbarAppearance",
         label: "Scrollbar mode",
@@ -58,7 +69,7 @@ export const OWNED_UI_SETTING_DECLARATIONS = Object.freeze([
         description: "Animation played over the last screen when the session quits.",
         application: "live",
         defaultValue: "fall",
-        allowedValues: Object.freeze(["fall", "dissolve", "starburst", "waves", "off"]),
+        allowedValues: Object.freeze(["fall", "dissolve", "starburst", "waves"]),
     }),
     Object.freeze({
         id: "quitEffectDurationMs",

package/dist/ui/settings/migrations.js

@@ -36,6 +36,19 @@ export const OWNED_UI_SETTINGS_MIGRATIONS = Object.freeze([
             return { ...values };
         },
     }),
+    Object.freeze({
+        to: 6,
+        description: "Move the disabled quit effect into the exit-animation toggle.",
+        migrate(values) {
+            // Invariant: a profile that chose off keeps quitting without an animation; the
+            // effect it stored is no longer a choice, so it resolves to the default.
+            if (values.quitEffect !== "off")
+                return { ...values };
+            const migrated = { ...values, quitAnimation: false };
+            delete migrated.quitEffect;
+            return migrated;
+        },
+    }),
 ]);
 export function assertOwnedUiSettingsMigrations(migrations, currentVersion = OWNED_UI_SETTINGS_VERSION) {
     const firstProduced = currentVersion - migrations.length + 1;