@timurproko/a1 0.1.8-dev.527 → 0.1.8-dev.536

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

@@ -8,7 +8,7 @@ export type { InputRow, InputRowOptions, LineInputOutcome, LineInputView } from
 export { PROMPT_GLYPH, PROMPT_PREFIX_WIDTH, PromptInput, promptArrow, promptRule, promptRuleText } from "./prompt-input.js";
 export type { PromptInputBody, PromptInputMetrics } from "./prompt-input.js";
 export { blockJumpTarget, blockRowSpan, clampScroll, indexOfKey, layoutList, maxScrollFor, moveSelection, rowKey, scrollForSelection, selectableIndexes, stickyHeaderFor, topPaddingRows, visibleRowCount, } from "./list-block.js";
-export type { ListLayout, ListRow, ListRowSpan } from "./list-block.js";
+export type { ListLayout, ListLayoutOptions, ListRow, ListRowSpan } from "./list-block.js";
 export { STEPPER_RESERVE, placementFor, regionAt, renderGroupHeader, renderListRow, renderNote, valueColumnFor } from "./list-view.js";
 export type { ListRegion, ListRowPlacement, ListRowState, ListViewRow } from "./list-view.js";
 export { MOUSE_TRACKING_OFF, MOUSE_TRACKING_ON, parseMouseInput, routeMouseInput } from "./mouse.js";

package/dist/ui/components/list-block.d.ts

@@ -37,14 +37,18 @@ export declare function moveSelection<T>(rows: readonly ListRow<T>[], current: n
 export declare function blockJumpTarget<T>(rows: readonly ListRow<T>[], current: number, delta: number): number | undefined;
 /** The block containing `index`: its header through the row before the next header. */
 export declare function blockRowSpan<T>(rows: readonly ListRow<T>[], index: number): ListRowSpan;
-/** The header pinned above the body when the top visible row belongs to a group. */
+/** The header pinned above the body while its content or outgoing spacer is at the top. */
 export declare function stickyHeaderFor<T>(rows: readonly ListRow<T>[], scroll: number): string | undefined;
+export interface ListLayoutOptions {
+    /** Settings keeps one opening row; embedded documents can start with their own prelude. */
+    readonly topPadding?: boolean;
+}
 /** One blank row above the first group while the list is scrolled to the top. */
-export declare function topPaddingRows(scroll: number): number;
+export declare function topPaddingRows(scroll: number, enabled?: boolean): number;
 /** Rows of content visible after the padding and any pinned header. */
-export declare function visibleRowCount<T>(rows: readonly ListRow<T>[], bodyHeight: number, scroll: number): number;
-export declare function maxScrollFor<T>(rows: readonly ListRow<T>[], bodyHeight: number): number;
-export declare function clampScroll<T>(rows: readonly ListRow<T>[], bodyHeight: number, scroll: number): {
+export declare function visibleRowCount<T>(rows: readonly ListRow<T>[], bodyHeight: number, scroll: number, options?: ListLayoutOptions): number;
+export declare function maxScrollFor<T>(rows: readonly ListRow<T>[], bodyHeight: number, options?: ListLayoutOptions): number;
+export declare function clampScroll<T>(rows: readonly ListRow<T>[], bodyHeight: number, scroll: number, options?: ListLayoutOptions): {
     readonly scroll: number;
     readonly visible: number;
 };
@@ -63,4 +67,4 @@ export interface ListLayout {
     readonly rowIndexes: readonly number[];
 }
 /** Everything a renderer needs for one frame, derived rather than remembered. */
-export declare function layoutList<T>(rows: readonly ListRow<T>[], bodyHeight: number, scroll: number): ListLayout;
+export declare function layoutList<T>(rows: readonly ListRow<T>[], bodyHeight: number, scroll: number, options?: ListLayoutOptions): ListLayout;

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

@@ -95,37 +95,37 @@ export function blockRowSpan(rows, index) {
     }
     return { from, to };
 }
-/** The header pinned above the body when the top visible row belongs to a group. */
+/** The header pinned above the body while its content or outgoing spacer is at the top. */
 export function stickyHeaderFor(rows, scroll) {
     const row = rows[scroll];
-    if (row === undefined || (row.kind !== "element" && row.kind !== "note"))
+    if (row === undefined || row.kind === "group")
         return undefined;
     const header = headerAbove(rows, scroll);
     const headerRow = header < 0 ? undefined : rows[header];
     return headerRow !== undefined && headerRow.kind === "group" ? headerRow.title : undefined;
 }
 /** One blank row above the first group while the list is scrolled to the top. */
-export function topPaddingRows(scroll) {
-    return scroll <= 0 ? 1 : 0;
+export function topPaddingRows(scroll, enabled = true) {
+    return enabled && scroll <= 0 ? 1 : 0;
 }
 /** Rows of content visible after the padding and any pinned header. */
-export function visibleRowCount(rows, bodyHeight, scroll) {
-    const reserved = topPaddingRows(scroll) + (stickyHeaderFor(rows, scroll) === undefined ? 0 : 1);
+export function visibleRowCount(rows, bodyHeight, scroll, options = {}) {
+    const reserved = topPaddingRows(scroll, options.topPadding !== false) + (stickyHeaderFor(rows, scroll) === undefined ? 0 : 1);
     return Math.max(1, bodyHeight - reserved);
 }
-export function maxScrollFor(rows, bodyHeight) {
+export function maxScrollFor(rows, bodyHeight, options = {}) {
     let scroll = Math.max(0, rows.length - 1);
     for (let pass = 0; pass < 8; pass++) {
-        const next = Math.max(0, rows.length - visibleRowCount(rows, bodyHeight, scroll));
+        const next = Math.max(0, rows.length - visibleRowCount(rows, bodyHeight, scroll, options));
         if (next === scroll)
             break;
         scroll = next;
     }
     return scroll;
 }
-export function clampScroll(rows, bodyHeight, scroll) {
-    const bounded = Math.min(Math.max(scroll, 0), maxScrollFor(rows, bodyHeight));
-    return { scroll: bounded, visible: visibleRowCount(rows, bodyHeight, bounded) };
+export function clampScroll(rows, bodyHeight, scroll, options = {}) {
+    const bounded = Math.min(Math.max(scroll, 0), maxScrollFor(rows, bodyHeight, options));
+    return { scroll: bounded, visible: visibleRowCount(rows, bodyHeight, bounded, options) };
 }
 /**
  * Scroll that brings the selection into view, moving the least it can. A reveal
@@ -158,14 +158,27 @@ export function scrollForSelection(rows, bodyHeight, scroll, selected, reveal) {
     return next;
 }
 /** Everything a renderer needs for one frame, derived rather than remembered. */
-export function layoutList(rows, bodyHeight, scroll) {
-    const clamped = clampScroll(rows, bodyHeight, scroll);
+export function layoutList(rows, bodyHeight, scroll, options = {}) {
+    const clamped = clampScroll(rows, bodyHeight, scroll, options);
     const sticky = stickyHeaderFor(rows, clamped.scroll);
-    const padding = topPaddingRows(clamped.scroll);
+    const padding = topPaddingRows(clamped.scroll, options.topPadding !== false);
     const indexes = [];
-    for (let offset = 0; offset < clamped.visible && clamped.scroll + offset < rows.length; offset++) {
+    // Invariant: a spacer at the scroll boundary belongs to the outgoing pinned section.
+    // The pin represents that transition, so the spacer spends no body row and the final
+    // setting remains reachable at the bottom.
+    const firstOffset = rows[clamped.scroll]?.kind === "spacer" && sticky !== undefined ? 1 : 0;
+    for (let offset = firstOffset; indexes.length < clamped.visible && clamped.scroll + offset < rows.length; offset++) {
         indexes.push(clamped.scroll + offset);
     }
+    // Invariant: a bottom clamp can land on the outgoing spacer with too few rows after it to fill the
+    // viewport. The pinned heading already represents that boundary, so fill the freed capacity
+    // from the same section rather than exposing a synthetic blank row at the bottom.
+    if (firstOffset > 0 && indexes.length < clamped.visible) {
+        const header = headerAbove(rows, clamped.scroll);
+        for (let index = clamped.scroll - 1; index > header && indexes.length < clamped.visible; index--) {
+            indexes.unshift(index);
+        }
+    }
     return {
         scroll: clamped.scroll,
         visible: clamped.visible,

package/dist/ui/components/list-view.d.ts

@@ -41,7 +41,7 @@ export interface ListRowPlacement {
  * a number does not shift its own value out of the column it shares.
  */
 export declare function valueColumnFor(rows: readonly ListViewRow[], indent?: number, gap?: number): number;
-/** A group's name, above the rows that belong to it. */
+/** A group's name with the shared one-cell section inset used by owned screens. */
 export declare function renderGroupHeader(title: string, width: number, theme: UiTheme): string;
 /**
  * One row, painted. The label carries the selection, the value carries the

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

@@ -11,9 +11,11 @@ export function valueColumnFor(rows, indent = 2, gap = 2) {
     const stepper = rows.some(row => row.stepper !== undefined) ? STEPPER_RESERVE : 0;
     return indent + widest + gap + stepper;
 }
-/** A group's name, above the rows that belong to it. */
+/** A group's name with the shared one-cell section inset used by owned screens. */
 export function renderGroupHeader(title, width, theme) {
-    return truncateToWidth(theme.fg("accent", theme.bold(title)), width);
+    if (width <= 0)
+        return "";
+    return ` ${truncateToWidth(theme.fg("mdHeading", theme.bold(title)), width - 1)}`;
 }
 /**
  * One row, painted. The label carries the selection, the value carries the

package/dist/ui/components/mouse.js

@@ -45,8 +45,8 @@ export function routeMouseInput(data, claim) {
     for (let match = pattern.exec(data); match !== null; match = pattern.exec(data)) {
         output += data.slice(index, match.index);
         index = match.index + match[0].length;
-        const event = toEvent(Number.parseInt(match[1] ?? "", 10), Number.parseInt(match[2] ?? "", 10), Number.parseInt(match[3] ?? "", 10), match[4] === "m");
-        if (event !== null && claim(event, match[0]))
+        const event = toEvent(Number(match[1]), Number(match[2]), Number(match[3]), match[4] === "m");
+        if (event === null || claim(event, match[0]))
             consumed = true;
         else
             output += match[0];
@@ -55,6 +55,8 @@ export function routeMouseInput(data, claim) {
     return { data: output, consumed };
 }
 function toEvent(code, column, row, released) {
+    if ((code & 66) === 66)
+        return null;
     if ((code & 64) !== 0) {
         const kind = (code & 1) === 0 ? "wheel-up" : "wheel-down";
         return { kind, button: 0, column, row };

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

@@ -1,8 +1,4 @@
-/**
- * Colour as a port, so a screen can be rendered and asserted without a terminal
- * or a theme, and so the component layer never imports a Pi adapter.
- */
-export type UiThemeToken = "accent" | "text" | "muted" | "dim" | "border" | "error";
+export type UiThemeToken = "accent" | "mdHeading" | "text" | "muted" | "dim" | "border" | "error";
 export interface UiTheme {
     fg(token: UiThemeToken, text: string): string;
     bold(text: string): string;

package/dist/ui/components/theme.js

@@ -1,7 +1,3 @@
-/**
- * Colour as a port, so a screen can be rendered and asserted without a terminal
- * or a theme, and so the component layer never imports a Pi adapter.
- */
 /** Renders every token as plain text. What tests assert against. */
 export const PLAIN_THEME = Object.freeze({
     fg: (_token, text) => text,

package/dist/ui/components/value-menu.d.ts

@@ -26,7 +26,9 @@ export interface ValueMenuFrame {
     readonly rows: number;
 }
 export interface ValueMenuLayout {
-    /** Rows available above the footer. */
+    /** First screen row available to the menu. Defaults to zero. */
+    readonly bodyTop?: number;
+    /** Rows available between the fixed header and footer. */
     readonly bodyHeight: number;
     /** Full surface width, so the menu stays inside it. */
     readonly surfaceWidth: number;

package/dist/ui/components/value-menu.js

@@ -2,10 +2,12 @@ import { overlaySpan } from "./spans.js";
 import { displayWidth, padToWidth } from "./text.js";
 /** Where the menu is placed: below its anchor where there is room, else above. */
 export function valueMenuFrame(state, anchor, layout) {
+    const bodyTop = layout.bodyTop ?? 0;
+    const bodyBottom = bodyTop + layout.bodyHeight;
     const below = anchor.screenRow + 1;
-    const top = below + state.choices.length <= layout.bodyHeight
+    const top = below + state.choices.length <= bodyBottom
         ? below
-        : Math.max(0, anchor.screenRow - state.choices.length);
+        : Math.max(bodyTop, anchor.screenRow - state.choices.length);
     const width = Math.max(...state.choices.map(choice => displayWidth(choice) + 4), 6);
     const column = Math.min(anchor.valueColumn, Math.max(0, layout.surfaceWidth - width - layout.reservedRight));
     return { top, column, width, rows: state.choices.length };
@@ -17,9 +19,15 @@ export function renderValueMenu(lines, state, frame, theme) {
         const target = frame.top + index;
         if (target < 0 || target >= output.length)
             return;
-        const mark = choice === state.current ? "✓ " : "  ";
-        const text = padToWidth(`${mark}${choice} `, frame.width);
-        const painted = index === state.index ? theme.highlight(text) : theme.panel(text);
+        const active = index === state.index;
+        const paint = active ? theme.highlight : theme.panel;
+        const current = choice === state.current;
+        const tail = padToWidth(`${current ? " " : "  "}${choice} `, frame.width - (current ? 1 : 0));
+        // Invariant: the effective-value check uses the same accent as modal marks, while
+        // the rest of an active row keeps its highlighted foreground and background.
+        const painted = current
+            ? `${paint(theme.fg("accent", "✓"))}${paint(tail)}`
+            : paint(tail);
         output[target] = overlaySpan(output[target] ?? "", frame.column, frame.column + frame.width, painted);
     });
     return output;

package/docs/local-worktree-cleanup.md

@@ -58,7 +58,7 @@ node scripts/governance/local-worktree-cleanup.mjs complete \
 
 `complete` is explicit cleanup authorization for that exact candidate. It creates and releases an exact registration when needed, applies the repository-owned generated-path policy, verifies live merge/archive/CI/ref evidence, evaluates only that candidate, uses journaled non-force Git removal, deletes only the unchanged local topic ref, and leaves persistent watcher authority unchanged. Repeating it reports the completed candidate as already absent. Existing conflicting ownership, identity drift, unavailable evidence, or unknown content remains blocking.
 
-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.
+The central disposable policy is `node_modules`, `dist`, `.builds`, `.artifacts`, `native/process-guardian/target`, `native/terminal-host/target`, and the exact generated file `src/integrations/pi/engine/pi-settings-metadata.json`. 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; Vitest writes the metadata file for source-side settings tests and leaves it shared for overlapping test processes until worktree cleanup. Registrations that still name `.artifacts/openspec-archive` or `.artifacts/validation` stay valid and are widened to the current policy 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`, `artifacts`, or `pi-settings-metadata-user.json`, 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 paths 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 or files 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 disposable path that stays locked after the retry budget reports `blocked` with `disposable-path-locked` and the 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. 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.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@timurproko/a1",
-  "version": "0.1.8-dev.527",
+  "version": "0.1.8-dev.536",
   "description": "Standalone terminal workspace for supervised native and managed agents",
   "type": "module",
   "privateLaunchContract": "neutral-launch-v1",
@@ -64,8 +64,8 @@
     "typecheck:bin": "tsgo -p tsconfig.bin.json"
   },
   "dependencies": {
-    "@earendil-works/pi-coding-agent": "0.86.1",
-    "@earendil-works/pi-tui": "0.86.1",
+    "@earendil-works/pi-coding-agent": "0.87.0",
+    "@earendil-works/pi-tui": "0.87.0",
     "@silvia-odwyer/photon-node": "0.3.4",
     "chalk": "5.6.2",
     "cross-spawn": "7.0.6",