omegon 0.7.3 → 0.7.5

package/extensions/00-splash/index.ts

@@ -43,10 +43,19 @@ export interface SplashItem {
   state: "hidden" | "pending" | "active" | "done" | "failed";
 }
 
+export interface QueuedNotification {
+  message: string;
+  type: "info" | "warning" | "error";
+}
+
 export interface SplashState {
   items: SplashItem[];
   /** Set to true when all session_start hooks have returned */
   loadingComplete: boolean;
+  /** True while splash is displayed — notifications should be queued */
+  active: boolean;
+  /** Queued notifications to flush after splash dismissal */
+  notificationQueue: QueuedNotification[];
 }
 
 function getSharedState(): SplashState {
@@ -61,6 +70,8 @@ function getSharedState(): SplashState {
         { label: "tools",      state: "pending" },
       ],
       loadingComplete: false,
+      active: true,
+      notificationQueue: [],
     };
     (globalThis as any)[SPLASH_KEY] = state;
   }
@@ -111,6 +122,7 @@ class SplashHeader implements Component {
   private onTransition: (() => void) | null = null;
   private cachedLines: string[] | undefined;
   private cachedWidth: number | undefined;
+  private promptBlink = false;
 
   private markRows: number;
   private logoWidth: number;
@@ -128,6 +140,21 @@ class SplashHeader implements Component {
     this.timer = setInterval(() => this.tick(), FRAME_INTERVAL_MS);
   }
 
+  /** Called externally (e.g. on keypress) to dismiss the splash. */
+  dismiss(): void {
+    if (this.transitioned) return;
+    this.transitioned = true;
+    this.dispose();
+    this.onTransition?.();
+    this.onTransition = null;
+  }
+
+  /** True when the animation is done and loading is complete — ready for dismissal. */
+  get readyToDismiss(): boolean {
+    const state = getSharedState();
+    return this.animDone && this.holdCount >= HOLD_FRAMES && state.loadingComplete;
+  }
+
   private tick(): void {
     this.frame++;
     this.scanFrame = (this.scanFrame + 1) % SCAN_FRAMES.length;
@@ -139,13 +166,9 @@ class SplashHeader implements Component {
 
     if (this.animDone && !this.transitioned) {
       this.holdCount++;
-      const state = getSharedState();
-      if (this.holdCount >= HOLD_FRAMES && state.loadingComplete) {
-        this.transitioned = true;
-        this.dispose();
-        this.onTransition?.();
-        this.onTransition = null; // prevent double-fire
-        return;
+      // Blink the "press any key" prompt every ~500ms (10 frames at 50ms)
+      if (this.readyToDismiss && this.holdCount % 10 === 0) {
+        this.promptBlink = !this.promptBlink;
       }
     }
 
@@ -178,6 +201,15 @@ class SplashHeader implements Component {
       lines.push(""); // spacer
       const checklistLines = this.renderChecklist(width);
       lines.push(...checklistLines);
+
+      // "Press any key" prompt when ready
+      if (this.readyToDismiss) {
+        lines.push(""); // spacer
+        const prompt = "press any key to continue";
+        const promptPad = Math.max(0, Math.floor((width - prompt.length) / 2));
+        const promptColor = this.promptBlink ? DIM : PRIMARY;
+        lines.push(" ".repeat(promptPad) + `${promptColor}${prompt}${RESET}`);
+      }
     }
 
     lines.push(""); // bottom spacer
@@ -460,8 +492,48 @@ export default function splashExtension(pi: ExtensionAPI): void {
     const canFitCompact = termWidth >= COMPACT_LINE_WIDTH + 4 && termRows >= COMPACT_LOGO_LINES.length + 6;
     const canFitWordmark = termWidth >= LINE_WIDTH + 4 && termRows >= WORDMARK_LINES.length + 6;
 
+    // -----------------------------------------------------------------------
+    // Notification queueing — intercept ctx.ui.notify while splash is active
+    // -----------------------------------------------------------------------
+    const state = getSharedState();
+    const originalNotify = ctx.ui.notify.bind(ctx.ui);
+    ctx.ui.notify = (message: string, type?: "info" | "warning" | "error") => {
+      if (state.active) {
+        state.notificationQueue.push({ message, type: type ?? "info" });
+      } else {
+        originalNotify(message, type);
+      }
+    };
+
+    /** Flush queued notifications and restore original notify. */
+    const flushAndRestore = () => {
+      state.active = false;
+      ctx.ui.notify = originalNotify;
+      for (const n of state.notificationQueue) {
+        originalNotify(n.message, n.type);
+      }
+      state.notificationQueue.length = 0;
+    };
+
+    // -----------------------------------------------------------------------
+    // Splash header setup
+    // -----------------------------------------------------------------------
+    let activeSplash: SplashHeader | null = null;
+
+    const dismissSplash = () => {
+      if (!activeSplash) return;
+      activeSplash.dismiss();
+      activeSplash = null;
+      if (unsubInput) { unsubInput(); unsubInput = null; }
+      flushAndRestore();
+    };
+
+    let unsubInput: (() => void) | null = null;
+
     if (!canFitCompact && !canFitWordmark) {
-      // Too small for any animation — minimal branded header
+      // Too small for any animation — minimal branded header, no splash gate
+      state.active = false;
+      ctx.ui.notify = originalNotify;
       ctx.ui.setHeader(() => new BrandedHeader(version));
     } else {
       let artLines: string[];
@@ -484,10 +556,21 @@ export default function splashExtension(pi: ExtensionAPI): void {
         const splash = new SplashHeader(tui, () => {
           // Transition to minimal branded header
           ctx.ui.setHeader((_, _t) => new BrandedHeader(version));
+          flushAndRestore();
         }, artLines, markRows, logoWidth);
         splash.start();
+        activeSplash = splash;
         return splash;
       });
+
+      // Listen for any keypress to dismiss splash once ready
+      unsubInput = ctx.ui.onTerminalInput((data) => {
+        if (activeSplash?.readyToDismiss && data) {
+          dismissSplash();
+          return { consume: true };
+        }
+        return undefined;
+      });
     }
 
     // Poll shared state to detect when all subsystems have reported.
@@ -503,17 +586,19 @@ export default function splashExtension(pi: ExtensionAPI): void {
       }
     }, FRAME_INTERVAL_MS);
 
-    // Safety timeout — don't hold splash forever if an extension never reports.
-    // 3s is generous; most startups complete in <2s.
+    // Safety timeout — if an extension never reports done, force the checklist
+    // to complete so the "press any key" prompt appears. Does NOT auto-dismiss;
+    // the user must press a key.
     const safetyTimer = setTimeout(() => {
       clearInterval(pollTimer);
       splashDone();
-    }, 3000);
+    }, 5000);
 
     // Clean up on early session exit to prevent timer leaks
     pi.on("session_shutdown", async () => {
       clearInterval(pollTimer);
       clearTimeout(safetyTimer);
+      if (activeSplash) dismissSplash();
     });
   });
 }

package/extensions/bootstrap/index.ts

@@ -470,11 +470,18 @@ function restartOmegon(): never {
 		'  [ "$_w" -ge 50 ] && break',
 		"done",
 		// Extra grace period for fd/terminal release
-		"sleep 0.2",
-		// Full terminal protocol reset — stty sane only resets line discipline,
-		// not terminal protocol state (kitty keyboard, bracketed paste, cursor, SGR)
-		"printf '\\033[<u\\033[>4;0m\\033[?2004l\\033[?25h\\033[0m\\033[r' 2>/dev/null",
+		"sleep 0.3",
+		// Hard terminal reset: RIS (Reset to Initial State) clears ALL protocol
+		// state — kitty keyboard protocol, bracketed paste, mouse tracking,
+		// modifyOtherKeys, SGR, scroll regions, alternate screen, everything.
+		// This is what `reset` does internally and has worked since the VT100.
+		"printf '\\033c' 2>/dev/null",
 		"stty sane 2>/dev/null",
+		// `reset` as belt-and-suspenders — reinitializes terminfo state.
+		// Some terminals (Kitty) maintain protocol state that RIS alone
+		// doesn't fully clear; reset queries terminfo and sends the full
+		// initialization sequence for the current TERM.
+		"reset 2>/dev/null",
 		// Clean up this script
 		`rm -f "${script}"`,
 		// Replace this shell with new omegon
@@ -484,26 +491,17 @@ function restartOmegon(): never {
 	// Reset terminal to cooked mode BEFORE exiting so the restart script
 	// (and the user) aren't stuck with raw-mode terminal if something goes wrong.
 	try {
-		// Full terminal protocol teardown: pop kitty keyboard protocol,
-		// disable modifyOtherKeys, disable bracketed paste, show cursor,
-		// reset SGR attributes, and clear any pending scroll region.
-		process.stdout.write(
-			"\x1b[<u" +        // Pop kitty keyboard protocol flags
-			"\x1b[>4;0m" +     // Disable modifyOtherKeys
-			"\x1b[?2004l" +    // Disable bracketed paste
-			"\x1b[?25h" +      // Show cursor
-			"\x1b[0m" +        // Reset all SGR attributes
-			"\x1b[r"           // Reset scroll region to full screen
-		);
+		// RIS (Reset to Initial State) — the only reliable way to ensure ALL
+		// terminal protocol state is cleared. Selective escape sequences are
+		// fragile and miss features we don't know about.
+		process.stdout.write("\x1bc");
 		// Pause stdin to prevent buffered input from being re-interpreted
 		// after raw mode is disabled (prevents Ctrl+D from closing parent shell).
 		process.stdin.pause();
 		if (process.stdin.isTTY && typeof process.stdin.setRawMode === "function") {
 			process.stdin.setRawMode(false);
 		}
-		// Also reset via stty — timeout guards against blocking on contested stdin.
-		// Use /dev/null for stdout/stderr to prevent any stray output (including
-		// terminal bells) from reaching the user's terminal during the transition.
+		// stty sane resets line discipline to known-good state.
 		spawnSync("stty", ["sane"], { stdio: ["inherit", "ignore", "ignore"], timeout: 2000 });
 	} catch { /* best-effort */ }
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "omegon",
-	"version": "0.7.3",
+	"version": "0.7.5",
 	"description": "Omegon — an opinionated distribution of pi (by Mario Zechner) with extensions for lifecycle management, memory, orchestration, and visualization",
 	"bin": {
 		"omegon": "bin/omegon.mjs",