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

package/dist/composition/owned-ui.js

@@ -120,7 +120,8 @@ 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",
+        enabled: settings.value("quitAnimation") !== false,
+        effect: effect === "dissolve" || effect === "starburst" || effect === "waves" ? effect : "fall",
         durationMs: typeof durationMs === "number" ? durationMs : 800,
     };
 }

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

@@ -64,9 +64,11 @@ export interface OwnedUiViewportSettingsPort {
     snapshot(): OwnedUiViewportSettings;
     onChange(listener: (settings: OwnedUiViewportSettings) => void): () => void;
 }
-export type OwnedUiQuitEffect = "fall" | "dissolve" | "starburst" | "waves" | "off";
+export type OwnedUiQuitEffect = "fall" | "dissolve" | "starburst" | "waves";
 /** Profile-local quit outro choice, read at the moment bare A1 quits. */
 export interface OwnedUiQuitOutroSettings {
+    /** False leaves the terminal immediately; the effect and duration are then ignored. */
+    readonly enabled: boolean;
     readonly effect: OwnedUiQuitEffect;
     /** Requested playback length; the player clamps it to its supported range. */
     readonly durationMs: number;

package/dist/features/owned-ui/settings-app.d.ts

@@ -14,6 +14,7 @@ export declare class SettingsApp implements UiApp {
     readonly id = "settings";
     constructor(session: OwnedUiSettingsSession);
     onActivate(host: AppHostServices): void;
+    onClose(_host: AppHostServices): void;
     render(rect: PaneRect, host: AppHostServices): readonly string[];
     onInput(data: string, host: AppHostServices): PaneInputResult;
     onMouse(event: PaneMouseEvent, _host: AppHostServices): PaneInputResult;

package/dist/features/owned-ui/settings-app.js

@@ -1,10 +1,15 @@
-import { GLOBAL_SCOPE, LineInput, PLAIN_THEME, ShortcutRegistry, assertNoShortcutConflicts, blockJumpTarget, dialogValueColumn, numericValues, RAIL_COLUMNS, renderDialogPanel, renderEmptyState, renderGroupHeader, renderInputRow, renderListRow, renderNote, renderStatusLine, dialogRowAt, menuRowAt, regionAt, renderValueMenu, withScrollbarRail, stepperEnds, steppedValue, valueColumnFor, valueMenuFrame, blockRowSpan, displayWidth, handleLineInputKey, humanizeLabel, humanizeTitle, indexOfKey, isThumbRow, layoutList, moveSelection, rowKey, scrollForSelection, scrollbarGeometry, scrollbarWheelRows, selectableIndexes, } from "../../ui/components/index.js";
+import { GLOBAL_SCOPE, LineInput, PLAIN_THEME, ShortcutRegistry, assertNoShortcutConflicts, blockJumpTarget, dialogValueColumn, numericValues, RAIL_COLUMNS, renderDialogPanel, renderEmptyState, renderGroupHeader, renderInputRow, renderListRow, renderNote, renderStatusLine, dialogRowAt, menuRowAt, regionAt, renderValueMenu, withScrollbarRail, stepperEnds, steppedValue, valueColumnFor, valueMenuFrame, blockRowSpan, displayWidth, handleLineInputKey, humanizeLabel, humanizeTitle, indexOfKey, isThumbRow, layoutList, moveSelection, rowKey, scrollForSelection, scrollForTrackPage, scrollbarGeometry, scrollbarPresentation, ScrollbarRails, scrollbarWheelRows, selectableIndexes, } from "../../ui/components/index.js";
 import { SETTINGS_APP_ID, SETTINGS_ROUTE } from "./settings-route.js";
 export { SETTINGS_APP_ID, SETTINGS_ROUTE } from "./settings-route.js";
 const SCOPE = SETTINGS_APP_ID;
 /** The panel a setting with parts opens: its own keys, its own hint. */
 const DIALOG_SCOPE = `${SETTINGS_APP_ID}-parts`;
 const SCROLLBAR_TOP_INSET = 1;
+/** Identity of the settings list rail in the shared rail state. */
+const RAIL_KEY = "settings";
+// Compatibility: the transcript rail stays lit this long after a scroll, and repaints just after.
+const SCROLL_LINGER_MS = 900;
+const SCROLL_LINGER_REPAINT_MS = 925;
 const SEARCH_PLACEHOLDER = "search settings";
 /** What a structured value offers instead of printing itself. */
 const CONFIGURE = "configure";
@@ -16,8 +21,10 @@ SETTINGS_SHORTCUTS.declare({ key: "shift+up", scope: SCOPE, description: "Previo
 SETTINGS_SHORTCUTS.declare({ key: "shift+down", scope: SCOPE, description: "Next section", section: "Navigate", hint: { keys: "Shift+↑↓", does: "to jump" } }, "block-down");
 SETTINGS_SHORTCUTS.declare({ key: "pageUp", scope: SCOPE, description: "Up a page", section: "Navigate" }, "page-up");
 SETTINGS_SHORTCUTS.declare({ key: "pageDown", scope: SCOPE, description: "Down a page", section: "Navigate" }, "page-down");
-SETTINGS_SHORTCUTS.declare({ key: "home", scope: SCOPE, description: "First setting", section: "Navigate" }, "first");
-SETTINGS_SHORTCUTS.declare({ key: "end", scope: SCOPE, description: "Last setting", section: "Navigate" }, "last");
+// Compatibility: the same chords the transcript uses for its content boundaries; plain
+// Home and End stay with the search input's cursor.
+SETTINGS_SHORTCUTS.declare({ key: "ctrl+home", scope: SCOPE, description: "First setting", section: "Navigate" }, "first");
+SETTINGS_SHORTCUTS.declare({ key: "ctrl+end", scope: SCOPE, description: "Last setting", section: "Navigate" }, "last");
 SETTINGS_SHORTCUTS.declare({ key: "enter", scope: SCOPE, description: "Change value", section: "Change", hint: { keys: "Enter/Space", does: "to change" } }, "activate");
 SETTINGS_SHORTCUTS.declare({ key: "space", scope: SCOPE, description: "Change value", section: "Change", hint: { keys: "Enter/Space", does: "to change" } }, "activate");
 SETTINGS_SHORTCUTS.declare({ key: "left", scope: SCOPE, description: "Previous value", section: "Change", hint: { keys: "←→", does: "to adjust" } }, "previous-value");
@@ -39,8 +46,11 @@ const KEYS = {
     "\u001b[C": "right",
     "\u001b[5~": "pageUp",
     "\u001b[6~": "pageDown",
-    "\u001b[H": "home",
-    "\u001b[F": "end",
+    // Protocol: xterm modifier form, then the rxvt Ctrl form of the same chords.
+    "\u001b[1;5H": "ctrl+home",
+    "\u001b[1;5F": "ctrl+end",
+    "\u001b[7^": "ctrl+home",
+    "\u001b[8^": "ctrl+end",
     "\u001b": "escape",
     "\r": "enter",
     "\n": "enter",
@@ -76,6 +86,14 @@ export class SettingsApp {
     #hoverRegion = "label";
     #frameRows = [];
     #menuFrame = null;
+    // Invariant: rail hover and drag live in the shared keyed state, as the transcript's do.
+    #rails = new ScrollbarRails();
+    // Rationale: the rail as drawn in the last frame, or null when nothing can be pointed at.
+    #railFrame = null;
+    // Invariant: a scroll lights the rail until this time; the timer repaints once it has passed.
+    #activeUntil = 0;
+    #activityTimer;
+    #renderedScroll;
     constructor(session) {
         this.#session = session;
     }
@@ -85,6 +103,10 @@ export class SettingsApp {
             host.requestRender();
         });
     }
+    onClose(_host) {
+        this.#clearActivityTimer();
+        this.#rails.clear();
+    }
     render(rect, host) {
         const theme = host.theme ?? PLAIN_THEME;
         this.#interruptArmed = host.interruptArmed;
@@ -102,7 +124,17 @@ export class SettingsApp {
         this.#reveal = undefined;
         const layout = layoutList(rows, bodyHeight, this.#scroll);
         this.#scroll = layout.scroll;
-        const contentWidth = Math.max(0, rect.width - RAIL_COLUMNS);
+        const now = Date.now();
+        // Rationale: every way of scrolling ends in this frame, so a moved list is noticed here
+        // once rather than at each wheel, drag, key, and search branch.
+        if (this.#renderedScroll !== undefined && this.#renderedScroll !== layout.scroll)
+            this.#noteScrollActivity(host, now);
+        this.#renderedScroll = layout.scroll;
+        // Invariant: auto and always keep the rail columns while the list fits, so a revealed
+        // rail never reflows the rows; hidden gives the columns back to the rows.
+        const appearance = this.#scrollbarAppearance();
+        const reservesRail = appearance !== "hidden";
+        const contentWidth = reservesRail ? Math.max(0, rect.width - RAIL_COLUMNS) : rect.width;
         const valueColumn = this.#valueColumn(rows);
         const geometry = scrollbarGeometry({
             contentLength: rows.length,
@@ -110,6 +142,22 @@ export class SettingsApp {
             scroll: layout.scroll,
             trackHeight: Math.max(0, bodyHeight - SCROLLBAR_TOP_INSET),
         });
+        const presentation = scrollbarPresentation({
+            geometry,
+            appearance,
+            style: this.#scrollbarStyle(),
+            hovered: this.#rails.isHovered(RAIL_KEY),
+            dragging: this.#rails.isDragging(RAIL_KEY),
+            activeUntil: this.#activeUntil,
+            now,
+        });
+        this.#railFrame = reservesRail && geometry !== null
+            ? {
+                rail: { key: RAIL_KEY, column: rect.width, rowStart: SCROLLBAR_TOP_INSET, trackHeight: geometry.trackHeight },
+                geometry,
+                page: layout.visible,
+            }
+            : null;
         const body = [];
         this.#frameRows = [];
         if (rows.length === 0) {
@@ -140,8 +188,9 @@ export class SettingsApp {
         }
         const withRail = withScrollbarRail(body.slice(0, bodyHeight), geometry, contentWidth, theme, {
             topInset: SCROLLBAR_TOP_INSET,
+            presentation,
         });
-        return this.#withMenu([...withRail, ...footer], selected, layout, valueColumn, theme, rect);
+        return this.#withMenu([...withRail, ...footer], selected, layout, valueColumn, theme, rect, reservesRail ? RAIL_COLUMNS : 0);
     }
     onInput(data, host) {
         if (this.#structured !== null)
@@ -278,13 +327,16 @@ export class SettingsApp {
             this.#scroll = Math.max(0, this.#scroll + (event.kind === "wheel-down" ? distance : -distance));
             return { consumed: true };
         }
+        const rail = this.#railPointer(event);
+        if (rail.owned)
+            return { consumed: true };
         const row = this.#frameRows.find(candidate => candidate.screenRow === event.row - 1);
         const previousKey = this.#hoverKey;
         const previousRegion = this.#hoverRegion;
         if (row === undefined) {
             this.#hoverKey = null;
             this.#hoverRegion = "label";
-            return { consumed: event.kind !== "motion", render: previousKey !== null };
+            return { consumed: event.kind !== "motion", render: previousKey !== null || rail.changed };
         }
         this.#hoverKey = row.key;
         this.#hoverRegion = regionAt(row, event.column);
@@ -303,9 +355,55 @@ export class SettingsApp {
             }
             return { consumed: true };
         }
-        const changed = previousKey !== this.#hoverKey || previousRegion !== this.#hoverRegion;
+        const changed = previousKey !== this.#hoverKey || previousRegion !== this.#hoverRegion || rail.changed;
         return { consumed: event.kind !== "motion", render: changed };
     }
+    // Rationale: the rail takes its share of a pointer report first: hover, a thumb drag, or a
+    // track page. Owned means the list must not see the report; changed means the rail looks different.
+    #railPointer(event) {
+        const frame = this.#railFrame;
+        const wasHovered = this.#rails.isHovered(RAIL_KEY);
+        if (frame === null) {
+            this.#rails.clear();
+            return { owned: false, changed: wasHovered };
+        }
+        const pointer = { column: event.column, row: event.row - 1 };
+        if (this.#rails.isDragging(RAIL_KEY)) {
+            // Invariant: a drag keeps the pointer wherever it goes until the button comes up.
+            if (event.kind === "release")
+                this.#rails.endDrag();
+            else {
+                const target = this.#rails.dragTo(frame.rail, frame.geometry, pointer);
+                if (target !== null)
+                    this.#scroll = target;
+            }
+            return { owned: true, changed: true };
+        }
+        const over = this.#rails.notePointer([frame.rail], pointer) !== null;
+        if (!over)
+            return { owned: false, changed: wasHovered };
+        // Invariant: the rail is not a row: pointing at it lights nothing in the list.
+        this.#hoverKey = null;
+        this.#hoverRegion = "label";
+        if (event.kind === "press" && !this.#rails.beginDrag(frame.rail, frame.geometry, pointer)) {
+            this.#scroll = scrollForTrackPage(frame.geometry, pointer.row - frame.rail.rowStart, this.#scroll, frame.page);
+        }
+        return { owned: true, changed: true };
+    }
+    #noteScrollActivity(host, now) {
+        this.#activeUntil = Math.max(this.#activeUntil, now + SCROLL_LINGER_MS);
+        this.#clearActivityTimer();
+        this.#activityTimer = setTimeout(() => {
+            this.#activityTimer = undefined;
+            host.requestRender();
+        }, SCROLL_LINGER_REPAINT_MS);
+        this.#activityTimer.unref?.();
+    }
+    #clearActivityTimer() {
+        if (this.#activityTimer !== undefined)
+            clearTimeout(this.#activityTimer);
+        this.#activityTimer = undefined;
+    }
     #openMenu(rows, selected) {
         const row = rows[selected];
         if (row === undefined || row.kind !== "element")
@@ -348,6 +446,7 @@ export class SettingsApp {
         // thing under the pointer, so it stops looking like it.
         this.#hoverKey = null;
         this.#hoverRegion = "label";
+        this.#rails.clear();
         this.#structured = { entry, flags: entry.flags.map(flag => flag.key), index: 0, record };
     }
     #structuredKey(data) {
@@ -410,13 +509,15 @@ export class SettingsApp {
         if (input === null)
             return { consumed: false };
         const key = KEYS[data];
-        if (key === "home" || key === "end") {
+        // Rationale: the boundary chords jump through the results; plain Home and End stay with
+        // the search cursor, which the shared line input moves below.
+        if (key === "ctrl+home" || key === "ctrl+end") {
             const rows = this.#rows();
             const selectable = selectableIndexes(rows);
-            const target = key === "end" ? selectable.at(-1) : selectable[0];
+            const target = key === "ctrl+end" ? selectable.at(-1) : selectable[0];
             if (target !== undefined) {
                 this.#select(rows, target);
-                if (key === "home")
+                if (key === "ctrl+home")
                     this.#scroll = 0;
             }
             return { consumed: true };
@@ -502,11 +603,22 @@ export class SettingsApp {
         return this.#pending.get(`${entry.backend}:${entry.id}`) ?? entry.value;
     }
     #scrollbarSpeed() {
+        const value = this.#scrollSetting("scrollbarSpeed");
+        return isScrollbarSpeed(value) ? value : "normal";
+    }
+    #scrollbarAppearance() {
+        const value = this.#scrollSetting("scrollbarAppearance");
+        return value === "always" || value === "hidden" ? value : "auto";
+    }
+    #scrollbarStyle() {
+        return this.#scrollSetting("scrollbarStyle") === "thick" ? "thick" : "thin";
+    }
+    // Invariant: a Scroll setting reads as the screen shows it: an accepted value first, then the source.
+    #scrollSetting(id) {
         const entry = this.#session.sections()
             .flatMap(section => section.entries)
-            .find(candidate => candidate.backend === "a1" && candidate.id === "scrollbarSpeed");
-        const value = entry === undefined ? this.#session.value("scrollbarSpeed") : this.#shownValue(entry);
-        return isScrollbarSpeed(value) ? value : "normal";
+            .find(candidate => candidate.backend === "a1" && candidate.id === id);
+        return entry === undefined ? this.#session.value(id) : this.#shownValue(entry);
     }
     #jump(rows, target) {
         this.#select(rows, target);
@@ -590,7 +702,7 @@ export class SettingsApp {
             ...(typeof shown === "number" && entry.editable ? { stepper: stepperEnds(range, shown) } : {}),
         };
     }
-    #withMenu(lines, _selected, _layout, valueColumn, theme, rect) {
+    #withMenu(lines, _selected, _layout, valueColumn, theme, rect, reservedRight) {
         const menu = this.#menu;
         const anchor = menu === null ? undefined : this.#frameRows.find(candidate => candidate.key === menu.anchorKey);
         if (menu === null || anchor === undefined) {
@@ -605,7 +717,7 @@ export class SettingsApp {
         const frame = valueMenuFrame(state, { screenRow: anchor.screenRow, valueColumn }, {
             bodyHeight: lines.length - this.#footerHeight,
             surfaceWidth: rect.width,
-            reservedRight: RAIL_COLUMNS,
+            reservedRight,
         });
         this.#menuFrame = frame;
         return renderValueMenu(lines, state, frame, theme);

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

@@ -44,12 +44,12 @@ 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. */
+        /** True when autocomplete is searching one space-free slash command that is the editor's only content. */
         isTopLevelCommandSearch() {
             if (!this.isShowingAutocomplete())
                 return false;
             const text = this.getText();
-            if (!/^\/[^\s/]*$/.test(text))
+            if (!/^\/\S*$/.test(text))
                 return false;
             const cursor = this.getCursor();
             return cursor.line === 0 && cursor.col === text.length;

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

@@ -1394,6 +1394,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 +1419,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 +1429,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 +1445,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 }),

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-17T13:26:08.181Z",
   "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-17T13:26:00.541Z",
   "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-17T13:27:04.398Z",
   "artifact": {
     "filename": "process-guardian.exe",
-    "sha256": "049f0659bfe5d506a900d07e219c6a96480e8495dede8375c7ea5f9e5dc1990d",
+    "sha256": "f7e5072d6fddb8e0672d8274699e8e47f515d98776ba3bd79b00391fcd38e667",
     "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;

package/docs/architecture/ui-reference-provenance.md

@@ -29,7 +29,7 @@ its own `core` facade layer; A1 is a product, so the port adapts imports and kee
 | `ui-components/list-block.ts` — sticky scroll | `settings/impl.ts` — `stickyHeaderGroup`, `topPaddingRows`, `visibleRowCountAt`, `clampScrollForView` | Same reservation arithmetic and two-pass reveal. |
 | `ui-components/mouse.ts` | `core/panes/sgr-mouse.ts` | Same SGR decoding and per-call regex reset; A1 emits its own event shape. |
 | `ui-components/mouse.ts` — tracking sequences | `core/host/pi/providers/host-bridge-surface.ts` | Mouse modes only. A1 does not take the alternate screen, because the Pi TUI owns the screen A1 renders through. |
-| `features/owned-ui/settings-app.ts` — section layout, pointer controls, and scrolling | `settings/impl.ts` — `settingsValueColumn`, block navigation, sticky sections, and pointer hit regions | Setting discovery is A1's own A1/Agent section model. Section navigation and pointer-only numeric controls follow the A1 reference; explicit `/` search, ruled shared input, shortcut-derived hints, hidden description rows, configured wheel cadence, and distinct floating scalar menus are reviewed owned interactions. |
+| `features/owned-ui/settings-app.ts` — section layout, pointer controls, and scrolling | `settings/impl.ts` — `settingsValueColumn`, block navigation, sticky sections, and pointer hit regions | Setting discovery is A1's own A1/Agent section model. Section navigation and pointer-only numeric controls follow the A1 reference; explicit `/` search, ruled shared input, shortcut-derived hints, hidden description rows, configured wheel cadence, a rail presented through the shared scrollbar settings, `Ctrl+Home`/`Ctrl+End` boundary jumps, and distinct floating scalar menus are reviewed owned interactions. |
 
 ## Ported from the pinned engine
 
@@ -39,7 +39,7 @@ its own `core` facade layer; A1 is a product, so the port adapts imports and kee
 | `pi-engine-adapter/adapter.ts`, `engine/workflows.ts`, and `pi-session-ui/session-shell.ts` — interactive command outcomes | Pi 0.84.2 `modes/interactive/interactive-mode.ts`, `core/model-resolver.ts`, and `config.ts` at commit `914cf1472e715297caa30db4b9535d534a9eb718` | Preserves route-specific status/warning/error semantics, authentication partial-success sequences, stored-credential logout wording, fork/clone empty states, import context/recovery, share URL and failure/cancellation behavior, and post-login warning lifetime. A1 deliberately returns recoverable failed workflow results instead of adopting Pi's process-owning shutdown/exit for fatal `/new`, `/resume`, and `/import` outcomes. Focused outcome evidence is in `test/integrations/pi/engine/workflows.test.ts` and `test/integrations/pi/session-ui/session-shell.test.ts`; terminal-cell geometry remains a separate milestone. |
 | `pi-engine-adapter/settings-integration.ts` — `SETTING_LABELS` | pinned Pi settings selector | Labels and descriptions transcribed so an owned screen reads as the vanilla route words it. Ids are mapped from the selector kebab-case to the exposed camelCase keys. |
 | `pi-engine/session-integration.ts` and `pi-components/shell-footer-status.ts` — steering queue | pinned Pi interactive mode `onSubmit` and `updatePendingMessagesDisplay` | Steering/follow-up uses `prompt(..., { streamingBehavior })`, allowing Pi to emit the accepted user row, while remaining steering rows preserve Pi's opening spacer, dim `Steering:` labels, dequeue hint, and order before `Working`. |
-| `ui-components/list-view.ts`, `dialog-panel.ts`, `value-menu.ts`, and `features/owned-ui/settings-app.ts` — setting presentation | pinned Pi `SettingsSelectorComponent`, Pi TUI `SettingsList`, `SelectList`, and `Input` at `0.84.2` | Cursor, selected label/value accents, unselected muted values, the 30-column label cap, dialog styling, notices, and narrow-width geometry retain pinned semantics. Scalar-menu placement and input remain shared, while A1/Agent grouping, pointer steppers, explicit `/` search, ruled shared input, shortcut-derived status hints, suppressed selected descriptions, `scrollbarSpeed`-driven wheel movement, and the dark floating menu with lighter active row and effective-value check mark are declared product-owned differences. Independent row evidence: `test/features/owned-ui/pinned-settings-presentation-parity.test.ts`; owned interaction evidence: `test/features/owned-ui/settings-app.test.ts`, `test/ui/components/value-menu.test.ts`, and `test/composition/settings-route-host.test.ts`. |
+| `ui-components/list-view.ts`, `dialog-panel.ts`, `value-menu.ts`, and `features/owned-ui/settings-app.ts` — setting presentation | pinned Pi `SettingsSelectorComponent`, Pi TUI `SettingsList`, `SelectList`, and `Input` at `0.84.2` | Cursor and selected label accents, unselected muted values, the 30-column label cap, dialog styling, notices, and narrow-width geometry retain pinned semantics. Scalar-menu placement and input remain shared, while the muted, hover-brightened selected value, A1/Agent grouping, pointer steppers, explicit `/` search, ruled shared input, shortcut-derived status hints, suppressed selected descriptions, `scrollbarSpeed`-driven wheel movement, a list rail that follows `scrollbarAppearance` and `scrollbarStyle` with transcript-style hover and drag, `Ctrl+Home`/`Ctrl+End` boundary jumps, and the dark floating menu with lighter active row and effective-value check mark are declared product-owned differences. Independent row evidence: `test/features/owned-ui/pinned-settings-presentation-parity.test.ts`; owned interaction evidence: `test/features/owned-ui/settings-app.test.ts`, `test/ui/components/value-menu.test.ts`, and `test/composition/settings-route-host.test.ts`. |
 | `features/owned-ui/project-trust-prompt.ts` — pre-resource selector | pinned Pi `cli/startup-ui.ts`, `cli/project-trust.ts`, and `core/project-trust.ts` at commit `914cf1472e715297caa30db4b9535d534a9eb718` | Uses a fixed, dependency-bounded A1 startup selector rather than importing private CLI modules. It preserves selected-option accent, navigation/accept/reject/cancel semantics, fail-closed behavior, raw-mode restoration, clearing, cursor restoration, and parent-screen restoration before diagnostics. |
 | `pi-session-ui/session-shell-root.ts` and `session-shell.ts` — fullscreen exit | pinned Pi `InteractiveMode.formatResumeCommand()` and shutdown output at commit `914cf1472e715297caa30db4b9535d534a9eb718` | Re-renders authoritative transcript components with semantic SGR intact, excludes inline-image control payloads and fullscreen-only chrome, restores the terminal first, then emits pinned dim `To resume this session:` wording with `a1`, compact session id, and conditional quoted `--session-dir`. |
 | `pi-tui-runtime/input-presentation-coordinator.ts` and custom-viewport dock reuse | pinned Pi TUI `TuiBase` input dispatch and immediate-render pending guard at `0.84.2` | Preserves each original terminal delivery and invokes the existing Pi handlers exactly once in order. Bare A1 alone drains finite-grammar text/edit/navigation bursts in one immediate event-loop opportunity so Pi's existing pending guard paints the newest state once; effectful, unknown, protocol, paste, and extension-owned input remains an immediate barrier. Geometry-stable dock frames reuse A1's established transcript viewport, while uncertain geometry and replacement-surface damage still fail closed. Independent evidence is under `test/support/input-responsiveness/`. |

package/docs/local-worktree-cleanup.md

@@ -4,9 +4,35 @@ Local cleanup completes the delivery order in [the archive runbook](openspec-arc
 
 The implementation is repository tooling, not part of the installed A1 product. It requires Node, Git, and GitHub read access; the explicit closed-unmerged discard operation additionally requires authenticated permission to delete its exact remote topic ref. No product build, dependency installation, interactive UI, or OS-service provisioning is needed. It supports this repository's `origin` on github.com, via HTTPS or SSH.
 
+## Hand-off and sweep: the ordinary agent path
+
+The delivering agent's session usually ends before the maintainer merges, so cleanup is split into two commands that never need the same session. When the validated PR is handed to the maintainer, and again after any repair push, the owning agent parks the worktree from the primary checkout:
+
+```bash
+node scripts/governance/local-worktree-cleanup.mjs handoff   --repo D:/Git/a1   --path D:/Git/a1/.worktrees/example-task   --change example-change   --pr 123
+```
+
+`handoff` registers the exact worktree if it is not registered yet (or reclaims the existing released entry), records its current HEAD and branch, applies the central disposable policy, and releases it. It evaluates nothing, deletes nothing, and does not enable the queue. That release is the candidate-scoped cleanup authorization for this worktree and its topic ref, exercised only once the merge, archive, validation, and remote-ref gates verify later; it never becomes discard authority for a PR that is later closed unmerged. It is idempotent per worktree: repeating it updates the recorded head instead of adding a second registration. Tracked, staged, unstaged, or untracked content outside the disposable roots blocks with `worktree-content` and the affected paths, because such content means unpushed work; unknown ignored content is judged at removal time, as it is for `complete`. A primary, foreign, replaced, or branch-changed path blocks with a named reason. A worktree that a session registered with the low-level `register` command and still owns is released by `handoff` (or `complete`) when `LOCAL_CLEANUP_OWNER_TOKEN` holds that registration's token; without it both block with `owned-worktree`, and a separate `release` is needed.
+
+Every delivery session then starts, before it creates a worktree, with one bounded sweep from the primary checkout, and runs it again when it verifies or is told of a merge:
+
+```bash
+node scripts/governance/local-worktree-cleanup.mjs sweep --repo D:/Git/a1
+```
+
+`sweep` evaluates every released registration in one pass under the queue limits (100 registrations, 500 remote requests, a durable round-robin cursor) with a 180-second elapsed budget, since each merged candidate costs three evidence loads, and completes each candidate whose PR is verified merged using exactly the `complete` safeguards. It needs no `enable` and starts no process: its authority is each candidate's release. A candidate whose PR is open, draft, or not yet finalized reports `pending`; a candidate whose PR closed without merge reports `awaiting-discard` and is never touched; blockers report their exact reason. An old stop sentinel does not prevent a sweep, but `disable` run while a sweep is executing stops it before its next destructive step. If another session holds the mutation lock the sweep reports `mutation-busy` and the agent relays it as deferred rather than waiting. The JSON report carries a `lines` array with one relayable line per candidate and pruned branch, for example `#458 close-absent-and-skewed-cleanup: removed [worktree-removed, local-ref-removed]`. Pending or blocked results never delay the new delivery.
+
+### Accepted ancestry
+
+Since the `OpenSpec finalization` workflow pushes its commit onto the PR branch after the agent's last push, the registered head is normally one commit behind the merged head. Cleanup therefore accepts a registered head, live worktree HEAD, or local topic-ref tip that equals the merged PR head or is one of its ancestors on GitHub, verified with the compare API: every commit reachable from such a tip is reachable from a head the maintainer accepted, so nothing is lost. A tip that holds a commit outside the merged head, or a commit GitHub does not know, still blocks with `candidate-head-association`, `worktree-identity-changed`, or `local-ref-advanced`, and the branch attachment must still be the registered one. Ref deletion reads the tip immediately before deleting, requires it to be accepted, and uses it as the compare-and-delete expectation. Ancestry of `develop` is never used, because the repository squash-merges.
+
+### Merged branch pruning
+
+The sweep also prunes local topic branches that have no live registration, such as the branch left behind when a worktree was deleted by hand. A branch is deleted only when all of these hold: its name follows `type/short-description` and is not `develop` or another protected or reserved name; no worktree has it checked out; the same-repository pull-request lookup by that head ref name returns at least one PR merged into `develop` and no open PR; the tip equals or is an ancestor of the most recent such merged PR's head; and `origin` no longer has the ref. Deletion is compare-and-delete against the tip reread immediately before. Everything else is reported and kept with `branch-no-pull-request`, `branch-open-pull-request`, `branch-closed-pull-request`, `branch-unmerged-commits`, `branch-checked-out`, or `branch-remote-present`. Branch pruning never deletes remote refs, worktrees, or registrations, and a preview never prunes.
+
 ## Standard completed-delivery command
 
-After authorized merge, accepted/archive verification, and remote topic-ref removal, the owning agent runs one command from the primary checkout:
+The exact-candidate form remains for a session that is still alive at merge time or wants to finish one candidate by name. After authorized merge, accepted/archive verification, and remote topic-ref removal, the owning agent runs one command from the primary checkout:
 
 ```bash
 node scripts/governance/local-worktree-cleanup.mjs complete \
@@ -20,7 +46,7 @@ node scripts/governance/local-worktree-cleanup.mjs complete \
 
 The central disposable policy is `node_modules`, `dist`, `.builds`, `.artifacts`, `native/process-guardian/target`, and `native/terminal-host/target`. The `.artifacts` root is the repository's ignored generated-artifact root (finalization and validation reports, packed candidates, agent-written logs and diffs); the two native roots contain repository-generated Cargo output. Registrations that still name `.artifacts/openspec-archive` or `.artifacts/validation` stay valid and are widened to the root on the next `complete`. Each encountered path must be ignored and stay inside the exact worktree with no link, special file, or nested repository boundary. Authority is component-exact: near matches such as `.artifacts-user` or `artifacts`, arbitrary `target` directories, and sibling native projects remain blocking. Tracked/staged/unstaged/untracked content and every unknown ignored path still block. A tracked regular `.gitmodules` file alone is ordinary content; actual nested `.git` metadata, gitlinks, configured submodules, and submodule changes block. Ordinary content and these approved generated roots are traversed under separate finite entry allowances, so a normal dependency installation does not consume the ordinary source-tree allowance; both allowances retain the same deadline and content-boundary checks. Once those checks pass, cleanup deletes the declared disposable roots itself with a bounded retry for transient Windows sharing violations before handing the worktree to Git, so non-force Git removal only has to delete tracked content. A root that stays locked after the retry budget reports `blocked` with `disposable-path-locked` and the root's path; the worktree, its `.git` pointer, and its journal are untouched, so stop the process holding the handle and rerun the same command.
 
-Agents do not manually remove generated content, call `git worktree remove`, or delete the local branch after delivery. The JSON result is authoritative: report success only for `removed` or verified `already-absent`; otherwise retain the worktree and report the exact blocker. Legacy roles can supply separate `--source-pr`, `--candidate-pr`, and `--role` values.
+Agents do not manually remove generated content, call `git worktree remove`, or delete the local branch after delivery. The JSON result is authoritative: report success only for `removed` or verified `already-absent`; otherwise retain the worktree and report the exact blocker. A handed-off entry whose worktree was deleted by hand completes through its journal, and its branch is deleted under the accepted-ancestry rule. Legacy roles can supply separate `--source-pr`, `--candidate-pr`, and `--role` values.
 
 ## Explicit closed-unmerged discard
 
@@ -54,7 +80,7 @@ Remote reads use `GH_TOKEN`/`GITHUB_TOKEN`, otherwise existing `gh auth token --
 
 ## Explicit queue/watch enablement
 
-The exact-candidate `complete` command does not enable or scan the persistent queue. Only after the maintainer separately authorizes queue/watch activation, use the reviewed tool in the primary/stable checkout outside `.worktrees/`:
+Neither `handoff`, `sweep`, nor the exact-candidate `complete` command enables the persistent queue; `sweep` scans released registrations under its own authority, while `once`/`watch` remain the separately enabled background route. Only after the maintainer separately authorizes queue/watch activation, use the reviewed tool in the primary/stable checkout outside `.worktrees/`:
 
 ```bash
 node scripts/governance/local-worktree-cleanup.mjs enable --repo D:/Git/a1
@@ -123,14 +149,15 @@ A session crash does not release ownership. After separately confirming that the
 node scripts/governance/local-worktree-cleanup.mjs recover --repo D:/Git/a1 --id REGISTRATION_ID --generation CURRENT_GENERATION --confirm-stopped
 ```
 
-Recovery never releases or deletes. The generation must still match. A Git worktree lock remains a veto. A leftover `mutation.lock` from a crashed cleanup process also remains a veto: stop all cleanup/claim processes, inspect the lock and `state.json`, and obtain explicit approval before manually removing that identified lock. There is no automatic stale-lock eviction or PID-based deletion.
+Recovery never releases or deletes. The generation must still match. A Git worktree lock remains a veto. A leftover `mutation.lock` from a killed cleanup process is evicted only on proof: the holder writes its PID and refreshes a heartbeat in the lock every five seconds, and a later `handoff`, `sweep`, `complete`, `discard`, claim, or queue pass evicts the lock only when that heartbeat (or, for an old lock without one, the file's modification time) is more than two minutes old and the PID no longer exists. A live, unprobeable, or own PID keeps the lock, as does a fresh or unreadable-but-fresh file, and the operation reports `mutation-busy`. Each eviction is journaled as `lock-evicted-<time>-<id>.json` beside `state.json` with the evicted record; it releases no ownership and advances no journal step. A lock that stays `mutation-busy` therefore has a live holder: wait for it or stop that process first.
 
 ## Outcomes and interruption handling
 
 State, journals, stop controls, and execution reports live in `<git-common-dir>/local-worktree-cleanup/`, outside removable checkouts. `status` omits owner-token hashes. Reports contain identities, local blockers, performed steps, and coverage, never file contents or credentials. Completed reports are retained for 30 days subject to a 10 MiB cap; unresolved queue/journal records are not evicted.
 
 - `eligible`: preview passed the gates; nothing was removed.
-- `pending`: archive/ref prerequisites have not finished.
+- `pending`: archive/ref prerequisites have not finished, or the handed-off PR is still open.
+- `awaiting-discard`: the handed-off PR closed without merge; only the explicit `discard` command may act.
 - `blocked`: ownership, content, path, provenance, authentication, or identity needs attention.
 - `unmanaged`: no local registration; no automatic adoption.
 - `removed`: worktree and eligible local-ref operations were verified.
@@ -138,7 +165,7 @@ State, journals, stop controls, and execution reports live in `<git-common-dir>/
 - `partial`: a destructive step began but all cleanup could not be verified; the same command resumes it.
 - `deferred`: a bounded pass or concurrent mutation owner prevented evaluation.
 
-Non-force Git removal is the only operation that deletes tracked content from an intact worktree. Local topic-ref deletion then compares the exact old SHA and refuses refs checked out elsewhere. `develop`, primary/current directories, changed heads, and active sessions are protected. Normal removal retires its own Git worktree registration; unrelated stale/missing registrations are never globally pruned.
+Non-force Git removal is the only operation that deletes tracked content from an intact worktree. Local topic-ref deletion then compares the tip read immediately before, which must be the journaled head or an accepted ancestor of the merged head, and refuses refs checked out elsewhere. `develop`, primary/current directories, changed heads, and active sessions are protected. Normal removal retires its own Git worktree registration; unrelated stale/missing registrations are never globally pruned.
 
 A released worktree whose directory was deleted by hand before cleanup ran is finished through its journal rather than failing on the missing directory: the same merge/archive evidence is verified, Git may hold no registration for the path or only this candidate's own dangling one, that registration is retired, the step is recorded as `worktree-already-absent`, and the unchanged local topic ref is deleted under the usual compare-and-delete rule. A `complete` invocation for an absent path that was never registered blocks with `worktree-absent-unregistered`, because there is no journaled head to compare the ref against.
 

package/docs/openspec-archive-automation.md

@@ -15,7 +15,7 @@ Version-1 and version-2 deliveries and their existing comments, acceptance PRs,
 5. **Ready and automated finalization:** mark the PR ready. The trusted `OpenSpec finalization` workflow reconciles current `develop`, conservatively synchronizes all deltas, moves the active change into its dated archive, stages the conditional acceptance manifest, commits that to the same branch with the archive App identity, and writes the emitted paths into the body's implementation fence. Running the [finalization command](#finalization-command) locally first is optional and yields the same bytes.
 6. **Validate:** one normal exact-head workflow validates the finalized head: implementation, synchronized specs, archive, manifest, tasks/evidence, exact PR-body list, and every selected product/governance scope before emitting the stable protected aggregate. A new commit or acceptance-list change re-finalizes automatically when needed and requires full renewed validation; no lifecycle body edit or second workflow run is required.
 7. **Manual merge accepts:** after the stable protected aggregate succeeds, an authorized human reviews and manually merges the exact validated head. That single action means the listed scenarios are accepted and explicitly authorizes integration. Auto-merge, merge queue, Apps, bots, and documentation reconciliation are forbidden.
-8. **Verify and clean:** trusted post-merge policy derives `Archived` and reports `accepted-and-archived` from committed bytes and immutable GitHub provenance without editing the accepted PR body. It publishes no lifecycle branch or PR. Shared exact-head remote cleanup may delete the unchanged topic ref; local cleanup remains separately ownership-controlled.
+8. **Verify and clean:** trusted post-merge policy derives `Archived` and reports `accepted-and-archived` from committed bytes and immutable GitHub provenance without editing the accepted PR body. It publishes no lifecycle branch or PR. Shared exact-head remote cleanup may delete the unchanged topic ref; local cleanup remains separately ownership-controlled: the agent parks the worktree with `handoff` at step 7, and the next session's `sweep` removes it once the merge, archive, and remote-ref evidence verify (see [local cleanup](local-worktree-cleanup.md)).
 
 The implementation, synchronized canonical specs, conditional acceptance record, and archive therefore reach `develop` atomically. Closing the PR unmerged integrates none of them.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@timurproko/a1",
-  "version": "0.1.8-dev.457",
+  "version": "0.1.8-dev.459",
   "description": "Standalone terminal workspace for supervised native and managed agents",
   "type": "module",
   "privateLaunchContract": "neutral-launch-v1",