@timurproko/a1 0.2.7-dev.1252 → 0.2.7-dev.1264

package/dist/app/session-shell/prompt-history-controller.d.ts

@@ -1,10 +1,10 @@
+import type { OwnedUiShellEditorPort } from "../../contracts/owned-ui/index.js";
 import { type PromptHistoryKind, type PromptHistoryPort } from "../../contracts/owned-ui/index.js";
-import type { PiShellEditorPort } from "../../integrations/pi/components/index.js";
 /** Merges bounded recall snapshots; the editor alone owns browsing, draft, cursor, and undo state. */
 export declare class PromptHistoryController {
     #private;
     readonly options: {
-        editor: PiShellEditorPort;
+        editor: OwnedUiShellEditorPort;
         store: PromptHistoryPort;
         limit: number;
         fallback: readonly string[];
@@ -16,7 +16,7 @@ export declare class PromptHistoryController {
         rehydrate?: (text: string) => string;
     };
     constructor(options: {
-        editor: PiShellEditorPort;
+        editor: OwnedUiShellEditorPort;
         store: PromptHistoryPort;
         limit: number;
         fallback: readonly string[];

package/dist/app/session-shell/prompt-submission.d.ts

@@ -1,13 +1,15 @@
+import type { OwnedUiShellComponents } from "../../contracts/owned-ui/index.js";
 import type { OwnedUiCommand, OwnedUiCommandResult, OwnedUiSessionBackend, OwnedUiSessionViewModel, PromptHistoryImageSidecarPort } from "../../contracts/owned-ui/index.js";
 import type { PromptHistoryController } from "./prompt-history-controller.js";
 import type { SessionConcern } from "./session-concern.js";
 import type { OwnedUiSessionShellRoot } from "./session-shell-root.js";
 import type { OwnedUiPresenterTerminal } from "./shell-host.js";
-export interface PromptSubmissionPorts {
+interface PromptSubmissionPorts {
     readonly backend: Pick<OwnedUiSessionBackend, "session" | "identity" | "workflows">;
-    readonly root: Pick<OwnedUiSessionShellRoot, "editor" | "hasPendingPastes" | "waitForPromptPastes" | "setExtensionWidget" | "prepareHistoryText" | "imageChipAttachmentsFromEditor" | "preparePromptSubmission" | "omitUnsentPromptImages" | "resumeViewportFollowing" | "beginImageSubmissionStatus" | "appendWorkflowResult">;
+    readonly root: Pick<OwnedUiSessionShellRoot, "editor" | "promptChips" | "viewport" | "waitForPromptPastes" | "setExtensionWidget" | "beginImageSubmissionStatus" | "workflow">;
     readonly terminal: Pick<OwnedUiPresenterTerminal, "requestRender">;
     readonly cwd: string;
+    readonly statusText: OwnedUiShellComponents["info"]["statusText"];
     promptHistory(): PromptHistoryController | null;
     imageSidecar(): PromptHistoryImageSidecarPort | undefined;
     disposed(): boolean;
@@ -44,3 +46,4 @@ export declare class PromptSubmission implements SessionConcern {
     onSessionReplaced(): void;
     dispose(): void;
 }
+export {};

package/dist/app/session-shell/prompt-submission.js

@@ -1,5 +1,4 @@
 import { assertOwnedUiCommand, assertPromptImages, ImageAttachmentError, } from "../../contracts/owned-ui/index.js";
-import { renderPiShellStatusText } from "../../integrations/pi/components/shell-presenters-info.js";
 const rejected = (diagnostic) => ({ outcome: "rejected", diagnostic });
 /**
  * Turns editor input into engine commands: prompts, steering, follow-ups, and bash, each recorded
@@ -43,7 +42,7 @@ export class PromptSubmission {
     /** Sends slash text the shell does not own as engine prompt input; history keeps what was typed. */
     sendSlashPrompt(text, typed = text) {
         this.#rememberInput(typed, "slash");
-        this.#ports.root.resumeViewportFollowing();
+        this.#ports.root.viewport.resumeFollowing();
         return this.execute({
             type: this.#ports.lifecycle() === "busy" ? "steer" : "prompt",
             correlationId: this.#ports.correlation("prompt-command"),
@@ -80,7 +79,7 @@ export class PromptSubmission {
     reportError(error, message) {
         // Security: arbitrary provider/extension error messages can contain the entire request.
         try {
-            this.#ports.root.appendWorkflowResult({ command: "debug", outcome: "failed", message: message
+            this.#ports.root.workflow.appendResult({ command: "debug", outcome: "failed", message: message
                     ?? (error instanceof ImageAttachmentError ? error.message : "Submission failed. Check the prompt and try again.") }, error instanceof ImageAttachmentError ? error.code : undefined);
             this.#ports.terminal.requestRender();
         }
@@ -97,7 +96,7 @@ export class PromptSubmission {
         const previous = this.#waiting.get(draft);
         if (previous !== undefined)
             return previous.result;
-        if (!root.hasPendingPastes(draft))
+        if (!root.promptChips.hasPending(draft))
             return this.#guard(draft, action);
         const controller = new AbortController();
         const generation = backend.identity.sessionGeneration;
@@ -120,7 +119,7 @@ export class PromptSubmission {
     #showWaiting() {
         const count = this.#waiting.size;
         this.#ports.root.setExtensionWidget("owned-image-preparation", count === 0 ? null : {
-            render: width => [...renderPiShellStatusText(`Waiting for images (${count} submission${count === 1 ? "" : "s"}) — Esc cancels; dequeue restores`, width)],
+            render: width => [...this.#ports.statusText(`Waiting for images (${count} submission${count === 1 ? "" : "s"}) — Esc cancels; dequeue restores`, width)],
             invalidate: () => { },
         }, "aboveEditor");
         this.#ports.terminal.requestRender();
@@ -155,7 +154,7 @@ export class PromptSubmission {
         const history = this.#ports.promptHistory();
         if (history === null)
             return;
-        const reusable = root.prepareHistoryText(text);
+        const reusable = root.promptChips.prepareHistoryText(text);
         if (reusable.length === 0) {
             history.rememberRecovery(text);
             return;
@@ -165,7 +164,7 @@ export class PromptSubmission {
         // recall path treats an absent sidecar the same as a corrupt one.
         const sidecar = this.#ports.imageSidecar();
         if (sidecar !== undefined) {
-            for (const record of root.imageChipAttachmentsFromEditor(text)) {
+            for (const record of root.promptChips.imageChipAttachments(text)) {
                 sidecar.write(record.id, { tag: record.tag, data: record.image.data, mimeType: record.image.mimeType, savedAt: new Date().toISOString() });
             }
         }
@@ -179,7 +178,7 @@ export class PromptSubmission {
         if (displayInput.startsWith("/"))
             return this.#ports.slashCommand(displayInput);
         const { root, backend } = this.#ports;
-        const prepared = root.preparePromptSubmission(displayInput);
+        const prepared = root.promptChips.prepareSubmission(displayInput);
         assertPromptImages(prepared.images);
         const input = prepared.text.trim();
         if (input.startsWith("!")) {
@@ -190,8 +189,8 @@ export class PromptSubmission {
         // Compatibility: match interactive Pi: input during compaction is queued steering; the engine
         // shows it in the pending rows and delivers it when compaction ends.
         const type = this.#ports.lifecycle() === "busy" ? "steer" : "prompt";
-        this.#rememberInput(root.omitUnsentPromptImages(displayInput).trim(), type);
-        root.resumeViewportFollowing();
+        this.#rememberInput(root.promptChips.omitUnsentImages(displayInput).trim(), type);
+        root.viewport.resumeFollowing();
         const command = {
             type,
             correlationId: this.#ports.correlation(type),
@@ -222,13 +221,13 @@ export class PromptSubmission {
                 message: result.cancelled ? "Bash command cancelled" : `Bash exited ${result.exitCode ?? 0}: ${command}`,
                 ...(result.output ? { detail: result.output } : {}),
             };
-            this.#ports.root.appendWorkflowResult(workflow);
+            this.#ports.root.workflow.appendResult(workflow);
             this.#ports.terminal.requestRender();
             return workflow.outcome === "failed" ? rejected(workflow.message) : { outcome: "completed", diagnostic: null };
         }
         catch (error) {
             const message = `Bash command failed: ${error instanceof Error ? error.message : String(error)}`;
-            this.#ports.root.appendWorkflowResult({ command: "debug", outcome: "failed", message });
+            this.#ports.root.workflow.appendResult({ command: "debug", outcome: "failed", message });
             this.#ports.terminal.requestRender();
             return rejected(message);
         }
@@ -238,13 +237,13 @@ export class PromptSubmission {
         const displayInput = draft.trim();
         if (!displayInput)
             return rejected("nothing to queue");
-        const prepared = root.preparePromptSubmission(displayInput);
+        const prepared = root.promptChips.prepareSubmission(displayInput);
         assertPromptImages(prepared.images);
         const text = prepared.text.trim();
         this.#rememberInput(displayInput, "follow-up");
         if (root.editor.getText() === draft)
             root.editor.setText("");
-        root.resumeViewportFollowing();
+        root.viewport.resumeFollowing();
         return this.execute({
             type: "follow-up",
             correlationId: this.#ports.correlation("follow-up"),

package/dist/app/session-shell/quit-outro-effects.d.ts

@@ -16,14 +16,14 @@ export interface QuitOutroCell {
     readonly glyph: string;
     readonly color: string;
 }
-export interface QuitOutroPlan {
+interface QuitOutroPlan {
     /** Sorted by `start`. */
     readonly sparkles: readonly QuitOutroCell[];
     /** Sorted by `end`. */
     readonly clears: readonly QuitOutroCell[];
 }
-export declare const QUIT_OUTRO_EFFECTS: readonly ["fall", "dissolve", "starburst", "waves"];
+declare const QUIT_OUTRO_EFFECTS: readonly ["fall", "dissolve", "starburst", "waves"];
 export type QuitOutroEffect = (typeof QUIT_OUTRO_EFFECTS)[number];
-export declare function isQuitOutroEffect(value: unknown): value is QuitOutroEffect;
 /** Builds the selected effect's deterministic plan for the captured row widths. */
 export declare function createQuitOutroPlan(effect: QuitOutroEffect, rowWidths: readonly number[], seed: number): QuitOutroPlan;
+export {};

package/dist/app/session-shell/quit-outro-effects.js

@@ -6,10 +6,7 @@
  * cell from `start`, and clears blank a cell at `end`. The player consumes both
  * in order, so a fixed seed yields a byte-stable animation.
  */
-export const QUIT_OUTRO_EFFECTS = Object.freeze(["fall", "dissolve", "starburst", "waves"]);
-export function isQuitOutroEffect(value) {
-    return typeof value === "string" && QUIT_OUTRO_EFFECTS.includes(value);
-}
+const QUIT_OUTRO_EFFECTS = Object.freeze(["fall", "dissolve", "starburst", "waves"]);
 const WHITE = "\x1b[38;2;238;238;238m";
 const DUST_GLYPHS = [".", "·", "'", ":", "+", "°"];
 const FALL_GLYPHS = [".", ".", "·", "'", ":", "°"];

package/dist/app/session-shell/quit-outro.d.ts

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

package/dist/app/session-shell/quit-outro.js

@@ -6,22 +6,21 @@
  * terminal cannot delay restoration past the configured clamp.
  */
 import { displayWidth, truncateToWidth } from "../../ui/components/index.js";
-import { rebaseTerminalDefaultBackground } from "../../integrations/pi/tui-runtime/index.js";
 import { createQuitOutroPlan } from "./quit-outro-effects.js";
-export const QUIT_OUTRO_MIN_MS = 300;
-export const QUIT_OUTRO_MAX_MS = 2000;
+const QUIT_OUTRO_MIN_MS = 300;
+const QUIT_OUTRO_MAX_MS = 2000;
 /** Wall-clock allowance beyond the clamped duration before playback abandons remaining ticks. */
-export const QUIT_OUTRO_GUARD_MS = 500;
+const QUIT_OUTRO_GUARD_MS = 500;
 const FRAME_MS = 1000 / 30;
 /** Tick ceiling for a clock that stops advancing: the longest playback plus its guard at 30 fps. */
-export const QUIT_OUTRO_MAX_TICKS = Math.ceil((QUIT_OUTRO_MAX_MS + QUIT_OUTRO_GUARD_MS) / FRAME_MS) + 1;
+const QUIT_OUTRO_MAX_TICKS = Math.ceil((QUIT_OUTRO_MAX_MS + QUIT_OUTRO_GUARD_MS) / FRAME_MS) + 1;
 const SYNC_BEGIN = "\x1b[?2026h";
 const SYNC_END = "\x1b[?2026l";
 const RESET = "\x1b[0m";
 const CLEAR_SCREEN = "\x1b[2J";
 const HOME = "\x1b[H";
 const HIDE_CURSOR = "\x1b[?25l";
-export function clampQuitOutroDuration(durationMs) {
+function clampQuitOutroDuration(durationMs) {
     if (!Number.isFinite(durationMs))
         return QUIT_OUTRO_MIN_MS;
     return Math.max(QUIT_OUTRO_MIN_MS, Math.min(QUIT_OUTRO_MAX_MS, Math.floor(durationMs)));
@@ -45,8 +44,8 @@ export function captureQuitOutroFrame(presented, columns, rows) {
     return { lines, columns: width, rows: height, rowWidths };
 }
 /** The clear-and-repaint block that seeds the animation surface with the captured frame. */
-export function createQuitOutroSurfaceFrame(frame, canvasBackgroundAnsi) {
-    if (canvasBackgroundAnsi === undefined) {
+function createQuitOutroSurfaceFrame(frame, canvas) {
+    if (canvas === undefined) {
         let output = `${SYNC_BEGIN}${HIDE_CURSOR}${CLEAR_SCREEN}${HOME}${RESET}`;
         for (let row = 0; row < frame.rows; row++) {
             const line = frame.lines[row] ?? "";
@@ -55,12 +54,13 @@ export function createQuitOutroSurfaceFrame(frame, canvasBackgroundAnsi) {
         }
         return `${output}${SYNC_END}`;
     }
+    const canvasBackgroundAnsi = canvas.ansi;
     let output = `${SYNC_BEGIN}${HIDE_CURSOR}${RESET}${canvasBackgroundAnsi}${CLEAR_SCREEN}${HOME}`;
     for (let row = 0; row < frame.rows; row++) {
         const line = frame.lines[row] ?? "";
         if (frame.rowWidths[row] > 0) {
             output += `${cursorAt(row, 0)}${canvasBackgroundAnsi}`
-                + `${rebaseTerminalDefaultBackground(line, canvasBackgroundAnsi)}${RESET}${canvasBackgroundAnsi}`;
+                + `${canvas.rebase(line, canvasBackgroundAnsi)}${RESET}${canvasBackgroundAnsi}`;
         }
     }
     return `${output}${RESET}${SYNC_END}`;
@@ -81,8 +81,8 @@ export async function playQuitOutro(frame, effect, durationMs, playback) {
     let sparkleIndex = 0;
     let clearIndex = 0;
     let ticks = 0;
-    const canvas = playback.canvasBackgroundAnsi;
-    playback.write(createQuitOutroSurfaceFrame(frame, canvas));
+    playback.write(createQuitOutroSurfaceFrame(frame, playback.canvas));
+    const canvas = playback.canvas?.ansi;
     const startedAt = now();
     for (;;) {
         ticks += 1;

package/dist/app/session-shell/resource-labels.d.ts

@@ -0,0 +1,2 @@
+import type { OwnedUiSessionBackend, OwnedUiShellResourceEntry } from "../../contracts/owned-ui/index.js";
+export declare function shellResourceEntries(backend: OwnedUiSessionBackend): readonly OwnedUiShellResourceEntry[];

package/dist/app/session-shell/resource-labels.js

@@ -0,0 +1,158 @@
+// Rationale: the startup header lists loaded resources with the shortest label that stays unambiguous.
+export function shellResourceEntries(backend) {
+    const resources = backend.extensions.nonVisualResources().map(resource => ({
+        section: resource.kind === "skill"
+            ? "Skills"
+            : resource.kind === "prompt-template"
+                ? "Prompts"
+                : resource.kind === "theme"
+                    ? "Themes"
+                    : "Context",
+        label: resource.kind === "prompt-template"
+            ? `/${resource.label}`
+            : resource.kind === "agent-context" || resource.kind === "system-prompt"
+                ? compactResourceLabel(resource.sourcePath ?? resource.label)
+                : resource.label,
+        sourcePath: resource.sourcePath,
+        diagnostic: resource.diagnostic,
+    }));
+    const extensions = backend.extensions.extensionResources().filter(extension => !extension.hidden);
+    const loadedExtensions = extensions.filter(extension => extension.diagnostic === null);
+    const extensionLabels = compactExtensionLabels(loadedExtensions);
+    for (const extension of extensions) {
+        const labelIndex = loadedExtensions.indexOf(extension);
+        resources.push({
+            section: "Extensions",
+            label: extensionLabels[labelIndex] ?? compactResourceLabel(extension.sourcePath ?? extension.resolvedPath ?? "extension"),
+            sourcePath: extension.sourcePath ?? extension.resolvedPath,
+            diagnostic: extension.diagnostic,
+        });
+    }
+    return resources;
+}
+function compactResourceLabel(path) {
+    const segments = compactPathSegments(path);
+    const leaf = segments.at(-1) ?? path;
+    if ((leaf === "index.ts" || leaf === "index.js") && segments.length > 1)
+        return segments.at(-2) ?? leaf;
+    return leaf;
+}
+/**
+ * Pinned from InteractiveMode's compact extension-label helpers at Pi commit
+ * 914cf1472e715297caa30db4b9535d534a9eb718. The source metadata crosses an
+ * A1-owned boundary first; the owned shell never inspects Pi's private root.
+ */
+function compactExtensionLabels(extensions) {
+    const localExtensions = extensions
+        .filter(extension => !isPackageExtensionSource(extension.sourceInfo))
+        .map(extension => {
+        const path = extension.sourcePath ?? extension.resolvedPath ?? "extension";
+        const segments = compactPathSegments(path);
+        if (segments.length > 1 && (segments.at(-1) === "index.ts" || segments.at(-1) === "index.js"))
+            segments.pop();
+        return { extension, segments };
+    });
+    return extensions.map(extension => {
+        const resourcePath = extension.sourcePath ?? extension.resolvedPath ?? "extension";
+        if (isPackageExtensionSource(extension.sourceInfo)) {
+            return compactPackageExtensionLabel(resourcePath, extension.sourceInfo);
+        }
+        const localIndex = localExtensions.findIndex(item => item.extension === extension);
+        const segments = localExtensions[localIndex]?.segments;
+        if (!segments || segments.length === 0)
+            return compactResourceLabel(resourcePath);
+        for (let count = 1; count <= segments.length; count += 1) {
+            const candidate = segments.slice(-count).join("/");
+            if (localExtensions.every((item, itemIndex) => itemIndex === localIndex || item.segments.slice(-count).join("/") !== candidate)) {
+                return candidate;
+            }
+        }
+        return segments.join("/");
+    });
+}
+function compactPackageExtensionLabel(resourcePath, sourceInfo) {
+    const sourceLabel = compactPackageSourceLabel(sourceInfo.source);
+    if (!sourceLabel)
+        return compactResourceLabel(resourcePath);
+    const shortPath = shortPackagePath(resourcePath, sourceInfo).replaceAll("\\", "/");
+    const packagePath = shortPath.startsWith("extensions/") ? shortPath.slice("extensions/".length) : shortPath;
+    const slash = packagePath.lastIndexOf("/");
+    const fileName = slash < 0 ? packagePath : packagePath.slice(slash + 1);
+    const directory = slash < 0 ? "" : packagePath.slice(0, slash);
+    const extension = fileName.lastIndexOf(".");
+    const name = extension <= 0 ? fileName : fileName.slice(0, extension);
+    if (name === "index")
+        return !directory || directory === "." ? sourceLabel : `${sourceLabel}:${directory}`;
+    return `${sourceLabel}:${packagePath}`;
+}
+function compactPackageSourceLabel(source) {
+    if (source.startsWith("npm:"))
+        return source.slice("npm:".length) || source;
+    if (!source.startsWith("git:"))
+        return source;
+    const gitSource = source.slice("git:".length).trim();
+    let repositoryPath;
+    const scpLike = gitSource.match(/^git@[^:]+:(.+)$/);
+    if (scpLike?.[1]) {
+        repositoryPath = scpLike[1];
+    }
+    else if (/^[a-z]+:\/\//i.test(gitSource)) {
+        try {
+            repositoryPath = new URL(gitSource).pathname.replace(/^\/+/, "");
+        }
+        catch {
+            return source;
+        }
+    }
+    else {
+        const slash = gitSource.indexOf("/");
+        if (slash >= 0)
+            repositoryPath = gitSource.slice(slash + 1);
+    }
+    if (!repositoryPath)
+        return source;
+    const ref = repositoryPath.indexOf("@");
+    const withoutRef = ref < 0 ? repositoryPath : repositoryPath.slice(0, ref);
+    return withoutRef.replace(/\.git$/, "") || source;
+}
+function shortPackagePath(resourcePath, sourceInfo) {
+    const fullPath = normalizeResourcePath(resourcePath);
+    const baseDir = sourceInfo.baseDir === null ? undefined : normalizeResourcePath(sourceInfo.baseDir).replace(/\/$/, "");
+    if (baseDir) {
+        const npmRoot = baseDir.match(/^(.*\/node_modules)\/(@?[^/]+(?:\/[^/]+)?)$/);
+        if (npmRoot?.[1] && fullPath.startsWith(`${npmRoot[1]}/`))
+            return relativeResourcePath(baseDir, fullPath);
+        if (fullPath === baseDir)
+            return ".";
+        if (fullPath.startsWith(`${baseDir}/`))
+            return fullPath.slice(baseDir.length + 1);
+    }
+    const npmMatch = fullPath.match(/node_modules\/(@?[^/]+(?:\/[^/]+)?)\/(.*)/);
+    if (npmMatch?.[2] && sourceInfo.source.startsWith("npm:"))
+        return npmMatch[2];
+    const gitMatch = fullPath.match(/git\/[^/]+\/[^/]+\/(.*)/);
+    if (gitMatch?.[1] && sourceInfo.source.startsWith("git:"))
+        return gitMatch[1];
+    return resourcePath;
+}
+function relativeResourcePath(from, to) {
+    const fromSegments = from.split("/").filter(Boolean);
+    const toSegments = to.split("/").filter(Boolean);
+    let common = 0;
+    while (common < fromSegments.length && common < toSegments.length
+        && fromSegments[common]?.toLowerCase() === toSegments[common]?.toLowerCase())
+        common += 1;
+    return [...fromSegments.slice(common).map(() => ".."), ...toSegments.slice(common)].join("/") || ".";
+}
+function compactPathSegments(path) {
+    return normalizeResourcePath(path).split("/").filter(segment => segment.length > 0 && segment !== "~");
+}
+function normalizeResourcePath(path) {
+    return path.replaceAll("\\", "/");
+}
+function isPackageExtensionSource(sourceInfo) {
+    const source = sourceInfo?.source ?? "";
+    return source.startsWith("npm:") || source.startsWith("git:");
+}
+// Performance: one painter set per root keeps identities stable, so the neutral viewport retains row-level
+// selection variants while each callback still resolves the live theme.

package/dist/app/session-shell/response-copy-protocol.d.ts

@@ -4,8 +4,8 @@ export declare const COPY_CLEANUP_MS = 250;
 export declare const MAX_COPY_BYTES: number;
 export declare const MAX_COPY_CONTROL_BYTES: number;
 export declare const COPY_CHUNK_UNITS = 16384;
-export type CopyOutcome = "delivered" | "submitted-unverified" | "failed" | "timed-out" | "superseded" | "canceled";
-export type CopyFailure = "size" | "unavailable" | "denied" | "transport" | "unsafe";
+type CopyOutcome = "delivered" | "submitted-unverified" | "failed" | "timed-out" | "superseded" | "canceled";
+type CopyFailure = "size" | "unavailable" | "denied" | "transport" | "unsafe";
 export interface CopyResult {
     readonly outcome: CopyOutcome;
     readonly failure?: CopyFailure;
@@ -54,3 +54,4 @@ export type CopyHelperOutput = {
     readonly result: CopyResult;
     readonly control?: string;
 };
+export {};

package/dist/app/session-shell/response-copy-transport.d.ts

@@ -15,26 +15,13 @@ export interface OwnedResponseCopyExecutor extends ResponseCopyExecutor {
     dispose(): void;
     readonly warmed: boolean;
 }
-export interface ResponseCopyTerminal {
+interface ResponseCopyTerminal {
     readonly maxBytes?: number;
     /** A supported non-blocking submission boundary, not clipboard acknowledgment. */
     submit(control: string, signal: AbortSignal): Promise<void>;
 }
 /** Never substitute a remote host's native clipboard for the terminal user's clipboard. */
 export declare function responseCopyDestination(env: NodeJS.ProcessEnv): "native" | "terminal";
-/**
- * Spawn options for one operating-system clipboard writer.
- * Platform: on POSIX the writer is detached into its own process group, as pinned Pi 1.4 does, so a writer
- * that daemonizes to keep serving the clipboard is not stopped when Ctrl+Z sends SIGTSTP to the shell's group.
- */
-export declare function platformClipboardWriteOptions(signal: AbortSignal, platform?: NodeJS.Platform): {
-    signal: AbortSignal;
-    windowsHide: boolean;
-    timeout: number;
-    killSignal: "SIGKILL";
-    maxBuffer: number;
-    detached: boolean;
-};
 /** Isolates preparation and native clipboard access; only the owner may submit terminal controls. */
 export declare function createResponseCopyExecutor(options?: {
     readonly terminal?: ResponseCopyTerminal;
@@ -52,3 +39,4 @@ export declare function createResponseCopyExecutor(options?: {
 }): OwnedResponseCopyExecutor;
 /** A spare-of-one pool of copy helpers; `createResponseCopyExecutor` takes its child and warms the next one after each copy. */
 export declare function createCopyHelperPool(helper?: URL, idleMs?: number): HelperPool;
+export {};

package/dist/app/session-shell/response-copy-transport.js

@@ -25,7 +25,7 @@ function platformClipboardCommands() {
  * Platform: on POSIX the writer is detached into its own process group, as pinned Pi 1.4 does, so a writer
  * that daemonizes to keep serving the clipboard is not stopped when Ctrl+Z sends SIGTSTP to the shell's group.
  */
-export function platformClipboardWriteOptions(signal, platform = process.platform) {
+function platformClipboardWriteOptions(signal, platform = process.platform) {
     return {
         signal,
         windowsHide: true,

package/dist/app/session-shell/session-lifecycle.d.ts

@@ -5,7 +5,7 @@ export interface SessionResumeCommandMetadata {
 }
 export declare function formatSessionResumeCommand(metadata: SessionResumeCommandMetadata): string;
 export declare function quoteCommandArgument(value: string): string;
-export interface ExitTextInput {
+interface ExitTextInput {
     readonly terminalMode: "regular" | "fullscreen";
     readonly customViewport: boolean;
     readonly exitMode: "transcript" | "resume-hint";
@@ -27,3 +27,4 @@ export declare class SessionStopLatch {
     /** The engine stopped on its own: dispose the shell, then resolve whether or not disposal failed. */
     settleAfter(dispose: () => Promise<void>): void;
 }
+export {};

package/dist/app/session-shell/session-prompt-history.d.ts

@@ -0,0 +1,29 @@
+import type { OwnedUiSessionViewModel, PromptHistoryImageSidecarAttachment, PromptHistoryImageSidecarPort } from "../../contracts/owned-ui/index.js";
+import type { OwnedUiShellEditorPort } from "../../contracts/owned-ui/index.js";
+import { PromptHistoryController } from "./prompt-history-controller.js";
+import type { OwnedUiShellHistoryOptions } from "./session-shell-root.js";
+type HistoryScope = "unique" | "shared";
+/** What prompt history needs from the session: the editor, the transcript, and a render request. */
+export interface SessionPromptHistoryPorts {
+    readonly editor: OwnedUiShellEditorPort;
+    usesDefaultInputSurface(): boolean;
+    rehydrate(text: string, resolveImage: (id: string) => PromptHistoryImageSidecarAttachment | null): string;
+    requestRender(): void;
+    transcript(): OwnedUiSessionViewModel["transcript"];
+    currentHistorySessionId(): string | null;
+}
+/**
+ * Binds persistent prompt history to the current session and scope, and replaces the store when either changes.
+ * Invariant: the controller is built in one place, so the initial and rebound histories behave the same.
+ */
+export declare class SessionPromptHistory {
+    #private;
+    constructor(options: OwnedUiShellHistoryOptions, ports: SessionPromptHistoryPorts);
+    get controller(): PromptHistoryController | null;
+    get imageSidecar(): PromptHistoryImageSidecarPort | undefined;
+    start(): void;
+    synchronize(): void;
+    close(): Promise<boolean>;
+    rebind(replaced: boolean, scope?: HistoryScope): void;
+}
+export {};

package/dist/app/session-shell/session-prompt-history.js

@@ -0,0 +1,80 @@
+import { PromptHistoryController } from "./prompt-history-controller.js";
+/** The user prompts in a transcript, oldest first: the recall a store-less or replaced history starts from. */
+function userTexts(transcript) {
+    return transcript.flatMap(block => block.kind === "user" ? [block.text] : []);
+}
+/**
+ * Binds persistent prompt history to the current session and scope, and replaces the store when either changes.
+ * Invariant: the controller is built in one place, so the initial and rebound histories behave the same.
+ */
+export class SessionPromptHistory {
+    #options;
+    #ports;
+    #controller;
+    #scope;
+    #sessionId;
+    #imageSidecar;
+    #started = false;
+    constructor(options, ports) {
+        this.#options = options;
+        this.#ports = ports;
+        this.#scope = options.scope ?? "unique";
+        this.#sessionId = options.sessionId;
+        this.#imageSidecar = options.imageSidecar;
+        this.#controller = this.#createController(options.store, userTexts(ports.transcript()));
+    }
+    get controller() { return this.#controller; }
+    get imageSidecar() { return this.#imageSidecar; }
+    start() {
+        this.#started = true;
+        this.#controller?.start();
+    }
+    synchronize() { this.#controller?.synchronize(); }
+    close() { return this.#controller?.close() ?? Promise.resolve(true); }
+    // Invariant: delivery recovery does not replace a store; conversation or live scope changes can.
+    rebind(replaced, scope) {
+        if (this.#options.forSession !== undefined || this.#options.forScope !== undefined) {
+            const sessionId = this.#ports.currentHistorySessionId();
+            const selectedScope = scope ?? this.#scope;
+            if (selectedScope !== this.#scope || sessionId !== this.#sessionId) {
+                if (!replaced)
+                    this.#ports.editor.recall?.restoreDraft?.();
+                const previous = this.#controller;
+                this.#controller = null;
+                this.#imageSidecar = undefined;
+                this.#scope = selectedScope;
+                this.#sessionId = sessionId ?? undefined;
+                void previous?.close().catch(() => false);
+                const destination = this.#options.forScope !== undefined
+                    ? this.#options.forScope(selectedScope, sessionId)
+                    : sessionId === null ? null : this.#options.forSession(sessionId);
+                if (destination !== null) {
+                    this.#imageSidecar = destination.imageSidecar;
+                    this.#controller = this.#createController(destination.store, replaced ? userTexts(this.#ports.transcript()) : []);
+                    if (this.#started)
+                        this.#controller.start();
+                }
+                else {
+                    // Security: missing identity must not reopen Shared or retain another session's recall.
+                    const fallback = replaced ? userTexts(this.#ports.transcript()).reverse() : [];
+                    this.#ports.editor.recall?.reset();
+                    this.#ports.editor.recall?.replace(fallback);
+                }
+                return;
+            }
+        }
+        if (replaced)
+            this.#controller?.reset(userTexts(this.#ports.transcript()));
+    }
+    #createController(store, fallback) {
+        return new PromptHistoryController({
+            editor: this.#ports.editor,
+            store,
+            limit: this.#options.limit,
+            fallback,
+            active: () => this.#ports.usesDefaultInputSurface(),
+            render: () => this.#ports.requestRender(),
+            rehydrate: value => this.#ports.rehydrate(value, id => this.#imageSidecar?.readAttachment(id) ?? null),
+        });
+    }
+}