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

package/README.md

@@ -71,6 +71,15 @@ preferred when consistent with your intent; genuinely unclear cases can remain
 empty. [Private diagnostic capture](docs/architecture/prompt-suggestions.md)
 explains how to distinguish skipped, empty, rejected, and timed-out suggestions.
 
+## Quitting
+
+`/quit`, `Ctrl+C` twice, and `Ctrl+D` on an empty prompt end a bare A1 session.
+The last screen dissolves on the alternate screen, the terminal is restored once,
+and only the dim `To resume this session:` hint is printed; the conversation is
+not echoed into your scrollback. `/settings` → Quit chooses the effect (`fall`,
+`dissolve`, `starburst`, `waves`, or `off`) and its duration (300–2000 ms). The
+`a1 pi` comparison profile keeps Pi's `fullscreenExitOutput` behavior.
+
 ## Prompt history
 
 Bare A1 recalls recent unique prompts across sessions with Up/Down. History is

package/dist/composition/owned-ui.js

@@ -84,6 +84,9 @@ export async function composeOwnedUi(options = {}) {
                 inputPresentation: { onEvent: event => clipboardDiagnostics.runtime(event) },
             }),
             ...(viewportSettings === null ? {} : { viewportSettings }),
+            ...(settings === null || !ownedSurfaces ? {} : {
+                quitOutro: { snapshot: () => quitOutroSettingsSnapshot(settings), interactive: process.stdout.isTTY === true },
+            }),
             ...(promptSuggestions === null ? {} : { promptSuggestions }),
             ...(promptHistory === null ? {} : { promptHistory: {
                     ...promptHistory,
@@ -113,6 +116,14 @@ export async function composeOwnedUi(options = {}) {
     };
     return { application, settings };
 }
+function quitOutroSettingsSnapshot(settings) {
+    const effect = settings.value("quitEffect");
+    const durationMs = settings.value("quitEffectDurationMs");
+    return {
+        effect: effect === "dissolve" || effect === "starburst" || effect === "waves" || effect === "off" ? effect : "fall",
+        durationMs: typeof durationMs === "number" ? durationMs : 800,
+    };
+}
 function viewportSettingsSnapshot(settings) {
     const appearance = settings.value("scrollbarAppearance");
     const style = settings.value("scrollbarStyle");

package/dist/contracts/owned-ui/model.d.ts

@@ -64,6 +64,16 @@ export interface OwnedUiViewportSettingsPort {
     snapshot(): OwnedUiViewportSettings;
     onChange(listener: (settings: OwnedUiViewportSettings) => void): () => void;
 }
+export type OwnedUiQuitEffect = "fall" | "dissolve" | "starburst" | "waves" | "off";
+/** Profile-local quit outro choice, read at the moment bare A1 quits. */
+export interface OwnedUiQuitOutroSettings {
+    readonly effect: OwnedUiQuitEffect;
+    /** Requested playback length; the player clamps it to its supported range. */
+    readonly durationMs: number;
+}
+export interface OwnedUiQuitOutroSettingsPort {
+    snapshot(): OwnedUiQuitOutroSettings;
+}
 export interface OwnedUiTerminalSurface {
     readonly columns: number;
     readonly rows: number;

package/dist/integrations/pi/components/shell-editor-autocomplete.js

@@ -63,6 +63,7 @@ export function createPiShellEditor(options) {
         ...(options.keybindingProfile === "a1" ? {
             terminalRows: options.getRows,
             getVisualLineCount: (width) => editorVisualLineCount(editor, width),
+            clearCommandSearchOnEscape: true,
         } : {}),
         ...(options.keybindingProfile === "a1" && options.promptPresentation !== undefined ? {
             ...(inputPresentation === undefined ? {} : { inputPresentation }),

package/dist/integrations/pi/components/upstream/components/owned-editor.d.ts

@@ -17,6 +17,8 @@ export interface OwnedEditorOptions extends EditorOptions {
     readonly terminalRows?: () => number;
     /** Reuses the editor's established atomic-aware visual layout when available. */
     readonly getVisualLineCount?: (width: number) => number | undefined;
+    /** Bare-A1 exception: Escape on a sole top-level slash-command search also clears the prompt. */
+    readonly clearCommandSearchOnEscape?: boolean;
 }
 export interface ShellEditorInstance extends EditorSurface {
     readonly actionHandlers: Map<AppKeybinding, () => void>;

package/dist/integrations/pi/components/upstream/components/owned-editor.js

@@ -21,6 +21,7 @@ export function createOwnedEditorClass(Base) {
         #styleSuggestionCaret;
         #terminalRows;
         #getVisualLineCount;
+        #clearCommandSearchOnEscape;
         #renderedBodyRowCount = 0;
         constructor(tui, theme, keybindings, options = {}) {
             super(tui, theme, options);
@@ -30,6 +31,7 @@ export function createOwnedEditorClass(Base) {
             this.#styleSuggestionCaret = options.styleSuggestionCaret ?? (text => `\u001b[7m${text}\u001b[27m`);
             this.#terminalRows = options.terminalRows ?? (() => 24);
             this.#getVisualLineCount = options.getVisualLineCount;
+            this.#clearCommandSearchOnEscape = options.clearCommandSearchOnEscape === true;
         }
         getRenderedBodyRowCount() { return this.#renderedBodyRowCount; }
         setPromptSuggestion(text) {
@@ -42,6 +44,16 @@ export function createOwnedEditorClass(Base) {
                 && this.getText().length === 0
                 && !this.isShowingAutocomplete();
         }
+        /** True when autocomplete is searching one top-level slash command that is the editor's only content. */
+        isTopLevelCommandSearch() {
+            if (!this.isShowingAutocomplete())
+                return false;
+            const text = this.getText();
+            if (!/^\/[^\s/]*$/.test(text))
+                return false;
+            const cursor = this.getCursor();
+            return cursor.line === 0 && cursor.col === text.length;
+        }
         setText(text) {
             if (text.length > 0)
                 this.#promptSuggestion = null;
@@ -92,6 +104,11 @@ export function createOwnedEditorClass(Base) {
                         return;
                     }
                 }
+                else if (this.#clearCommandSearchOnEscape && this.isTopLevelCommandSearch()) {
+                    // Escape on a bare slash-command search restores the empty prompt instead of only closing the menu.
+                    this.setText("");
+                    return;
+                }
                 super.handleInput(data);
                 return;
             }

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

@@ -178,6 +178,8 @@ export declare class PiEngineAdapter implements OwnedUiPromptSuggestionGenerator
     configuredTheme(): string | undefined;
     /** Settings port for the live runtime, or null before the runtime is available. */
     settingsPort(): PiSettingsIntegration | null;
+    /** Which settings surface this adapter serves; hidden-in-bare effects are unbindable in bare mode. */
+    get settingsProductMode(): "bare" | "comparison";
     bindSettingsOwner(owner: AgentSettingOwner, handlers: PiSettingOwnerHandlers): () => void;
     pinnedModelSelectorContext(): {
         readonly currentModel: unknown;

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

@@ -224,10 +224,8 @@ export class PiEngineAdapter {
             return "unavailable";
         if (!session.model.reasoning)
             return "ordinary";
-        const levels = session.getAvailableThinkingLevels?.() ?? [];
-        // Compatibility: capability order, not the user's current setting or a provider-name heuristic.
-        return ["off", "minimal", "low", "medium", "high", "xhigh", "max"]
-            .find(level => levels.includes(level)) ?? "unavailable";
+        // Performance: the run's own level keeps the provider's thinking parameters, and the cached prefix, identical.
+        return readSuggestionReasoning(session.thinkingLevel);
     }
     async generate(request) {
         assertOwnedUiPromptSuggestionRequest(request);
@@ -246,15 +244,23 @@ export class PiEngineAdapter {
             return { identity, outcome: request.signal.aborted ? "cancelled" : "unavailable", text: null };
         }
         const model = session.model;
-        const agentState = session.agent.state;
+        const agent = session.agent;
+        const agentState = agent.state;
         const policy = this.suggestionReasoningPolicy();
         if (model === undefined || policy === "unavailable" || typeof runtime.services.modelRuntime.completeSimple !== "function") {
             return { identity, outcome: "unavailable", text: null };
         }
-        const messages = agentState.messages.filter(message => message.role === "user" || message.role === "assistant" || message.role === "toolResult");
+        // Performance: mirror the primary loop's request shape so the provider serves the conversation prefix
+        // from the run's prompt cache. `onResponse` stays out: extensions must not see a suggestion as a response.
         const reasoning = policy === "ordinary" || policy === "off" ? undefined : policy;
         let response;
         try {
+            const transformed = typeof agent.transformContext === "function"
+                ? await agent.transformContext(agentState.messages, request.signal)
+                : agentState.messages;
+            const messages = typeof agent.convertToLlm === "function"
+                ? await agent.convertToLlm(transformed)
+                : transformed.filter(message => message.role === "user" || message.role === "assistant" || message.role === "toolResult");
             response = await runtime.services.modelRuntime.completeSimple(model, {
                 systemPrompt: agentState.systemPrompt,
                 messages: [
@@ -265,6 +271,10 @@ export class PiEngineAdapter {
             }, {
                 signal: request.signal,
                 ...(reasoning === undefined ? {} : { reasoning }),
+                ...(agent.sessionId === undefined ? {} : { sessionId: agent.sessionId }),
+                ...(agent.thinkingBudgets === undefined ? {} : { thinkingBudgets: agent.thinkingBudgets }),
+                ...(agent.transport === undefined ? {} : { transport: agent.transport }),
+                ...(agent.onPayload === undefined ? {} : { onPayload: agent.onPayload }),
             });
         }
         catch {
@@ -748,6 +758,10 @@ export class PiEngineAdapter {
         }
         return this.#settingsIntegration;
     }
+    /** Which settings surface this adapter serves; hidden-in-bare effects are unbindable in bare mode. */
+    get settingsProductMode() {
+        return this.#settingsProductMode;
+    }
     bindSettingsOwner(owner, handlers) {
         const settings = this.settingsPort();
         if (settings === null)
@@ -3235,6 +3249,11 @@ function readModel(value) {
         displayName: stringValue(value.name) ?? modelId,
     };
 }
+function readSuggestionReasoning(value) {
+    return value === "minimal" || value === "low" || value === "medium" || value === "high" || value === "xhigh" || value === "max"
+        ? value
+        : "off";
+}
 function readThinkingLevel(value) {
     return value === "off" || value === "minimal" || value === "low" || value === "medium"
         || value === "high" || value === "xhigh"

package/dist/integrations/pi/engine/settings-effects.d.ts

@@ -1,6 +1,6 @@
 import type { AgentJsonValue, AgentSettingApplicationBoundary, AgentSettingChangeOutcome, AgentSettingOwner } from "../../../contracts/agent-engine/index.js";
 export type PiSettingKey = "autoCompact" | "showImages" | "imageWidthCells" | "autoResizeImages" | "blockImages" | "enableSkillCommands" | "steeringMode" | "followUpMode" | "transport" | "httpIdleTimeoutMs" | "thinkingLevel" | "theme" | "hideThinkingBlock" | "mermaidRenderingMode" | "showCacheMissNotices" | "collapseChangelog" | "enableInstallTelemetry" | "quietStartup" | "defaultProjectTrust" | "doubleEscapeAction" | "treeFilterMode" | "showHardwareCursor" | "editorPaddingX" | "outputPad" | "autocompleteMaxVisible" | "clearOnShrink" | "showTerminalProgress" | "tuiMode" | "fullscreenExitOutput" | "fullscreenScrollbar" | "warnings";
-export type PiSettingVisualClass = "none" | "transcript" | "transcript-geometry" | "editor-menu" | "queue-transcript" | "status-error" | "retry-error" | "footer-transcript" | "markdown" | "transcript-notice" | "startup-transcript" | "startup-selector" | "selector" | "terminal-cursor" | "editor-geometry" | "menu-geometry" | "terminal-frame" | "terminal-status" | "restored-parent-output" | "hidden";
+export type PiSettingVisualClass = "none" | "transcript" | "transcript-geometry" | "editor-menu" | "queue-transcript" | "status-error" | "retry-error" | "footer-transcript" | "markdown" | "transcript-notice" | "startup-transcript" | "startup-selector" | "selector" | "terminal-cursor" | "editor-geometry" | "menu-geometry" | "terminal-frame" | "terminal-status" | "hidden";
 export interface PiSettingVisualEvidence {
     /** Reviewed visual family; `none` still names the behavior that can emit styled diagnostics. */
     readonly class: PiSettingVisualClass;

package/dist/integrations/pi/engine/settings-effects.js

@@ -31,7 +31,7 @@ export const PI_SETTING_EFFECTS = Object.freeze({
     clearOnShrink: effect("live", "terminal", "terminal-frame", "pinned resize clearing and resulting terminal frame", "pi-terminal-operation-parity"),
     showTerminalProgress: effect("live", "terminal", "terminal-status", "pinned OSC progress lifecycle", "pi-terminal-operation-parity"),
     tuiMode: hiddenEffect("next-session", "shell", "pinned regular/fullscreen selector and terminal lifecycle", "pi-terminal-operation-parity"),
-    fullscreenExitOutput: effect("current-exit", "shutdown", "restored-parent-output", "pinned styled transcript and compact dim resume hint", "pinned-fullscreen-exit-parity"),
+    fullscreenExitOutput: hiddenEffect("current-exit", "shutdown", "pinned styled transcript and compact dim resume hint", "pinned-fullscreen-exit-parity"),
     fullscreenScrollbar: hiddenEffect("live", "shell", "pinned fullscreen scrollbar reservation", "pi-terminal-operation-parity"),
     warnings: effect("live", "agent", "transcript-notice", "pinned warning rows by warning part", "pinned-transcript-lifecycle-parity"),
 });

package/dist/integrations/pi/session-ui/quit-outro-effects.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Deterministic quit-outro effect plans, ported from the v2 sketch.
+ *
+ * Each effect turns the captured frame's per-row visible widths and a seed into
+ * two sorted schedules over unit playback progress: sparkles paint a glyph at a
+ * cell from `start`, and clears blank a cell at `end`. The player consumes both
+ * in order, so a fixed seed yields a byte-stable animation.
+ */
+export interface QuitOutroCell {
+    readonly row: number;
+    readonly col: number;
+    /** Progress at which the sparkle glyph is painted. */
+    readonly start: number;
+    /** Progress at which the cell is cleared. */
+    readonly end: number;
+    readonly glyph: string;
+    readonly color: string;
+}
+export interface QuitOutroPlan {
+    /** Sorted by `start`. */
+    readonly sparkles: readonly QuitOutroCell[];
+    /** Sorted by `end`. */
+    readonly clears: readonly QuitOutroCell[];
+}
+export declare const QUIT_OUTRO_EFFECTS: readonly ["fall", "dissolve", "starburst", "waves"];
+export type QuitOutroEffect = (typeof QUIT_OUTRO_EFFECTS)[number];
+export declare function isQuitOutroEffect(value: unknown): value is QuitOutroEffect;
+/** Builds the selected effect's deterministic plan for the captured row widths. */
+export declare function createQuitOutroPlan(effect: QuitOutroEffect, rowWidths: readonly number[], seed: number): QuitOutroPlan;

package/dist/integrations/pi/session-ui/quit-outro-effects.js

@@ -0,0 +1,242 @@
+/**
+ * Deterministic quit-outro effect plans, ported from the v2 sketch.
+ *
+ * Each effect turns the captured frame's per-row visible widths and a seed into
+ * two sorted schedules over unit playback progress: sparkles paint a glyph at a
+ * cell from `start`, and clears blank a cell at `end`. The player consumes both
+ * in order, so a fixed seed yields a byte-stable animation.
+ */
+export const QUIT_OUTRO_EFFECTS = Object.freeze(["fall", "dissolve", "starburst", "waves"]);
+export function isQuitOutroEffect(value) {
+    return typeof value === "string" && QUIT_OUTRO_EFFECTS.includes(value);
+}
+const WHITE = "\x1b[38;2;238;238;238m";
+const DUST_GLYPHS = [".", "·", "'", ":", "+", "°"];
+const FALL_GLYPHS = [".", ".", "·", "'", ":", "°"];
+const GRAVITY = 85;
+function mulberry32(seed) {
+    let value = seed >>> 0;
+    return () => {
+        value = (value + 0x6d2b79f5) | 0;
+        let next = Math.imul(value ^ (value >>> 15), 1 | value);
+        next = (next + Math.imul(next ^ (next >>> 7), 61 | next)) ^ next;
+        return ((next ^ (next >>> 14)) >>> 0) / 4294967296;
+    };
+}
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+function pick(random, values) {
+    return values[Math.floor(random() * values.length)];
+}
+function rowWidth(rowWidths, row) {
+    return Math.max(0, Math.floor(rowWidths[row] ?? 0));
+}
+function finish(sparkles, clears) {
+    sparkles.sort((a, b) => a.start - b.start);
+    clears.sort((a, b) => a.end - b.end);
+    return { sparkles, clears };
+}
+/** Calm white ASCII dust dissolve. */
+function dissolvePlan(rowWidths, seed) {
+    const random = mulberry32(seed);
+    const height = Math.max(1, rowWidths.length);
+    const width = Math.max(1, ...rowWidths);
+    const sparkles = [];
+    const clears = [];
+    for (let row = 0; row < rowWidths.length; row++) {
+        for (let col = 0; col < rowWidth(rowWidths, row); col++) {
+            const sweep = (row / height) * 0.14 + (col / width) * 0.08;
+            const start = Math.min(0.76, sweep + random() * 0.54);
+            const cell = {
+                row, col, start,
+                end: Math.min(0.96, start + 0.1 + random() * 0.1),
+                glyph: pick(random, DUST_GLYPHS),
+                color: WHITE,
+            };
+            clears.push(cell);
+            if (random() < 0.34)
+                sparkles.push(cell);
+        }
+    }
+    return finish(sparkles, clears);
+}
+/** Soft white harmonic ripple dissolve. */
+function starburstPlan(rowWidths, seed) {
+    const random = mulberry32(seed);
+    const height = Math.max(1, rowWidths.length);
+    const width = Math.max(1, ...rowWidths);
+    const center = (width - 1) / 2;
+    const sparkles = [];
+    const clears = [];
+    for (let row = 0; row < rowWidths.length; row++) {
+        for (let col = 0; col < rowWidth(rowWidths, row); col++) {
+            const distance = Math.abs(col - center) / Math.max(1, width / 2);
+            const ripple = (Math.sin(distance * Math.PI * 3 + (row / height) * Math.PI) + 1) * 0.035;
+            const sweep = distance * 0.2 + (row / height) * 0.1 + ripple;
+            const start = Math.min(0.79, sweep + random() * 0.34);
+            const cell = {
+                row, col, start,
+                end: Math.min(0.97, start + 0.12 + random() * 0.1),
+                glyph: pick(random, DUST_GLYPHS),
+                color: WHITE,
+            };
+            clears.push(cell);
+            if (random() < 0.38)
+                sparkles.push(cell);
+        }
+    }
+    return finish(sparkles, clears);
+}
+/** White dotted fragments accelerating downward and collecting in a floor pile. */
+function fallPlan(rowWidths, seed) {
+    const random = mulberry32(seed);
+    const height = Math.max(1, rowWidths.length);
+    const width = Math.max(1, ...rowWidths);
+    const floor = height - 1;
+    const area = Math.max(1, width * height);
+    const fragmentChance = clamp(150 / area, 0.1, 0.24);
+    const particles = [];
+    const sparkles = [];
+    const clears = [];
+    let fallbackParticle;
+    for (let row = 0; row < rowWidths.length; row++) {
+        for (let col = 0; col < rowWidth(rowWidths, row); col++) {
+            const release = 0.025 + random() * 0.13 + (1 - row / height) * 0.035;
+            const glyph = pick(random, FALL_GLYPHS);
+            clears.push({ row, col, start: release, end: release + 0.04, glyph, color: WHITE });
+            if (row >= floor)
+                continue;
+            const particle = { row, col, release, glyph, velocityCol: (random() - 0.5) * 9 };
+            fallbackParticle ??= particle;
+            if (random() < fragmentChance)
+                particles.push(particle);
+        }
+    }
+    if (particles.length === 0 && fallbackParticle)
+        particles.push(fallbackParticle);
+    const arrival = (particle) => particle.release + Math.sqrt((2 * (floor - particle.row)) / GRAVITY);
+    particles.sort((a, b) => arrival(a) - arrival(b));
+    const pileHeights = Array(width).fill(0);
+    for (const particle of particles) {
+        const floorFallTime = Math.max(0.05, Math.sqrt((2 * (floor - particle.row)) / GRAVITY));
+        const predictedCol = clamp(Math.round(particle.col + particle.velocityCol * floorFallTime), 0, width - 1);
+        let landingCol = predictedCol;
+        for (let radius = 1; radius <= 3; radius++) {
+            for (const candidate of [predictedCol - radius, predictedCol + radius]) {
+                if (candidate >= 0 && candidate < width && pileHeights[candidate] < pileHeights[landingCol])
+                    landingCol = candidate;
+            }
+        }
+        const stackHeight = pileHeights[landingCol]++;
+        const restingRow = clamp(floor - stackHeight, particle.row + 1, floor);
+        const fallDistance = Math.max(1, restingRow - particle.row);
+        const fallTime = Math.sqrt((2 * fallDistance) / GRAVITY);
+        const velocityCol = (landingCol - particle.col) / fallTime;
+        const steps = Math.max(4, Math.min(14, Math.ceil(fallTime / 0.045)));
+        const interval = fallTime / steps;
+        for (let step = 1; step < steps; step++) {
+            const elapsed = step * interval;
+            const progress = step / steps;
+            const row = particle.row + 0.5 * GRAVITY * elapsed * elapsed;
+            const col = particle.col + velocityCol * elapsed + Math.sin(progress * Math.PI) * 0.3;
+            const start = clamp(particle.release + elapsed, 0, 0.93);
+            const cell = {
+                row: clamp(Math.round(row), 0, floor),
+                col: clamp(Math.round(col), 0, width - 1),
+                start,
+                end: Math.min(0.96, start + Math.max(0.025, interval * 0.72)),
+                glyph: particle.glyph,
+                color: WHITE,
+            };
+            sparkles.push(cell);
+            clears.push(cell);
+        }
+        const settledAt = clamp(particle.release + fallTime, 0, 0.93);
+        const settled = { row: restingRow, col: landingCol, start: settledAt, end: 0.97, glyph: particle.glyph, color: WHITE };
+        sparkles.push(settled);
+        clears.push(settled);
+    }
+    return finish(sparkles, clears);
+}
+/** Soft white dotted radio pulses expanding from a gently moving center. */
+function wavesPlan(rowWidths, seed) {
+    const random = mulberry32(seed);
+    const height = Math.max(1, rowWidths.length);
+    const width = Math.max(1, ...rowWidths);
+    const baseCenterCol = (width - 1) / 2;
+    const baseCenterRow = (height - 1) / 2;
+    const sparkles = [];
+    const clears = [];
+    const addPulseCell = (row, col, start, lifetime, glyph) => {
+        const safeStart = clamp(start, 0, 0.94);
+        const cell = {
+            row: clamp(Math.round(row), 0, height - 1),
+            col: clamp(Math.round(col), 0, width - 1),
+            start: safeStart,
+            end: clamp(safeStart + lifetime, safeStart + 0.02, 0.98),
+            glyph,
+            color: WHITE,
+        };
+        sparkles.push(cell);
+        clears.push(cell);
+    };
+    // Rationale: clear the frame in the same outward direction as the expanding signal.
+    for (let row = 0; row < rowWidths.length; row++) {
+        for (let col = 0; col < rowWidth(rowWidths, row); col++) {
+            const x = (col - baseCenterCol) / Math.max(1, width * 0.5);
+            const y = (row - baseCenterRow) / Math.max(1, height * 0.5);
+            const distance = Math.min(1.25, Math.sqrt(x * x + y * y));
+            const start = 0.04 + random() * 0.1;
+            const cell = {
+                row, col, start,
+                end: Math.min(0.95, 0.18 + distance * 0.54 + random() * 0.12),
+                glyph: pick(random, DUST_GLYPHS),
+                color: WHITE,
+            };
+            clears.push(cell);
+            if (random() < 0.055)
+                sparkles.push(cell);
+        }
+    }
+    const pulseCount = 4;
+    const expansionSteps = 9;
+    for (let pulse = 0; pulse < pulseCount; pulse++) {
+        const pulseStart = 0.025 + pulse * 0.135;
+        const phase = pulse * 1.47 + random() * 0.45;
+        for (let step = 0; step <= expansionSteps; step++) {
+            const progress = step / expansionSteps;
+            const centerCol = baseCenterCol + Math.sin(phase + progress * Math.PI) * width * 0.035;
+            const centerRow = baseCenterRow + Math.cos(phase + progress * Math.PI * 0.8) * height * 0.065;
+            const radiusCol = progress * width * 0.56;
+            const radiusRow = progress * height * 0.56;
+            const samples = Math.max(10, Math.min(58, Math.round(12 + radiusCol * 0.48)));
+            const time = pulseStart + progress * 0.28;
+            if (step === 0) {
+                addPulseCell(centerRow, centerCol, time, 0.1, pulse % 2 === 0 ? "+" : "°");
+                continue;
+            }
+            for (let sample = 0; sample < samples; sample++) {
+                if (random() < 0.08 + progress * 0.06)
+                    continue;
+                const angle = (sample / samples) * Math.PI * 2 + Math.sin(phase) * 0.035;
+                const shimmer = (random() - 0.5) * (0.25 + progress * 0.55);
+                const row = centerRow + Math.sin(angle) * radiusRow + shimmer * 0.4;
+                const col = centerCol + Math.cos(angle) * radiusCol + shimmer;
+                const glyph = progress < 0.28 ? "°" : progress < 0.62 ? "·" : random() < 0.72 ? "." : "'";
+                addPulseCell(row, col, time + random() * 0.018, 0.065 + (1 - progress) * 0.055, glyph);
+            }
+        }
+    }
+    return finish(sparkles, clears);
+}
+const PLANS = Object.freeze({
+    fall: fallPlan,
+    dissolve: dissolvePlan,
+    starburst: starburstPlan,
+    waves: wavesPlan,
+});
+/** Builds the selected effect's deterministic plan for the captured row widths. */
+export function createQuitOutroPlan(effect, rowWidths, seed) {
+    return PLANS[effect](rowWidths, seed);
+}

package/dist/integrations/pi/session-ui/quit-outro.d.ts

@@ -0,0 +1,38 @@
+import { type QuitOutroEffect } from "./quit-outro-effects.js";
+export interface QuitOutroFrame {
+    /** Row content as presented, truncated to `columns`; index 0 is the top row. */
+    readonly lines: readonly string[];
+    readonly columns: number;
+    readonly rows: number;
+    /** Visible width of each line, at most `columns`. */
+    readonly rowWidths: readonly number[];
+}
+export interface QuitOutroPlayback {
+    write(data: string): void;
+    /** Monotonic clock seam; defaults to `Date.now`. */
+    now?(): number;
+    /** Delay seam; defaults to a timer. */
+    sleep?(ms: number): Promise<void>;
+    /** Plan seed; defaults to a time- and geometry-derived value. */
+    readonly seed?: number;
+}
+export declare const QUIT_OUTRO_MIN_MS = 300;
+export declare const QUIT_OUTRO_MAX_MS = 2000;
+/** Wall-clock allowance beyond the clamped duration before playback abandons remaining ticks. */
+export declare const QUIT_OUTRO_GUARD_MS = 500;
+/** Tick ceiling for a clock that stops advancing: the longest playback plus its guard at 30 fps. */
+export declare const QUIT_OUTRO_MAX_TICKS: number;
+export declare function clampQuitOutroDuration(durationMs: number): number;
+/**
+ * Captures the presented rows into an outro frame. Returns null when nothing is
+ * visible, so a blank screen never animates.
+ */
+export declare function captureQuitOutroFrame(presented: readonly string[], columns: number, rows: number): QuitOutroFrame | null;
+/** The clear-and-repaint block that seeds the animation surface with the captured frame. */
+export declare function createQuitOutroSurfaceFrame(frame: QuitOutroFrame): string;
+/**
+ * Plays the effect over the frame. Resolves true when the plan was played to
+ * completion or abandoned at its guard, false when there was nothing to play.
+ * Write failures propagate so the caller can decide to continue restoration.
+ */
+export declare function playQuitOutro(frame: QuitOutroFrame, effect: QuitOutroEffect, durationMs: number, playback: QuitOutroPlayback): Promise<boolean>;

package/dist/integrations/pi/session-ui/quit-outro.js

@@ -0,0 +1,98 @@
+/**
+ * Bare A1's quit outro: the last presented fullscreen frame is captured, the
+ * selected effect animates over it on the alternate screen, and only then does
+ * the shell leave that screen. Every tick is one synchronized-output block so a
+ * terminal never shows a half-painted step, and playback is bounded so a slow
+ * terminal cannot delay restoration past the configured clamp.
+ */
+import { displayWidth, truncateToWidth } from "../../../ui/components/index.js";
+import { createQuitOutroPlan } from "./quit-outro-effects.js";
+export const QUIT_OUTRO_MIN_MS = 300;
+export const QUIT_OUTRO_MAX_MS = 2000;
+/** Wall-clock allowance beyond the clamped duration before playback abandons remaining ticks. */
+export const QUIT_OUTRO_GUARD_MS = 500;
+const FRAME_MS = 1000 / 30;
+/** Tick ceiling for a clock that stops advancing: the longest playback plus its guard at 30 fps. */
+export const QUIT_OUTRO_MAX_TICKS = Math.ceil((QUIT_OUTRO_MAX_MS + QUIT_OUTRO_GUARD_MS) / FRAME_MS) + 1;
+const SYNC_BEGIN = "\x1b[?2026h";
+const SYNC_END = "\x1b[?2026l";
+const RESET = "\x1b[0m";
+const CLEAR_SCREEN = "\x1b[2J";
+const HOME = "\x1b[H";
+const HIDE_CURSOR = "\x1b[?25l";
+export function clampQuitOutroDuration(durationMs) {
+    if (!Number.isFinite(durationMs))
+        return QUIT_OUTRO_MIN_MS;
+    return Math.max(QUIT_OUTRO_MIN_MS, Math.min(QUIT_OUTRO_MAX_MS, Math.floor(durationMs)));
+}
+function cursorAt(row, col) {
+    return `\x1b[${row + 1};${col + 1}H`;
+}
+/**
+ * Captures the presented rows into an outro frame. Returns null when nothing is
+ * visible, so a blank screen never animates.
+ */
+export function captureQuitOutroFrame(presented, columns, rows) {
+    const width = Math.max(1, Math.floor(columns));
+    const height = Math.max(1, Math.floor(rows));
+    const lines = presented.slice(0, height).map(line => truncateToWidth(line, width));
+    while (lines.length < height)
+        lines.push("");
+    const rowWidths = lines.map(line => Math.min(width, displayWidth(line)));
+    if (rowWidths.every(w => w === 0))
+        return null;
+    return { lines, columns: width, rows: height, rowWidths };
+}
+/** The clear-and-repaint block that seeds the animation surface with the captured frame. */
+export function createQuitOutroSurfaceFrame(frame) {
+    let output = `${SYNC_BEGIN}${HIDE_CURSOR}${CLEAR_SCREEN}${HOME}${RESET}`;
+    for (let row = 0; row < frame.rows; row++) {
+        const line = frame.lines[row] ?? "";
+        if (frame.rowWidths[row] > 0)
+            output += `${cursorAt(row, 0)}${line}${RESET}`;
+    }
+    return `${output}${SYNC_END}`;
+}
+/**
+ * Plays the effect over the frame. Resolves true when the plan was played to
+ * completion or abandoned at its guard, false when there was nothing to play.
+ * Write failures propagate so the caller can decide to continue restoration.
+ */
+export async function playQuitOutro(frame, effect, durationMs, playback) {
+    const now = playback.now ?? (() => Date.now());
+    const sleep = playback.sleep ?? ((ms) => new Promise(resolve => setTimeout(resolve, ms)));
+    const seed = playback.seed ?? (Date.now() ^ (frame.columns << 16) ^ frame.rows);
+    const plan = createQuitOutroPlan(effect, frame.rowWidths, seed);
+    if (plan.clears.length === 0)
+        return false;
+    const duration = clampQuitOutroDuration(durationMs);
+    let sparkleIndex = 0;
+    let clearIndex = 0;
+    let ticks = 0;
+    playback.write(createQuitOutroSurfaceFrame(frame));
+    const startedAt = now();
+    for (;;) {
+        ticks += 1;
+        const elapsed = now() - startedAt;
+        const progress = Math.min(1, elapsed / duration);
+        let output = `${SYNC_BEGIN}${RESET}`;
+        while (sparkleIndex < plan.sparkles.length && plan.sparkles[sparkleIndex].start <= progress) {
+            const cell = plan.sparkles[sparkleIndex++];
+            output += `${cursorAt(cell.row, cell.col)}${cell.color}${cell.glyph}`;
+        }
+        while (clearIndex < plan.clears.length && plan.clears[clearIndex].end <= progress) {
+            const cell = plan.clears[clearIndex++];
+            output += `${cursorAt(cell.row, cell.col)}${RESET} `;
+        }
+        const finished = clearIndex >= plan.clears.length || progress >= 1
+            || elapsed > duration + QUIT_OUTRO_GUARD_MS || ticks >= QUIT_OUTRO_MAX_TICKS;
+        // Invariant: the last block leaves the alternate screen blank regardless of which
+        // cells the plan reached, so the leave never reveals a half-cleared frame.
+        if (finished)
+            output += `${CLEAR_SCREEN}${HOME}`;
+        playback.write(`${output}${RESET}${SYNC_END}`);
+        if (finished)
+            return true;
+        await sleep(FRAME_MS);
+    }
+}