rovecode 0.4.0 → 0.4.2

package/package.json

@@ -1,62 +1,62 @@
-{
-  "name": "rovecode",
-  "version": "0.4.0",
-  "license": "AGPL-3.0-only",
-  "author": "9Code Labs",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/9Code-Labs/rovecode.git"
-  },
-  "homepage": "https://github.com/9Code-Labs/rovecode",
-  "description": "Rovecode: a coding agent for the terminal. Research-derived harness on Bun/TypeScript with evidence-based ports from open-source harnesses (sextant TUI, MCP, ACP, headless server, repo-map, shadow-git checkpoints, execpolicy, model routers).",
-  "type": "module",
-  "module": "src/index.ts",
-  "exports": {
-    ".": "./src/index.ts",
-    "./sdk": "./src/sdk/index.ts",
-    "./package.json": "./package.json",
-    "./*": "./*"
-  },
-  "bin": {
-    "rovecode": "bin/rovecode.ts"
-  },
-  "files": [
-    "bin",
-    "src",
-    "vendor",
-    "tsconfig.json",
-    "THIRD_PARTY_NOTICES.md"
-  ],
-  "engines": {
-    "bun": ">=1.3.14"
-  },
-  "scripts": {
-    "build": "bun run scripts/build.ts",
-    "build:cli": "bun -e \"require('node:fs').rmSync('dist/cli', { recursive: true, force: true })\" && bun build --target=bun --splitting --sourcemap=external src/cli/main.ts --outdir dist/cli && bun run smoke:cli && bun run smoke:dist",
-    "smoke:cli": "bun dist/cli/main.js --version",
-    "smoke:dist": "bun dist/cli/main.js smoke-tui --sextant",
-    "test": "bun test",
-    "gauntlet": "bun src/cli/main.ts gauntlet",
-    "typecheck": "tsc --noEmit",
-    "check": "node scripts/build-model-index.mjs --check && tsc --noEmit && bun test",
-    "smoke": "bun src/cli/main.ts smoke-tui --sextant",
-    "publish:site": "bash scripts/publish-site-data.sh",
-    "build:model-index": "node scripts/build-model-index.mjs"
-  },
-  "dependencies": {
-    "@ast-grep/napi": "^0.45.3",
-    "@modelcontextprotocol/sdk": "^1.30.0",
-    "@zed-industries/agent-client-protocol": "^0.4.5",
-    "diff": "^9.0.0",
-    "get-east-asian-width": "1.6.0",
-    "gpt-tokenizer": "^4.0.0",
-    "marked": "18.0.11",
-    "tokenlens": "^1.3.1"
-  },
-  "devDependencies": {
-    "@opencode-ai/models": "^0.0.64",
-    "@types/bun": "latest",
-    "@xterm/headless": "6.0.0",
-    "typescript": "^5.9.3"
-  }
-}
+{
+  "name": "rovecode",
+  "version": "0.4.2",
+  "license": "AGPL-3.0-only",
+  "author": "9Code Labs",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/9Code-Labs/rovecode.git"
+  },
+  "homepage": "https://github.com/9Code-Labs/rovecode",
+  "description": "Rovecode: a coding agent for the terminal. Research-derived harness on Bun/TypeScript with evidence-based ports from open-source harnesses (sextant TUI, MCP, ACP, headless server, repo-map, shadow-git checkpoints, execpolicy, model routers).",
+  "type": "module",
+  "module": "src/index.ts",
+  "exports": {
+    ".": "./src/index.ts",
+    "./sdk": "./src/sdk/index.ts",
+    "./package.json": "./package.json",
+    "./*": "./*"
+  },
+  "bin": {
+    "rovecode": "bin/rovecode.ts"
+  },
+  "files": [
+    "bin",
+    "src",
+    "vendor",
+    "tsconfig.json",
+    "THIRD_PARTY_NOTICES.md"
+  ],
+  "engines": {
+    "bun": ">=1.3.14"
+  },
+  "scripts": {
+    "build": "bun run scripts/build.ts",
+    "build:cli": "bun -e \"require('node:fs').rmSync('dist/cli', { recursive: true, force: true })\" && bun build --target=bun --splitting --sourcemap=external src/cli/main.ts --outdir dist/cli && bun run smoke:cli && bun run smoke:dist",
+    "smoke:cli": "bun dist/cli/main.js --version",
+    "smoke:dist": "bun dist/cli/main.js smoke-tui --sextant",
+    "test": "bun test",
+    "gauntlet": "bun src/cli/main.ts gauntlet",
+    "typecheck": "tsc --noEmit",
+    "check": "node scripts/build-model-index.mjs --check && tsc --noEmit && bun test",
+    "smoke": "bun src/cli/main.ts smoke-tui --sextant",
+    "publish:site": "bash scripts/publish-site-data.sh",
+    "build:model-index": "node scripts/build-model-index.mjs"
+  },
+  "dependencies": {
+    "@ast-grep/napi": "^0.45.3",
+    "@modelcontextprotocol/sdk": "^1.30.0",
+    "@zed-industries/agent-client-protocol": "^0.4.5",
+    "diff": "^9.0.0",
+    "get-east-asian-width": "1.6.0",
+    "gpt-tokenizer": "^4.0.0",
+    "marked": "18.0.11",
+    "tokenlens": "^1.3.1"
+  },
+  "devDependencies": {
+    "@opencode-ai/models": "^0.0.64",
+    "@types/bun": "latest",
+    "@xterm/headless": "6.0.0",
+    "typescript": "^5.9.3"
+  }
+}

package/src/sextant/boot.ts

@@ -0,0 +1,74 @@
+/** The boot gate (#46): the cockpit stays in its reveal animation until every panel the layout asked
+ *  for has painted CLEAN at least once — then `ready` flips and the surface accepts submits. A panel
+ *  that keeps faulting can never lock the UI: the cap forces readiness and the toast already names the
+ *  fault (frame.ts safe()). Future surfaces/versions get the same discipline by constructing one of
+ *  these and asking it, instead of re-rolling boot timing by hand.
+ *
+ *  Wiring: the frame loop owns the gate → renderFrame's per-panel guard reports clean/fault into it →
+ *  the loop holds FRAME_MS pacing and swallows submits until `ready`. */
+
+import { REVEAL_STEP_MS } from "./frame.ts";
+
+/** panels the gate knows about; the loop re-declares the live set every frame (layout-dependent) */
+export const BOOT_PANELS = ["files", "code", "messages", "plan", "usage", "pet"] as const;
+
+/** the animation itself: six reveal steps at 90 ms + a beat to settle */
+export const BOOT_ANIM_MS = REVEAL_STEP_MS * 6;
+
+/** a faulting panel may delay readiness at most this long — then the gate opens anyway */
+export const BOOT_CAP_MS = 3000;
+
+export interface BootGate {
+  /** true once every live panel painted clean (and the animation finished) or the cap elapsed */
+  readonly ready: boolean;
+  /** 0..1 — animation progress for loaders; faults do not stall it (the cap guarantees 1) */
+  readonly progress: number;
+  /** names of live panels that have not painted clean yet */
+  readonly pending: readonly string[];
+}
+
+export interface Boot {
+  readonly gate: BootGate;
+  /** frame loop → gate: the clock, and which panels this layout actually shows */
+  tick(now: number, livePanels: readonly string[]): void;
+  /** renderFrame safe() → gate: a panel painted clean / threw */
+  clean(panel: string): void;
+  fault(panel: string): void;
+}
+
+export function createBoot(bootAt: number): Boot {
+  const cleanPanels = new Set<string>();
+  const faulted = new Set<string>();
+  let live: readonly string[] = [...BOOT_PANELS];
+  let now = bootAt;
+
+  const gate: BootGate = {
+    get ready(): boolean {
+      const animDone = now - bootAt >= BOOT_ANIM_MS;
+      if (now - bootAt >= BOOT_CAP_MS) return true;
+      if (!animDone) return false;
+      return live.every((p) => cleanPanels.has(p) || faulted.has(p));
+    },
+    get progress(): number {
+      return Math.min(1, (now - bootAt) / BOOT_ANIM_MS);
+    },
+    get pending(): readonly string[] {
+      return live.filter((p) => !cleanPanels.has(p) && !faulted.has(p));
+    },
+  };
+
+  return {
+    gate,
+    tick(n: number, livePanels: readonly string[]): void {
+      now = n;
+      live = livePanels;
+    },
+    clean(panel: string): void {
+      cleanPanels.add(panel);
+      faulted.delete(panel);
+    },
+    fault(panel: string): void {
+      faulted.add(panel); // faults count toward readiness — the cap + toast carry the story
+    },
+  };
+}

package/src/sextant/frame.ts

@@ -9,7 +9,7 @@ import { GridScreen } from "./grid.ts";
 import { drawFiles, drawFrame, drawToasts } from "./draw-frame.ts";
 import { drawPlan, drawUsage } from "./draw-plan.ts";
 import { panel } from "./layout.ts";
-import { pruneToasts } from "./model.ts";
+import { pruneToasts, pushToast } from "./model.ts";
 import type { DumpFrame, Layout, LayoutOptions, Rect, ScreenLike, SextantState, Theme } from "./types.ts";
 import { mainPage } from "./draw-tabs.ts";
 
@@ -22,6 +22,9 @@ export interface FrameDeps {
   /** overrides per panel; a missing painter draws an empty titled box */
   painters?: Partial<Painters>;
   layoutOpts?: LayoutOptions;
+  /** #46 boot gate: the per-panel guard reports clean/fault into it so the surface can hold its
+   *  reveal until every live panel has painted once. Omit = no gating (tests, dumps). */
+  boot?: import("./boot.ts").Boot;
 }
 
 /** boot reveal (app.js render()): panels appear in 90 ms steps after bootAt */
@@ -73,20 +76,46 @@ export function renderFrame(scr: ScreenLike, s: SextantState, theme: Theme, now:
   const L = (deps.layout ?? layoutFallback)(scr.w, scr.h, deps.layoutOpts ?? { pet: true });
   pruneToasts(s, now);
   const age = now - s.bootAt;
-  P.frame(scr, L.frame, s, theme, now);
-  if (L.files && age >= 0) P.files(scr, L.files, s, theme, now);
+  // A painter that throws must never take the rest of the frame down with it — a blank panel with a
+  // toast beats a half-drawn cockpit. The first failure per panel is recorded on the state so the
+  // loop can surface it once instead of spamming every frame.
+  // the panels this layout actually shows — the gate waits on exactly these, no more
+  deps.boot?.tick(now, [
+    ...(L.files ? ["files"] : []),
+    "code",
+    "messages",
+    ...(L.plan ? ["plan"] : []),
+    ...(L.usage ? ["usage"] : []),
+    ...(L.pet ? ["pet"] : []),
+  ]);
+  const safe = (name: keyof Painters, fn: () => void): void => {
+    try {
+      fn();
+      if (s.painterError === name || s.painterError?.startsWith(name + ":")) s.painterError = undefined;
+      deps.boot?.clean(name);
+    } catch (e) {
+      const msg = `${name}: ${e instanceof Error ? e.message : String(e)}`;
+      deps.boot?.fault(name);
+      if (s.painterError !== msg) {
+        s.painterError = msg;
+        pushToast(s, `panel fault — ${msg}`, now, "error");
+      }
+    }
+  };
+  safe("frame", () => P.frame(scr, L.frame, s, theme, now));
+  if (L.files && age >= 0) safe("files", () => P.files(scr, L.files!, s, theme, now));
   // paging (draw-tabs.ts): on a narrow terminal the main slot shows the panel `s.page` names when
   // the layout hid it; the tab strip itself is painted by the frame loop after the panels
   const main = mainPage(L, s);
   if (age >= REVEAL_STEP_MS) {
-    if (main === "files") P.files(scr, L.code, s, theme, now);
-    else if (main === "plan") P.plan(scr, L.code, s, theme, now);
-    else P.code(scr, L.code, s, theme, now);
+    if (main === "files") safe("files", () => P.files(scr, L.code, s, theme, now));
+    else if (main === "plan") safe("plan", () => P.plan(scr, L.code, s, theme, now));
+    else safe("code", () => P.code(scr, L.code, s, theme, now));
   }
-  if (age >= REVEAL_STEP_MS * 2) P.messages(scr, L.messages, s, theme, now);
-  if (L.plan && age >= REVEAL_STEP_MS * 3) P.plan(scr, L.plan, s, theme, now);
-  if (L.usage && age >= REVEAL_STEP_MS * 4) P.usage(scr, L.usage, s, theme, now);
-  if (L.pet && age >= REVEAL_STEP_MS * 5) P.pet(scr, L.pet, s, theme, now);
+  if (age >= REVEAL_STEP_MS * 2) safe("messages", () => P.messages(scr, L.messages, s, theme, now));
+  if (L.plan && age >= REVEAL_STEP_MS * 3) safe("plan", () => P.plan(scr, L.plan!, s, theme, now));
+  if (L.usage && age >= REVEAL_STEP_MS * 4) safe("usage", () => P.usage(scr, L.usage!, s, theme, now));
+  if (L.pet && age >= REVEAL_STEP_MS * 5) safe("pet", () => P.pet(scr, L.pet!, s, theme, now));
   drawToasts(scr, s, theme, now);
   return L;
 }

package/src/sextant/sextant-frame-loop.ts

@@ -12,10 +12,11 @@ import { drawMessages, messagesScroll, promptCursor } from "./draw-messages.ts";
 import { drawPet, SWAY_MS } from "./draw-pet.ts";
 import { fuzzy, tokenize } from "./engine.ts";
 import { renderFrame } from "./frame.ts";
+import { createBoot, type Boot } from "./boot.ts";
 import { parseInput } from "./input.ts";
 import { handleInput, type KeyCtx } from "./keys.ts";
 import { layout as layoutFn } from "./layout.ts";
-import { treeRows } from "./model.ts";
+import { treeRows, pushToast } from "./model.ts";
 import { drawHelp, drawPalette, drawSuggest, suggestions } from "./overlays.ts";
 import { drawMarket } from "./draw-market.ts";
 import { drawContext } from "./draw-context.ts";
@@ -95,6 +96,11 @@ export class FrameLoop {
   private rows: TreeRow[] = [];
   /** frames painted (tests: "a render happened") */
   frames = 0;
+  /** #46: the cockpit opens for submits once every live panel painted clean (boot.ts) */
+  private boot: Boot | null = null;
+  private bootToastAt = 0;
+  /** Enter presses caught while the boot gate was closed; replayed in order when it opens */
+  private bootQueue: InputEvent[] = [];
 
   constructor(private readonly d: FrameLoopDeps) {
     const { cols, rows } = d.io.size();
@@ -191,6 +197,16 @@ export class FrameLoop {
   dispatch(ev: InputEvent): void {
     const now = this.d.clock();
     this.markDirty(); // and wake: the tick that follows this key (onTick: file reload) must come in one frame, not one sleep
+    // #46: while the boot reveal runs, Enter would submit into a half-loaded surface — QUEUE it and
+    // replay once the gate opens (typing still buffers into the editor live). Nothing is ever lost.
+    if (this.boot && !this.boot.gate.ready && ev.type === "key" && ev.name === "enter") {
+      this.bootQueue.push(ev);
+      if (now - this.bootToastAt > 2000) {
+        this.bootToastAt = now;
+        pushToast(this.d.state, "cockpit is loading — your input is queued", now, "info");
+      }
+      return;
+    }
     if (this.d.beforeInput?.(ev, now)) return;
     const kc = this.d.keyCtx();
     const ctx: KeyCtx = { layout: this.L, hooks: kc.hooks, local: kc.local, hits: this.hits, rows: this.rows, fuzzy, drag: this.drag };
@@ -202,6 +218,8 @@ export class FrameLoop {
    *  storms and effects, the boot reveal. These hold the loop at FRAME_MS. */
   moving(now: number): boolean {
     const s = this.d.state, P = this.d.pet.state;
+    // #46: the gate holds the loop hot until the surface is truly ready (not just REVEAL_MS elapsed)
+    if (this.boot && !this.boot.gate.ready) return true;
     return s.running || s.card !== null || s.files.touched.size > 0 || now - s.bootAt < REVEAL_MS
       || now < P.stormUntil || P.fx.some((f) => f.until > now);
   }
@@ -239,17 +257,36 @@ export class FrameLoop {
     return Math.min(IDLE_TICK_MS, Math.max(FRAME_MS, this.ambientDue - now));
   }
 
-  /** paint one frame: panels (renderFrame) → suggestion box → palette → help → scroll write-backs → cursor → flush */
+  /** paint one frame: panels (renderFrame) → suggestion box → palette → help → scroll write-backs → cursor → flush.
+   *  The whole body is guarded: a fault anywhere (huge home-dir file tree, odd git state, a painter
+   *  edge case) must surface as a toast and leave the LAST good frame on screen — never a blank cockpit. */
   render(now: number): void {
+    try {
+      this.renderInner(now);
+      this.lastFrameError = undefined;
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      if (this.lastFrameError !== msg) {
+        this.lastFrameError = msg;
+        try { pushToast(this.d.state, `frame fault — ${msg}`, now, "error"); } catch { /* state itself is sick */ }
+      }
+    }
+  }
+
+  private lastFrameError: string | undefined;
+
+  private renderInner(now: number): void {
     const scr = this.screen;
     if (!scr) return;
     const s = this.d.state, theme = this.d.theme(), pet = this.d.pet;
     scr.begin(theme.bg);
     this.rows = treeRows(s, now); // the same (version, now) key drawFiles uses → one build per frame (model.ts cache)
     const hits: HitZone[] = [];
+    if (!this.boot) this.boot = createBoot(s.bootAt);
     const L = renderFrame(scr, s, theme, now, {
       layout: layoutFn,
       layoutOpts: this.layoutOpts(),
+      boot: this.boot,
       painters: {
         code: (g, r, st, th, t) => drawCode(g, r, st, th, t, { tokenize }),
         messages: drawMessages,
@@ -257,6 +294,12 @@ export class FrameLoop {
       },
     });
     this.L = L;
+    // the gate just opened → flush queued submits through the normal path
+    if (this.boot.gate.ready && this.bootQueue.length > 0) {
+      const queued = this.bootQueue;
+      this.bootQueue = [];
+      for (const ev of queued) this.dispatch(ev);
+    }
     if (L.pet) hits.push({ rect: L.pet, onClick: () => pet.poke(this.d.clock()) });
     // the frame's border rows (frame-hits.ts): unread badge → notices, theme name → next theme, effort → /effort
     for (const z of frameHits(L.frame, s, theme, now)) hits.push(z);

package/src/sextant/types.ts

@@ -388,6 +388,9 @@ export interface SextantState {
   context: ContextState | null;
   help: boolean;
   toasts: Toast[];
+  /** last painter failure seen by renderFrame's per-panel guard (frame.ts); surfaced as a toast by
+   *  the frame loop, cleared on the next clean frame of that panel. Undefined = all panels clean. */
+  painterError?: string;
   /** the notification history behind the toasts (Notice); newest last */
   notices: Notice[];
   /** images staged for the next user message (names), shown as chips above the prompt; synced from