omegon 0.10.1 → 0.10.3

package/bin/omegon.mjs

@@ -135,20 +135,31 @@ function purgeSelfReferentialPackages() {
 }
 purgeSelfReferentialPackages();
 
-process.argv = injectBundledResourceArgs(process.argv);
-
 // ---------------------------------------------------------------------------
-// Pre-import splash — show a simple loading indicator while the module graph
-// resolves. The TUI takes over once interactive mode starts.
+// CLI launch — subprocess with restart-loop support.
+//
+// Instead of importing the CLI directly (which makes restart impossible since
+// Node can't replace its own process image), we spawn it as a child process.
+// If the child exits with code 75 (EX_TEMPFAIL), we re-spawn — this is the
+// restart signal from /update and /restart commands.
+//
+// This keeps the wrapper as the foreground process group leader throughout,
+// so the re-spawned CLI always owns the terminal and can receive input.
 // ---------------------------------------------------------------------------
+import { spawn as nodeSpawn } from "node:child_process";
+
+const RESTART_EXIT_CODE = 75;
+
+const cliArgs = injectBundledResourceArgs(process.argv).slice(2);
+
 const isInteractive = process.stdout.isTTY &&
   !process.argv.includes("-p") &&
   !process.argv.includes("--print") &&
   !process.argv.includes("--help") &&
   !process.argv.includes("-h");
 
-let preImportCleanup;
-if (isInteractive) {
+function showPreImportSpinner() {
+  if (!isInteractive) return undefined;
   const PRIMARY = "\x1b[38;2;42;180;200m";
   const DIM = "\x1b[38;2;64;88;112m";
   const RST = "\x1b[0m";
@@ -157,9 +168,8 @@ if (isInteractive) {
   const spinner = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
   let frame = 0;
 
-  // Safety net: restore cursor on any exit path (crash, SIGTERM, etc.)
   const restoreCursor = () => { try { process.stdout.write(SHOW_CURSOR); } catch {} };
-  process.on('exit', restoreCursor);
+  process.on("exit", restoreCursor);
 
   process.stdout.write(HIDE_CURSOR);
   process.stdout.write(`\n  ${PRIMARY}omegon${RST} ${DIM}loading…${RST}`);
@@ -170,16 +180,52 @@ if (isInteractive) {
     frame++;
   }, 80);
 
-  preImportCleanup = () => {
+  return () => {
     clearInterval(spinTimer);
-    process.removeListener('exit', restoreCursor);
-    // Clear the loading line and restore cursor
+    process.removeListener("exit", restoreCursor);
     process.stdout.write(`\r\x1b[2K${SHOW_CURSOR}`);
   };
 }
 
-try {
-  await import(cli);
-} finally {
-  preImportCleanup?.();
+function launchCli() {
+  return new Promise((resolve) => {
+    const cleanup = showPreImportSpinner();
+
+    const child = nodeSpawn(process.execPath, [cli, ...cliArgs], {
+      stdio: "inherit",
+      env: process.env,
+    });
+
+    // Let the child handle SIGINT (Ctrl+C) — the wrapper ignores it.
+    const ignoreInt = () => {};
+    process.on("SIGINT", ignoreInt);
+    // Forward SIGTERM so graceful shutdown works.
+    const fwdTerm = () => child.kill("SIGTERM");
+    process.on("SIGTERM", fwdTerm);
+
+    // Clean up spinner once the child's TUI takes over. The child will
+    // clear the screen on startup anyway, but a brief delay ensures the
+    // spinner doesn't flicker.
+    if (cleanup) {
+      setTimeout(() => cleanup(), 200);
+    }
+
+    child.on("exit", (code, signal) => {
+      process.removeListener("SIGINT", ignoreInt);
+      process.removeListener("SIGTERM", fwdTerm);
+      if (signal) {
+        // Re-raise the signal so the wrapper exits with the right status
+        process.kill(process.pid, signal);
+      }
+      resolve(code ?? 1);
+    });
+  });
 }
+
+// Main loop — restart on exit code 75
+let exitCode;
+do {
+  exitCode = await launchCli();
+} while (exitCode === RESTART_EXIT_CODE);
+
+process.exit(exitCode);

package/extensions/bootstrap/index.ts

@@ -25,7 +25,7 @@ import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { homedir, tmpdir } from "node:os";
 import type { ExtensionAPI } from "@styrene-lab/pi-coding-agent";
-import { resolveOmegonSubprocess } from "../lib/omegon-subprocess.ts";
+
 import { checkAllProviders, type AuthResult } from "../01-auth/auth.ts";
 import { loadPiConfig } from "../lib/model-preferences.ts";
 import {
@@ -436,101 +436,18 @@ export default function (pi: ExtensionAPI) {
  * exit and release the terminal), then exec's the new Omegon. This avoids
  * two TUI processes fighting over the same terminal simultaneously.
  */
+/**
+ * Restart Omegon by exiting with code 75.
+ *
+ * The bin/omegon.mjs wrapper runs the CLI in a subprocess loop. When it sees
+ * exit code 75 (EX_TEMPFAIL), it re-spawns a fresh CLI process. Because the
+ * wrapper stays as the foreground process group leader throughout, the new
+ * CLI always owns the terminal and can receive input — no detached spawn,
+ * no competing with the shell for stdin.
+ */
 function restartOmegon(): never {
-	const { command, argvPrefix } = resolveOmegonSubprocess();
-	const userArgs = process.argv.slice(2).filter(a =>
-		!a.startsWith("--extensions-dir=") &&
-		!a.startsWith("--themes-dir=") &&
-		!a.startsWith("--skills-dir=") &&
-		!a.startsWith("--prompts-dir=") &&
-		!a.startsWith("--extension=") && !a.startsWith("--extension ") &&
-		!a.startsWith("--skill=") && !a.startsWith("--skill ") &&
-		!a.startsWith("--prompt-template=") && !a.startsWith("--prompt-template ") &&
-		!a.startsWith("--theme=") && !a.startsWith("--theme ") &&
-		!a.startsWith("--no-skills") &&
-		!a.startsWith("--no-prompt-templates") &&
-		!a.startsWith("--no-themes") &&
-		!a.startsWith("--no-extensions")
-	);
-
-	const parts = [command, ...argvPrefix, ...userArgs].map(shellEscape);
-	const script = join(tmpdir(), `omegon-restart-${process.pid}.sh`);
-	const oldPid = process.pid;
-	writeFileSync(script, [
-		"#!/bin/sh",
-		// Trap signals so Ctrl+C works; ignore HUP so parent death doesn't kill us
-		"trap 'stty sane 2>/dev/null; exit 130' INT TERM",
-		"trap '' HUP",
-		// Wait for the old process to fully die (poll with timeout)
-		"_w=0",
-		`while kill -0 ${oldPid} 2>/dev/null; do`,
-		"  sleep 0.1",
-		"  _w=$((_w + 1))",
-		// Bail after ~5 seconds — proceed anyway
-		'  [ "$_w" -ge 50 ] && break',
-		"done",
-		// Extra grace period for fd/terminal release
-		"sleep 0.3",
-		// Hard terminal reset via /dev/tty — avoids stdout buffering that
-		// bleeds into the exec'd process. RIS clears all protocol state
-		// (kitty keyboard protocol, bracketed paste, mouse tracking, etc.).
-		// Do NOT use `reset` here — it outputs terminfo init strings to
-		// stdout which the new TUI interprets as input (causing stray
-		// characters and double renders).
-		"printf '\\033c' >/dev/tty 2>/dev/null",
-		"stty sane 2>/dev/null",
-		// Clean up this script
-		`rm -f "${script}"`,
-		// Replace this shell with new omegon
-		`exec ${parts.join(" ")}`,
-	].join("\n") + "\n", { mode: 0o755 });
-
-	// 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 {
-		// RIS (Reset to Initial State) — the only reliable way to ensure ALL
-		// terminal protocol state is cleared. Write directly to the TTY fd
-		// to bypass pi's TUI layer which intercepts process.stdout and would
-		// mangle the escape sequence into visible ANSI garbage.
-		const { openSync, writeSync, closeSync } = require("fs") as typeof import("fs");
-		let ttyFd = -1;
-		try {
-			ttyFd = openSync("/dev/tty", "w");
-			writeSync(ttyFd, "\x1bc");
-			closeSync(ttyFd);
-		} catch {
-			// Fallback if /dev/tty isn't available (shouldn't happen on macOS/Linux)
-			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);
-		}
-		// stty sane resets line discipline to known-good state.
-		spawnSync("stty", ["sane"], { stdio: ["inherit", "ignore", "ignore"], timeout: 2000 });
-	} catch { /* best-effort */ }
-
-	// Spawn restart script detached (survives parent exit) but with SIGHUP
-	// ignored in the script so process-group teardown doesn't kill it.
-	// detached: true puts it in its own process group; the script's signal
-	// traps ensure Ctrl+C still works once the new omegon exec's.
-	const child = spawn("sh", [script], {
-		stdio: "inherit",
-		detached: true,
-		env: process.env,
-	});
-	child.unref();
-
-	// Clean exit — the script waits for us to die before starting new omegon
-	process.exit(0);
-}
-
-/** Escape a string for POSIX shell */
-function shellEscape(s: string): string {
-	if (/^[a-zA-Z0-9_./:=-]+$/.test(s)) return s;
-	return `'${s.replace(/'/g, "'\\''")}'`;
+	const RESTART_EXIT_CODE = 75;
+	process.exit(RESTART_EXIT_CODE);
 }
 
 /** Run a command, collect stdout+stderr, resolve with exit code. */

package/extensions/sermon-widget.ts

@@ -23,8 +23,8 @@ import { SERMON } from "./sermon.js";
 const CHAR_INTERVAL_MS = 67;
 const WORD_PAUSE_MS = 120;
 
-/** Maximum visible characters on the scrawl line. */
-const MAX_VISIBLE = 72;
+/** Minimum visible characters (floor for very narrow terminals). */
+const MIN_VISIBLE = 40;
 
 // Glitch vocabulary — borrowed from the splash CRT noise aesthetic
 const NOISE_CHARS = "▓▒░█▄▀▌▐▊▋▍▎▏◆■□▪◇┼╬╪╫";
@@ -40,15 +40,18 @@ const COMBINING_GLITCH = [
 // Sermon palette — much dimmer than the spinner verb.
 // The sermon is background thought, not actionable signal.
 // Base text is near the noise floor; glitch accents stay subdued.
+// IMPORTANT: glitch colors must return to SERMON_DIM, never RESET (which
+// snaps to terminal default — often bright white, causing flash).
 const SERMON_DIM   = "\x1b[38;2;50;55;65m";     // #323741 — barely visible
-const GLITCH_GLYPH = "\x1b[38;2;55;75;90m";     // #374b5a — noise glyphs, slightly brighter
-const GLITCH_COLOR = "\x1b[38;2;30;100;115m";    // #1e6473 — muted teal shimmer
-const RESET        = "\x1b[0m";
+const GLITCH_GLYPH = "\x1b[38;2;55;70;80m";     // #374650 — noise glyphs, only slightly above base
+const GLITCH_COLOR = "\x1b[38;2;45;80;90m";      // #2d505a — very muted teal, close to base
+const RESET_TO_DIM = SERMON_DIM;                  // return to base after glitch, never full reset
+const RESET        = "\x1b[0m";                   // only for end-of-line
 
-// Glitch probabilities per character per render
-const P_SUBSTITUTE = 0.03;
-const P_COLOR      = 0.05;
-const P_COMBINING  = 0.015;
+// Glitch probabilities per character per render — kept subtle
+const P_SUBSTITUTE = 0.02;
+const P_COLOR      = 0.035;
+const P_COMBINING  = 0.01;
 
 function randomFrom<T>(arr: readonly T[] | string): T | string {
   return arr[Math.floor(Math.random() * arr.length)];
@@ -60,14 +63,14 @@ function glitchChar(ch: string): string {
 
   const r = Math.random();
 
-  // Substitution — replace with noise glyph, slightly brighter than base
+  // Substitution — replace with noise glyph, only slightly above base
   if (r < P_SUBSTITUTE) {
-    return GLITCH_GLYPH + randomFrom(NOISE_CHARS) + RESET;
+    return GLITCH_GLYPH + randomFrom(NOISE_CHARS) + RESET_TO_DIM;
   }
 
-  // Color shimmer — subdued teal flicker
+  // Color shimmer — very muted teal, not a flash
   if (r < P_SUBSTITUTE + P_COLOR) {
-    return GLITCH_COLOR + ch + RESET;
+    return GLITCH_COLOR + ch + RESET_TO_DIM;
   }
 
   // Combining diacritics — corruption overlay at base dim
@@ -93,9 +96,9 @@ export function createSermonWidget(
     cursor = (cursor + 1) % SERMON.length;
     revealed += ch;
 
-    // Sliding window — keep only the tail
-    if (revealed.length > MAX_VISIBLE) {
-      revealed = revealed.slice(revealed.length - MAX_VISIBLE);
+    // Sliding window — keep a generous buffer; render() trims to actual width
+    if (revealed.length > 300) {
+      revealed = revealed.slice(revealed.length - 300);
     }
 
     tui.requestRender();
@@ -111,7 +114,8 @@ export function createSermonWidget(
 
   return {
     render(width: number): string[] {
-      const maxW = Math.min(MAX_VISIBLE, width - 4);
+      // Use full terminal width minus a small indent (2 chars)
+      const maxW = Math.max(MIN_VISIBLE, width - 4);
       const visible = revealed.length > maxW
         ? revealed.slice(revealed.length - maxW)
         : revealed;