@timurproko/a1 0.1.8-dev.0aceebe → 0.1.8-dev.21b95d6

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
@@ -30,16 +31,19 @@ Pi extension packages install into A1's own profile, so bare `a1` loads them and
 `a1 pi` and `a1 sandbox` do not. Sources are Pi's: `npm:`, git, or a local path.
 
 ```sh
-a1 install npm:pi-mcp-adapter   # install a package into ~/.a1/agent
-a1 remove npm:pi-mcp-adapter    # remove it again (alias: a1 uninstall)
-a1 list                         # list packages installed for a1
-a1 update --extensions          # update every installed package
-a1 update npm:pi-mcp-adapter    # update one of them
-a1 update --models              # refresh model catalogs
+a1 pi install npm:pi-mcp-adapter   # install a package into ~/.a1/agent
+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
 ```
 
 A running session loads a newly installed package after a restart. Pi's own
-profile at `~/.pi/agent` is managed by Pi itself.
+profile at `~/.pi/agent` is managed by Pi itself. Extension configuration is
+isolated too: for example, MCP configuration for bare `a1` belongs under
+`~/.a1/agent` (or the project), so `~/.pi/agent/mcp.json` is not read. Run
+`/mcp setup` inside bare `a1` to configure it; the MCP footer status appears
+when that A1 configuration contains a server.
 
 ## Develop
 

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

@@ -5,7 +5,7 @@
   "platform": "darwin",
   "architecture": "arm64",
   "capability": "unsupported",
-  "builtAt": "2026-08-24T07:04:20.048Z",
+  "builtAt": "2026-08-25T08:21:01.149Z",
   "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-24T07:04:23.438Z",
+  "builtAt": "2026-08-25T08:20:57.618Z",
   "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-24T07:04:56.702Z",
+  "builtAt": "2026-08-25T08:21:59.118Z",
   "artifact": {
     "filename": "process-guardian.exe",
-    "sha256": "856c57a950c47109893dd631bf5ee4fbe467b98433d9b8d3cc7ffaf4124f15a9",
+    "sha256": "82d4ad108c0e73f59b8bca207c751a7822e21045895c1453296fff6b649042ea",
     "size": 172544
   },
   "provenance": {

package/dist/src/cli/dispatch.js

@@ -5,12 +5,13 @@ export function cliUsage(capabilities) {
         "",
         ...(capabilities.developmentProfiles ? ["pi", "sandbox"] : []),
         "version",
-        "update [self|<source>|--extensions|--models]",
+        "update [self|--models]",
         "update:next",
         "update:<commit>",
-        "install <source>",
-        "remove <source>",
-        "list",
+        "pi install <source>",
+        "pi remove <source>",
+        "pi list",
+        "pi update [--extensions|<source>]",
     ]);
 }
 const PROFILE_WORDS = new Set(["pi", "sandbox"]);
@@ -32,7 +33,13 @@ export function parseCliCommand(arguments_, capabilities) {
     if (arguments_.length === 0)
         return { kind: "launch", profileId: "a1" };
     const [command, ...rest] = arguments_;
-    if (capabilities.developmentProfiles && (command === "pi" || command === "sandbox")) {
+    if (command === "pi") {
+        if (rest.length > 0)
+            return parsePiPackageCommand(rest);
+        if (capabilities.developmentProfiles)
+            return { kind: "launch", profileId: "pi" };
+    }
+    if (capabilities.developmentProfiles && command === "sandbox") {
         return withoutArguments(rest, { kind: "launch", profileId: command });
     }
     if (command === "version")
@@ -41,11 +48,9 @@ export function parseCliCommand(arguments_, capabilities) {
         return parseColonUpdate(command.slice("update:".length), rest);
     if (command === "update")
         return parseUpdate(rest);
-    if (command === "install" || command === "remove" || command === "uninstall") {
-        return parseSourceCommand(command === "install" ? "install" : "remove", rest);
+    if (command === "install" || command === "remove" || command === "uninstall" || command === "list") {
+        return packageNamespaceRejection(command, rest.join(" ") || undefined);
     }
-    if (command === "list")
-        return withoutArguments(rest, { kind: "packages", request: { verb: "list", source: null } });
     if (command === "ui")
         return { kind: "error", message: `The ui subcommand was removed; run bare ${PRODUCT_TEXT.commandName} for the owned UI.` };
     if (command === "agent")
@@ -71,10 +76,9 @@ function parseColonUpdate(suffix, rest) {
     return { kind: "update", channel: "next", target: suffix };
 }
 /**
- * `update` carries both meanings pinned Pi gives it: itself by default, and the
- * profile's packages when a target says so. Pi is refused as a target because A1
- * certifies each release against one pinned Pi, so moving Pi underneath it would
- * invalidate what was certified.
+ * Top-level `update` owns A1 itself and A1's model catalogs. Extension package
+ * maintenance lives under the `pi` compatibility namespace, while updating the
+ * pinned Pi runtime remains impossible.
  */
 function parseUpdate(rest) {
     if (rest.length === 0)
@@ -90,18 +94,42 @@ function parseUpdate(rest) {
             message: PRODUCT_TEXT.diagnostic(`pins the Pi version it was certified against; run ${PRODUCT_TEXT.commandName} update to move ${PRODUCT_TEXT.displayName} itself.`),
         };
     }
-    // A release channel is spelled with the colon. Taking the bare word as a package
-    // source would turn a near miss into a confident search for a package nobody has.
     if (target === "next" || target === "stable") {
         const form = target === "next" ? `${PRODUCT_TEXT.commandName} update:next` : `${PRODUCT_TEXT.commandName} update`;
         return { kind: "error", message: PRODUCT_TEXT.diagnostic(`selects a release channel with a colon; run ${form}.`) };
     }
-    if (target === "--extensions")
-        return { kind: "packages", request: { verb: "update", source: null } };
     if (target === "--models")
         return { kind: "packages", request: { verb: "refresh-models", source: null } };
+    if (target === "--extensions" || (target !== undefined && !target.startsWith("-"))) {
+        return packageNamespaceRejection("update", target === "--extensions" ? "--extensions" : target);
+    }
+    return unknownOption(target ?? "", "update");
+}
+function parsePiPackageCommand(arguments_) {
+    const [verb, ...rest] = arguments_;
+    if (verb === "install" || verb === "remove" || verb === "uninstall") {
+        return parseSourceCommand(verb === "install" ? "install" : "remove", rest);
+    }
+    if (verb === "list")
+        return withoutArguments(rest, { kind: "packages", request: { verb: "list", source: null } });
+    if (verb === "update")
+        return parsePiPackageUpdate(rest);
+    return { kind: "error", message: PRODUCT_TEXT.diagnostic(`received an unknown pi package command: ${verb ?? ""}`) };
+}
+function parsePiPackageUpdate(rest) {
+    if (rest.length === 0) {
+        return { kind: "error", message: PRODUCT_TEXT.diagnostic(`pi update needs --extensions or a package source.`) };
+    }
+    if (rest.length > 1)
+        return { kind: "error", message: PRODUCT_TEXT.diagnostic("pi update accepts one target.") };
+    const [target] = rest;
+    if (target === "--extensions")
+        return { kind: "packages", request: { verb: "update", source: null } };
+    if (target === "--models") {
+        return { kind: "error", message: PRODUCT_TEXT.diagnostic(`refreshes its model catalogs at the top level; run ${PRODUCT_TEXT.commandName} update --models.`) };
+    }
     if (target === undefined || target.startsWith("-"))
-        return unknownOption(target ?? "", "update");
+        return unknownOption(target ?? "", "pi update");
     if (PROFILE_WORDS.has(target))
         return profileRejection("update");
     return { kind: "packages", request: { verb: "update", source: target } };
@@ -129,6 +157,13 @@ function withoutArguments(rest, command) {
         return profileRejection("list");
     return { kind: "error", message: PRODUCT_TEXT.diagnostic("commands do not accept additional arguments.") };
 }
+function packageNamespaceRejection(verb, target) {
+    const suffix = target === undefined ? "" : ` ${target}`;
+    return {
+        kind: "error",
+        message: PRODUCT_TEXT.diagnostic(`manages extension packages under its pi namespace; run ${PRODUCT_TEXT.commandName} pi ${verb}${suffix}.`),
+    };
+}
 function profileRejection(verb) {
     return {
         kind: "error",

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-component-adapter/shell-presenters-transcript.js

@@ -1,6 +1,7 @@
 import { AssistantMessageComponent, BashExecutionComponent, CompactionSummaryMessageComponent, CustomMessageComponent, DynamicBorder, getMarkdownTheme, parseSkillBlock, ToolExecutionComponent, UserMessageComponent, } from "@earendil-works/pi-coding-agent";
 import { SkillInvocationMessageComponent, } from "./upstream/components/skill-invocation-message.js";
 import { Container, Markdown, Spacer, Text, } from "#pi-tui";
+import { PRODUCT_TEXT } from "../../product-identity.js";
 import { KeybindingsManager, } from "./upstream/adjacent/core/keybindings.js";
 import { PINNED_PI_LAYOUT, piTheme, } from "./theme.js";
 import { componentPort, createTuiFacade, ensureTheme, formatSessionTokens, isRecord, } from "./shell-shared-facade.js";
@@ -168,7 +169,7 @@ export function renderPiShellPackageUpdateNotice(packages, width) {
     container.addChild(new Spacer(1));
     container.addChild(new DynamicBorder(text => theme.fg("warning", text)));
     container.addChild(new Text(`${theme.bold(theme.fg("warning", "Package Updates Available"))}\n`
-        + `${theme.fg("muted", "Package updates are available. Run ")}${theme.fg("accent", "pi update --extensions")}\n`
+        + `${theme.fg("muted", "Package updates are available. Run ")}${theme.fg("accent", `${PRODUCT_TEXT.commandName} pi update --extensions`)}\n`
         + `${theme.fg("muted", "Packages:")}\n`
         + packages.map(name => `- ${name}`).join("\n"), 1, 0));
     container.addChild(new DynamicBorder(text => theme.fg("warning", text)));

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;
@@ -143,7 +153,7 @@ export class PiEngineAdapter {
         if (this.#disposed || updates.length === 0)
             return;
         const packages = updates.map(name => `- ${name}`).join("\n");
-        this.#addDiagnostic("info", "package-updates", `Package updates are available. Run pi update --extensions\nPackages:\n${packages}`, true);
+        this.#addDiagnostic("info", "package-updates", `Package updates are available. Run ${PRODUCT_IDENTITY.commandName} pi update --extensions\nPackages:\n${packages}`, true);
         this.#emitView();
     }
     onEvent(listener) {
@@ -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,
@@ -373,9 +384,10 @@ export class PiEngineAdapter {
         }
         const extensionCommands = this.#session?.extensionRunner?.getRegisteredCommands?.();
         if (Array.isArray(extensionCommands)) {
-            for (const command of extensionCommands.filter(isRecord)) {
-                const name = stringProperty(command, "name");
-                if (!name || usedNames.has(name))
+            const registered = extensionCommands.filter(isRecord);
+            for (const command of registered) {
+                const name = stringProperty(command, "invocationName") ?? stringProperty(command, "name");
+                if (!name || usedNames.has(name) || isPiPrefixedCompatibilityAlias(command, registered))
                     continue;
                 commands.push({ name, description: stringProperty(command, "description") ?? "Extension command", source: "extension" });
                 usedNames.add(name);
@@ -724,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,
@@ -1350,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);
@@ -1402,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;
             }
@@ -1452,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;
             }
@@ -1472,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);
@@ -1575,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);
@@ -1660,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,
@@ -1751,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) {
@@ -1773,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) {
@@ -1786,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;
@@ -1847,6 +1927,7 @@ export class PiEngineAdapter {
     }
     async #processEventQueue() {
         try {
+            let deliveredSinceYield = 0;
             while (this.#eventQueue.length > 0) {
                 const event = this.#eventQueue.shift();
                 if (!event)
@@ -1859,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 {
@@ -2245,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: [] };
@@ -2274,10 +2378,60 @@ function stringProperty(value, key) {
     const item = value[key];
     return typeof item === "string" && item.length > 0 ? item : undefined;
 }
+/**
+ * Some ecosystem extensions retain a `pi-<name>` slash-command alias beside
+ * their unprefixed command. A1 presents the product-neutral command once while
+ * leaving Pi's runner free to accept the compatibility alias when typed.
+ */
+function isPiPrefixedCompatibilityAlias(command, commands) {
+    const name = stringProperty(command, "name");
+    if (!name?.startsWith("pi-") || name.length === 3)
+        return false;
+    const canonicalName = name.slice(3);
+    const description = stringProperty(command, "description");
+    const sourcePath = extensionCommandSourcePath(command);
+    return commands.some(candidate => candidate !== command
+        && stringProperty(candidate, "name") === canonicalName
+        && stringProperty(candidate, "description") === description
+        && extensionCommandSourcePath(candidate) === sourcePath);
+}
+function extensionCommandSourcePath(command) {
+    return isRecord(command) ? stringProperty(command.sourceInfo, "path") : undefined;
+}
 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/dist/src/foundation/release/index.d.ts

@@ -1,7 +1,6 @@
 export * from "./bootstrap.js";
 export * from "./cohort-selection.js";
 export * from "./cohort-state.js";
-export * from "./development-preview-release.js";
 export * from "./process-cleanup.js";
 export * from "./release.js";
 export * from "./release-gc.js";

package/dist/src/foundation/release/index.js

@@ -1,7 +1,6 @@
 export * from "./bootstrap.js";
 export * from "./cohort-selection.js";
 export * from "./cohort-state.js";
-export * from "./development-preview-release.js";
 export * from "./process-cleanup.js";
 export * from "./release.js";
 export * from "./release-gc.js";

package/dist/src/foundation/release/update.js

@@ -314,7 +314,9 @@ export async function runSelfUpdate(options) {
     if (resolved.version === null)
         return resolved.exitCode;
     const targetVersion = resolved.version;
-    output.stdout(`${PRODUCT_TEXT.commandName} update (${UPDATE_CHANNEL_LABELS[channel]}): ${runningVersion} → ${targetVersion}.\n`);
+    // No full stop after a version: it already ends in a dot-separated identifier,
+    // and a trailing one reads as part of the version rather than as punctuation.
+    output.stdout(`${PRODUCT_TEXT.commandName} update (${UPDATE_CHANNEL_LABELS[channel]}): ${runningVersion} → ${targetVersion}\n`);
     const progress = createUpdateProgress(output, options.progress ?? (options.output === undefined && process.stdout.isTTY === true));
     const rootLookup = await measure("global-root", async () => await runNpm(runner, ["root", "--global"], true, output, "resolve npm's global package root"));
     if (rootLookup.result === null)
@@ -403,7 +405,7 @@ export async function runSelfUpdate(options) {
         await transactionStore.clearCompleted();
         options.onPhaseTiming?.({ phase: "transaction-complete", durationMs: Math.max(0, now() - transactionStartedAt) });
         progress.finish();
-        output.stdout(`${PRODUCT_TEXT.commandName} updated successfully: ${targetVersion}.\n`);
+        output.stdout(`${PRODUCT_TEXT.commandName} updated successfully: ${targetVersion}\n`);
         return 0;
     }
     catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@timurproko/a1",
-  "version": "0.1.8-dev.0aceebe",
+  "version": "0.1.8-dev.21b95d6",
   "description": "Standalone terminal workspace for supervised native and managed agents",
   "type": "module",
   "packageManager": "npm@11.13.0",

package/dist/src/foundation/release/development-preview-release.d.ts

@@ -1,49 +0,0 @@
-export declare const PREVIEW_RELEASE_SCHEMA: string;
-export interface DevelopmentPreviewCandidate {
-    readonly version: string;
-    readonly requiresVersionCommit: boolean;
-}
-export interface DevelopmentPreviewRegistryState {
-    readonly published: boolean;
-    readonly nextVersion: string | null;
-}
-export interface DevelopmentPreviewVerificationOptions {
-    readonly attempts?: number;
-    readonly delayMs?: number;
-    readonly delay?: (milliseconds: number) => Promise<void>;
-}
-export interface DevelopmentPreviewPublishResult {
-    readonly published: boolean;
-    readonly recoveredPublishError: unknown | null;
-}
-export interface UncertifiedDevelopmentPreviewEvidenceInput {
-    readonly packageName: string;
-    readonly version: string;
-    readonly commit: string;
-    readonly tarball: string;
-    readonly integrity: string;
-    readonly shasum: string;
-    readonly platform: NodeJS.Platform;
-    readonly architecture: string;
-    readonly recordedAt: string;
-}
-export interface UncertifiedDevelopmentPreviewEvidence extends UncertifiedDevelopmentPreviewEvidenceInput {
-    readonly schema: typeof PREVIEW_RELEASE_SCHEMA;
-    readonly channel: "next";
-    readonly certificationStatus: "uncertified-development-preview";
-    readonly terminalCapability: "owned-ui";
-    readonly manualAcceptance: "accepted";
-    readonly physicalHostCertification: "deferred";
-    readonly crossPlatformCertification: "deferred";
-    readonly stableReleaseEligible: false;
-}
-export declare function createUncertifiedDevelopmentPreviewEvidence(input: UncertifiedDevelopmentPreviewEvidenceInput): UncertifiedDevelopmentPreviewEvidence;
-export declare function requireManuallyAcceptedDevelopmentPreview(version: string, acceptedVersion: string): void;
-export declare function selectDevelopmentPreviewCandidate(currentVersion: string, publishedVersions: readonly string[]): DevelopmentPreviewCandidate;
-/**
- * Treats npm's process result as provisional: browser-auth completion can fail
- * after the immutable upload succeeds. Registry identity remains authoritative.
- */
-export declare function publishDevelopmentPreviewWithRecovery(publish: () => Promise<void>, verify: () => Promise<void>): Promise<DevelopmentPreviewPublishResult>;
-export declare function verifyDevelopmentPreviewRegistry(version: string, observe: () => Promise<DevelopmentPreviewRegistryState>, repairNextTag: () => Promise<void>, options?: DevelopmentPreviewVerificationOptions): Promise<void>;
-export declare function developmentPreviewTarballName(packageName: string, version: string): string;

package/dist/src/foundation/release/development-preview-release.js

@@ -1,114 +0,0 @@
-import { compare, inc, prerelease, valid } from "semver";
-import { PRODUCT_IDENTITY } from "../../product-identity.js";
-export const PREVIEW_RELEASE_SCHEMA = PRODUCT_IDENTITY.evidence.previewReleaseSchema;
-export function createUncertifiedDevelopmentPreviewEvidence(input) {
-    const prereleaseParts = prerelease(input.version);
-    if (valid(input.version) === null || prereleaseParts?.[0] !== "dev") {
-        throw new Error(`uncertified preview requires a development prerelease: ${input.version}`);
-    }
-    return {
-        schema: PREVIEW_RELEASE_SCHEMA,
-        channel: "next",
-        certificationStatus: "uncertified-development-preview",
-        terminalCapability: "owned-ui",
-        manualAcceptance: "accepted",
-        physicalHostCertification: "deferred",
-        crossPlatformCertification: "deferred",
-        stableReleaseEligible: false,
-        ...input,
-    };
-}
-export function requireManuallyAcceptedDevelopmentPreview(version, acceptedVersion) {
-    const acceptedPrerelease = prerelease(acceptedVersion);
-    if (valid(acceptedVersion) === null || acceptedPrerelease?.[0] !== "dev") {
-        throw new Error(`invalid manually accepted development preview: ${acceptedVersion}`);
-    }
-    if (version !== acceptedVersion) {
-        throw new Error(`development preview ${version} has no exact manual acceptance; accepted version is ${acceptedVersion}`);
-    }
-}
-export function selectDevelopmentPreviewCandidate(currentVersion, publishedVersions) {
-    if (valid(currentVersion) === null)
-        throw new Error(`invalid current package version: ${currentVersion}`);
-    const published = publishedVersions.map(version => {
-        if (valid(version) === null)
-            throw new Error(`invalid published package version: ${version}`);
-        return version;
-    });
-    const publishedSet = new Set(published);
-    const highestPublished = published.reduce((highest, version) => highest === null || compare(version, highest) > 0 ? version : highest, null);
-    const currentPrerelease = prerelease(currentVersion);
-    const currentIsUnpublishedLeadingDev = currentPrerelease?.[0] === "dev"
-        && !publishedSet.has(currentVersion)
-        && (highestPublished === null || compare(currentVersion, highestPublished) > 0);
-    if (currentIsUnpublishedLeadingDev)
-        return { version: currentVersion, requiresVersionCommit: false };
-    const base = highestPublished === null || compare(currentVersion, highestPublished) > 0
-        ? currentVersion
-        : highestPublished;
-    const basePrerelease = prerelease(base);
-    let candidate = basePrerelease?.[0] === "dev"
-        ? inc(base, "prerelease", "dev")
-        : inc(base, "prepatch", "dev");
-    if (candidate === null)
-        throw new Error(`could not increment development preview from ${base}`);
-    while (publishedSet.has(candidate)) {
-        candidate = inc(candidate, "prerelease", "dev");
-        if (candidate === null)
-            throw new Error(`could not increment development preview from ${base}`);
-    }
-    return { version: candidate, requiresVersionCommit: candidate !== currentVersion };
-}
-/**
- * Treats npm's process result as provisional: browser-auth completion can fail
- * after the immutable upload succeeds. Registry identity remains authoritative.
- */
-export async function publishDevelopmentPreviewWithRecovery(publish, verify) {
-    let publishError = null;
-    try {
-        await publish();
-    }
-    catch (error) {
-        publishError = error;
-    }
-    try {
-        await verify();
-        return { published: true, recoveredPublishError: publishError };
-    }
-    catch (verificationError) {
-        if (publishError !== null)
-            throw new AggregateError([publishError, verificationError], "npm publish failed and the exact version could not be verified in the registry");
-        throw verificationError;
-    }
-}
-export async function verifyDevelopmentPreviewRegistry(version, observe, repairNextTag, options = {}) {
-    const attempts = options.attempts ?? 12;
-    const delayMs = options.delayMs ?? 2_000;
-    const delay = options.delay ?? (async (milliseconds) => await new Promise(resolvePromise => setTimeout(resolvePromise, milliseconds)));
-    if (!Number.isInteger(attempts) || attempts < 1)
-        throw new Error(`invalid registry verification attempts: ${attempts}`);
-    let repaired = false;
-    let last = { published: false, nextVersion: null };
-    for (let attempt = 1; attempt <= attempts; attempt += 1) {
-        last = await observe();
-        if (last.published && last.nextVersion === version)
-            return;
-        if (last.published && !repaired) {
-            await repairNextTag();
-            repaired = true;
-        }
-        if (attempt < attempts)
-            await delay(delayMs);
-    }
-    if (!last.published)
-        throw new Error(`npm registry did not expose published version ${version} after ${attempts} attempts`);
-    throw new Error(`npm next resolved ${last.nextVersion ?? "nothing"}; expected ${version} after ${attempts} attempts`);
-}
-export function developmentPreviewTarballName(packageName, version) {
-    if (valid(version) === null)
-        throw new Error(`invalid development preview version: ${version}`);
-    const unscopedName = packageName.startsWith("@") ? packageName.slice(1).replace("/", "-") : packageName;
-    if (!/^[a-z0-9._-]+$/i.test(unscopedName))
-        throw new Error(`invalid package name: ${packageName}`);
-    return `${unscopedName}-${version}.tgz`;
-}