@timurproko/a1 0.1.8-dev.260 → 0.1.8-dev.271

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

@@ -1,4 +1,5 @@
 import { CURSOR_MARKER, decodeKittyPrintable, visibleWidth, } from "#pi-tui";
+import { promptPathWordRanges } from "./path-word-ranges.js";
 export class OwnedEditorUxInterception {
     interceptors;
     fallback;
@@ -59,12 +60,13 @@ class PromptSelectionInterceptor {
     #lastClick;
     #redoStack = [];
     #selectionRevision = 0;
+    #wordDirection;
     #geometry;
     constructor(editor, keybindings, options) {
         this.editor = editor;
         this.keybindings = keybindings;
         this.options = options;
-        installAtomicSegmentation(editor, options.atomicRanges);
+        installAtomicSegmentation(editor, options.atomicRanges, () => this.#wordDirection);
     }
     handleInput(data, next) {
         if (this.keybindings.matches(data, "owned.editor.selectAll")) {
@@ -167,24 +169,30 @@ class PromptSelectionInterceptor {
         if (this.keybindings.matches(data, "tui.editor.cursorWordLeft")) {
             const before = this.#cursor();
             const startedWithAtomicFocus = this.#atomicFocus() !== undefined;
-            next();
+            this.#delegateWord(-1, next);
             let after = this.#cursor();
             const landedAtomic = this.#atomicRangeAt(after);
             if (!startedWithAtomicFocus && landedAtomic?.start === after.col && after.col > 0) {
                 const line = editorState(this.editor).lines[after.line] ?? "";
                 const previous = [...GRAPHEMES.segment(line.slice(0, after.col))].at(-1);
                 if (previous !== undefined && !/^\s+$/u.test(previous.segment)) {
-                    next();
+                    this.#delegateWord(-1, next);
                     after = this.#cursor();
                 }
             }
-            if (!samePosition(before, after))
+            const line = editorState(this.editor).lines[after.line] ?? "";
+            const landedPath = promptPathWordRanges(line).some(range => range.start === after.col);
+            if (!samePosition(before, after) && !landedPath)
                 this.#moveOntoPreviousSeparator();
             this.#requestRender();
             return;
         }
         const beforeText = this.editor.getText();
-        next();
+        const wordDirection = this.#wordDirectionFor(data);
+        if (wordDirection === undefined)
+            next();
+        else
+            this.#delegateWord(wordDirection, next);
         if (this.editor.getText() !== beforeText)
             this.#redoStack = [];
     }
@@ -584,11 +592,28 @@ class PromptSelectionInterceptor {
     #snapshot() {
         return { text: this.editor.getText(), cursor: this.#cursor() };
     }
+    #wordDirectionFor(data) {
+        if (this.keybindings.matches(data, "tui.editor.deleteWordBackward"))
+            return -1;
+        if (this.keybindings.matches(data, "tui.editor.deleteWordForward")
+            || this.keybindings.matches(data, "tui.editor.cursorWordRight"))
+            return 1;
+        return undefined;
+    }
+    #delegateWord(direction, next) {
+        this.#wordDirection = direction;
+        try {
+            next();
+        }
+        finally {
+            this.#wordDirection = undefined;
+        }
+    }
     #requestRender() {
         this.options.requestRender();
     }
 }
-function installAtomicSegmentation(editor, rangesForText) {
+function installAtomicSegmentation(editor, rangesForText, wordDirection) {
     if (Reflect.get(editor, ATOMIC_SEGMENTATION) === true)
         return;
     const originalValue = Reflect.get(editor, "segment");
@@ -597,7 +622,14 @@ function installAtomicSegmentation(editor, rangesForText) {
     const original = originalValue.bind(editor);
     Reflect.set(editor, "segment", (text, mode) => {
         const segments = [...original(text, mode)].filter(isEditorSegment);
-        const ranges = rangesForText(text);
+        const ranges = rangesForText(text).map(range => ({ ...range, wordLike: false }));
+        if (mode === "word") {
+            for (const range of contextualPathRanges(editor, text, wordDirection())) {
+                if (!ranges.some(existing => rangesOverlap(existing, range)))
+                    ranges.push({ ...range, wordLike: true });
+            }
+        }
+        ranges.sort((left, right) => left.start - right.start);
         if (ranges.length === 0)
             return segments;
         const merged = [];
@@ -608,10 +640,12 @@ function installAtomicSegmentation(editor, rangesForText) {
             const range = ranges[rangeIndex];
             if (range !== undefined && segment.index >= range.start && segment.index < range.end) {
                 if (segment.index === range.start) {
+                    const source = text.slice(range.start, range.end);
                     merged.push({
-                        segment: text.slice(range.start, range.end).replaceAll(" ", ATOMIC_SPACE_SENTINEL),
+                        segment: range.wordLike ? "w".repeat(source.length) : source.replaceAll(" ", ATOMIC_SPACE_SENTINEL),
                         index: range.start,
                         input: text,
+                        ...(range.wordLike ? { isWordLike: true } : {}),
                     });
                 }
                 continue;
@@ -622,6 +656,25 @@ function installAtomicSegmentation(editor, rangesForText) {
     });
     Reflect.set(editor, ATOMIC_SEGMENTATION, true);
 }
+function contextualPathRanges(editor, text, direction) {
+    if (direction === undefined)
+        return promptPathWordRanges(text);
+    const state = editorState(editor);
+    const line = state.lines[state.cursorLine] ?? "";
+    const offset = direction < 0 ? 0 : state.cursorCol;
+    if (text !== (direction < 0 ? line.slice(0, state.cursorCol) : line.slice(state.cursorCol))) {
+        return promptPathWordRanges(text);
+    }
+    const end = offset + text.length;
+    return promptPathWordRanges(line).flatMap(range => {
+        const start = Math.max(range.start, offset);
+        const finish = Math.min(range.end, end);
+        return finish <= start ? [] : [{ start: start - offset, end: finish - offset }];
+    });
+}
+function rangesOverlap(left, right) {
+    return left.start < right.end && right.start < left.end;
+}
 function isEditorSegment(value) {
     if (typeof value !== "object" || value === null)
         return false;

package/dist/integrations/pi/components/path-word-ranges.d.ts

@@ -0,0 +1,2 @@
+import type { PiShellEditorTextRange } from "./shell-shared-facade.js";
+export declare function promptPathWordRanges(line: string): readonly PiShellEditorTextRange[];

package/dist/integrations/pi/components/path-word-ranges.js

@@ -0,0 +1,37 @@
+const WHITESPACE = /\s/u;
+const DRIVE_ROOT = /^[A-Za-z]:[\\/]/u;
+const UNC_ROOT = /^(?:\\\\|\/\/)[^\\/\s]+[\\/][^\\/\s]+/u;
+const POSIX_ROOT = /^\//u;
+const EXPLICIT_RELATIVE_ROOT = /^(?:\.{1,2}|~)[\\/]/u;
+export function promptPathWordRanges(line) {
+    const ranges = [];
+    let index = 0;
+    while (index < line.length) {
+        while (index < line.length && WHITESPACE.test(line[index] ?? ""))
+            index += 1;
+        if (index >= line.length)
+            break;
+        const start = index;
+        const quote = line[index] === '"' || line[index] === "'" ? line[index] : undefined;
+        if (quote !== undefined) {
+            const closing = line.indexOf(quote, index + 1);
+            if (closing >= 0 && (closing + 1 === line.length || WHITESPACE.test(line[closing + 1] ?? ""))) {
+                if (isExplicitPath(line.slice(index + 1, closing)))
+                    ranges.push({ start, end: closing + 1 });
+                index = closing + 1;
+                continue;
+            }
+        }
+        while (index < line.length && !WHITESPACE.test(line[index] ?? ""))
+            index += 1;
+        if (isExplicitPath(line.slice(start, index)))
+            ranges.push({ start, end: index });
+    }
+    return ranges;
+}
+function isExplicitPath(value) {
+    return DRIVE_ROOT.test(value)
+        || UNC_ROOT.test(value)
+        || POSIX_ROOT.test(value)
+        || EXPLICIT_RELATIVE_ROOT.test(value);
+}

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

@@ -9,7 +9,7 @@ export declare const REQUIRED_PI_CAPABILITY_OPERATIONS: Readonly<{
     readonly "commands-events": readonly ["prompt", "steer", "followUp", "abort", "compact", "setModel", "setThinkingLevel", "subscribe", "dispose"];
     readonly "models-authentication": readonly ["models.list", "models.refresh", "auth.status", "auth.login", "auth.logout", "auth.cancel"];
     readonly settings: readonly ["settings.read", "settings.write", "settings.flush"];
-    readonly "resources-extensions": readonly ["resources.discover", "extensions.bind", "extensions.reload", "renderers.invoke"];
+    readonly "resources-extensions": readonly ["resources.discover", "extensions.inline", "extensions.bind", "extensions.reload", "renderers.invoke"];
     readonly workflows: readonly ["workflow.route", "workflow.validate", "workflow.diagnostics"];
     readonly disposal: readonly ["subscription.dispose", "session.dispose", "services.cleanup"];
 }>;

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

@@ -4,13 +4,14 @@ import { join } from "node:path";
 import { createAgentSessionFromServices, createAgentSessionRuntime, createAgentSessionServices, ModelRuntime, SessionManager, VERSION, } from "@earendil-works/pi-coding-agent";
 import { OWNED_UI_CONTRACT_VERSION } from "../../../contracts/owned-ui/index.js";
 import { PRODUCT_IDENTITY } from "../../../product-identity.js";
+import { createWindowsNulCleanupExtension } from "./windows-filesystem-hygiene.js";
 export const REQUIRED_PI_CAPABILITY_OPERATIONS = Object.freeze({
     "public-exports": ["services.create", "session.create", "runtime.create"],
     "session-lifecycle": ["session.new", "session.resume", "session.rebind", "session.dispose"],
     "commands-events": ["prompt", "steer", "followUp", "abort", "compact", "setModel", "setThinkingLevel", "subscribe", "dispose"],
     "models-authentication": ["models.list", "models.refresh", "auth.status", "auth.login", "auth.logout", "auth.cancel"],
     settings: ["settings.read", "settings.write", "settings.flush"],
-    "resources-extensions": ["resources.discover", "extensions.bind", "extensions.reload", "renderers.invoke"],
+    "resources-extensions": ["resources.discover", "extensions.inline", "extensions.bind", "extensions.reload", "renderers.invoke"],
     workflows: ["workflow.route", "workflow.validate", "workflow.diagnostics"],
     disposal: ["subscription.dispose", "session.dispose", "services.cleanup"],
 });
@@ -59,11 +60,18 @@ export async function runPiUpgradeConformance() {
                 refreshOnCreate: false,
                 allowModelNetwork: false,
             });
+            const cleanupExtension = createWindowsNulCleanupExtension({ platform: "win32" });
+            if (cleanupExtension === null)
+                throw new Error("Windows NUL cleanup extension is unavailable");
             services = await createAgentSessionServices({
                 cwd: root,
                 agentDir: join(root, "agent"),
                 modelRuntime,
+                resourceLoaderOptions: { extensionFactories: [cleanupExtension] },
             });
+            if (!services.resourceLoader.getExtensions().extensions.some(extension => extension.path === "<inline:windows-nul-file-cleanup>")) {
+                throw new Error("named inline extension factory was not loaded");
+            }
         }
         catch (error) {
             throw new PiUpgradeConformanceError("services", error);

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

@@ -2,6 +2,7 @@ import { createAgentSessionFromServices, createAgentSessionRuntime, createAgentS
 import { resolvePiProjectTrustPreflight, } from "./project-trust-preflight.js";
 import { openSelectedPiSession, resolveSessionArgumentPath } from "./session-selection.js";
 import { markStartupPhase } from "../../../foundation/startup/index.js";
+import { createWindowsNulCleanupExtension } from "./windows-filesystem-hygiene.js";
 /**
  * Mirrors pinned Pi's CLI startup: resolve the `models` patterns from settings
  * into a scoped model list, keep the resolver's warnings (e.g. "No models match
@@ -44,7 +45,15 @@ export async function createPiRuntimeServicesAfterTrust(options) {
     });
     const settingsManager = createSettingsManager(options.cwd, options.agentDir, trust.trusted);
     await markStartupPhase(process.env, "settings-loaded");
-    const services = await createServices({ cwd: options.cwd, agentDir: options.agentDir, settingsManager });
+    const cleanupExtension = createWindowsNulCleanupExtension();
+    const services = await createServices({
+        cwd: options.cwd,
+        agentDir: options.agentDir,
+        settingsManager,
+        ...(cleanupExtension === null ? {} : {
+            resourceLoaderOptions: { extensionFactories: [cleanupExtension] },
+        }),
+    });
     await markStartupPhase(process.env, "pi-services");
     await markStartupPhase(process.env, "resource-discovery");
     return { services, trust };

package/dist/integrations/pi/engine/windows-filesystem-hygiene.d.ts

@@ -0,0 +1,21 @@
+import { type InlineExtension } from "@earendil-works/pi-coding-agent";
+interface FileMetadata {
+    isFile(): boolean;
+    isSymbolicLink(): boolean;
+}
+interface CleanupFileSystem {
+    lstat(path: string): Promise<FileMetadata>;
+    unlink(path: string): Promise<void>;
+}
+interface CleanupPaths {
+    dirname(path: string): string;
+    join(...paths: string[]): string;
+    resolve(...paths: string[]): string;
+}
+export interface WindowsNulCleanupOptions {
+    readonly platform?: NodeJS.Platform;
+    readonly fileSystem?: CleanupFileSystem;
+    readonly paths?: CleanupPaths;
+}
+export declare function createWindowsNulCleanupExtension(options?: WindowsNulCleanupOptions): InlineExtension | null;
+export {};

package/dist/integrations/pi/engine/windows-filesystem-hygiene.js

@@ -0,0 +1,55 @@
+import { isBashToolResult, isEditToolResult, isWriteToolResult, } from "@earendil-works/pi-coding-agent";
+import { lstat, unlink } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+const DEFAULT_FILE_SYSTEM = { lstat, unlink };
+const DEFAULT_PATHS = { dirname, join, resolve };
+const SIMPLE_CD = /(?:^|[;&|\n])\s*cd\s+(?:"([^"\r\n]+)"|'([^'\r\n]+)'|([^\s;&|]+))/;
+export function createWindowsNulCleanupExtension(options = {}) {
+    if ((options.platform ?? process.platform) !== "win32")
+        return null;
+    const fileSystem = options.fileSystem ?? DEFAULT_FILE_SYSTEM;
+    const paths = options.paths ?? DEFAULT_PATHS;
+    return {
+        name: "windows-nul-file-cleanup",
+        factory: pi => registerNulCleanup(pi, fileSystem, paths),
+    };
+}
+function registerNulCleanup(pi, fileSystem, paths) {
+    const cleanDirectory = async (directory) => {
+        const candidate = paths.join(directory, "nul");
+        try {
+            const metadata = await fileSystem.lstat(candidate);
+            if (metadata.isFile() && !metadata.isSymbolicLink())
+                await fileSystem.unlink(candidate);
+        }
+        catch {
+            return;
+        }
+    };
+    pi.on("session_start", async (_event, ctx) => {
+        await cleanDirectory(ctx.cwd);
+    });
+    pi.on("tool_result", async (event, ctx) => {
+        const directories = new Set([ctx.cwd]);
+        if (isBashToolResult(event)) {
+            const command = stringInput(event.input, "command");
+            const target = command === null ? null : simpleCdTarget(command);
+            if (target !== null)
+                directories.add(paths.resolve(ctx.cwd, target));
+        }
+        if (isWriteToolResult(event) || isEditToolResult(event)) {
+            const target = stringInput(event.input, "path");
+            if (target !== null)
+                directories.add(paths.dirname(paths.resolve(ctx.cwd, target)));
+        }
+        await Promise.all(Array.from(directories, cleanDirectory));
+    });
+}
+function simpleCdTarget(command) {
+    const match = SIMPLE_CD.exec(command);
+    return match?.[1] ?? match?.[2] ?? match?.[3] ?? null;
+}
+function stringInput(input, key) {
+    const value = input[key];
+    return typeof value === "string" && value.length > 0 ? value : null;
+}

package/dist/integrations/pi/session-ui/session-shell-root.d.ts

@@ -92,7 +92,7 @@ export declare class OwnedUiSessionShellRoot implements PiTuiComponentPort {
     applyTranscriptBlock(block: OwnedUiSessionViewModel["transcript"][number]): void;
     render(width: number): readonly string[];
     viewportFrameDescriptor(): TranscriptViewportFrameDescriptor | null;
-    /** Visible rows of the transient working-status tail, for rendering evidence. */
+    /** Visible non-selectable Steering, alignment, and Working rows, for rendering evidence. */
     viewportTransientTailRowCount(): number;
     hasActiveSelection(): boolean;
     setViewportConfig(config: OwnedUiViewportSettings): void;

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

@@ -45,7 +45,6 @@ export class OwnedUiSessionShellRoot {
     #dockInputReuseEnabled;
     #dockInputCandidate = false;
     #dockInputSnapshot;
-    #dockInputStatusSignature;
     #visibleViewportSnapshot;
     #fullViewportCompositions = 0;
     #dockOnlyViewportCompositions = 0;
@@ -232,14 +231,18 @@ export class OwnedUiSessionShellRoot {
         // intentional final gutter after their right-aligned timestamp.
         const documentWidth = width;
         const document = this.#renderDocumentLayout(documentWidth);
+        const steeringRows = this.#renderQueued(width);
         const statusRows = this.#renderStatus(width);
-        const statusSignature = statusRows.length === 0 ? undefined : `${statusRows.length}\u0000${statusRows.join("\u0000")}`;
+        const transientSignature = transientRowsSignature(steeringRows, statusRows);
         const snapshot = this.#visibleViewportSnapshot;
         const dockInputCandidate = this.#dockInputCandidate;
         const dockInputSnapshot = dockInputCandidate ? this.#dockInputSnapshot : undefined;
-        const dockInputStatusSignature = dockInputCandidate ? this.#dockInputStatusSignature : statusSignature;
-        // Invariant: queued rows stay docked while live Working rows form one scrollable tail.
-        const scrollRows = [...document.rows, ...statusRows];
+        const dockInputTransientSignature = dockInputCandidate
+            ? dockInputSnapshot?.transientSignature ?? transientSignature
+            : transientSignature;
+        // Invariant: pending Steering and live Working rows share one non-selectable
+        // viewport tail; only non-working status, widgets, input, and footer stay docked.
+        const scrollRows = [...document.rows, ...steeringRows, ...statusRows];
         const dockRows = dock.rows;
         const selectableDocumentRowCount = document.rows.length;
         const dockStartRow = height - dockRows.length + 1;
@@ -256,7 +259,7 @@ export class OwnedUiSessionShellRoot {
             && snapshot.width === width
             && snapshot.height === height
             && snapshot.documentRows === (dockInputSnapshot?.documentRows ?? scrollRows)
-            && snapshot.statusSignature === dockInputStatusSignature
+            && snapshot.transientSignature === dockInputTransientSignature
             && snapshot.promptAnchors === (dockInputSnapshot?.promptAnchors ?? document.promptAnchors)
             && snapshot.dockLength === dockRows.length
             && snapshot.inputSurface === (dockInputSnapshot?.inputSurface ?? this.#inputSurface)
@@ -264,9 +267,9 @@ export class OwnedUiSessionShellRoot {
             && snapshot.selectionRevision === (dockInputSnapshot?.selectionRevision ?? this.#viewportController.selectionRevision)
             ? this.#viewportController.composeDockOnly(dockRows, width, height)
             : null;
-        // Performance: a still-active spinner can tick before its first delayed presentation.
-        // Its newest tail signature is recomputed below and therefore cannot hide that change.
-        if (frame !== null && dockInputStatusSignature !== statusSignature)
+        // Performance: a spinner tick or queue update can race the input-triggered
+        // render. Recompute the complete transient signature before reusing rows.
+        if (frame !== null && dockInputTransientSignature !== transientSignature)
             frame = null;
         if (frame === null) {
             frame = this.#viewportController.compose({
@@ -274,15 +277,16 @@ export class OwnedUiSessionShellRoot {
                 ...(this.#viewportController.transcriptPointerSelecting
                     ? { paintDocumentRow: heldNativeHyperlinkStyle }
                     : {}),
-                // Invariant: selection and copying stop at the real document tail; live Working
-                // rows remain transient presentation chrome at every fit boundary.
+                // Invariant: selection and copying stop at the real document tail; Steering,
+                // fitting alignment, and live Working remain transient presentation chrome.
                 selectableDocumentRowCount,
+                bottomAlignedTailRowCount: statusRows.length,
                 dockRows,
                 promptAnchors: document.promptAnchors,
                 width,
                 height,
-                // Invariant: the control belongs immediately above the complete dock,
-                // never on top of a queued or Working row.
+                // Invariant: the control belongs immediately above the complete dock and
+                // floats over transient viewport content rather than consuming a dock row.
                 bottomControlRow: Math.max(0, height - Math.min(height, dockRows.length) - 1),
                 theme: this.#viewportTheme,
             });
@@ -294,8 +298,7 @@ export class OwnedUiSessionShellRoot {
             width,
             height,
             documentRows: scrollRows,
-            statusSignature,
-            dockInputStatusSignature,
+            transientSignature,
             promptAnchors: document.promptAnchors,
             dockLength: dockRows.length,
             inputSurface: this.#inputSurface,
@@ -308,7 +311,7 @@ export class OwnedUiSessionShellRoot {
     viewportFrameDescriptor() {
         return this.#viewportController.frame?.descriptor ?? null;
     }
-    /** Visible rows of the transient working-status tail, for rendering evidence. */
+    /** Visible non-selectable Steering, alignment, and Working rows, for rendering evidence. */
     viewportTransientTailRowCount() {
         return this.#viewportController.frame?.hits.transientTail.length ?? 0;
     }
@@ -338,7 +341,7 @@ export class OwnedUiSessionShellRoot {
         return this.#renderDockLayout(width).rows;
     }
     #renderDockLayout(width) {
-        const queued = this.#view.editor.queuedSubmissions.length === 0 ? [] : this.#queued.render(width);
+        const queued = this.#customViewport ? [] : this.#renderQueued(width);
         const statusRows = this.#customViewport ? this.#status.renderDock(width) : this.#renderStatus(width);
         const transientRows = [...queued, ...statusRows];
         const aboveWidgets = this.#renderWidgets("aboveEditor", width);
@@ -352,6 +355,9 @@ export class OwnedUiSessionShellRoot {
             inputRows: input.length,
         };
     }
+    #renderQueued(width) {
+        return this.#view.editor.queuedSubmissions.length === 0 ? [] : this.#queued.render(width);
+    }
     layoutRoot() {
         const document = layoutPort(width => this.#renderDocument(width), () => this.invalidate());
         const queued = layoutPort(width => this.#view.editor.queuedSubmissions.length === 0 ? [] : this.#queued.render(width), () => this.#queued.invalidate());
@@ -781,14 +787,15 @@ export class OwnedUiSessionShellRoot {
     }
     #captureDockInputSnapshot() {
         const width = Math.max(1, this.#componentRuntime.getColumns());
+        const steeringRows = this.#renderQueued(width);
         const statusRows = this.#renderStatus(width);
-        this.#dockInputStatusSignature = statusRows.length === 0 ? undefined : `${statusRows.length}\u0000${statusRows.join("\u0000")}`;
+        const transientSignature = transientRowsSignature(steeringRows, statusRows);
         const snapshot = this.#visibleViewportSnapshot;
         this.#dockInputSnapshot = snapshot === undefined
             ? undefined
             : {
                 documentRows: snapshot.documentRows,
-                statusSignature: this.#dockInputStatusSignature,
+                transientSignature,
                 promptAnchors: snapshot.promptAnchors,
                 inputSurface: this.#inputSurface,
                 viewportRevision: this.#viewportController.presentationRevision,
@@ -824,7 +831,6 @@ export class OwnedUiSessionShellRoot {
         this.#visibleViewportSnapshot = undefined;
         this.#dockInputCandidate = false;
         this.#dockInputSnapshot = undefined;
-        this.#dockInputStatusSignature = undefined;
         if (this.#inputSurface !== this.editor)
             this.#inputSurface.dispose?.();
         this.#extensionHeader?.dispose?.();
@@ -1156,3 +1162,6 @@ function isPackageExtensionSource(sourceInfo) {
     const source = sourceInfo?.source ?? "";
     return source.startsWith("npm:") || source.startsWith("git:");
 }
+function transientRowsSignature(steeringRows, statusRows) {
+    return `${steeringRows.length}\u0000${steeringRows.join("\u0000")}\u0001${statusRows.length}\u0000${statusRows.join("\u0000")}`;
+}

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

@@ -5,7 +5,7 @@
   "platform": "darwin",
   "architecture": "arm64",
   "capability": "supported",
-  "builtAt": "2026-09-06T12:29:18.472Z",
+  "builtAt": "2026-09-06T15:05:45.656Z",
   "artifact": {
     "filename": "process-guardian",
     "sha256": "dc03605e5780e2aeebb4ecafd62868dc673e22ddd38b024a369aff704ff136dc",

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

@@ -5,7 +5,7 @@
   "platform": "linux",
   "architecture": "x64",
   "capability": "supported",
-  "builtAt": "2026-09-06T12:29:19.551Z",
+  "builtAt": "2026-09-06T15:05:42.977Z",
   "artifact": {
     "filename": "process-guardian",
     "sha256": "ee8a00eaaf79c707459bbbfb52518e9739314967049fbe5fa625f36ce33db9ee",

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

@@ -5,10 +5,10 @@
   "platform": "win32",
   "architecture": "x64",
   "capability": "supported",
-  "builtAt": "2026-09-06T12:30:04.599Z",
+  "builtAt": "2026-09-06T15:06:12.448Z",
   "artifact": {
     "filename": "process-guardian.exe",
-    "sha256": "ce28943a65f5bdd6fd5a2c8b7d513a87402652e9c9089fb3a0b6323083fdd9d2",
+    "sha256": "7cca17597d89ae0dad9cd14114acc0795f688d54f6580b897463fba11af479ca",
     "size": 177664
   },
   "provenance": {

package/dist/runtime-payload-inventory.json

@@ -5,6 +5,7 @@
     "bin/guardian.js",
     "bin/supervisor.js",
     "bin/ui.js",
+    "bin/update-recovery.js",
     "bin/warmup.js"
   ],
   "declaredAssets": [

package/dist/ui/components/transcript-viewport.d.ts

@@ -24,6 +24,8 @@ export interface TranscriptViewportFrameInput {
     readonly paintDocumentRow?: (row: string) => string;
     /** Leading document rows that participate in pointer selection and copying. */
     readonly selectableDocumentRowCount?: number;
+    /** Final transient rows to bottom-align with unused viewport space while content fits. */
+    readonly bottomAlignedTailRowCount?: number;
     readonly dockRows: readonly string[];
     readonly promptAnchors: readonly TranscriptPromptAnchor[];
     readonly width: number;
@@ -86,6 +88,12 @@ export interface TranscriptViewportFrameDescriptor {
     };
     readonly previousFollowingEnd: boolean | null;
     readonly followingEnd: boolean;
+    /** Complete non-selectable suffix, including pending steering, alignment, and status rows. */
+    readonly transientRowCount: number;
+    /** Flexible rows inserted before the bottom-aligned live status while content fits. */
+    readonly transientAlignmentGapRows: number;
+    /** Live status rows at the end of the transient suffix. */
+    readonly bottomAlignedTailRowCount: number;
     readonly verticalShiftRows: number;
     readonly safeVerticalShift: boolean;
     /** Monotonic interaction revision used to reject stale selection evidence. */