@timurproko/a1 0.1.8-dev.ade9b77 → 0.1.8-dev.c64be0e

package/README.md

@@ -9,10 +9,11 @@ npm install --global @timurproko/a1@latest
 ## Commands
 
 ```sh
-a1              # A1-owned UI and profile: ~/.a1/agent
-a1 version      # show Installed, Release (latest), and Next versions
-a1 update       # update to npm latest
-a1 update:next  # update to npm next (or a1 update:<commit> for a specific preview)
+a1                      # A1-owned UI and profile: ~/.a1/agent
+a1 version              # show Installed, Release (latest), and Next versions
+a1 update               # update to npm latest
+a1 update:next          # update to npm next (or a1 update:<commit> for a specific preview)
+a1 update --models      # refresh A1's model catalogs
 ```
 
 Prerelease builds — what `a1 update:next` installs — add two development profiles
@@ -35,7 +36,6 @@ a1 pi remove npm:pi-mcp-adapter    # remove it again (alias: a1 pi uninstall)
 a1 pi list                         # list packages installed for a1
 a1 pi update --extensions          # update every installed package
 a1 pi update npm:pi-mcp-adapter    # update one of them
-a1 update --models                 # refresh A1's model catalogs
 ```
 
 A running session loads a newly installed package after a restart. Pi's own

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

@@ -5,7 +5,7 @@
   "platform": "darwin",
   "architecture": "arm64",
   "capability": "unsupported",
-  "builtAt": "2026-08-25T06:52:40.013Z",
+  "builtAt": "2026-08-25T08:31:32.388Z",
   "artifact": {
     "filename": "process-guardian",
     "sha256": "7524bf568992517f50ed53196c861c5edeba0d7275633bb4735ab45bd5963a28",

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

@@ -5,7 +5,7 @@
   "platform": "linux",
   "architecture": "x64",
   "capability": "supported",
-  "builtAt": "2026-08-25T06:52:58.359Z",
+  "builtAt": "2026-08-25T08:31:49.348Z",
   "artifact": {
     "filename": "process-guardian",
     "sha256": "29e22fe29de2828982bc67ef418c4adcaab1490281477b7bea592ec6fe621bcd",

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

@@ -5,10 +5,10 @@
   "platform": "win32",
   "architecture": "x64",
   "capability": "supported",
-  "builtAt": "2026-08-25T06:54:04.992Z",
+  "builtAt": "2026-08-25T08:32:11.007Z",
   "artifact": {
     "filename": "process-guardian.exe",
-    "sha256": "b8b0c81f275bd95b0cf4a63dd19f734a845947e47feded1d85a7a3562cf072db",
+    "sha256": "b22997c85da32360cdb382f568e618757654c746cccb825b7c771d011cca9ba6",
     "size": 172544
   },
   "provenance": {

package/dist/src/cli/packages.d.ts

@@ -11,6 +11,12 @@ export interface PackageCommandRequest {
     readonly verb: PackageCommandVerb;
     readonly source: string | null;
 }
+export interface PackageCommandStyle {
+    readonly dim: (message: string) => string;
+    readonly bold: (message: string) => string;
+    readonly green: (message: string) => string;
+    readonly red: (message: string) => string;
+}
 export interface PackageCommandEnvironment {
     readonly createPort: (input: AgentPackagesPortInput) => AgentPackagesPort;
     readonly cwd?: string;
@@ -18,6 +24,8 @@ export interface PackageCommandEnvironment {
     readonly stdout?: (message: string) => void;
     readonly stderr?: (message: string) => void;
     readonly initializeProfile?: typeof initializeProductProfile;
+    /** Defaults to Chalk's terminal-aware styles; injectable for transcript tests. */
+    readonly style?: PackageCommandStyle;
 }
 export declare function runPackageCommand(request: PackageCommandRequest, environment: PackageCommandEnvironment): Promise<number>;
-export declare function renderPackageOutcome(outcome: AgentPackageOutcome, profileRoot: string): string;
+export declare function renderPackageOutcome(outcome: AgentPackageOutcome, profileRoot: string, style?: PackageCommandStyle): string;

package/dist/src/cli/packages.js

@@ -1,3 +1,4 @@
+import chalk from "chalk";
 import { configurationRootForProfile, initializeProductProfile, resolveLaunchProfilePaths } from "../features/launch/index.js";
 import { PRODUCT_TEXT } from "../product-identity.js";
 export async function runPackageCommand(request, environment) {
@@ -5,6 +6,7 @@ export async function runPackageCommand(request, environment) {
     const stderr = environment.stderr ?? (message => process.stderr.write(message));
     const cwd = environment.cwd ?? process.cwd();
     const processEnvironment = environment.environment ?? process.env;
+    const style = environment.style ?? chalk;
     const paths = resolveLaunchProfilePaths({ environment: processEnvironment });
     const profileRoot = configurationRootForProfile("a1", paths);
     if (profileRoot === null)
@@ -19,10 +21,10 @@ export async function runPackageCommand(request, environment) {
     const port = environment.createPort({
         profileRoot,
         cwd,
-        onProgress: progress => stdout(`${progress.message}\n`),
+        onProgress: progress => stdout(`${style.dim(progress.message)}\n`),
     });
     const outcome = await runVerb(port, request);
-    const rendered = renderPackageOutcome(outcome, profileRoot);
+    const rendered = renderPackageOutcome(outcome, profileRoot, style);
     (outcome.status === "completed" ? stdout : stderr)(rendered);
     return outcome.status === "completed" ? 0 : 1;
 }
@@ -37,38 +39,40 @@ async function runVerb(port, request) {
         throw new Error(PRODUCT_TEXT.diagnostic(`requires a source for ${request.verb}`));
     return request.verb === "install" ? await port.install(request.source) : await port.remove(request.source);
 }
-export function renderPackageOutcome(outcome, profileRoot) {
-    const name = PRODUCT_TEXT.displayName;
+export function renderPackageOutcome(outcome, profileRoot, style = chalk) {
+    // Model refresh remains an A1 top-level command. The `a1 pi` compatibility
+    // transcript applies to package operations only.
+    if (outcome.operation === "refresh-models") {
+        if (outcome.status === "failed") {
+            return `${PRODUCT_TEXT.diagnostic(`could not ${describeOperation(outcome.operation)}: ${outcome.detail ?? "unknown failure"}`)}\n`;
+        }
+        return `${PRODUCT_TEXT.displayName} refreshed the model catalogs in ${profileRoot}.\n`;
+    }
     if (outcome.status === "failed") {
-        return `${PRODUCT_TEXT.diagnostic(`could not ${describeOperation(outcome.operation)}: ${outcome.detail ?? "unknown failure"}`)}\n`;
+        return `${style.red(`Error: ${outcome.detail ?? "Unknown package command error"}`)}\n`;
     }
     if (outcome.status === "not-found") {
-        return `${PRODUCT_TEXT.diagnostic(`found no package matching ${outcome.source ?? "that source"} in ${profileRoot}.`)}\n`;
+        return `${style.red(`No matching package found for ${outcome.source ?? "that source"}`)}\n`;
     }
     switch (outcome.operation) {
         case "install":
-            return `${name} installed ${outcome.source} into ${profileRoot}.\n`
-                + `Restart ${PRODUCT_TEXT.commandName} for a running session to load it.\n`;
+            return `${style.green(`Installed ${outcome.source}`)}\n`;
         case "remove":
-            return `${name} removed ${outcome.source} from ${profileRoot}.\n`;
+            return `${style.green(`Removed ${outcome.source}`)}\n`;
         case "update":
-            return outcome.source === null
-                ? `${name} updated the packages in ${profileRoot}.\n`
-                : `${name} updated ${outcome.source}.\n`;
-        case "refresh-models":
-            return `${name} refreshed the model catalogs in ${profileRoot}.\n`;
+            return `${style.green(outcome.source === null ? "Updated packages" : `Updated ${outcome.source}`)}\n`;
         case "list":
-            return renderPackageList(outcome, profileRoot);
+            return renderPackageList(outcome, style);
     }
 }
-function renderPackageList(outcome, profileRoot) {
+function renderPackageList(outcome, style) {
     if (outcome.packages.length === 0)
-        return `${PRODUCT_TEXT.displayName} has no packages installed in ${profileRoot}.\n`;
-    const lines = [`Packages installed for ${PRODUCT_TEXT.commandName} in ${profileRoot}:`];
+        return `${style.dim("No packages installed.")}\n`;
+    const lines = [style.bold("User packages:")];
     for (const entry of outcome.packages) {
-        lines.push(`  ${entry.source}${entry.filtered ? " (partly enabled)" : ""}`);
+        lines.push(`  ${entry.source}${entry.filtered ? " (filtered)" : ""}`);
         if (entry.installedPath !== null)
-            lines.push(`    ${entry.installedPath}`);
+            lines.push(style.dim(`    ${entry.installedPath}`));
     }
     return `${lines.join("\n")}\n`;
 }

package/dist/src/foundation/pi-component-adapter/index.d.ts

@@ -3,7 +3,7 @@ export * from "./conformance.js";
 export * from "./shell-components.js";
 export * from "./theme.js";
 export * from "./upstream/theme/theme-controller.js";
-export { applyConfiguredPiTheme, getAvailablePiThemes } from "./upstream/theme/theme.js";
+export { applyConfiguredPiTheme, getAvailablePiThemes, onPiThemeChange } from "./upstream/theme/theme.js";
 export * from "./upstream/components/countdown-timer.js";
 export * from "./upstream/components/extension-editor.js";
 export * from "./upstream/components/session-selector.js";

package/dist/src/foundation/pi-component-adapter/index.js

@@ -3,7 +3,7 @@ export * from "./conformance.js";
 export * from "./shell-components.js";
 export * from "./theme.js";
 export * from "./upstream/theme/theme-controller.js";
-export { applyConfiguredPiTheme, getAvailablePiThemes } from "./upstream/theme/theme.js";
+export { applyConfiguredPiTheme, getAvailablePiThemes, onPiThemeChange } from "./upstream/theme/theme.js";
 export * from "./upstream/components/countdown-timer.js";
 export * from "./upstream/components/extension-editor.js";
 export * from "./upstream/components/session-selector.js";

package/dist/src/foundation/pi-engine-adapter/adapter.d.ts

@@ -60,11 +60,18 @@ export interface OwnedPiResourceSummary {
     readonly sourcePath: string | null;
     readonly diagnostic: string | null;
 }
+export interface OwnedPiExtensionSourceSummary {
+    readonly source: string;
+    readonly scope: "user" | "project" | "temporary";
+    readonly origin: "package" | "top-level";
+    readonly baseDir: string | null;
+}
 export interface OwnedPiExtensionResourceSummary {
     readonly kind: "extension";
     readonly id: string;
     readonly sourcePath: string | null;
     readonly resolvedPath: string | null;
+    readonly sourceInfo: OwnedPiExtensionSourceSummary | null;
     readonly loaded: boolean;
     readonly hidden: boolean;
     readonly diagnostic: string | null;

package/dist/src/foundation/pi-engine-adapter/adapter.js

@@ -11,6 +11,12 @@ import { createPiRuntimeIntegration } from "./runtime-integration.js";
 import { PiSessionCommandIntegration } from "./session-integration.js";
 import { PiSettingsIntegration } from "./settings-integration.js";
 const execFileAsync = promisify(execFile);
+/**
+ * Engine events delivered before the queue hands the event loop a turn. Small enough
+ * that a streaming burst never holds input, large enough that an ordinary turn is one
+ * batch.
+ */
+const EVENT_DELIVERY_BATCH = 16;
 const DEFAULT_SURFACE = {
     columns: 100,
     rows: 32,
@@ -53,6 +59,8 @@ export class PiEngineAdapter {
     #activeCommandIds = [];
     #completedCommands = new Map();
     #transcript = [];
+    #transcriptIndex = new Map();
+    #transcriptSnapshot;
     #messageBlockIds = new WeakMap();
     #messageFallbackIds = new Map();
     #toolBlockIds = new Map();
@@ -61,6 +69,8 @@ export class PiEngineAdapter {
     #eventQueue = [];
     #eventQueueProcessing;
     #droppedEventCount = 0;
+    #agentRunActive = false;
+    #statusKind = null;
     #sessionCommands;
     #gitBranch = null;
     #extensionUi;
@@ -278,6 +288,7 @@ export class PiEngineAdapter {
                     id: `extension-${resources.length}`,
                     sourcePath: extension.path,
                     resolvedPath: extension.resolvedPath,
+                    sourceInfo: extensionSourceSummary(extension.sourceInfo),
                     loaded: true,
                     hidden: extension.hidden === true,
                     diagnostic: null,
@@ -725,7 +736,7 @@ export class PiEngineAdapter {
             sessionId: this.#sessionId,
             revision: this.#viewRevision,
             lifecycle: this.#lifecycle,
-            transcript: this.#transcript.map(block => ({ ...block })),
+            transcript: this.#transcriptSnapshot ??= Object.freeze([...this.#transcript]),
             editor: { ...this.#editor, queuedSubmissions: [...this.#editor.queuedSubmissions] },
             status: {
                 ...this.#status,
@@ -1351,6 +1362,8 @@ export class PiEngineAdapter {
             submitEnabled: true,
         };
         this.#status = { ...this.#status, workingMessage: null, badges: [] };
+        this.#statusKind = null;
+        this.#agentRunActive = false;
         this.#activeModel = readModel(session.model);
         this.#reconcileActiveModelAvailability();
         this.#thinkingLevel = readThinkingLevel(session.thinkingLevel);
@@ -1403,28 +1416,76 @@ export class PiEngineAdapter {
             this.#emitView();
         }
     }
+    /**
+     * Replaces the transcript and the index that finds a block by its identifier. Every
+     * lookup goes through the index, so streaming a chunk costs the same in a long session
+     * as in a new one.
+     */
+    #setTranscript(blocks) {
+        this.#transcript = blocks;
+        this.#transcriptIndex.clear();
+        for (const [index, block] of blocks.entries())
+            this.#transcriptIndex.set(block.id, index);
+        this.#transcriptSnapshot = undefined;
+    }
+    #transcriptBlock(id) {
+        const index = this.#transcriptIndex.get(id);
+        return index === undefined ? undefined : this.#transcript[index];
+    }
+    /** Shows the state named by `kind`, which becomes the state a later end can clear. */
+    #enterWorkState(kind, message) {
+        const wasBusy = this.#lifecycle === "busy";
+        this.#statusKind = kind;
+        this.#lifecycle = "busy";
+        this.#status = { ...this.#status, workingMessage: message };
+        if (!wasBusy)
+            this.#emitEvent({ type: "session-lifecycle", lifecycle: "busy", reason: null });
+        this.#emitEvent({ type: "status", status: this.#status });
+    }
+    /**
+     * Ends one named state. A state the shell is not in is left alone, so a finished
+     * compaction or retry cannot clear the working state it never replaced. While the run
+     * continues, ending either of those returns to working rather than to idle.
+     */
+    #endWorkState(kind) {
+        if (this.#statusKind !== kind)
+            return;
+        if (this.#agentRunActive) {
+            this.#enterWorkState("working", "Working...");
+            return;
+        }
+        this.#leaveWorkStates();
+    }
+    /** Leaves every work state and reports the session idle. */
+    #leaveWorkStates() {
+        this.#statusKind = null;
+        this.#lifecycle = "ready";
+        this.#status = { ...this.#status, workingMessage: null };
+        this.#emitEvent({ type: "session-lifecycle", lifecycle: "ready", reason: null });
+        this.#emitEvent({ type: "status", status: this.#status });
+    }
     #handlePiEvent(event) {
         if (!isRecord(event) || typeof event.type !== "string")
             return;
         switch (event.type) {
             case "agent_start":
-                this.#lifecycle = "busy";
-                this.#status = { ...this.#status, workingMessage: "Working..." };
-                this.#emitEvent({ type: "session-lifecycle", lifecycle: "busy", reason: null });
-                this.#emitEvent({ type: "status", status: this.#status });
+                this.#agentRunActive = true;
+                this.#enterWorkState("working", "Working...");
                 return;
             case "message_start":
                 this.#upsertMessageBlock(event.message, "live");
                 return;
             case "message_update": {
-                const block = this.#upsertMessageBlock(event.message, "live");
-                if (block && isRecord(event.assistantMessageEvent) && typeof event.assistantMessageEvent.delta === "string") {
-                    this.#upsertTranscriptBlock({
-                        ...block,
-                        text: block.text.endsWith(event.assistantMessageEvent.delta)
-                            ? block.text
-                            : `${block.text}${event.assistantMessageEvent.delta}`,
-                    });
+                const delta = isRecord(event.assistantMessageEvent) && typeof event.assistantMessageEvent.delta === "string"
+                    ? event.assistantMessageEvent.delta
+                    : undefined;
+                // The delta is folded in before the block is stored, so a chunk is one update to
+                // one block rather than a store without the delta followed by a store with it.
+                const blocks = this.#messageBlocks(event.message, "live", this.#transcript.length);
+                for (const [index, block] of blocks.entries()) {
+                    this.#upsertTranscriptBlock(index === 0 && delta !== undefined && !block.text.endsWith(delta)
+                        ? { ...block, text: `${block.text}${delta}` }
+                        : block);
                 }
                 return;
             }
@@ -1453,11 +1514,18 @@ export class PiEngineAdapter {
                 if (finalMessages.length > 0)
                     this.#rebuildTranscript(finalMessages, "finalized");
                 else
-                    this.#transcript = this.#transcript.map(block => block.status === "live" ? { ...block, status: "finalized" } : block);
-                this.#lifecycle = "ready";
-                this.#status = { ...this.#status, workingMessage: null };
-                this.#emitEvent({ type: "session-lifecycle", lifecycle: "ready", reason: null });
-                this.#emitEvent({ type: "status", status: this.#status });
+                    this.#setTranscript(this.#transcript.map(block => block.status === "live" ? { ...block, status: "finalized" } : block));
+                // Ending a turn leaves the working state, as the recorded pinned baseline does, but
+                // it leaves only that state: a compaction or retry being shown outlives the turn
+                // that ended under it. Settlement ends the run, and with it every state — the
+                // engine ends a turn for each continuation it makes and settles once.
+                if (event.type === "agent_settled") {
+                    this.#agentRunActive = false;
+                    this.#leaveWorkStates();
+                }
+                else if (this.#statusKind === null || this.#statusKind === "working") {
+                    this.#leaveWorkStates();
+                }
                 this.#emitView();
                 return;
             }
@@ -1473,20 +1541,16 @@ export class PiEngineAdapter {
                 return;
             }
             case "auto_retry_start":
-                this.#lifecycle = "busy";
-                this.#status = { ...this.#status, workingMessage: "Retrying…" };
-                this.#emitEvent({ type: "status", status: this.#status });
+                this.#enterWorkState("retry", "Retrying…");
                 return;
             case "auto_retry_end":
-            case "compaction_end":
-                this.#lifecycle = "ready";
-                this.#status = { ...this.#status, workingMessage: null };
-                this.#emitEvent({ type: "status", status: this.#status });
+                this.#endWorkState("retry");
                 return;
             case "compaction_start":
-                this.#lifecycle = "busy";
-                this.#status = { ...this.#status, workingMessage: "Compacting…" };
-                this.#emitEvent({ type: "status", status: this.#status });
+                this.#enterWorkState("compaction", "Compacting…");
+                return;
+            case "compaction_end":
+                this.#endWorkState("compaction");
                 return;
             case "thinking_level_changed":
                 this.#thinkingLevel = readThinkingLevel(event.level);
@@ -1576,7 +1640,13 @@ export class PiEngineAdapter {
                 }
             }
         }
-        this.#transcript = blocks;
+        // An authoritative rebuild restates most of what is already there. Reusing the block
+        // that already says it keeps its revision, and with it the rows the shell rendered for
+        // it — otherwise every turn that ends re-renders the whole session.
+        this.#setTranscript(blocks.map(block => {
+            const existing = this.#transcriptBlock(block.id);
+            return existing !== undefined && sameBlockContent(existing, block) ? existing : block;
+        }));
     }
     #upsertMessageBlock(message, status) {
         const blocks = this.#messageBlocks(message, status, this.#transcript.length);
@@ -1661,7 +1731,7 @@ export class PiEngineAdapter {
                 : this.#toolBlockIds.get(toolCallId) ?? `tool-${toolCallId}`;
             if (toolCallId !== undefined)
                 this.#toolBlockIds.set(toolCallId, blockId);
-            const existing = this.#transcript.find(block => block.id === blockId);
+            const existing = this.#transcriptBlock(blockId);
             const existingPayload = isRecord(existing?.payload) ? existing.payload : undefined;
             return [{
                     id: blockId,
@@ -1752,11 +1822,20 @@ export class PiEngineAdapter {
         });
     }
     #upsertTranscriptBlock(block) {
-        const index = this.#transcript.findIndex(existing => existing.id === block.id);
-        if (index >= 0)
+        const index = this.#transcriptIndex.get(block.id);
+        if (index !== undefined) {
+            const existing = this.#transcript[index];
+            // Nothing to tell the shell about a block that repeats itself, and keeping the
+            // revision keeps the rows it already rendered.
+            if (existing !== undefined && sameBlockContent(existing, block))
+                return;
             this.#transcript[index] = block;
-        else
+        }
+        else {
+            this.#transcriptIndex.set(block.id, this.#transcript.length);
             this.#transcript.push(block);
+        }
+        this.#transcriptSnapshot = undefined;
         this.#emitEvent({ type: "transcript-block", block });
     }
     #messageBlockId(message, fallbackIndex, status, occurrence) {
@@ -1774,7 +1853,7 @@ export class PiEngineAdapter {
             }
         }
         else {
-            id = [...cached].reverse().find(candidate => this.#transcript.some(block => block.id === candidate && block.status === "live"));
+            id = [...cached].reverse().find(candidate => this.#transcriptBlock(candidate)?.status === "live");
             if (id === undefined && status === "finalized")
                 id = cached.at(-1);
             if (id === undefined) {
@@ -1787,7 +1866,7 @@ export class PiEngineAdapter {
         return id;
     }
     #nextBlockRevision(id) {
-        const existing = this.#transcript.find(block => block.id === id);
+        const existing = this.#transcriptBlock(id);
         if (existing)
             return existing.revision + 1;
         this.#nextBlockSequence += 1;
@@ -1848,6 +1927,7 @@ export class PiEngineAdapter {
     }
     async #processEventQueue() {
         try {
+            let deliveredSinceYield = 0;
             while (this.#eventQueue.length > 0) {
                 const event = this.#eventQueue.shift();
                 if (!event)
@@ -1860,6 +1940,14 @@ export class PiEngineAdapter {
                         this.#recordDiagnostic("warning", "event-listener", error instanceof Error ? error.message : String(error), true);
                     }
                 }
+                deliveredSinceYield += 1;
+                // A microtask chain runs to exhaustion before the loop turns, so a streaming
+                // burst would hold typed input, pointer reports, and timed indicators until it
+                // drained. Yielding on a macrotask hands those their turn between batches.
+                if (deliveredSinceYield >= EVENT_DELIVERY_BATCH && this.#eventQueue.length > 0) {
+                    deliveredSinceYield = 0;
+                    await new Promise(resolve => { setImmediate(resolve); });
+                }
             }
         }
         finally {
@@ -2246,11 +2334,26 @@ function extensionResourceDiagnostic(index, sourcePath, diagnostic) {
         id: `extension-diagnostic-${index}`,
         sourcePath,
         resolvedPath: null,
+        sourceInfo: null,
         loaded: false,
         hidden: false,
         diagnostic,
     };
 }
+function extensionSourceSummary(value) {
+    if (!isRecord(value))
+        return null;
+    const source = stringProperty(value, "source");
+    const scope = value.scope;
+    const origin = value.origin;
+    const baseDir = value.baseDir;
+    if (!source
+        || (scope !== "user" && scope !== "project" && scope !== "temporary")
+        || (origin !== "package" && origin !== "top-level")
+        || (baseDir !== undefined && typeof baseDir !== "string"))
+        return null;
+    return { source, scope, origin, baseDir: baseDir ?? null };
+}
 function collectionResult(value, key) {
     if (!isRecord(value))
         return { values: [], diagnostics: [] };
@@ -2299,6 +2402,36 @@ function compactResourceLabel(path) {
     const segments = path.replaceAll("\\", "/").split("/").filter(Boolean);
     return segments.at(-1) ?? path;
 }
+/**
+ * Whether two blocks say the same thing. A block that says what it already said is not a
+ * new revision: the shell renders a block once per revision, so bumping one it did not
+ * need re-renders it for nothing.
+ */
+function sameBlockContent(left, right) {
+    return left.kind === right.kind
+        && left.status === right.status
+        && left.title === right.title
+        && left.text === right.text
+        && sameValue(left.payload, right.payload);
+}
+function sameValue(left, right) {
+    if (left === right)
+        return true;
+    if (typeof left !== typeof right || left === null || right === null)
+        return false;
+    if (Array.isArray(left) || Array.isArray(right)) {
+        if (!Array.isArray(left) || !Array.isArray(right) || left.length !== right.length)
+            return false;
+        return left.every((value, index) => sameValue(value, right[index]));
+    }
+    if (typeof left !== "object")
+        return false;
+    const leftKeys = Object.keys(left);
+    const rightRecord = right;
+    if (leftKeys.length !== Object.keys(rightRecord).length)
+        return false;
+    return leftKeys.every(key => Object.hasOwn(rightRecord, key) && sameValue(left[key], rightRecord[key]));
+}
 function textFromContent(content) {
     if (typeof content === "string")
         return content;

package/dist/src/foundation/pi-owned-ui-integration/session-shell.d.ts

@@ -39,6 +39,12 @@ export declare class OwnedUiSessionShellRoot implements PiTuiComponentPort {
         readonly onDequeue?: () => void;
     }, startup?: PiShellHeaderOptions, agentDir?: string, extensionRenderers?: PiShellExtensionRendererResolver);
     update(view: OwnedUiSessionViewModel): void;
+    /**
+     * Applies one block: its component is created or updated in place and the order grows
+     * only when the block is new. A streamed chunk costs one component update rather than a
+     * walk of the whole transcript.
+     */
+    applyTranscriptBlock(block: OwnedUiSessionViewModel["transcript"][number]): void;
     render(width: number): readonly string[];
     layoutRoot(): PiTuiLayoutNode;
     transcriptComponent(id: string): PiShellTranscriptComponentPort | undefined;

package/dist/src/foundation/pi-owned-ui-integration/session-shell.js

@@ -1,6 +1,6 @@
 import { MOUSE_TRACKING_OFF, MOUSE_TRACKING_ON, parseMouseInput } from "../ui-components/index.js";
 import { PINNED_PI_HIDDEN_COMMAND_NAMES, PINNED_PI_WORKFLOW_COMMAND_NAMES, } from "../pi-engine-adapter/index.js";
-import { createPiExtensionUiBridge, createPiQueuedInputStatus, createPiShellArmin, createPiShellAuthProviderSelector, createPiShellChangelog, createPiShellDaxnuts, createPiShellDialog, createPiShellEarendilAnnouncement, createPiShellEditor, createPiShellExtensionSelector, createPiShellFooter, createPiShellHeader, createPiShellHotkeys, createPiShellLoadedResources, createPiShellLoginDialog, createPiShellModelSelector, createPiShellOperationLoader, createPiShellReloadBox, createPiShellScopedModelsSelector, createPiShellSelector, createPiShellSessionInfo, createPiShellSessionSelector, createPiShellSettingsSelector, createPiShellStatus, createPiShellTranscriptComponent, createPiShellTreeSelector, createPiShellTrustSelector, createPiShellUserMessageSelector, piTheme, renderPiShellPackageUpdateNotice, renderPiShellStartupDiagnostic, renderPiShellStatusText, renderPiShellTranscriptBlock, } from "../pi-component-adapter/index.js";
+import { createPiExtensionUiBridge, createPiQueuedInputStatus, createPiShellArmin, createPiShellAuthProviderSelector, createPiShellChangelog, createPiShellDaxnuts, createPiShellDialog, createPiShellEarendilAnnouncement, createPiShellEditor, createPiShellExtensionSelector, createPiShellFooter, createPiShellHeader, createPiShellHotkeys, createPiShellLoadedResources, createPiShellLoginDialog, createPiShellModelSelector, createPiShellOperationLoader, createPiShellReloadBox, createPiShellScopedModelsSelector, createPiShellSelector, createPiShellSessionInfo, createPiShellSessionSelector, createPiShellSettingsSelector, createPiShellStatus, createPiShellTranscriptComponent, createPiShellTreeSelector, createPiShellTrustSelector, createPiShellUserMessageSelector, onPiThemeChange, piTheme, renderPiShellPackageUpdateNotice, renderPiShellStartupDiagnostic, renderPiShellStatusText, renderPiShellTranscriptBlock, } from "../pi-component-adapter/index.js";
 import { PiTuiRuntimeAdapter, } from "../pi-tui-runtime-adapter/index.js";
 export class OwnedUiSessionShellRoot {
     editor;
@@ -8,6 +8,9 @@ export class OwnedUiSessionShellRoot {
     resources;
     #cwd;
     #transcript = new Map();
+    #blocksById = new Map();
+    #renderedRows = new Map();
+    #themeUnsubscribe;
     #transcriptOrder = [];
     #view;
     #status;
@@ -54,6 +57,9 @@ export class OwnedUiSessionShellRoot {
                 this.editor.addToHistory(block.text);
         }
         this.#syncTranscript(view.transcript);
+        // Colours come from the active theme, so rendered rows outlive their revision only
+        // until the theme under them changes.
+        this.#themeUnsubscribe = onPiThemeChange(() => this.#renderedRows.clear());
     }
     update(view) {
         this.#view = view;
@@ -65,6 +71,25 @@ export class OwnedUiSessionShellRoot {
         this.editor.setThinkingLevel(view.thinkingLevel);
         this.invalidate();
     }
+    /**
+     * Applies one block: its component is created or updated in place and the order grows
+     * only when the block is new. A streamed chunk costs one component update rather than a
+     * walk of the whole transcript.
+     */
+    applyTranscriptBlock(block) {
+        this.#blocksById.set(block.id, block);
+        const component = this.#transcript.get(block.id);
+        if (component === undefined) {
+            const created = createPiShellTranscriptComponent(block, this.#cwd, this.#extensionRenderers);
+            created.setExpanded(this.#toolsExpanded);
+            this.#transcript.set(block.id, created);
+            this.#transcriptOrder.push(block.id);
+        }
+        else if (component.revision !== block.revision) {
+            component.update(block);
+        }
+        this.invalidate();
+    }
     render(width) {
         const queued = this.#view.editor.queuedSubmissions.length === 0 ? [] : this.#queued.render(width);
         return [
@@ -128,10 +153,10 @@ export class OwnedUiSessionShellRoot {
     }
     #renderDocument(width) {
         const transcript = this.#transcriptOrder.flatMap((id, index) => {
-            const block = this.#view.transcript.find(item => item.id === id);
+            const block = this.#blocksById.get(id);
             if (!this.#thinkingVisible && block?.kind === "thinking")
                 return [];
-            const rows = this.#transcript.get(id)?.render(width) ?? [];
+            const rows = this.#blockRows(id, block, width);
             if (index > 0 && block?.kind === "user")
                 return ["", ...rows];
             return rows;
@@ -167,6 +192,25 @@ export class OwnedUiSessionShellRoot {
             ...diagnosticRows,
         ];
     }
+    /**
+     * Rows for one transcript block. A finalized block renders once for a given revision
+     * and width and is reused after that, so a frame costs what changed rather than what
+     * the session has accumulated. A live block, and anything the shell drives itself, is
+     * rendered every time because its content is still moving.
+     */
+    #blockRows(id, block, width) {
+        const component = this.#transcript.get(id);
+        if (component === undefined)
+            return [];
+        if (block === undefined || block.status !== "finalized")
+            return component.render(width);
+        const cached = this.#renderedRows.get(id);
+        if (cached && cached.width === width && cached.revision === block.revision)
+            return cached.rows;
+        const rows = component.render(width);
+        this.#renderedRows.set(id, { width, revision: block.revision, rows });
+        return rows;
+    }
     transcriptComponent(id) {
         return this.#transcript.get(id);
     }
@@ -334,6 +378,8 @@ export class OwnedUiSessionShellRoot {
         this.#extensionWorkingMessage = undefined;
         this.#status.setWorkingOverride(undefined);
         this.#footer.update(this.#viewWithExtensionStatuses(this.#view));
+        // An extension renderer may have drawn transcript blocks that are now unrendered by it.
+        this.#renderedRows.clear();
         this.invalidate();
     }
     addExtensionNotification(message, type) {
@@ -384,11 +430,13 @@ export class OwnedUiSessionShellRoot {
         this.#inputSurface.setFocused?.(focused);
     }
     dispose() {
+        this.#themeUnsubscribe();
         this.header.dispose?.();
         this.resources.dispose?.();
         for (const component of this.#transcript.values())
             component.dispose?.();
         this.#transcript.clear();
+        this.#renderedRows.clear();
         if (this.#inputSurface !== this.editor)
             this.#inputSurface.dispose?.();
         this.#extensionHeader?.dispose?.();
@@ -402,12 +450,16 @@ export class OwnedUiSessionShellRoot {
         this.#queued.dispose?.();
     }
     #syncTranscript(blocks) {
+        this.#blocksById.clear();
+        for (const block of blocks)
+            this.#blocksById.set(block.id, block);
         const nextIds = new Set(blocks.map(block => block.id));
         for (const [id, component] of this.#transcript) {
             if (id.startsWith("workflow-status-") || nextIds.has(id))
                 continue;
             component.dispose?.();
             this.#transcript.delete(id);
+            this.#renderedRows.delete(id);
         }
         for (const block of blocks) {
             const component = this.#transcript.get(block.id);
@@ -431,8 +483,9 @@ export class OwnedUiSessionShellRoot {
             if (block !== undefined)
                 order.push(block.id);
         }
+        const placed = new Set(order);
         for (const statusId of statusIds) {
-            if (!order.includes(statusId))
+            if (!placed.has(statusId))
                 order.push(statusId);
         }
         this.#transcriptOrder = order;
@@ -498,6 +551,8 @@ export class OwnedUiSessionShellRoot {
         this.resources.setExpanded(expanded);
         for (const component of this.#transcript.values())
             component.setExpanded(expanded);
+        // Expansion changes what a block draws without changing its revision.
+        this.#renderedRows.clear();
         this.invalidate();
     }
 }
@@ -525,12 +580,14 @@ function shellResourceEntries(backend) {
         sourcePath: resource.sourcePath,
         diagnostic: resource.diagnostic,
     }));
-    for (const extension of backend.extensionResources()) {
-        if (extension.hidden)
-            continue;
+    const extensions = backend.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: compactResourceLabel(extension.sourcePath ?? extension.resolvedPath ?? "extension"),
+            label: extensionLabels[labelIndex] ?? compactResourceLabel(extension.sourcePath ?? extension.resolvedPath ?? "extension"),
             sourcePath: extension.sourcePath ?? extension.resolvedPath,
             diagnostic: extension.diagnostic,
         });
@@ -538,12 +595,129 @@ function shellResourceEntries(backend) {
     return resources;
 }
 function compactResourceLabel(path) {
-    const segments = path.replaceAll("\\", "/").split("/").filter(Boolean);
+    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:");
+}
 export class OwnedUiSessionShell {
     backend;
     root;
@@ -560,6 +734,7 @@ export class OwnedUiSessionShell {
     #sequence = 0;
     #started = false;
     #disposed = false;
+    #pointerReporting = false;
     #compactionQueue = [];
     #lastClearTime = 0;
     #activeLoginDialog;
@@ -638,8 +813,13 @@ export class OwnedUiSessionShell {
         });
         this.root.editor.setAutocompleteCommands(this.backend.workflowAutocompleteCommands());
         this.#unsubscribe = this.backend.onEvent(event => {
-            this.#syncView();
-            if (this.view().lifecycle === "ready" && this.#compactionQueue.length > 0)
+            // A streamed chunk names one block, and touching only that block is what keeps the
+            // cost of a chunk the same in a long session as in a new one. Everything else
+            // resynchronizes the view, which is cheap next to re-reading the transcript.
+            const view = event.type === "transcript-block" && this.#sessionGeneration === this.backend.sessionGeneration
+                ? this.#syncBlock(event.block)
+                : this.#syncView();
+            if (view.lifecycle === "ready" && this.#compactionQueue.length > 0)
                 void this.#flushCompactionQueue();
             if (event.type === "session-lifecycle" && event.lifecycle === "stopped")
                 this.#resolveStopped?.();
@@ -1232,22 +1412,51 @@ export class OwnedUiSessionShell {
             this.root.appendDaxnuts();
         }
     }
+    /**
+     * Turns terminal pointer reporting on for a screen that reads the pointer, and off for
+     * every path that ends it. While it is on the terminal hands A1 the wheel and the
+     * button instead of scrolling and selecting itself, so leaving it on outlives the
+     * screen that wanted it and takes the terminal's own scrolling and selection with it.
+     */
+    #setPointerReporting(enabled) {
+        if (this.#pointerReporting === enabled)
+            return;
+        this.#pointerReporting = enabled;
+        if (!this.runtime.active)
+            return;
+        this.runtime.writeControl(enabled ? MOUSE_TRACKING_ON : MOUSE_TRACKING_OFF);
+    }
     async dispose() {
         if (this.#disposed)
             return;
         this.#disposed = true;
+        this.#setPointerReporting(false);
         this.#unsubscribe();
         this.#dialogHandle?.hide();
         await this.backend.unbindExtensionUi();
         this.#extensionBridge.dispose();
         await this.runtime.dispose();
     }
+    /**
+     * Applies one transcript block without re-reading the session. The listeners still hear
+     * the view they would have heard, so nothing downstream can tell the difference.
+     */
+    #syncBlock(block) {
+        this.root.applyTranscriptBlock(block);
+        this.runtime.requestRender();
+        const view = this.view();
+        for (const listener of this.#listeners)
+            listener(view);
+        return view;
+    }
     #syncView() {
         const view = this.view();
         if (this.backend.sessionGeneration !== this.#sessionGeneration) {
             this.#sessionGeneration = this.backend.sessionGeneration;
             this.#activeLoginDialog = undefined;
             this.#extensionBridge.reset();
+            // A replaced session takes its screens with it, pointer reporting included.
+            this.#setPointerReporting(false);
             this.root.setInputSurface(null);
             this.root.resetExtensionUi();
             this.root.resetWorkflowPresentation();
@@ -1257,6 +1466,7 @@ export class OwnedUiSessionShell {
         this.runtime.requestRender();
         for (const listener of this.#listeners)
             listener(view);
+        return view;
     }
     #openOwnedRoute(route) {
         const surface = this.#routeHost?.open(route) ?? null;
@@ -1267,7 +1477,7 @@ export class OwnedUiSessionShell {
         this.#dialogHandle?.hide();
         // Any-event reporting: hover and drag are what the screen is driven by, and
         // it also stops the terminal treating a drag as a text selection.
-        this.runtime.writeControl(MOUSE_TRACKING_ON);
+        this.#setPointerReporting(true);
         // The interrupt chord is global, so it is watched on raw input rather than
         // through the overlay: the pinned shell handles that key before an overlay
         // ever sees it, which is why an owned screen must not rely on being asked.
@@ -1290,7 +1500,7 @@ export class OwnedUiSessionShell {
         });
         const closeSurface = () => {
             removeInterruptWatch();
-            this.runtime.writeControl(MOUSE_TRACKING_OFF);
+            this.#setPointerReporting(false);
             this.#dialogHandle?.hide();
             this.#dialogHandle = undefined;
             this.#dialogId = undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@timurproko/a1",
-  "version": "0.1.8-dev.ade9b77",
+  "version": "0.1.8-dev.c64be0e",
   "description": "Standalone terminal workspace for supervised native and managed agents",
   "type": "module",
   "packageManager": "npm@11.13.0",
@@ -57,6 +57,7 @@
   "dependencies": {
     "@earendil-works/pi-coding-agent": "0.84.2",
     "@earendil-works/pi-tui": "0.84.2",
+    "chalk": "5.6.2",
     "cross-spawn": "7.0.6",
     "grok-mermaid": "0.2.2",
     "semver": "7.8.5"