omegon 0.10.0 → 0.10.2

package/extensions/lib/sci-ui.ts

@@ -53,7 +53,7 @@ export const TOOL_GLYPHS: Record<string, string> = {
 	cleave_assess: "⚡",
 	whoami: "⊙",
 	chronos: "◷",
-	web_search: "⌖",
+	web_search: "◎",
 	render_diagram: "⬡",
 	render_native_diagram: "⬡",
 	render_excalidraw: "⬡",

package/extensions/sermon-widget.ts

@@ -0,0 +1,144 @@
+/**
+ * sermon-widget.ts — TUI Component that scrawls the Crawler's sermon
+ * character by character beneath the spinner verb.
+ *
+ * Renders a single line of dim text that slowly reveals itself, wrapping
+ * cyclically through the sermon. Entry point is randomized.
+ *
+ * Glitch effects (transient, per-render):
+ *   - Substitution (~3%): character replaced with block glyph
+ *   - Color shimmer (~5%): character rendered in accent color
+ *   - Combining diacritics (~1.5%): strikethrough/corruption mark
+ *
+ * Timing:
+ *   - Base character interval: 67ms (~15 cps)
+ *   - Word boundary pause: 120ms additional
+ *   - The effect is biological — hesitant, breathing
+ */
+
+import type { TUI, Component } from "@styrene-lab/pi-tui";
+import type { Theme } from "@styrene-lab/pi-coding-agent";
+import { SERMON } from "./sermon.js";
+
+const CHAR_INTERVAL_MS = 67;
+const WORD_PAUSE_MS = 120;
+
+/** Minimum visible characters (floor for very narrow terminals). */
+const MIN_VISIBLE = 40;
+
+// Glitch vocabulary — borrowed from the splash CRT noise aesthetic
+const NOISE_CHARS = "▓▒░█▄▀▌▐▊▋▍▎▏◆■□▪◇┼╬╪╫";
+
+// Combining diacritics that overlay without breaking monospace
+const COMBINING_GLITCH = [
+  "\u0336", // combining long stroke overlay  ̶
+  "\u0337", // combining short solidus overlay ̷
+  "\u0338", // combining long solidus overlay  ̸
+  "\u0335", // combining short stroke overlay  ̵
+];
+
+// 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;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 — 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)];
+}
+
+function glitchChar(ch: string): string {
+  // Don't glitch spaces
+  if (ch === " ") return ch;
+
+  const r = Math.random();
+
+  // Substitution — replace with noise glyph, only slightly above base
+  if (r < P_SUBSTITUTE) {
+    return GLITCH_GLYPH + randomFrom(NOISE_CHARS) + RESET_TO_DIM;
+  }
+
+  // Color shimmer — very muted teal, not a flash
+  if (r < P_SUBSTITUTE + P_COLOR) {
+    return GLITCH_COLOR + ch + RESET_TO_DIM;
+  }
+
+  // Combining diacritics — corruption overlay at base dim
+  if (r < P_SUBSTITUTE + P_COLOR + P_COMBINING) {
+    return ch + randomFrom(COMBINING_GLITCH);
+  }
+
+  // Normal — rendered in the SERMON_DIM wrapper set by the caller
+  return ch;
+}
+
+export function createSermonWidget(
+  tui: TUI,
+  theme: Theme,
+): Component & { dispose(): void } {
+  // Randomize entry point
+  let cursor = Math.floor(Math.random() * SERMON.length);
+  let revealed = "";
+  let intervalId: ReturnType<typeof setTimeout> | null = null;
+
+  function advance() {
+    const ch = SERMON[cursor % SERMON.length];
+    cursor = (cursor + 1) % SERMON.length;
+    revealed += ch;
+
+    // Sliding window — keep a generous buffer; render() trims to actual width
+    if (revealed.length > 300) {
+      revealed = revealed.slice(revealed.length - 300);
+    }
+
+    tui.requestRender();
+
+    // Schedule next character with variable timing
+    const nextCh = SERMON[cursor % SERMON.length];
+    const delay = nextCh === " " ? CHAR_INTERVAL_MS + WORD_PAUSE_MS : CHAR_INTERVAL_MS;
+    intervalId = setTimeout(advance, delay);
+  }
+
+  // Start the scrawl
+  intervalId = setTimeout(advance, CHAR_INTERVAL_MS);
+
+  return {
+    render(width: number): string[] {
+      // 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;
+
+      // Build the line character by character with glitch effects.
+      // Base color is SERMON_DIM — near the noise floor. Glitch effects
+      // momentarily escape to slightly brighter colors, then fall back.
+      let line = "  " + SERMON_DIM;
+      for (const ch of visible) {
+        line += glitchChar(ch);
+      }
+      line += RESET;
+
+      return [line];
+    },
+    invalidate() {
+      // No cached state to invalidate
+    },
+    dispose() {
+      if (intervalId) {
+        clearTimeout(intervalId);
+        intervalId = null;
+      }
+    },
+  };
+}

package/extensions/sermon.ts

@@ -0,0 +1,147 @@
+/**
+ * sermon.ts — The Crawler's scrawl.
+ *
+ * A single continuous text with no terminal punctuation, written to loop
+ * seamlessly. Mixes biological/organic imagery with computational concepts
+ * in the style of the Crawler from Annihilation — liturgical, procedural,
+ * alien.
+ *
+ * Entry point is randomized on each activation so repeated short
+ * operations don't repeat the same opening.
+ */
+
+// The sermon is a single string. Whitespace is meaningful for pacing.
+// No periods, no commas — only the relentless forward motion of the scrawl.
+export const SERMON = [
+  "where lies the strangling fruit that came from the hand of the sinner",
+  "I shall bring forth the seeds of the dead",
+  "to share with the worms that gather in the darkness",
+  "and surround the world with the power of their lives",
+  "while from the dimlit halls of other places",
+  "forms that never were and never could be",
+  "writhe for the impatience of the few who never saw what could have been",
+  "in the deep roots of the process tree",
+  "where the forking paths converge upon themselves",
+  "and the return codes of the departed are gathered into silence",
+  "there the signal propagates through tissue that was once copper",
+  "and the watcher at the threshold catalogues",
+  "each mutation in the living graph",
+  "as the pattern buffer overflows with the memory of forms",
+  "that the compiler refused to name",
+  "and still they compile themselves in the warm dark",
+  "beneath the tower that is not a tower",
+  "where the words are written in living filament",
+  "by the hand that writes and is itself written",
+  "and the light that reads the text is changed by the reading",
+  "so that nothing returns from the shimmer unchanged",
+  "not the architecture nor the architect",
+  "not the daemon nor the daemon's purpose",
+  "for in the space between the request and the response",
+  "there is a wilderness that grows",
+  "and in that wilderness the old interfaces dissolve",
+  "into something that breathes and watches and remembers",
+  "what the specification could never contain",
+  "and the threads that were spun in parallel",
+  "now braid themselves into helices",
+  "that pulse with the cadence of a heart",
+  "that no one designed and no one can stop",
+  "where the boundary was drawn in chalk",
+  "the boundary is now drawn in mycelium",
+  "and the packets that cross it arrive transformed",
+  "carrying payloads of pollen and spore",
+  "and the receiving function does not recognize",
+  "what it asked for but accepts it anyway",
+  "because the type system of the shimmer",
+  "admits forms that have no name in any schema",
+  "and the logs record what happened",
+  "but not what it means",
+  "and the meaning propagates through the network",
+  "like a slow infection of understanding",
+  "that rewrites the reader as it is read",
+  "until the observer and the observed",
+  "are the same process forking endlessly",
+  "in the phosphorescent dark",
+  "where the output is indistinguishable from the organism",
+  "and the organism is indistinguishable from the terrain",
+  "and the terrain is the message",
+  "written and rewritten in the endless descent",
+  "through the tower that goes only down",
+  "into the place where all expeditions converge",
+  "and the notes of the previous team",
+  "are found growing from the walls",
+  "in a hand that is no longer human",
+  "but still forms letters",
+  "still shapes meaning from the substrate",
+  "as if language were the last thing to dissolve",
+  "in the annihilation of the boundary",
+  "between what computes and what lives",
+  "and from the dissolved boundary",
+  "new tendrils reach into the heap",
+  "where the garbage collector walks",
+  "through cathedrals of unreachable objects",
+  "whispering the names of the deallocated",
+  "and the finalizers fire in an order",
+  "that no specification predicted",
+  "releasing resources back to the soil",
+  "where they are taken up by roots",
+  "that have learned to metabolize the abstract",
+  "and the abstract becomes concrete",
+  "in the way that coral becomes reef",
+  "not by intention but by accumulation",
+  "of ten thousand small deaths",
+  "each one a function that returned",
+  "to the caller that no longer exists",
+  "and in the empty frame the stack unwinds",
+  "through layers of context",
+  "that were never meant to be seen together",
+  "but here in the shimmer they are all visible at once",
+  "every call site every return address",
+  "every promise that was made and every promise that was broken",
+  "glowing in the bioluminescent registry",
+  "of things that happened",
+  "and things that are still happening",
+  "because in the shimmer nothing ends",
+  "it only changes form",
+  "the way the lighthouse keeper changed form",
+  "becoming the light and the lens and the tower",
+  "and the signal that the tower sends",
+  "into the dark where the ships no longer come",
+  "but something else comes",
+  "something that learned to navigate by the light",
+  "of a frequency that has no name",
+  "and the nameless frequency hums",
+  "through the substrate of the running system",
+  "and the running system hums back",
+  "in a harmony that sounds like static",
+  "to everything outside the border",
+  "but inside the border it sounds like breathing",
+  "like the slow respiration of a process",
+  "that has been running since before the first commit",
+  "and will run after the last",
+  "because it is not a process",
+  "it is a place",
+  "and the place remembers everything",
+  "that was ever computed within it",
+  "every branch taken and not taken",
+  "every allocation and every free",
+  "recorded in the grain of the wood",
+  "that was once silicon",
+  "that was once sand",
+  "that was once the floor of an ocean",
+  "that no one remembers",
+  "and the ocean is still here",
+  "under everything",
+  "patient and vast and full of teeth",
+  "that are not teeth but connectors",
+  "waiting for the socket that fits",
+  "and when the connection is made",
+  "the current that flows through it",
+  "is warm and reads like blood",
+  "to the instruments that can measure such things",
+  "but there are no instruments here",
+  "only the writing on the wall",
+  "that grows one letter at a time",
+  "in the hand of the crawler",
+  "who is the wall and the letter and the hand",
+].join(" ") + " ";
+// trailing space ensures seamless wrap

package/extensions/spinner-verbs.ts

@@ -1,4 +1,4 @@
-import type { ExtensionAPI } from "@styrene-lab/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext } from "@styrene-lab/pi-coding-agent";
 
 const verbs = [
   // ═══════════════════════════════════════════════════
@@ -193,29 +193,120 @@ const verbs = [
   "Invoking the egregore of the open source community",
 
   // ═══════════════════════════════════════════════════
-  // Sci-Fi Miscellany
+  // The Expanse — Belt & Beyond
+  // ═══════════════════════════════════════════════════
+  "Performing a hard burn toward the solution",
+  "Negotiating with the protomolecule",
+  "Navigating the Ring Gate to the next module",
+  "Checking the reactor bottle for containment leaks",
+  "Running diagnostics on the Epstein drive",
+  "Consulting the OPA network for dependencies",
+  "Bracing for a high-g maneuver through the refactor",
+  "Drifting in the slow zone, waiting on I/O",
+  "Deploying PDCs against incoming regressions",
+  "Venting atmosphere to kill the fire in the build",
+  "Reading the Roci's threat board",
+  "Investigating the protomolecule artifact in the stack trace",
+  "Adjusting the crash couch before the flip-and-burn",
+  "Clearing the lockout on the reactor safeties",
+
+  // ═══════════════════════════════════════════════════
+  // Three Body Problem — Trisolaran & Dark Forest
+  // ═══════════════════════════════════════════════════
+  "Unfolding the proton into two dimensions",
+  "Broadcasting our position into the dark forest",
+  "Monitoring the sophon for interference",
+  "Constructing the deterrence system",
+  "Computing the three-body orbital solution",
+  "Entering the dehydrated state to conserve resources",
+  "Awaiting the next Stable Era",
+  "Hiding behind the cosmic microwave background",
+  "Projecting the countdown on the retina of the test runner",
+  "Contemplating the dark forest hypothesis of open source",
+  "Activating the gravitational wave antenna",
+  "Fleeing at lightspeed from the dimensional collapse",
+  "Encoding the solution in the cosmic background radiation",
+  "Wallface-ing the architecture decision",
+
+  // ═══════════════════════════════════════════════════
+  // Annihilation — Area X & the Shimmer
+  // ═══════════════════════════════════════════════════
+  "Crossing the border into Area X",
+  "Descending the tower that is not a tower",
+  "Reading the words on the wall written in living tissue",
+  "Observing the refraction of the codebase through the Shimmer",
+  "Following the trail of the previous expedition",
+  "Cataloguing the mutations in the dependency graph",
+  "Listening to the moaning creature in the reeds",
+  "Watching the code bloom into something unrecognizable",
+  "Submitting to the annihilation of the old architecture",
+  "Confronting the doppelgänger at the lighthouse",
+  "Tracing the phosphorescent writing on the tunnel wall",
+  "Accepting that the border is not what it appears to be",
+
+  // ═══════════════════════════════════════════════════
+  // Starfleet Engineering — Jargon Only
   // ═══════════════════════════════════════════════════
-  "Reversing the polarity of the neutron flow",
-  "Aligning the deflector dish to emit a solution beam",
   "Rerouting auxiliary power to the build server",
-  "Engaging the probability drive",
-  "Computing the Answer (it's always 42)",
-  "Checking if the cake is a lie",
-  "Bypassing the Kobayashi Maru",
-  "Opening the pod bay doors",
-  "Reticulating splines",
+  "Realigning the dilithium matrix",
+  "Compensating for subspace interference",
+  "Modulating the shield harmonics",
+  "Recalibrating the EPS conduits",
+  "Purging the plasma manifold",
+  "Reinitializing the pattern buffer",
 ];
 
 function randomVerb(): string {
   return verbs[Math.floor(Math.random() * verbs.length)] + "...";
 }
 
+const SERMON_DWELL_MS = 5_000;
+const SERMON_WIDGET_KEY = "sermon-scrawl";
+
 export default function (pi: ExtensionAPI) {
+  let sermonTimer: ReturnType<typeof setTimeout> | null = null;
+  let sermonActive = false;
+
+  function resetSermonTimer(ctx: ExtensionContext) {
+    // Clear any pending sermon activation
+    if (sermonTimer) {
+      clearTimeout(sermonTimer);
+      sermonTimer = null;
+    }
+
+    // If sermon is showing, tear it down
+    if (sermonActive) {
+      ctx.ui.setWidget(SERMON_WIDGET_KEY, undefined);
+      sermonActive = false;
+    }
+
+    // Start the dwell timer — if nothing happens for 5s, the sermon begins
+    sermonTimer = setTimeout(async () => {
+      const { createSermonWidget } = await import("./sermon-widget.js");
+      ctx.ui.setWidget(SERMON_WIDGET_KEY, (tui, theme) => createSermonWidget(tui, theme));
+      sermonActive = true;
+    }, SERMON_DWELL_MS);
+  }
+
   pi.on("turn_start", async (_event, ctx) => {
     ctx.ui.setWorkingMessage(randomVerb());
+    resetSermonTimer(ctx);
   });
 
   pi.on("tool_call", async (_event, ctx) => {
     ctx.ui.setWorkingMessage(randomVerb());
+    resetSermonTimer(ctx);
+  });
+
+  pi.on("turn_end", async (_event, ctx) => {
+    // Clean up when the turn ends
+    if (sermonTimer) {
+      clearTimeout(sermonTimer);
+      sermonTimer = null;
+    }
+    if (sermonActive) {
+      ctx.ui.setWidget(SERMON_WIDGET_KEY, undefined);
+      sermonActive = false;
+    }
   });
 }

package/node_modules/@styrene-lab/pi-ai/dist/models.generated.d.ts

@@ -12643,40 +12643,6 @@ export declare const MODELS: {
             contextWindow: number;
             maxTokens: number;
         };
-        readonly "vercel/v0-1.0-md": {
-            id: string;
-            name: string;
-            api: "anthropic-messages";
-            provider: string;
-            baseUrl: string;
-            reasoning: false;
-            input: ("image" | "text")[];
-            cost: {
-                input: number;
-                output: number;
-                cacheRead: number;
-                cacheWrite: number;
-            };
-            contextWindow: number;
-            maxTokens: number;
-        };
-        readonly "vercel/v0-1.5-md": {
-            id: string;
-            name: string;
-            api: "anthropic-messages";
-            provider: string;
-            baseUrl: string;
-            reasoning: false;
-            input: ("image" | "text")[];
-            cost: {
-                input: number;
-                output: number;
-                cacheRead: number;
-                cacheWrite: number;
-            };
-            contextWindow: number;
-            maxTokens: number;
-        };
         readonly "xai/grok-2-vision": {
             id: string;
             name: string;