@astrofoundry/pi-astro 0.14.2 → 0.14.4

package/extensions/astro-welcome/art.ts

@@ -1,98 +1,92 @@
 import { fgBg, PALETTE, type RGB } from "./colors.ts";
 
-const _ = "·";
-const S = "S";
-const X = "X";
-const A = "A";
-const Y = "Y";
-const W = "W";
-const M = "M";
-const D = "D";
-const G = "G";
-const T = "T";
-const E = "E";
-const F = "F";
-const O = "O";
-const R = "R";
-
-type PaletteKey = typeof _ | typeof S | typeof X | typeof A | typeof Y | typeof W | typeof M | typeof D | typeof G | typeof T | typeof E | typeof F | typeof O | typeof R;
+type PaletteKey =
+    | "·"
+    | "S"
+    | "X"
+    | "A"
+    | "Y"
+    | "L"
+    | "H"
+    | "B"
+    | "V"
+    | "K"
+    | "W"
+    | "M"
+    | "D"
+    | "G"
+    | "T"
+    | "E"
+    | "F"
+    | "O"
+    | "R";
 
 const PIXEL_COLOR: Record<PaletteKey, RGB | null> = {
-    [_]: null,
-    [S]: PALETTE.suitLight,
-    [X]: PALETTE.suitMid,
-    [A]: PALETTE.suitShadow,
-    [Y]: PALETTE.suitTrim,
-    [W]: PALETTE.visorLow,
-    [M]: PALETTE.visorMid,
-    [D]: PALETTE.visorTop,
-    [G]: PALETTE.backpack,
-    [T]: PALETTE.earthBlue,
-    [E]: PALETTE.earthGreen,
-    [F]: PALETTE.flameYellow,
-    [O]: PALETTE.flameOrange,
-    [R]: PALETTE.flameRed,
+    "·": null,
+    S: PALETTE.suitLight,
+    X: PALETTE.suitMid,
+    A: PALETTE.suitShadow,
+    Y: PALETTE.suitTrim,
+    L: PALETTE.suitGoldHigh,
+    H: PALETTE.suitGoldShadow,
+    B: PALETTE.flagBlue,
+    V: PALETTE.voidBlack,
+    K: PALETTE.outline,
+    W: PALETTE.visorLow,
+    M: PALETTE.visorMid,
+    D: PALETTE.visorTop,
+    G: PALETTE.backpack,
+    T: PALETTE.earthBlue,
+    E: PALETTE.earthGreen,
+    F: PALETTE.flameYellow,
+    O: PALETTE.flameOrange,
+    R: PALETTE.flameRed,
 };
 
-const ASTRONAUT_FLOATING: readonly string[] = [
-    "··········SSSSSSSSSS··········",
-    "·······SSSSXXXXXXXXSSSS·······",
-    "·····SSXXMMMMMMMMMMMMXXSS·····",
-    "····SXMMDDDDDDDDDDDDDDMMSS····",
-    "···SXMDDDDWWDDDDDDWWDDDDMMS···",
-    "···SXMDDWWWWDDDDDDWWWWDDMMS···",
-    "···SXMDDDDDDDDDDDDDDDDDDMMS···",
-    "···SXMDDDDDDDDWWDDDDDDDDMMS···",
-    "····SXMMDDDDDDDDDDDDDDMMSS····",
-    "·····SSXXMMMMMMMMMMMMXXSS·····",
-    "·······SSXXXXXXXXXXXXSS·······",
-    "··········SXAAAAAAXSS·········",
-    "·······SSSSSSSSSSSSSSSS·······",
-    "······SSSSGGGGSSSSGGGGSSS·····",
-    "·····SSSSGGGGSSAAYAASSGGSSS···",
-    "·····SSGGGGSSSAYYYAASSGGGGS···",
-    "·····SSGGGSSSSAYAYASSSSGGGS···",
-    "·····SSGGGSSSSAAAASSSSSGGGS···",
-    "·····SSGGGSSSSSSSSSSSSGGGS····",
-    "······SSSSSSSSSSSSSSSSSS······",
-    "········SSAAAAAASSSSSSAAAA····",
-    "········SSSAAAASSSSAAAAS······",
-    "········SXXSSSSSSSXXXSS·······",
-    "·········SSSS·····SSSS········",
-    "··········SSS······SSS········",
-    "··········SS········SS········",
-];
-
-const ASTRONAUT_FLAG: readonly string[] = [
-    "··········SSSSSSSSSS··········",
-    "·······SSSSXXXXXXXXSSSS·······",
-    "·····SSXXMMMMMMMMMMMMXXSS·····",
-    "····SXMMDDDDDDDDDDDDDDMMSS····",
-    "···SXMDDDDWWDDDDDDWWDDDDMMS···",
-    "···SXMDDWWWWDDDDDDWWWWDDMMS···",
-    "···SXMDDDDDDDDDDDDDDDDDDMMS···",
-    "···SXMDDDDDDDDWWDDDDDDDDMMS···",
-    "····SXMMDDDDDDDDDDDDDDMMSS····",
-    "·····SSXXMMMMMMMMMMMMXXSS·····",
-    "·······SSXXXXXXXXXXXXSS·······",
-    "··········SXAAAAAAXSS·········",
-    "······YYYYYSSSSSSSSSSSSSS·····",
-    "······YYYYYSSGGGGSSSGGGGSSS···",
-    "······YYYYYSSGGGGSSSSGGGSS····",
-    "······YYYYYSSGGGSSSSSSGGGS····",
-    "······YYYYYSSGGSSSSSSSSGGS····",
-    "········SSSSSSSSSSSSSSSSSS····",
-    "········SSAAAAAASSSAAAASS·····",
-    "········SSSAAAASSSAAAAAS······",
-    "········SXXSSSSSSSXXXSS·······",
-    "·········SSSS·····SSSS········",
-    "··········SSS······SSS········",
-    "··········SS········SS········",
-    "·························E····",
-    "·························TT···",
+const ASTRONAUT_PORTRAIT: readonly string[] = [
+    "········································",
+    "···················YY···················",
+    "·················YYYYYY·················",
+    "··············YYYYYYYYYYYY··············",
+    "············YYYYYYYYYYYYYYYY············",
+    "··········YYYYYYYYYYYYYYYYYYYY··········",
+    "·········YYYYYYYYYYYYYYYYYYYYYY·········",
+    "········YYYYYYYYYYYYYYYYYYYYYYYY········",
+    "········YYYYYYKKKKKKKKKKKKYYYYYY········",
+    "········YYYYKKKKKKKKKKKKKKKKYYYY········",
+    "········YYYKKKKKKKKKKKKKKKKKKYYY········",
+    "········YYYKKKKKKKKKKKKKKKKKKYYY········",
+    "········YYYKKKKKKKKKKKKKKKKKKYYY········",
+    "········YYYKKKKKKKKKKKKKKKKKKYYY········",
+    "········YYYKKKKKKKKKKKKKKKKKKYYY········",
+    "········YYYYKKKKKKKKKKKKKKKKYYYY········",
+    "········YYYYYYKKKKKKKKKKKKYYYYYY········",
+    "········YYYYYYYYYYYYYYYYYYYYYYYY········",
+    "·········YYYYYYYYYYYYYYYYYYYYYY·········",
+    "··········YYYYYYYYYYYYYYYYYYYY··········",
+    "············YYYYYYYYYYYYYYYY············",
+    "··············YYYYYYYYYYYY··············",
+    "················YYYYYYYY················",
+    "················YYYYYYYY················",
+    "·············YYYYYYYYYYYYYY·············",
+    "··········YYYYYYYYYYYYYYYYYYYY··········",
+    "········YYYYYYYYYYYYYYYYYYYYYYYY········",
+    "······YYYYYYYYYYYYYYYYYYYYYYYYYYYY······",
+    "·····YYYYYYYYYYYYYYYYYYYYYYYYYYYYYY·····",
+    "····YYYYYYYYYYYYYYYYYYYYYYYBSYYYYYYY····",
+    "····YYYYYYYYYYYYYYYYYYYYYBSBBYYYYYYY····",
+    "····YYYYYYYYYYYYYYYYYYYBBBBBBYYYYYYY····",
+    "····YYYYYYYYYYYYYYYYYBBSBBBBBYYYYYYY····",
+    "····YYYYYYYYYYYYYYYBBBBBBBBBBYYYYYYY····",
+    "····YYYYYYYYYYYYYBBSBBBBBBBBBYYYYYYY····",
+    "····YYYYYYYYYYYBBBBBBBBBBBBBBYYYYYYY····",
+    "····YYYYYYYYYBBSBBBBBBBBBBBBBYYYYYYY····",
+    "····YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY····",
+    "···YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY···",
+    "··YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY··",
 ];
 
-export const VARIANTS = [ASTRONAUT_FLOATING, ASTRONAUT_FLAG] as const;
+export const VARIANTS = [ASTRONAUT_PORTRAIT] as const;
 
 export function pickVariant(seed: number): readonly string[] {
     const idx = Math.abs(seed) % VARIANTS.length;
@@ -121,5 +115,5 @@ export function renderArt(grid: readonly string[]): string[] {
     return rows;
 }
 
-export const ART_WIDTH = ASTRONAUT_FLOATING[0].length;
-export const ART_HEIGHT = Math.ceil(ASTRONAUT_FLOATING.length / 2);
+export const ART_WIDTH = ASTRONAUT_PORTRAIT[0].length;
+export const ART_HEIGHT = Math.ceil(ASTRONAUT_PORTRAIT.length / 2);

package/extensions/astro-welcome/colors.ts

@@ -16,10 +16,16 @@ export const PALETTE = {
     visorTop: [40, 80, 180] as const,
     visorMid: [80, 160, 240] as const,
     visorLow: [180, 220, 255] as const,
-    suitLight: [240, 240, 230] as const,
+    suitLight: [255, 255, 255] as const,
     suitMid: [200, 200, 195] as const,
     suitShadow: [120, 120, 130] as const,
-    suitTrim: [240, 200, 60] as const,
+    suitTrim: [254, 209, 0] as const,
+    suitGoldHigh: [255, 220, 110] as const,
+    suitGoldShadow: [200, 150, 30] as const,
+    flagBlue: [0, 51, 160] as const,
+    voidBlack: [10, 12, 30] as const,
+    outline: [22, 32, 64] as const,
+    highlight: [255, 255, 255] as const,
     backpack: [80, 80, 90] as const,
     earthBlue: [50, 110, 200] as const,
     earthGreen: [70, 160, 100] as const,

package/extensions/astro-welcome/compose.test.ts

@@ -6,6 +6,7 @@ const baseStats: WelcomeStats = {
     contextWindow: 1_000_000,
     extensionCount: 9,
     cavemanLevel: undefined,
+    pkgVersion: "0.14.2",
 };
 
 describe("composeWelcome", () => {
@@ -48,6 +49,16 @@ describe("composeWelcome", () => {
         expect(() => composeWelcome(40, 1, baseStats)).not.toThrow();
     });
 
+    it("renders the version subtitle when pkgVersion is provided", () => {
+        const lines = composeWelcome(120, 1, baseStats);
+        expect(lines.join("\n")).toContain("v0.14.2");
+    });
+
+    it("omits the version row when pkgVersion is undefined", () => {
+        const lines = composeWelcome(120, 1, { ...baseStats, pkgVersion: undefined });
+        expect(lines.join("\n")).not.toMatch(/v\d+\.\d+\.\d+/);
+    });
+
     it("produces deterministic output for the same seed", () => {
         const a = composeWelcome(120, 99, baseStats);
         const b = composeWelcome(120, 99, baseStats);

package/extensions/astro-welcome/compose.ts

@@ -9,6 +9,7 @@ export interface WelcomeStats {
     contextWindow: number | undefined;
     extensionCount: number;
     cavemanLevel: string | undefined;
+    pkgVersion: string | undefined;
 }
 
 const TITLE = "★ ASTRO PI ★";
@@ -69,10 +70,12 @@ class CompositeMask implements Mask {
 }
 
 export function composeWelcome(width: number, seed: number, stats: WelcomeStats): string[] {
-    const totalRows = ART_HEIGHT + 7;
+    const hasVersion = !!stats.pkgVersion;
+    const versionRow = 1;
+    const artStartRow = hasVersion ? 2 : 1;
+    const totalRows = artStartRow + ART_HEIGHT + 6;
     const safeWidth = Math.max(40, width);
     const artStartCol = Math.max(0, Math.floor((safeWidth - ART_WIDTH) / 2));
-    const artStartRow = 1;
 
     const mask = new CompositeMask(totalRows, safeWidth);
     mask.occupyArt(artStartRow, artStartCol, ART_HEIGHT, ART_WIDTH);
@@ -81,6 +84,13 @@ export function composeWelcome(width: number, seed: number, stats: WelcomeStats)
     const titlePlaced = centerInLine(titleLine, safeWidth);
     mask.occupy(0, titlePlaced.col, visibleWidth(titleLine));
 
+    let versionPlaced: { line: string; col: number } | null = null;
+    if (hasVersion) {
+        const versionLine = fg(PALETTE.hint, `v${stats.pkgVersion}`);
+        versionPlaced = centerInLine(versionLine, safeWidth);
+        mask.occupy(versionRow, versionPlaced.col, visibleWidth(versionLine));
+    }
+
     const taglineRaw = pickMessage(seed);
     const taglineLine = fg(PALETTE.tagline, taglineRaw);
     const taglineRow = artStartRow + ART_HEIGHT + 1;
@@ -106,6 +116,7 @@ export function composeWelcome(width: number, seed: number, stats: WelcomeStats)
         let line = stars[r] ?? " ".repeat(safeWidth);
 
         if (r === 0) line = overlay(line, titlePlaced.line, safeWidth);
+        if (versionPlaced && r === versionRow) line = overlay(line, versionPlaced.line, safeWidth);
         if (r === taglineRow) line = overlay(line, taglinePlaced.line, safeWidth);
         if (r === statsRow) line = overlay(line, statsPlaced.line, safeWidth);
         if (r === hintRow) line = overlay(line, hintPlaced.line, safeWidth);

package/extensions/astro-welcome/index.test.ts

@@ -23,7 +23,7 @@ interface FakeCtx {
     hasUI: boolean;
     cwd: string;
     model: { id: string; contextWindow: number } | undefined;
-    sessionManager: { getEntries: () => unknown[] };
+    sessionManager: { getEntries: () => unknown[]; getBranch: () => unknown[] };
     ui: {
         custom: ReturnType<typeof vi.fn>;
     };
@@ -75,7 +75,7 @@ function makeCtx(overrides: Partial<FakeCtx> = {}): FakeCtx & { _factory: Captur
         hasUI: true,
         cwd: "/Users/astro/proj",
         model: { id: "anthropic/claude-sonnet-4-6", contextWindow: 1_000_000 },
-        sessionManager: { getEntries: () => [] },
+        sessionManager: { getEntries: () => [], getBranch: () => [] },
         ui: { custom: customMock },
         get _factory() {
             return state.factory;
@@ -108,10 +108,12 @@ describe("astro-welcome extension", () => {
         expect(pi.handlers.before_agent_start).toBeDefined();
     });
 
-    it("session_start opens a centered overlay via ctx.ui.custom", async () => {
+    it("session_start opens a centered overlay via ctx.ui.custom (after a short delay)", async () => {
         const { pi } = await install();
         const ctx = makeCtx();
         await pi.handlers.session_start({}, ctx);
+        expect(ctx.ui.custom).not.toHaveBeenCalled();
+        vi.advanceTimersByTime(100);
         expect(ctx.ui.custom).toHaveBeenCalledTimes(1);
         const opts = ctx._factory!.options as { overlay: boolean; overlayOptions: { anchor: string } };
         expect(opts.overlay).toBe(true);
@@ -122,6 +124,35 @@ describe("astro-welcome extension", () => {
         const { pi } = await install();
         const ctx = makeCtx({ hasUI: false });
         await pi.handlers.session_start({}, ctx);
+        vi.advanceTimersByTime(100);
+        expect(ctx.ui.custom).not.toHaveBeenCalled();
+    });
+
+    it("does not show welcome a second time within the same process", async () => {
+        const { pi } = await install();
+        const ctx1 = makeCtx();
+        await pi.handlers.session_start({}, ctx1);
+        vi.advanceTimersByTime(100);
+        ctx1._factory!.component!.handleInput!("x");
+        await ctx1._factory!.settle;
+        const ctx2 = makeCtx();
+        await pi.handlers.session_start({}, ctx2);
+        vi.advanceTimersByTime(100);
+        expect(ctx2.ui.custom).not.toHaveBeenCalled();
+    });
+
+    it("skips welcome when session already has assistant activity (e.g. /reload mid-session)", async () => {
+        const { pi } = await install();
+        const ctx = makeCtx({
+            sessionManager: {
+                getBranch: () => [
+                    { type: "message", message: { role: "assistant" } },
+                ],
+                getEntries: () => [],
+            },
+        });
+        await pi.handlers.session_start({}, ctx);
+        vi.advanceTimersByTime(100);
         expect(ctx.ui.custom).not.toHaveBeenCalled();
     });
 
@@ -129,6 +160,7 @@ describe("astro-welcome extension", () => {
         const { pi } = await install();
         const ctx = makeCtx();
         await pi.handlers.session_start({}, ctx);
+        vi.advanceTimersByTime(100);
         const settle = ctx._factory!.settle;
         vi.advanceTimersByTime(6_000);
         await expect(settle).resolves.toBeUndefined();
@@ -138,24 +170,36 @@ describe("astro-welcome extension", () => {
         const { pi } = await install();
         const ctx = makeCtx();
         await pi.handlers.session_start({}, ctx);
+        vi.advanceTimersByTime(100);
         const settle = ctx._factory!.settle;
         ctx._factory!.component!.handleInput!("x");
         await expect(settle).resolves.toBeUndefined();
     });
 
-    it("dismisses on before_agent_start (external dismiss)", async () => {
+    it("dismisses on before_agent_start (external dismiss after mount)", async () => {
         const { pi } = await install();
         const ctx = makeCtx();
         await pi.handlers.session_start({}, ctx);
+        vi.advanceTimersByTime(100);
         const settle = ctx._factory!.settle;
         await pi.handlers.before_agent_start({ prompt: "hi" }, ctx);
         await expect(settle).resolves.toBeUndefined();
     });
 
+    it("before_agent_start fired during the 100ms mount-delay cancels the overlay entirely", async () => {
+        const { pi } = await install();
+        const ctx = makeCtx();
+        await pi.handlers.session_start({}, ctx);
+        await pi.handlers.before_agent_start({ prompt: "fast" }, ctx);
+        vi.advanceTimersByTime(200);
+        expect(ctx.ui.custom).not.toHaveBeenCalled();
+    });
+
     it("dismiss is idempotent — second trigger does not throw", async () => {
         const { pi } = await install();
         const ctx = makeCtx();
         await pi.handlers.session_start({}, ctx);
+        vi.advanceTimersByTime(100);
         ctx._factory!.component!.handleInput!("a");
         await ctx._factory!.settle;
         expect(() => ctx._factory!.component!.handleInput!("b")).not.toThrow();
@@ -166,6 +210,7 @@ describe("astro-welcome extension", () => {
         const { pi } = await install();
         const ctx = makeCtx();
         await pi.handlers.session_start({}, ctx);
+        vi.advanceTimersByTime(100);
         const lines = ctx._factory!.component!.render(120);
         const joined = lines.join("\n");
         expect(joined).toContain("ASTRO PI");
@@ -182,9 +227,11 @@ describe("astro-welcome extension", () => {
                 getEntries: () => [
                     { type: "custom", customType: "caveman-mode", data: { level: "ultra" } },
                 ],
+                getBranch: () => [],
             },
         });
         await pi.handlers.session_start({}, ctx);
+        vi.advanceTimersByTime(100);
         const lines = ctx._factory!.component!.render(120);
         expect(lines.join("\n")).toContain("caveman: ultra");
     });

package/extensions/astro-welcome/index.ts

@@ -1,10 +1,12 @@
 import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
 import { composeWelcome, type WelcomeStats } from "./compose.ts";
 import { ART_HEIGHT, ART_WIDTH } from "./art.ts";
+import { readPackageVersion } from "./version.ts";
 
 const DISMISS_AFTER_MS = 6_000;
+const MOUNT_DELAY_MS = 100;
 const OVERLAY_WIDTH = Math.max(ART_WIDTH + 30, 70);
-const OVERLAY_HEIGHT = ART_HEIGHT + 7;
+const OVERLAY_HEIGHT = ART_HEIGHT + 8;
 
 function readCavemanLevel(ctx: ExtensionContext): string | undefined {
     const entries = ctx.sessionManager.getEntries();
@@ -18,74 +20,106 @@ function readCavemanLevel(ctx: ExtensionContext): string | undefined {
     return undefined;
 }
 
+function hasSessionActivity(ctx: ExtensionContext): boolean {
+    for (const entry of ctx.sessionManager.getBranch()) {
+        if (entry.type === "message" && entry.message.role === "assistant") return true;
+    }
+    return false;
+}
+
 export default function astroWelcomeExtension(pi: ExtensionAPI): void {
+    let shownThisProcess = false;
     let externalDismiss: (() => void) | null = null;
+    let dismissedBeforeMount = false;
+    let pendingMount: ReturnType<typeof setTimeout> | null = null;
 
     pi.on("session_start", async (_event, ctx) => {
+        if (shownThisProcess) return;
         if (!ctx.hasUI) return;
+        if (hasSessionActivity(ctx)) return;
+        shownThisProcess = true;
 
         const seed = Date.now() & 0xffff_ffff;
+        let pkgVersion: string | undefined;
+        try {
+            pkgVersion = readPackageVersion();
+        } catch {
+            pkgVersion = undefined;
+        }
         const stats: WelcomeStats = {
             modelDisplay: ctx.model?.id,
             contextWindow: ctx.model?.contextWindow,
             extensionCount: pi.getAllTools().length,
             cavemanLevel: readCavemanLevel(ctx),
+            pkgVersion,
         };
 
-        let dismissed = false;
-        let timer: ReturnType<typeof setTimeout> | null = null;
+        dismissedBeforeMount = false;
 
-        ctx.ui
-            .custom(
-                (tui, _theme, _kb, done) => {
-                    const dismiss = (): void => {
-                        if (dismissed) return;
-                        dismissed = true;
-                        if (timer !== null) {
-                            clearTimeout(timer);
-                            timer = null;
-                        }
-                        externalDismiss = null;
-                        done(undefined);
-                    };
+        pendingMount = setTimeout(() => {
+            pendingMount = null;
+            if (dismissedBeforeMount) return;
 
-                    timer = setTimeout(dismiss, DISMISS_AFTER_MS);
-                    externalDismiss = dismiss;
+            let dismissed = false;
+            let timer: ReturnType<typeof setTimeout> | null = null;
 
-                    return {
-                        invalidate(): void {
-                            tui.requestRender();
-                        },
-                        render(width: number): string[] {
-                            return composeWelcome(width, seed, stats);
-                        },
-                        handleInput(): void {
-                            dismiss();
-                        },
-                        dispose(): void {
+            ctx.ui
+                .custom(
+                    (tui, _theme, _kb, done) => {
+                        const dismiss = (): void => {
+                            if (dismissed) return;
+                            dismissed = true;
                             if (timer !== null) {
                                 clearTimeout(timer);
                                 timer = null;
                             }
                             externalDismiss = null;
+                            done(undefined);
+                        };
+
+                        timer = setTimeout(dismiss, DISMISS_AFTER_MS);
+                        externalDismiss = dismiss;
+
+                        return {
+                            invalidate(): void {
+                                tui.requestRender();
+                            },
+                            render(width: number): string[] {
+                                return composeWelcome(width, seed, stats);
+                            },
+                            handleInput(): void {
+                                dismiss();
+                            },
+                            dispose(): void {
+                                if (timer !== null) {
+                                    clearTimeout(timer);
+                                    timer = null;
+                                }
+                                externalDismiss = null;
+                            },
+                        };
+                    },
+                    {
+                        overlay: true,
+                        overlayOptions: {
+                            anchor: "center",
+                            width: OVERLAY_WIDTH,
+                            maxHeight: OVERLAY_HEIGHT,
                         },
-                    };
-                },
-                {
-                    overlay: true,
-                    overlayOptions: {
-                        anchor: "center",
-                        width: OVERLAY_WIDTH,
-                        maxHeight: OVERLAY_HEIGHT,
                     },
-                },
-            )
-            .catch(() => {
-                /* overlay close errors are not fatal */
-            });
+                )
+                .catch(() => {
+                    /* overlay close errors are not fatal */
+                });
+        }, MOUNT_DELAY_MS);
     });
 
     pi.on("before_agent_start", async () => {
+        if (pendingMount !== null) {
+            clearTimeout(pendingMount);
+            pendingMount = null;
+            dismissedBeforeMount = true;
+        }
         externalDismiss?.();
     });
 }

package/extensions/astro-welcome/version.ts

@@ -0,0 +1,12 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const extensionDir = path.dirname(fileURLToPath(import.meta.url));
+const packageJsonPath = path.resolve(extensionDir, "..", "..", "package.json");
+
+export function readPackageVersion(): string | undefined {
+    const raw = fs.readFileSync(packageJsonPath, "utf8");
+    const pkg = JSON.parse(raw) as { version?: unknown };
+    return typeof pkg.version === "string" ? pkg.version : undefined;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrofoundry/pi-astro",
-  "version": "0.14.2",
+  "version": "0.14.4",
   "description": "Personal pi customizations (extensions, skills, prompts, themes) for the pi coding agent.",
   "keywords": [
     "pi-package"