@timurproko/a1 0.1.8-dev.290 → 0.1.8-dev.322

package/dist/foundation/release/restart-certification.js

@@ -2,6 +2,7 @@ import { createHash } from "node:crypto";
 import { lstat, readFile, realpath, stat } from "node:fs/promises";
 import { basename, isAbsolute, relative, resolve, sep } from "node:path";
 import { PRODUCT_IDENTITY } from "../../product-identity.js";
+import { assertCurrentLaunchContract } from "../launch-context/index.js";
 import { DEPENDENCY_LAYER_MANIFEST, dependencyLayerCertificationPath } from "./dependency-layer.js";
 import { immutablePlatformPolicy } from "./immutable-platform.js";
 import { PRODUCT_PACKAGE_NAME } from "./release.js";
@@ -11,6 +12,7 @@ const RESTART_SEAL_VERSION = 1;
 const REQUIRED_LAUNCH_ENTRIES = ["bin/supervisor.js", "bin/guardian.js"];
 /** Build compact restart authority after complete content verification established read-only payload files. */
 export async function createRestartSeal(release, dataDir) {
+    assertCurrentLaunchContract(release);
     const policy = immutablePlatformPolicy();
     if (policy === null)
         return null;
@@ -45,6 +47,7 @@ export async function createRestartSeal(release, dataDir) {
     }));
     const core = {
         version: RESTART_SEAL_VERSION,
+        launchContract: release.launchContract,
         platform: process.platform,
         platformPolicy: policy,
         releaseId: release.releaseId,
@@ -81,6 +84,7 @@ export async function readRestartCertifiedRelease(record, dataDir, onEvent) {
         throw new Error("restart certification differs from the approved release record");
     }
     const seal = normalizeRestartSeal(certification.restartSeal);
+    assertCurrentLaunchContract(seal);
     if (seal.platform !== process.platform || seal.platformPolicy !== immutablePlatformPolicy()) {
         throw new Error("restart certification platform immutability evidence is unsupported");
     }
@@ -129,6 +133,7 @@ export async function readRestartCertifiedRelease(record, dataDir, onEvent) {
     }
     return {
         packageName: PRODUCT_PACKAGE_NAME,
+        launchContract: seal.launchContract,
         packageVersion: seal.packageVersion,
         contentDigest: seal.contentDigest,
         releaseId: seal.releaseId,

package/dist/foundation/release/update-recovery.d.ts

@@ -1,7 +1,9 @@
+import { PRIVATE_LAUNCH_CONTRACT } from "../launch-context/index.js";
 import type { UpdateTransaction, UpdateRecoveryState } from "./update-transaction.js";
 export declare const UPDATE_RECOVERY_SCHEMA: "a1-update-recovery-v1";
 export interface UpdateRecoveryCapsule {
     readonly schema: typeof UPDATE_RECOVERY_SCHEMA;
+    readonly launchContract: typeof PRIVATE_LAUNCH_CONTRACT;
     readonly transactionId: string;
     readonly packageName: string;
     readonly targetVersion: string;

package/dist/foundation/release/update-recovery.js

@@ -5,6 +5,7 @@ import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 import { PRODUCT_IDENTITY, PRODUCT_TEXT } from "../../product-identity.js";
 import { processIsAlive } from "./process-cleanup.js";
+import { PRIVATE_LAUNCH_CONTRACT, assertCurrentLaunchContract } from "../launch-context/index.js";
 export const UPDATE_RECOVERY_SCHEMA = "a1-update-recovery-v1";
 const WORKER_TIMEOUT_MS = 15 * 60 * 1_000;
 const POLL_MS = 50;
@@ -18,6 +19,7 @@ export function updateLauncherPaths(globalRoot, platform = process.platform) {
 /** Validate transaction-scoped recovery authority without trusting npm temporary names. */
 export async function readUpdateRecoveryCapsule(manifestPath, platform = process.platform) {
     const capsule = JSON.parse(await readFile(manifestPath, "utf8"));
+    assertCurrentLaunchContract(capsule);
     if (capsule.schema !== UPDATE_RECOVERY_SCHEMA || !/^[0-9a-f-]{36}$/i.test(capsule.transactionId) || typeof capsule.targetVersion !== "string"
         || capsule.packageName !== PRODUCT_TEXT.packageName || typeof capsule.packageRoot !== "string" || typeof capsule.globalRoot !== "string"
         || typeof capsule.launcherRoot !== "string" || !Array.isArray(capsule.launchers) || typeof capsule.priorReleaseId !== "string"
@@ -59,6 +61,7 @@ export async function readUpdateRecoveryCapsule(manifestPath, platform = process
     if (priorReleaseRoot.split(sep).at(-1) !== capsule.priorReleaseId)
         throw new Error("recovery prior release identity is invalid");
     const priorManifest = JSON.parse(await readFile(resolve(priorReleaseRoot, capsule.releaseManifestName), "utf8"));
+    assertCurrentLaunchContract(priorManifest);
     if (priorManifest.releaseId !== capsule.priorReleaseId || priorManifest.contentDigest !== capsule.priorContentDigest) {
         throw new Error("recovery prior release manifest differs from the capsule");
     }
@@ -95,6 +98,7 @@ export async function prepareUpdateRecoveryCapsule(options) {
         const npmCli = await resolveNpmCli(canonicalGlobal, options.environment ?? process.env);
         const capsule = {
             schema: UPDATE_RECOVERY_SCHEMA,
+            launchContract: PRIVATE_LAUNCH_CONTRACT,
             transactionId: options.transaction.transactionId,
             packageName: PRODUCT_TEXT.packageName,
             targetVersion: options.transaction.targetVersion,

package/dist/foundation/release/update.js

@@ -13,6 +13,7 @@ import { cleanupVerifiedOwner, processIsAlive } from "./process-cleanup.js";
 import { materializeRelease, readMaterializedRelease } from "./release-store.js";
 import { scheduleReleaseCleanup } from "./release-gc.js";
 import { warmMaterializedRelease } from "./warmup.js";
+import { assertCurrentLaunchContract } from "../launch-context/index.js";
 import { UpdateTransactionStore } from "./update-transaction.js";
 import { removeUpdateRecoveryCapsule, runProtectedPackageReplacement } from "./update-recovery.js";
 export const PRODUCT_PACKAGE = PRODUCT_TEXT.packageName;
@@ -77,6 +78,8 @@ export function createUpdateLifecycleCoordinator(environment = process.env, file
         async targetIsActive(targetVersion) {
             const state = await stateStore.read();
             const activeId = state.references.active;
+            if (activeId)
+                assertCurrentLaunchContract(state.releases[activeId] ?? {});
             if (!activeId || state.releases[activeId]?.packageVersion !== targetVersion)
                 return false;
             const endpoint = await readActiveEndpoint(paths, activeId, environment);
@@ -85,6 +88,8 @@ export function createUpdateLifecycleCoordinator(environment = process.env, file
         async shutdownVerifiedOwners(targetVersion) {
             const state = await stateStore.read();
             const activeId = state.references.active;
+            if (activeId)
+                assertCurrentLaunchContract(state.releases[activeId] ?? {});
             const priorActiveVersion = activeId ? state.releases[activeId]?.packageVersion ?? null : null;
             const owner = await readActiveEndpoint(paths, activeId, environment);
             if (!owner)

package/dist/foundation/release/warmup.d.ts

@@ -1,3 +1,3 @@
-import type { MaterializedRelease } from "./release-store.js";
+import { type MaterializedRelease } from "./release-store.js";
 /** Import the exact immutable startup graph in a terminal-free bounded child process. */
 export declare function warmMaterializedRelease(release: MaterializedRelease, environment: NodeJS.ProcessEnv, timeoutMs?: number): Promise<void>;

package/dist/foundation/release/warmup.js

@@ -1,13 +1,14 @@
 import { spawn } from "node:child_process";
-import { resolve } from "node:path";
+import { resolveReleaseEntryPoint } from "./release-store.js";
 import { releaseEnvironment } from "./bootstrap.js";
-import { PRODUCT_IDENTITY } from "../../product-identity.js";
+import { PRIVATE_ENVIRONMENT, assertCurrentLaunchContract } from "../launch-context/index.js";
 /** Import the exact immutable startup graph in a terminal-free bounded child process. */
 export async function warmMaterializedRelease(release, environment, timeoutMs = 30_000) {
-    const entry = resolve(release.releaseRoot, "bin", "warmup.js");
+    assertCurrentLaunchContract(release);
+    const entry = await resolveReleaseEntryPoint(release, "bin/warmup.js");
     await new Promise((resolvePromise, rejectPromise) => {
         const child = spawn(process.execPath, [entry], {
-            env: { ...releaseEnvironment(environment, release), [PRODUCT_IDENTITY.environment.immutableWarmup]: "1" },
+            env: { ...releaseEnvironment(environment, release), [PRIVATE_ENVIRONMENT.immutableWarmup]: "1" },
             stdio: "ignore",
             windowsHide: true,
         });

package/dist/foundation/startup/startup-runtime.js

@@ -5,18 +5,20 @@ import { dirname, resolve } from "node:path";
 import { homedir, platform } from "node:os";
 import { performance } from "node:perf_hooks";
 import { PRODUCT_IDENTITY } from "../../product-identity.js";
+import { readLaunchContext } from "../launch-context/index.js";
 /** Initialize opt-in startup tracing from a caller-provided evidence path. */
 export function initializeStartupTrace(environment, profileId, startedAtMs = performance.timeOrigin + performance.now()) {
     const configured = environment[PRODUCT_IDENTITY.environment.startupTrace];
     if (!configured || parseContext(configured) !== null)
         return;
+    const launch = readLaunchContext(environment);
     const context = {
         path: resolve(configured),
         traceId: randomUUID(),
         startedAtMs,
         profileId,
-        releaseId: environment[PRODUCT_IDENTITY.environment.releaseId] ?? null,
-        dependencyLayerIds: parseLayerIds(environment[PRODUCT_IDENTITY.environment.releaseLayers]),
+        releaseId: launch.releaseId ?? null,
+        dependencyLayerIds: parseLayerIds(launch.releaseLayers),
     };
     environment[PRODUCT_IDENTITY.environment.startupTrace] = JSON.stringify(context);
 }
@@ -25,17 +27,18 @@ export async function markStartupPhase(environment, phase) {
     const context = parseContext(environment[PRODUCT_IDENTITY.environment.startupTrace]);
     if (context === null)
         return;
+    const elapsedMs = Math.max(0, performance.timeOrigin + performance.now() - context.startedAtMs);
+    const launch = readLaunchContext(environment);
+    const dependencyLayerIds = parseLayerIds(launch.releaseLayers);
     const event = {
         schema: PRODUCT_IDENTITY.evidence.startupTraceSchema,
         traceId: context.traceId,
         phase,
-        elapsedMs: Math.max(0, performance.timeOrigin + performance.now() - context.startedAtMs),
+        elapsedMs,
         processId: process.pid,
         profileId: context.profileId,
-        releaseId: environment[PRODUCT_IDENTITY.environment.releaseId] ?? context.releaseId,
-        dependencyLayerIds: parseLayerIds(environment[PRODUCT_IDENTITY.environment.releaseLayers]).length > 0
-            ? parseLayerIds(environment[PRODUCT_IDENTITY.environment.releaseLayers])
-            : context.dependencyLayerIds,
+        releaseId: launch.releaseId ?? context.releaseId,
+        dependencyLayerIds: dependencyLayerIds.length > 0 ? dependencyLayerIds : context.dependencyLayerIds,
         nodeVersion: process.version,
         fileReadOperations: process.resourceUsage().fsRead,
     };
@@ -43,9 +46,7 @@ export async function markStartupPhase(environment, phase) {
     await appendFile(context.path, `${JSON.stringify(event)}\n`, { encoding: "utf8", mode: 0o600 });
 }
 export function assertImmutableWarmupEnvironment(environment) {
-    if (environment[PRODUCT_IDENTITY.environment.immutableWarmup] !== "1") {
-        throw new Error("warmup entry is private to verified update activation");
-    }
+    readLaunchContext(environment, "warmup");
 }
 /** Enable the compile cache directly from launch environment without loading profile services. */
 export function enableEnvironmentCompileCache(environment) {
@@ -54,7 +55,8 @@ export function enableEnvironmentCompileCache(environment) {
         ?? (platform() === "win32"
             ? resolve(environment.LOCALAPPDATA ?? home, PRODUCT_IDENTITY.state.windowsControlDirectory)
             : resolve(environment.XDG_DATA_HOME ?? resolve(home, ".local", "share"), PRODUCT_IDENTITY.state.unixControlDirectory)));
-    return enableStartupCompileCache(dataDir, environment[PRODUCT_IDENTITY.environment.releaseId] ?? null, parseLayerIds(environment[PRODUCT_IDENTITY.environment.releaseLayers]));
+    const launch = readLaunchContext(environment);
+    return enableStartupCompileCache(dataDir, launch.releaseId ?? null, parseLayerIds(launch.releaseLayers));
 }
 /** Enable Node's supported persistent compile cache in an immutable-identity namespace. */
 export function enableStartupCompileCache(dataDir, releaseId, dependencyLayerIds) {

package/dist/foundation/supervision/main.js

@@ -6,16 +6,18 @@ import { publishSupervisorStartupResult, supervisorStartupFailure, supervisorSta
 import { ControlStore } from "../storage/index.js";
 import { resolveCohortEndpoint, resolveProductPaths } from "./paths.js";
 import { SupervisorServer } from "./server.js";
-import { PRODUCT_IDENTITY, PRODUCT_TEXT } from "../../product-identity.js";
+import { PRODUCT_TEXT } from "../../product-identity.js";
+import { readLaunchContext } from "../launch-context/index.js";
 export async function runSupervisor(arguments_ = []) {
     const productPaths = resolveProductPaths();
     mkdirSync(productPaths.runtimeDir, { recursive: true, mode: 0o700 });
     mkdirSync(productPaths.endpointsDir, { recursive: true, mode: 0o700 });
     let paths = productPaths;
     const log = (message) => appendFileSync(paths.supervisorLogPath, `${new Date().toISOString()} ${message}\n`);
-    const releaseRoot = process.env[PRODUCT_IDENTITY.environment.releaseRoot];
-    const releaseId = process.env[PRODUCT_IDENTITY.environment.releaseId];
-    const contentDigest = process.env[PRODUCT_IDENTITY.environment.releaseDigest];
+    const context = readLaunchContext(process.env, "release");
+    const releaseRoot = context.releaseRoot;
+    const releaseId = context.releaseId;
+    const contentDigest = context.releaseDigest;
     const attemptId = startupAttempt(arguments_);
     const resultPath = attemptId ? supervisorStartupResultPath(productPaths.runtimeDir, attemptId) : null;
     let stage = "release-environment";
@@ -24,9 +26,8 @@ export async function runSupervisor(arguments_ = []) {
         if (!releaseRoot || !releaseId || !contentDigest)
             throw new Error(PRODUCT_TEXT.diagnostic("supervisor must be launched from a verified immutable release"));
         stage = "release-certification";
-        const release = await readCertifiedReleaseManifest({ releaseRoot, releaseId, contentDigest }, resolve(paths.dataDir, "releases"), { allowLegacyParentCertification: true });
-        // Compatibility: an older updater may have written release evidence before restart seals
-        // existed, even when its layer certification has already been upgraded by a retry.
+        const release = await readCertifiedReleaseManifest({ releaseRoot, releaseId, contentDigest }, resolve(paths.dataDir, "releases"));
+        // Invariant: readiness follows current-contract certification, never an old-updater upgrade path.
         await recordParentCertifiedRelease(release, paths.dataDir);
         stage = "immutable-root";
         await assertImmutableExecutionRoot(release, paths.dataDir);

package/dist/integrations/pi/components/editor-interaction.d.ts

@@ -0,0 +1,38 @@
+import type { Editor } from "#pi-tui";
+export interface EditorInteractionState {
+    lines: string[];
+    cursorLine: number;
+    cursorCol: number;
+}
+export interface EditorInteractionPort {
+    snapshot(): EditorInteractionState;
+    setCursor(line: number, col: number): void;
+    replaceLines(lines: readonly string[]): void;
+    updateUndoStates(update: (state: EditorInteractionState) => void): void;
+    scrollOffset(): number;
+    visualLines(width: number): Array<{
+        logicalLine: number;
+        startCol: number;
+        length: number;
+    }>;
+    setSegmentTransform(transform: (text: string, mode: "word" | "grapheme", segments: Iterable<Intl.SegmentData>) => Iterable<Intl.SegmentData>): void;
+}
+export interface EditorRecallPort {
+    replace(entries: readonly string[]): void;
+    position(): {
+        readonly index: number;
+        readonly total: number;
+    };
+    observe(listener: () => void): () => void;
+    reset(): void;
+}
+export interface EditorSurface extends Pick<Editor, Exclude<keyof Editor, "setText" | "render" | "handleInput">> {
+    setText(text: string): void;
+    render(width: number): string[];
+    handleInput(data: string): void;
+    readonly interaction?: EditorInteractionPort;
+    readonly recall?: EditorRecallPort;
+}
+export type SelectionEditor = Pick<Editor, "getText" | "getCursor" | "setText" | "insertTextAtCursor" | "invalidate" | "onChange" | "getPaddingX" | "isShowingAutocomplete"> & {
+    readonly interaction?: EditorInteractionPort;
+};

package/dist/integrations/pi/components/editor-interaction.js

@@ -0,0 +1 @@
+export {};

package/dist/integrations/pi/components/history-editor-loader.d.ts

@@ -0,0 +1,5 @@
+import { type ShellEditorInstance, type OwnedEditorOptions } from "./upstream/components/owned-editor.js";
+import type { EditorTheme, TUI } from "#pi-tui";
+import type { KeybindingsManager } from "./upstream/adjacent/core/keybindings.js";
+export type HistoryEditorConstructor = new (tui: TUI, theme: EditorTheme, keybindings: KeybindingsManager, options?: OwnedEditorOptions) => ShellEditorInstance;
+export declare function loadHistoryEditor(): Promise<HistoryEditorConstructor>;

package/dist/integrations/pi/components/history-editor-loader.js

@@ -0,0 +1,5 @@
+import { createOwnedEditorClass } from "./upstream/components/owned-editor.js";
+export async function loadHistoryEditor() {
+    const { HistoryEditorCore } = await import("./upstream/history/editor-core.js");
+    return createOwnedEditorClass(HistoryEditorCore);
+}

package/dist/integrations/pi/components/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./components.js";
+export { loadHistoryEditor, type HistoryEditorConstructor } from "./history-editor-loader.js";
 export * from "./conformance.js";
 export * from "./shell-components.js";
 export * from "./theme.js";

package/dist/integrations/pi/components/index.js

@@ -1,4 +1,5 @@
 export * from "./components.js";
+export { loadHistoryEditor } from "./history-editor-loader.js";
 export * from "./conformance.js";
 export * from "./shell-components.js";
 export * from "./theme.js";

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

@@ -1,4 +1,4 @@
-import { type Editor } from "#pi-tui";
+import type { SelectionEditor as Editor } from "./editor-interaction.js";
 import type { KeybindingsManager } from "./upstream/adjacent/core/keybindings.js";
 import type { PiShellClipboardContent, PiShellEditorTextRange } from "./shell-shared-facade.js";
 /**
@@ -52,6 +52,7 @@ export interface PromptSelectionUxOptions {
     };
     readonly transformPastedContent: (content: PiShellClipboardContent) => string;
     readonly atomicRanges: (line: string) => readonly PiShellEditorTextRange[];
+    readonly hiddenRanges?: (line: string) => readonly PiShellEditorTextRange[];
     readonly expandCopiedText: (text: string) => string;
     readonly paintSelection: (line: string, from: number, to: number, atomic: boolean) => string;
     readonly decorateRow: (row: string, width: number) => string;

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

@@ -202,6 +202,47 @@ class PromptSelectionInterceptor {
             this.#redoStack = [];
     }
     render(width, next) {
+        const state = editorState(this.editor);
+        const hidden = state.lines.map(line => this.options.hiddenRanges?.(line) ?? []);
+        if (!hidden.some(ranges => ranges.length > 0))
+            return this.#renderVisible(width, next);
+        const original = { ...state, lines: [...state.lines] };
+        const selection = this.#selection;
+        const project = (position) => ({
+            line: position.line,
+            col: hideColumn(position.col, hidden[position.line] ?? []),
+        });
+        const lines = state.lines.map((line, index) => {
+            for (const range of [...(hidden[index] ?? [])].reverse())
+                line = line.slice(0, range.start) + line.slice(range.end);
+            return line;
+        });
+        // Rationale: project pending clipboard identities out before layout, not after painting.
+        // Keep the semantic draft/undo/submission markers intact and restore them even if rendering throws.
+        try {
+            this.#setRenderState(lines, project({ line: original.cursorLine, col: original.cursorCol }));
+            if (selection !== undefined)
+                this.#selection = { anchor: project(selection.anchor), head: project(selection.head) };
+            const rows = this.#renderVisible(width, next);
+            if (this.#geometry !== undefined) {
+                this.#geometry.hiddenRanges = hidden;
+                this.#geometry.lines = lines;
+            }
+            return rows;
+        }
+        finally {
+            this.#setRenderState(original.lines, { line: original.cursorLine, col: original.cursorCol });
+            this.#selection = selection;
+        }
+    }
+    #setRenderState(lines, cursor) {
+        if (this.editor.interaction !== undefined)
+            this.editor.interaction.replaceLines(lines);
+        else
+            editorState(this.editor).lines = lines;
+        this.#setCursor(cursor);
+    }
+    #renderVisible(width, next) {
         const rows = next().map(row => row.replaceAll(ATOMIC_SPACE_SENTINEL, " "));
         const maxPadding = Math.max(0, Math.floor((width - 1) / 2));
         const padding = Math.min(this.editor.getPaddingX(), maxPadding);
@@ -211,10 +252,10 @@ class PromptSelectionInterceptor {
         const layoutWidth = Math.max(1, contentWidth - (padding ? 0 : 1));
         const visualLines = editorVisualLineMap(this.editor, layoutWidth)
             ?? buildVisualLineMap(editorState(this.editor).lines, layoutWidth);
-        const scrollOffset = numericProperty(this.editor, "scrollOffset");
+        const scrollOffset = this.editor.interaction?.scrollOffset() ?? numericProperty(this.editor, "scrollOffset");
         const maxVisibleLines = Math.max(5, Math.floor(this.options.getRows() * 0.3));
         const textRows = Math.max(0, Math.min(visualLines.length - scrollOffset, maxVisibleLines, rows.length - 2));
-        this.#geometry = { width, padding, layoutWidth, visualLines, scrollOffset, textRows };
+        this.#geometry = { width, padding, layoutWidth, visualLines, scrollOffset, textRows, hiddenRanges: [] };
         if (this.#atomicFocus() !== undefined) {
             for (let row = 0; row < rows.length; row += 1) {
                 rows[row] = (rows[row] ?? "").replaceAll(CURSOR_MARKER, "");
@@ -344,12 +385,12 @@ class PromptSelectionInterceptor {
         const visual = geometry.visualLines[geometry.scrollOffset + textRow];
         if (visual === undefined)
             return undefined;
-        const line = editorState(this.editor).lines[visual.logicalLine] ?? "";
+        const line = (geometry.lines ?? editorState(this.editor).lines)[visual.logicalLine] ?? "";
         const segment = line.slice(visual.startCol, visual.startCol + visual.length);
         const displayColumn = Math.max(0, column - 1 - geometry.padding - (this.options.promptPrefixWidth ?? 0));
         return {
             line: visual.logicalLine,
-            col: visual.startCol + indexAtDisplayWidth(segment, displayColumn),
+            col: restoreColumn(visual.startCol + indexAtDisplayWidth(segment, displayColumn), geometry.hiddenRanges[visual.logicalLine] ?? []),
         };
     }
     #selectWord(position) {
@@ -464,15 +505,21 @@ class PromptSelectionInterceptor {
         const selection = this.#selection === undefined ? undefined : { anchor: remap(this.#selection.anchor), head: remap(this.#selection.head) };
         const next = current.slice(0, from) + text + current.slice(to);
         // Compatibility: completing a paste updates its provisional undo snapshots, not the user's undo history.
-        editorState(this.editor).lines = next.split("\n");
-        const undo = Reflect.get(this.editor, "undoStack");
-        const snapshots = typeof undo === "object" && undo !== null ? Reflect.get(undo, "stack") : undefined;
-        if (Array.isArray(snapshots))
-            for (const snapshot of snapshots) {
-                const state = typeof snapshot === "object" && snapshot !== null ? Reflect.get(snapshot, "state") : undefined;
-                if (isEditorState(state))
-                    replaceSnapshotMarker(state, marker, text);
-            }
+        if (this.editor.interaction !== undefined) {
+            this.editor.interaction.replaceLines(next.split("\n"));
+            this.editor.interaction.updateUndoStates(state => replaceSnapshotMarker(state, marker, text));
+        }
+        else {
+            editorState(this.editor).lines = next.split("\n");
+            const undo = Reflect.get(this.editor, "undoStack");
+            const snapshots = typeof undo === "object" && undo !== null ? Reflect.get(undo, "stack") : undefined;
+            if (Array.isArray(snapshots))
+                for (const snapshot of snapshots) {
+                    const state = typeof snapshot === "object" && snapshot !== null ? Reflect.get(snapshot, "state") : undefined;
+                    if (isEditorState(state))
+                        replaceSnapshotMarker(state, marker, text);
+                }
+        }
         for (const snapshot of this.#redoStack) {
             const state = { lines: snapshot.text.split("\n"), cursorLine: snapshot.cursor.line, cursorCol: snapshot.cursor.col };
             replaceSnapshotMarker(state, marker, text);
@@ -602,6 +649,10 @@ class PromptSelectionInterceptor {
         return this.editor.getCursor();
     }
     #setCursor(position) {
+        if (this.editor.interaction !== undefined) {
+            this.editor.interaction.setCursor(position.line, position.col);
+            return;
+        }
         const state = editorState(this.editor);
         const line = clamp(position.line, 0, Math.max(0, state.lines.length - 1));
         state.cursorLine = line;
@@ -615,6 +666,7 @@ class PromptSelectionInterceptor {
             : state.cursorCol >= range.start && state.cursorCol < range.end);
         if (atomic !== undefined) {
             state.cursorCol = delta < 0 ? atomic.start : atomic.end;
+            this.editor.interaction?.setCursor(state.cursorLine, state.cursorCol);
             return;
         }
         if (delta < 0) {
@@ -626,6 +678,7 @@ class PromptSelectionInterceptor {
                 state.cursorLine -= 1;
                 state.cursorCol = (state.lines[state.cursorLine] ?? "").length;
             }
+            this.editor.interaction?.setCursor(state.cursorLine, state.cursorCol);
             return;
         }
         if (state.cursorCol < line.length) {
@@ -635,6 +688,7 @@ class PromptSelectionInterceptor {
             state.cursorLine += 1;
             state.cursorCol = 0;
         }
+        this.editor.interaction?.setCursor(state.cursorLine, state.cursorCol);
     }
     #atomicRangeAt(position) {
         const line = editorState(this.editor).lines[position.line] ?? "";
@@ -674,14 +728,8 @@ class PromptSelectionInterceptor {
     }
 }
 function installAtomicSegmentation(editor, rangesForText, wordDirection) {
-    if (Reflect.get(editor, ATOMIC_SEGMENTATION) === true)
-        return;
-    const originalValue = Reflect.get(editor, "segment");
-    if (typeof originalValue !== "function")
-        return;
-    const original = originalValue.bind(editor);
-    Reflect.set(editor, "segment", (text, mode) => {
-        const segments = [...original(text, mode)].filter(isEditorSegment);
+    const transform = (text, mode, values) => {
+        const segments = [...values].filter(isEditorSegment);
         const ranges = rangesForText(text).map(range => ({ ...range, wordLike: false }));
         if (mode === "word") {
             for (const range of contextualPathRanges(editor, text, wordDirection())) {
@@ -713,7 +761,18 @@ function installAtomicSegmentation(editor, rangesForText, wordDirection) {
             merged.push(segment);
         }
         return merged;
-    });
+    };
+    if (editor.interaction !== undefined) {
+        editor.interaction.setSegmentTransform(transform);
+        return;
+    }
+    if (Reflect.get(editor, ATOMIC_SEGMENTATION) === true)
+        return;
+    const originalValue = Reflect.get(editor, "segment");
+    if (typeof originalValue !== "function")
+        return;
+    const original = originalValue.bind(editor);
+    Reflect.set(editor, "segment", (text, mode) => transform(text, mode, original(text, mode)));
     Reflect.set(editor, ATOMIC_SEGMENTATION, true);
 }
 function contextualPathRanges(editor, text, direction) {
@@ -786,7 +845,19 @@ function samePosition(left, right) {
 function sameSnapshot(left, right) {
     return left.text === right.text && samePosition(left.cursor, right.cursor);
 }
+function hideColumn(column, ranges) {
+    return column - ranges.reduce((removed, range) => removed + Math.max(0, Math.min(column, range.end) - range.start), 0);
+}
+function restoreColumn(column, ranges) {
+    let restored = column;
+    for (const range of ranges)
+        if (restored >= range.start)
+            restored += range.end - range.start;
+    return restored;
+}
 function editorState(editor) {
+    if (editor.interaction !== undefined)
+        return editor.interaction.snapshot();
     const value = Object.getOwnPropertyDescriptor(editor, "state")?.value;
     if (!isEditorState(value))
         throw new Error("Pi editor state is unavailable");
@@ -806,6 +877,8 @@ function numericProperty(target, key) {
     return typeof value === "number" ? value : 0;
 }
 function editorVisualLineMap(editor, width) {
+    if (editor.interaction !== undefined)
+        return editor.interaction.visualLines(width);
     const builder = Reflect.get(editor, "buildVisualLineMap");
     if (typeof builder !== "function")
         return undefined;

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

@@ -1,5 +1,6 @@
 import { getSelectListTheme } from "@earendil-works/pi-coding-agent";
 import { CombinedAutocompleteProvider, matchesKey, setKeybindings, } from "#pi-tui";
+import { PROMPT_HISTORY_EDITOR_REPLACEMENT } from "../../../contracts/owned-ui/index.js";
 import { KeybindingsManager } from "./upstream/adjacent/core/keybindings.js";
 import { OwnedEditor } from "./upstream/components/owned-editor.js";
 import { OwnedEditorUxInterception, createPromptSelectionInterceptor, } from "./owned-editor-ux.js";
@@ -36,12 +37,18 @@ export function createPiShellEditor(options) {
         ? KeybindingsManager.createForOwnedInput(options.agentDir)
         : KeybindingsManager.create(options.agentDir);
     setKeybindings(keybindings);
-    const editor = new OwnedEditor(tui, {
+    if (options.persistentHistory === true && options.keybindingProfile === "a1" && options.historyEditor === undefined) {
+        throw new Error("Persistent history requires the loaded owned editor");
+    }
+    const EditorClass = options.keybindingProfile === "a1" && options.persistentHistory === true ? options.historyEditor : OwnedEditor;
+    const editor = new EditorClass(tui, {
         borderColor: (value) => piTheme().fg("borderMuted", value),
         selectList: getSelectListTheme(),
     }, keybindings, {
         paddingX: PINNED_PI_LAYOUT.editorPaddingX,
         autocompleteMaxVisible: PINNED_PI_LAYOUT.autocompleteMaxVisible,
+        persistentHistory: options.persistentHistory === true,
+        styleHistoryLabel: text => piTheme().fg("dim", text),
         ...(options.keybindingProfile === "a1" && options.promptPresentation !== undefined ? {
             promptPrefix: options.promptPresentation.prefix,
             styleSuggestion: options.promptPresentation.styleSuggestion,
@@ -57,6 +64,7 @@ export function createPiShellEditor(options) {
                 ...(options.beginClipboardPaste === undefined ? {} : { beginClipboardPaste: options.beginClipboardPaste }),
                 transformPastedContent: options.transformPastedContent ?? (content => content.kind === "text" ? content.text : ""),
                 atomicRanges: options.editorAtomicRanges ?? (() => []),
+                hiddenRanges: options.editorHiddenRanges ?? (() => []),
                 expandCopiedText: options.expandCopiedEditorText ?? (text => text),
                 paintSelection: options.paintEditorSelection ?? (line => line),
                 decorateRow: options.decorateEditorRow ?? (row => row),
@@ -142,6 +150,8 @@ export function createPiShellEditor(options) {
     return {
         render: width => editorUx?.render(width) ?? editor.render(width),
         activateKeybindings: () => setKeybindings(keybindings),
+        keybindingConfig: () => keybindings.getEffectiveConfig(),
+        reloadKeybindings: () => { keybindings.reload(); setKeybindings(keybindings); },
         matchesTerminalKey: (data, key) => matchesKey(data, key),
         handleInput: data => {
             if (editorUx === undefined)
@@ -163,6 +173,7 @@ export function createPiShellEditor(options) {
             editor.insertTextAtCursor(text);
         },
         addToHistory: text => editor.addToHistory(text),
+        ...(editor.recall === undefined ? {} : { recall: editor.recall, historyReplacement: PROMPT_HISTORY_EDITOR_REPLACEMENT }),
         setSubmitEnabled: enabled => {
             editor.disableSubmit = !enabled;
         },

package/dist/integrations/pi/components/shell-presenters-info.d.ts

@@ -1,4 +1,5 @@
-import { type PiShellComponentPort } from "./shell-shared-facade.js";
+import { type KeybindingsConfig } from "#pi-tui";
+import { type PiShellComponentPort, type PiShellExtensionRendererResolver } from "./shell-shared-facade.js";
 export interface PiShellSessionInfoPresentation {
     readonly sessionName?: string;
     readonly stats: {
@@ -30,7 +31,13 @@ export interface PiShellSessionInfoPresentation {
     }[];
 }
 export declare function renderPiShellStatusText(message: string, width: number, outputPad?: 0 | 1): readonly string[];
+export interface PiShellCommandMessagePresentation {
+    readonly kind: "error" | "warning" | "accent" | "new" | "name" | "debug";
+    readonly message: string;
+    readonly detail?: string;
+}
+export declare function renderPiShellCommandMessage(presentation: PiShellCommandMessagePresentation, width: number, outputPad?: 0 | 1): readonly string[];
 export declare function createPiShellSessionInfo(presentation: PiShellSessionInfoPresentation): PiShellComponentPort;
 export declare function createPiShellCollapsedChangelog(): PiShellComponentPort;
 export declare function createPiShellChangelog(markdown: string): PiShellComponentPort;
-export declare function createPiShellHotkeys(): PiShellComponentPort;
+export declare function createPiShellHotkeys(bindings?: KeybindingsConfig, getShortcuts?: NonNullable<PiShellExtensionRendererResolver["getShortcuts"]>, profile?: "pi" | "a1"): PiShellComponentPort;