@timurproko/a1 0.1.1-dev.11 → 0.1.1-dev.12

package/README.md

@@ -20,12 +20,14 @@ a1 update:next  # update to npm next
 ## Develop
 
 ```sh
-npm ci              # install exact locked dependencies
-npm run build       # compile TypeScript and the process guardian into dist
-npm start           # build and launch an isolated development instance
-npm run test:fast   # typecheck + fast suite, no build needed
-npm test            # same as test:fast
-npm run test:full   # complete non-physical suite
+npm ci                  # install exact locked dependencies
+npm run build           # compile TypeScript and the process guardian into dist
+npm start               # build and launch an isolated development `a1`
+npm run start:pi        # build and launch an isolated development `a1 pi`
+npm run start:sandbox   # build and launch an isolated development `a1 sandbox`
+npm run test:fast       # typecheck + fast suite, no build needed
+npm test                # same as test:fast
+npm run test:full       # complete non-physical suite
 ```
 
 ## Release

package/bin/module-identity.js

@@ -0,0 +1,75 @@
+/**
+ * One pi-tui module identity per process.
+ *
+ * npm can materialize @earendil-works/pi-tui twice under A1's package root:
+ * once as A1's direct dependency at the node_modules root, and once nested
+ * inside @earendil-works/pi-coding-agent's isolated dependency tree. A1's
+ * owned UI imports the root copy while pinned Pi's extension loader hands
+ * extensions the nested copy, so every TUI class exists twice: `instanceof`
+ * checks and prototype patches made by extensions land on classes the
+ * renderer never uses — extension chrome silently disappears and routed
+ * input dead-ends.
+ *
+ * Repair runs at launch, not at install: npm's `prepare` hook is skipped for
+ * registry installs, so an installed A1 must self-heal the same way a source
+ * checkout does. The root copy is replaced with a junction (Windows) or
+ * directory symlink to the nested copy so every loader resolves the same
+ * files and therefore the same module instances.
+ *
+ * This lives in bin/ (shipped, plain JS) rather than src/ deliberately: its
+ * whole job is repairing the node_modules layout, which the Pi API boundary
+ * policy rightly forbids ordinary production code from touching.
+ *
+ * The repair is idempotent and fail-open: a hoisted tree (single copy), an
+ * already-linked root, a version mismatch, or a filesystem that refuses the
+ * link all leave the tree as it was — launch proceeds with a warning rather
+ * than failing, because a degraded UI beats no UI.
+ */
+import { existsSync, lstatSync, readFileSync, renameSync, rmSync, symlinkSync } from "node:fs";
+import { join } from "node:path";
+
+function packageVersion(directory) {
+  return JSON.parse(readFileSync(join(directory, "package.json"), "utf8")).version;
+}
+
+/**
+ * Collapse a duplicated @earendil-works/pi-tui under `packageRoot` onto the
+ * copy pinned Pi resolves, so extensions and the owned UI share one module
+ * instance. Must run before anything in the process imports pi-tui.
+ * Returns a discriminated outcome; never throws.
+ */
+export function ensureSinglePiTuiModule(packageRoot) {
+  const rootCopy = join(packageRoot, "node_modules", "@earendil-works", "pi-tui");
+  const nestedCopy = join(
+    packageRoot,
+    "node_modules", "@earendil-works", "pi-coding-agent",
+    "node_modules", "@earendil-works", "pi-tui",
+  );
+  try {
+    if (!existsSync(nestedCopy)) return { kind: "single-copy" };
+    if (existsSync(rootCopy) && lstatSync(rootCopy).isSymbolicLink()) return { kind: "already-linked" };
+    if (existsSync(rootCopy)) {
+      const rootVersion = packageVersion(rootCopy);
+      const nestedVersion = packageVersion(nestedCopy);
+      if (rootVersion !== nestedVersion) return { kind: "version-mismatch", rootVersion, nestedVersion };
+      const retired = `${rootCopy}.duplicate`;
+      rmSync(retired, { recursive: true, force: true });
+      renameSync(rootCopy, retired);
+      rmSync(retired, { recursive: true, force: true });
+    }
+    symlinkSync(nestedCopy, rootCopy, "junction");
+    return { kind: "linked" };
+  } catch (error) {
+    return { kind: "failed", message: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+/** Launch-entry wrapper: repair, and warn on stderr when the tree stays split. */
+export function ensureSinglePiTuiModuleAtLaunch(packageRoot, warn) {
+  const outcome = ensureSinglePiTuiModule(packageRoot);
+  if (outcome.kind === "version-mismatch") {
+    warn(`a1: pi-tui is duplicated at incompatible versions (${outcome.rootVersion} vs ${outcome.nestedVersion}); extension UI may not render.\n`);
+  } else if (outcome.kind === "failed") {
+    warn(`a1: could not unify the duplicated pi-tui module (${outcome.message}); extension UI may not render.\n`);
+  }
+}

package/bin/ui.js

@@ -1,5 +1,13 @@
 #!/usr/bin/env node
 
+const { ensureSinglePiTuiModuleAtLaunch } = await import("./module-identity.js");
+const { fileURLToPath } = await import("node:url");
+
+// Before the composition loads pinned Pi's terminal stack: collapse npm's
+// duplicated copies of it so extensions and the owned UI share one module
+// identity (see bin/module-identity.js for the full story).
+ensureSinglePiTuiModuleAtLaunch(fileURLToPath(new URL("..", import.meta.url)), message => process.stderr.write(message));
+
 const { runSelectedInteractiveRuntime } = await import("../dist/src/features/launch/index.js");
 
 runSelectedInteractiveRuntime(process.env.A1_LAUNCH_PROFILE ?? "a1", {

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

@@ -5,7 +5,7 @@
   "platform": "darwin",
   "architecture": "arm64",
   "capability": "unsupported",
-  "builtAt": "2026-08-23T09:25:46.770Z",
+  "builtAt": "2026-08-23T13:01:43.157Z",
   "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-23T09:25:43.327Z",
+  "builtAt": "2026-08-23T13:01:56.341Z",
   "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-23T09:26:36.967Z",
+  "builtAt": "2026-08-23T13:02:22.268Z",
   "artifact": {
     "filename": "process-guardian.exe",
-    "sha256": "1fd994f340bfa8423eee47ab6b7c3a19a5b1a19dea88814af27d8a989cfa0da0",
+    "sha256": "f36ba90394ff9d7bd32612d8b89f96f23afa394e22260466271938ae27ee5c9f",
     "size": 172544
   },
   "provenance": {

package/dist/src/foundation/pi-component-adapter/shell-presenters-transcript.d.ts

@@ -37,6 +37,21 @@ export declare function createPiShellChangelog(markdown: string): PiShellCompone
 export declare function createPiShellHotkeys(): PiShellComponentPort;
 export declare function createPiShellTranscriptComponent(initial: OwnedUiTranscriptBlock, cwd: string, extensions?: PiShellExtensionRendererResolver): PiShellTranscriptComponentPort;
 export declare function renderPiShellTranscriptBlock(block: OwnedUiTranscriptBlock, width: number, cwd: string): readonly string[];
+/**
+ * Pinned Pi's CLI prints startup diagnostics with `reportDiagnostics` before
+ * the banner: the whole line, prefix included, in chalk's basic ANSI severity
+ * colour — not the theme's tokens — with info lines dim and unprefixed.
+ */
+export declare function renderPiShellStartupDiagnostic(diagnostic: {
+    readonly severity: "info" | "warning" | "error";
+    readonly message: string;
+}, width: number): readonly string[];
+/**
+ * Pinned Pi's `showPackageUpdateNotification` banner: warning-coloured dynamic
+ * borders around a bold warning title, the muted update instruction with the
+ * accent command, and the package list.
+ */
+export declare function renderPiShellPackageUpdateNotice(packages: readonly string[], width: number): readonly string[];
 type PiAssistantMessage = NonNullable<ConstructorParameters<typeof AssistantMessageComponent>[0]>;
 export declare function validatedAssistantMessage(block: OwnedUiTranscriptBlock): PiAssistantMessage;
 export {};

package/dist/src/foundation/pi-component-adapter/shell-presenters-transcript.js

@@ -141,6 +141,39 @@ export function renderPiShellTranscriptBlock(block, width, cwd) {
     ensureTheme();
     return transcriptComponent(block, cwd, true).render(width);
 }
+/**
+ * Pinned Pi's CLI prints startup diagnostics with `reportDiagnostics` before
+ * the banner: the whole line, prefix included, in chalk's basic ANSI severity
+ * colour — not the theme's tokens — with info lines dim and unprefixed.
+ */
+export function renderPiShellStartupDiagnostic(diagnostic, width) {
+    ensureTheme();
+    const escape = String.fromCharCode(27);
+    const chalk = diagnostic.severity === "error"
+        ? { open: `${escape}[31m`, close: `${escape}[39m`, prefix: "Error: " }
+        : diagnostic.severity === "warning"
+            ? { open: `${escape}[33m`, close: `${escape}[39m`, prefix: "Warning: " }
+            : { open: `${escape}[2m`, close: `${escape}[22m`, prefix: "" };
+    return new Text(`${chalk.open}${chalk.prefix}${diagnostic.message}${chalk.close}`, 0, 0).render(width);
+}
+/**
+ * Pinned Pi's `showPackageUpdateNotification` banner: warning-coloured dynamic
+ * borders around a bold warning title, the muted update instruction with the
+ * accent command, and the package list.
+ */
+export function renderPiShellPackageUpdateNotice(packages, width) {
+    ensureTheme();
+    const theme = piTheme();
+    const container = new Container();
+    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", "Packages:")}\n`
+        + packages.map(name => `- ${name}`).join("\n"), 1, 0));
+    container.addChild(new DynamicBorder(text => theme.fg("warning", text)));
+    return container.render(width);
+}
 function transcriptComponent(block, cwd, expanded, extensions) {
     switch (block.kind) {
         case "user": {

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

@@ -1,4 +1,4 @@
-import { type AgentSessionRuntime, type SessionInfo } from "@earendil-works/pi-coding-agent";
+import { type AgentSessionRuntime, type AgentSessionServices, type SessionInfo } from "@earendil-works/pi-coding-agent";
 import { OWNED_UI_EXTENSION_CONTRACT_VERSION, OWNED_UI_EXTENSION_RENDER_CALLBACKS, OWNED_UI_EXTENSION_UI_CALLBACKS, OWNED_UI_EXTENSION_UI_PROPERTIES, type OwnedUiCommand, type OwnedUiCommandOutcome, type OwnedUiEvent, type OwnedUiSessionViewModel, type OwnedUiSnapshot } from "../owned-ui-contracts/index.js";
 import { type PiAuthenticationProviderOption, type PiBashWorkflowResult, type PiPinnedSettingsCallback, type PiPinnedSettingsSnapshot, type PiWorkflowAutocompleteCommand, type PiWorkflowHost, type PiWorkflowInteractionHost, type PiWorkflowOption, type PiWorkflowRequest, type PiWorkflowResult } from "./workflows.js";
 import type { AgentSettingsPort } from "../agent-engine-contracts/index.js";
@@ -51,6 +51,7 @@ export interface PiScopedModelsRefreshResult extends PiScopedModelsContext {
     readonly status: string;
     readonly statusKind: "success" | "warning";
 }
+type PiServicesApi = AgentSessionServices;
 export type PiEngineRuntimeFactory = (input: PiEngineRuntimeFactoryInput) => Promise<AgentSessionRuntime>;
 export interface OwnedPiResourceSummary {
     readonly kind: "skill" | "prompt-template" | "agent-context" | "system-prompt" | "theme";
@@ -90,6 +91,11 @@ export interface PiEngineAdapterOptions {
      * offering stay here.
      */
     readonly availableThemes?: () => readonly string[];
+    /**
+     * Startup extension-package update probe, mirroring pinned Pi's interactive
+     * mode. Returns display names of packages with updates available.
+     */
+    readonly checkPackageUpdates?: (settingsManager: PiServicesApi["settingsManager"]) => Promise<readonly string[]>;
 }
 export interface AdapterCommandResult {
     readonly outcome: OwnedUiCommandOutcome;
@@ -155,3 +161,4 @@ export declare class PiEngineAdapter {
     dispose(): Promise<void>;
 }
 export declare function createPiEngineAdapter(options?: PiEngineAdapterOptions): Promise<PiEngineAdapter>;
+export {};

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

@@ -4,7 +4,7 @@ import { tmpdir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { promisify } from "node:util";
 import { PRODUCT_IDENTITY } from "../../product-identity.js";
-import { copyToClipboard, getAgentDir, ProjectTrustStore, SessionManager, } from "@earendil-works/pi-coding-agent";
+import { copyToClipboard, DefaultPackageManager, getAgentDir, ProjectTrustStore, SessionManager, } from "@earendil-works/pi-coding-agent";
 import { OWNED_UI_EXTENSION_CONTRACT_VERSION, OWNED_UI_EXTENSION_RENDER_CALLBACKS, OWNED_UI_EXTENSION_UI_CALLBACKS, OWNED_UI_EXTENSION_UI_PROPERTIES, assertOwnedUiCommand, assertOwnedUiExtensionUiPort, assertOwnedUiSnapshot, } from "../owned-ui-contracts/index.js";
 import { PINNED_PI_SETTINGS_CALLBACKS, PINNED_PI_WORKFLOW_COMMAND_NAMES, } from "./workflows.js";
 import { createPiRuntimeIntegration } from "./runtime-integration.js";
@@ -19,6 +19,7 @@ const DEFAULT_SURFACE = {
 };
 export class PiEngineAdapter {
     #runtimeFactory;
+    #checkPackageUpdates;
     #cwd;
     #agentDir;
     #sessionId;
@@ -73,6 +74,10 @@ export class PiEngineAdapter {
         this.#agentDir = options.agentDir ?? getAgentDir();
         this.#sessionId = options.sessionId ?? "owned-session-1";
         this.#runtimeFactory = options.createRuntime ?? createDefaultPiRuntime;
+        this.#checkPackageUpdates = options.checkPackageUpdates
+            ?? (options.createRuntime
+                ? async () => []
+                : settingsManager => checkDefaultPiPackageUpdates(this.#cwd, this.#agentDir, settingsManager));
         this.#workflowHost = options.workflowHost ?? defaultWorkflowHost();
         this.#availableThemes = options.availableThemes ?? null;
         this.#workflowInteraction = { prompt: async () => null, notify() { } };
@@ -122,8 +127,25 @@ export class PiEngineAdapter {
         this.#editor = { ...this.#editor, submitEnabled: true };
         this.#emitEvent({ type: "session-lifecycle", lifecycle: "ready", reason: null });
         this.#emitView();
+        void this.#announcePackageUpdates(runtime.services.settingsManager);
         return this.view();
     }
+    async #announcePackageUpdates(settingsManager) {
+        if (process.env.PI_OFFLINE)
+            return;
+        let updates;
+        try {
+            updates = await this.#checkPackageUpdates(settingsManager);
+        }
+        catch {
+            return;
+        }
+        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.#emitView();
+    }
     onEvent(listener) {
         this.#listeners.add(listener);
         listener(this.#event({ type: "session-view", view: this.view() }));
@@ -1876,6 +1898,11 @@ export async function createPiEngineAdapter(options = {}) {
 async function createDefaultPiRuntime(input) {
     return createPiRuntimeIntegration({ cwd: input.cwd, agentDir: input.agentDir });
 }
+async function checkDefaultPiPackageUpdates(cwd, agentDir, settingsManager) {
+    const packageManager = new DefaultPackageManager({ cwd, agentDir, settingsManager });
+    const updates = await packageManager.checkForAvailableUpdates();
+    return updates.map(update => update.displayName);
+}
 function pinnedSessionInfoPresentation(value, sessionName, entries, modelRuntime) {
     const stats = isRecord(value) ? value : {};
     const tokens = dynamicObject(stats, "tokens");

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

@@ -1,4 +1,4 @@
-import { type AgentSession, type AgentSessionRuntime } from "@earendil-works/pi-coding-agent";
+import { type AgentSession, type AgentSessionRuntime, type AgentSessionServices, type ScopedModel } from "@earendil-works/pi-coding-agent";
 export interface PiRuntimeIntegrationOptions {
     readonly cwd: string;
     readonly agentDir: string;
@@ -10,9 +10,26 @@ export type PiSessionReplacement = {
     readonly kind: "resume";
     readonly sessionPath: string;
 };
+interface ConfiguredModelScope {
+    readonly scopedModels: readonly ScopedModel[];
+    readonly model: ScopedModel["model"] | undefined;
+    readonly thinkingLevel: ScopedModel["thinkingLevel"];
+    readonly diagnostics: readonly {
+        type: "info" | "warning" | "error";
+        message: string;
+    }[];
+}
+/**
+ * Mirrors pinned Pi's CLI startup: resolve the `models` patterns from settings
+ * into a scoped model list, keep the resolver's warnings (e.g. "No models match
+ * pattern ..."), and pick the same initial model pinned Pi would pick — the
+ * saved default when it is in scope, otherwise the first scoped model.
+ */
+export declare function resolveConfiguredModelScope(services: Pick<AgentSessionServices, "settingsManager" | "modelRuntime">): Promise<ConfiguredModelScope>;
 export declare function createPiRuntimeIntegration(options: PiRuntimeIntegrationOptions): Promise<AgentSessionRuntime>;
 export declare function bindPiRuntimeSession(runtime: AgentSessionRuntime, rebind: (session: AgentSession) => Promise<void>): () => void;
 export declare function replacePiRuntimeSession(runtime: AgentSessionRuntime, replacement: PiSessionReplacement): Promise<{
     readonly cancelled: boolean;
 }>;
 export declare function disposePiRuntimeIntegration(runtime: AgentSessionRuntime): Promise<void>;
+export {};

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

@@ -1,14 +1,49 @@
-import { createAgentSessionFromServices, createAgentSessionRuntime, createAgentSessionServices, SessionManager, } from "@earendil-works/pi-coding-agent";
+import { createAgentSessionFromServices, createAgentSessionRuntime, createAgentSessionServices, resolveModelScopeWithDiagnostics, SessionManager, } from "@earendil-works/pi-coding-agent";
+/**
+ * Mirrors pinned Pi's CLI startup: resolve the `models` patterns from settings
+ * into a scoped model list, keep the resolver's warnings (e.g. "No models match
+ * pattern ..."), and pick the same initial model pinned Pi would pick — the
+ * saved default when it is in scope, otherwise the first scoped model.
+ */
+export async function resolveConfiguredModelScope(services) {
+    const patterns = services.settingsManager.getEnabledModels();
+    if (!patterns || patterns.length === 0) {
+        return { scopedModels: [], model: undefined, thinkingLevel: undefined, diagnostics: [] };
+    }
+    const { scopedModels, diagnostics } = await resolveModelScopeWithDiagnostics([...patterns], services.modelRuntime, { signal: AbortSignal.timeout(15_000) });
+    let selected;
+    if (scopedModels.length > 0) {
+        const savedProvider = services.settingsManager.getDefaultProvider();
+        const savedModelId = services.settingsManager.getDefaultModel();
+        const savedModel = savedProvider && savedModelId
+            ? services.modelRuntime.getModel(savedProvider, savedModelId)
+            : undefined;
+        selected = (savedModel
+            ? scopedModels.find(scoped => scoped.model.provider === savedModel.provider && scoped.model.id === savedModel.id)
+            : undefined) ?? scopedModels[0];
+    }
+    return {
+        scopedModels,
+        model: selected?.model,
+        thinkingLevel: selected?.thinkingLevel,
+        diagnostics: diagnostics.map(diagnostic => ({ type: diagnostic.type, message: diagnostic.message })),
+    };
+}
 export async function createPiRuntimeIntegration(options) {
     const sessionManager = SessionManager.create(options.cwd, options.sessionDir ?? process.env.PI_CODING_AGENT_SESSION_DIR);
     const createRuntime = async ({ cwd, sessionManager: targetSessionManager, sessionStartEvent, }) => {
         const services = await createAgentSessionServices({ cwd, agentDir: options.agentDir });
+        const modelScope = await resolveConfiguredModelScope(services);
+        const hasExistingSession = targetSessionManager.buildSessionContext().messages.length > 0;
         const created = await createAgentSessionFromServices({
             services,
             sessionManager: targetSessionManager,
             ...(sessionStartEvent ? { sessionStartEvent } : {}),
+            ...(modelScope.model && !hasExistingSession ? { model: modelScope.model } : {}),
+            ...(modelScope.thinkingLevel && !hasExistingSession ? { thinkingLevel: modelScope.thinkingLevel } : {}),
+            ...(modelScope.scopedModels.length > 0 ? { scopedModels: [...modelScope.scopedModels] } : {}),
         });
-        return { ...created, services, diagnostics: services.diagnostics };
+        return { ...created, services, diagnostics: [...modelScope.diagnostics] };
     };
     return createAgentSessionRuntime(createRuntime, {
         cwd: options.cwd,

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, 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, piTheme, renderPiShellPackageUpdateNotice, renderPiShellStartupDiagnostic, renderPiShellStatusText, renderPiShellTranscriptBlock, } from "../pi-component-adapter/index.js";
 import { PiTuiRuntimeAdapter, } from "../pi-tui-runtime-adapter/index.js";
 export class OwnedUiSessionShellRoot {
     editor;
@@ -136,7 +136,17 @@ export class OwnedUiSessionShellRoot {
                 return ["", ...rows];
             return rows;
         });
-        const diagnosticRows = this.#view.diagnostics.slice(-3).flatMap(diagnostic => renderPiShellTranscriptBlock({
+        const diagnostics = this.#view.diagnostics;
+        const startupRows = diagnostics
+            .filter(diagnostic => diagnostic.code === "engine-startup")
+            .flatMap(diagnostic => renderPiShellStartupDiagnostic(diagnostic, width));
+        const packageUpdateRows = diagnostics
+            .filter(diagnostic => diagnostic.code === "package-updates")
+            .flatMap(diagnostic => renderPiShellPackageUpdateNotice(diagnostic.message.split("\n").filter(line => line.startsWith("- ")).map(line => line.slice(2)), width));
+        const diagnosticRows = diagnostics
+            .filter(diagnostic => diagnostic.code !== "engine-startup" && diagnostic.code !== "package-updates")
+            .slice(-3)
+            .flatMap(diagnostic => renderPiShellTranscriptBlock({
             id: `diagnostic-${diagnostic.sequence}`,
             kind: diagnostic.severity === "error" ? "error" : "system",
             status: "finalized",
@@ -149,9 +159,11 @@ export class OwnedUiSessionShellRoot {
         if (resourceRows.at(-1) === "")
             resourceRows.pop();
         return [
+            ...startupRows,
             ...(this.#extensionHeader ?? this.header).render(width),
             ...resourceRows,
             ...transcript,
+            ...packageUpdateRows,
             ...diagnosticRows,
         ];
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@timurproko/a1",
-  "version": "0.1.1-dev.11",
+  "version": "0.1.1-dev.12",
   "description": "Standalone terminal workspace for supervised native and managed agents",
   "type": "module",
   "packageManager": "npm@11.13.0",
@@ -46,7 +46,7 @@
     "start:sandbox": "npm run build && node scripts/dev-launch.mjs sandbox",
     "prepack": "node scripts/prepack-gate.mjs",
     "prepublishOnly": "npm run test:release",
-    "prepare": "npm run build",
+    "prepare": "node scripts/unify-pi-tui.mjs && npm run build",
     "update:pi-settings-metadata": "node scripts/update-pi-settings-metadata.mjs"
   },
   "dependencies": {