loom-agent 1.2.9 → 1.2.12

package/README.md

@@ -1,8 +1,8 @@
 # Loom Code
 
-[![npm version](https://img.shields.io/npm/v/loom-code?style=flat&color=blue)](https://www.npmjs.com/package/loom-agent)
-[![License: MIT](https://img.shields.io/npm/l/loom-code?style=flat&color=green)](LICENSE)
-[![Platform: Win/Mac/Linux](https://img.shields.io/badge/terminal-Win%20%7C%20Mac%20%7C%20Linux-orange)](#)
+[![npm version](https://img.shields.io/npm/v/loom-agent?style=flat&color=blue)](https://www.npmjs.com/package/loom-agent)
+[![License: MIT](https://img.shields.io/npm/l/loom-agent?style=flat&color=green)](LICENSE)
+[![Platform: Win/Mac/Linux](https://img.shields.io/badge/platform-Win--Mac--Linux-orange)](#)
 
 An AI-powered coding agent for the terminal with multi-provider support and a full terminal UI.
 

package/bin/loom-bun.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env bun
+// npm invokes bin targets through Node on Windows, so re-launch under Bun
+// when this file was not started by Bun itself.
+const path = require("path");
+const { spawnSync } = require("child_process");
+
+if (!(typeof Bun !== "undefined" && process.versions.bun)) {
+  const result = spawnSync(process.platform === "win32" ? "bun.exe" : "bun", ["--conditions=browser", __filename, ...process.argv.slice(2)], {
+    stdio: "inherit",
+    cwd: process.cwd(),
+    env: process.env,
+    windowsHide: false,
+  });
+  if (result.error) {
+    console.error("[loom] Bun is required for the full CLI. Install it from https://bun.sh/");
+    process.exit(1);
+  }
+  process.exit(result.status == null ? 1 : result.status);
+}
+
+process.env.BUN_CONFIG = path.join(__dirname, "..", "bunfig.toml");
+process.title = "loom-code";
+(async () => {
+  try {
+    const { main } = require("../src/core/cli.js");
+    await main();
+  } catch (err) {
+    console.error(err && err.message ? err.message : String(err));
+    process.exit(1);
+  }
+})();

package/bin/loom-tui.js

@@ -1,52 +1,23 @@
-#!/usr/bin/env node
-// Loom Code — TUI launcher. Prefers bun for the TSX/JSX pipeline; falls back to
-// plain node for environments without bun (the TUI will tell the user to install
-// bun first).
-const { spawnSync } = require('child_process');
-const path = require('path');
-const fs = require('fs');
-const os = require('os');
+#!/usr/bin/env bun
+// npm invokes bin targets through Node on Windows, so re-launch under Bun
+// when this file was not started by Bun itself.
+const path = require("path");
+const { spawnSync } = require("child_process");
 
-function findBun() {
-  const candidates = [
-    // Common install locations
-    path.join(os.homedir(), '.bun', 'bin', 'bun.exe'),
-    path.join(os.homedir(), '.bun', 'bin', 'bun'),
-    '/usr/local/bin/bun',
-    '/opt/homebrew/bin/bun',
-    path.join(os.homedir(), 'bin', 'bun'),
-    path.join(os.homedir(), '.local', 'bin', 'bun'),
-  ];
-  for (const p of candidates) { try { if (fs.existsSync(p)) return p; } catch {} }
-  // PATH lookup (fast)
-  try {
-    const out = require('child_process').execSync('bun --version', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true }).trim();
-    if (out) return 'bun';
-  } catch {}
-  return null;
+if (!(typeof Bun !== "undefined" && process.versions.bun)) {
+	const result = spawnSync(process.platform === "win32" ? "bun.exe" : "bun", ["--conditions=browser", __filename, ...process.argv.slice(2)], {
+		stdio: "inherit",
+		cwd: process.cwd(),
+		env: process.env,
+		windowsHide: false,
+	});
+	if (result.error) {
+		console.error("[loom] Bun is required for the TUI. Install it from https://bun.sh/");
+		process.exit(1);
+	}
+	process.exit(result.status == null ? 1 : result.status);
 }
 
-const entry = path.join(__dirname, '..', 'src', 'tui-open.tsx');
-// Start bun from the package root so it discovers our bunfig.toml/tsconfig.json
-// (Solid JSX preloader); the user's real cwd rides along in LOOM_START_CWD and
-// is restored by the bootstrap shim before app code runs.
-const pkgRoot = path.join(__dirname, '..');
-process.env.LOOM_START_CWD = process.cwd();
-process.env.LOOM_BIN_NAME = "loom";
-const bun = findBun();
-
-if (bun) {
-  // Pin Solid to its CLIENT build: from this spawn context bun can resolve
-  // solid-js under the "node" export condition (= SSR build, renders one
-  // static frame then ignores all signal updates -> frozen splash).
-  const result = spawnSync(bun, ['run', entry, ...process.argv.slice(2)], {
-    stdio: 'inherit',
-    cwd: pkgRoot,
-    env: process.env,
-  });
-  process.exit(result.status ?? 0);
-}
-
-console.log('Loom TUI requires bun (https://bun.sh) to run the TSX/JSX pipeline.');
-console.log('Install bun first, then use: bun run ' + entry);
-process.exit(1);
+process.env.BUN_CONFIG = path.join(__dirname, "..", "bunfig.toml");
+require("../src/tui-preload.js");
+(async () => { await import("../src/tui-open.tsx"); })();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "loom-agent",
-  "version": "1.2.9",
+  "version": "1.2.12",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/toshalkumbhar8979-design/loomcode.git"
@@ -9,10 +9,14 @@
   "bugs": {
     "url": "https://github.com/toshalkumbhar8979-design/loomcode/issues"
   },
-  "description": "Loom Code — AI-powered coding agent for the terminal. Multi-provider support including NVIDIA. OpenTUI interface.",
+  "description": "Loom Code — AI-powered coding agent for the terminal. Multi-provider support including NVIDIA. OpenTUI interface.",
   "main": "src/index.js",
+  "publishConfig": {
+    "access": "public",
+    "tag": "latest"
+  },
   "bin": {
-    "loom": "bin/loom.js",
+    "loom": "bin/loom-bun.js",
     "loom-tui": "bin/loom-tui.js"
   },
   "scripts": {
@@ -23,13 +27,13 @@
     "test:unit": "bun test src/core/agents.test.js src/core/hooks.test.js src/core/custom-commands.test.js src/core/background-tasks.test.js src/core/memory.test.js src/core/subagent-log.test.js src/core/session.test.js src/tools/index.test.js src/providers/providers.test.js src/providers/caching.test.js src/providers/caching-thinking.test.js src/providers/registry.test.js src/mcp/mcp-client.test.js src/mcp/mcp-manager.test.js src/core/session-store.test.js src/skills/skills-manager.test.js src/core/usage.test.js src/core/permissions.test.js src/core/format.test.js src/acp/acp-server.test.js src/web/web-server.test.js src/tui/keybinds.test.ts",
     "lint:core": "node node_modules/typescript/bin/tsc -p tsconfig.core.json",
     "smoke:acp": "node scripts/acp-smoke.js",
-    "tui": "node bin/loom-tui.js",
+    "tui": "bun bin/loom-tui.js",
     "tui:win": "\"%USERPROFILE%\\..\\bun\\bin\\bun.exe\" run src/tui-open.tsx",
     "prepublishOnly": "npm test",
     "lint": "tsc --noEmit"
   },
   "dependencies": {
-    "@anthropic-ai/sdk": "^0.37.0",
+    "@anthropic-ai/sdk": "^0.120.0",
     "@opentui/core": "^0.5.1",
     "@opentui/solid": "^0.5.1",
     "@shikijs/themes": "4.4.3",
@@ -41,23 +45,26 @@
     "dayjs": "^1.11.0",
     "diff": "^7.0.0",
     "dotenv": "^16.4.0",
-    "glob": "^11.0.0",
+    "glob": "^13.0.6",
     "inquirer": "^12.1.0",
-    "openai": "^4.73.0",
+    "openai": "^5.23.2",
     "ora": "^8.0.0",
     "shell-quote": "^1.8.1",
-    "solid-js": "^1.9.14",
+    "solid-js": "1.9.12",
     "strip-ansi": "^7.1.0",
     "tiktoken": "^1.0.22",
     "uuid": "^11.0.0",
     "wrap-ansi": "^9.0.0"
   },
   "optionalDependencies": {
-    "@opentui/core-win32-x64": "^0.5.1",
     "@opentui/core-darwin-arm64": "^0.5.1",
     "@opentui/core-darwin-x64": "^0.5.1",
+    "@opentui/core-linux-arm64": "^0.5.1",
     "@opentui/core-linux-x64": "^0.5.1",
-    "@opentui/core-linux-arm64": "^0.5.1"
+    "@opentui/core-win32-x64": "^0.5.1"
+  },
+  "overrides": {
+    "glob": "^13.0.6"
   },
   "devDependencies": {
     "@types/bun": "^1.2.0",
@@ -66,6 +73,7 @@
   "files": [
     "bunfig.toml",
     "tsconfig.json",
+    "bin/loom-bun.js",
     "bin/loom.js",
     "bin/loom-tui.js",
     "src/**/*.js",

package/src/core/cli.js

@@ -554,6 +554,18 @@ if (args.includes('--help') || args.includes('-h')) {
 
   if ((args.includes('--tui') || (!args.includes('--basic') && process.stdin.isTTY))) {
     const canRaw = process.stdin.isTTY && typeof process.stdin.setRawMode === 'function';
+    // Fast path: when this process is ALREADY bun (launched via bin/loom-bun.js),
+    // import the TUI in-process — no spawn, no second console-mode negotiation.
+    const underBun = typeof Bun !== 'undefined' && !!process.versions.bun;
+    if (underBun && canRaw) {
+      try {
+        const tuiModule = '../tui-open.tsx';
+        await import(tuiModule);
+        return;
+      } catch (err) {
+        console.error('[loom] TUI failed: ' + (err && err.message ? err.message : err));
+      }
+    }
     if (canRaw) {
       // Launch new OpenTUI TUI via bun
       const bunPath = findBun();
@@ -566,10 +578,11 @@ if (args.includes('--help') || args.includes('-h')) {
         const pkgRoot = path.join(__dirname, '..', '..');
         process.env.LOOM_START_CWD = process.cwd();
         process.env.LOOM_BIN_NAME = "loom";
+        process.env.BUN_CONFIG = path.join(pkgRoot, "bunfig.toml");
         // --conditions=browser pins Solid to its client build (see
         // bin/loom-tui.js) — without it the SSR build loads and the TUI
         // renders one static frame then never updates.
-        const tuiArgs = [tuiEntry];
+        const tuiArgs = ["--conditions=browser", tuiEntry];
         if (sessionId) tuiArgs.push('-s', sessionId);
         if (autoMode) tuiArgs.push('--auto');
         const prompt = promptArgs.join(' ');

package/src/core/session.js

@@ -100,9 +100,12 @@ class Session {
     this.todos = [];
     this.compactCount = 0;
     this.lastCompact = null;
-    // Start MCP tool discovery in the background so the first turn doesn't
-    // stall on server startup (npx downloads, etc.).
-    try { require('../mcp/mcp-client').warm(); } catch {}
+    // Let the TUI render before starting MCP discovery. The first warm-up can
+    // launch npx and download packages, so starting it in the constructor can
+    // make startup appear frozen before the renderer gets its first frame.
+    setTimeout(() => {
+      try { require('../mcp/mcp-client').warm(); } catch {}
+    }, 0);
   }
 
   setMode(mode) {

package/src/tui/App.tsx

@@ -2,6 +2,7 @@
 // useKeyboard handles ALL text input char-by-char.
 import { onMount, onCleanup, createMemo, Show } from "solid-js";
 import { useKeyboard, usePaste, useRenderer, useSelectionHandler } from "@opentui/solid";
+import { createTimeline } from "@opentui/core";
 import path from "path";
 import fs from "fs";
 import os from "os";
@@ -462,10 +463,10 @@ export function App(props: { initialPrompt?: string; resumeSession?: string; aut
       if (resp.interrupted) {
         // Keep the partial text in the bubble; the session already stored it,
         // so the user can type "continue" to resume the task.
-        patchMessageAt(idx, { thinking: false, interrupted: true, thinkTime: Date.now() - t0, isError: false });
+        patchMessageAt(idx, { thinking: false, interrupted: true, thinkTime: Date.now() - t0, isError: false, parts: snapshotParts() });
         appendMessage({ role: "system", content: "Interrupted \u2014 partial response kept. Type \"continue\" to resume the task." });
       } else {
-        patchMessageAt(idx, { content: resp.content || "(no response)", thinking: false, thinkTime: Date.now() - t0, isError: isErr });
+        patchMessageAt(idx, { content: resp.content || "(no response)", thinking: false, thinkTime: Date.now() - t0, isError: isErr, parts: snapshotParts() });
       }
       if (!isErr && sess.mode === "plan") {
         appendMessage({ role: "system", content: "Plan complete \u2014 press Tab to switch to Build, then send \"go\" to execute." });
@@ -475,15 +476,20 @@ export function App(props: { initialPrompt?: string; resumeSession?: string; aut
       ensureTextPart("Error: " + String(e?.message || e).slice(0, 500));
       flushStream();
       var err = e || {};
-      patchMessageAt(idx, { content: "Error: " + String(err.message || err).slice(0, 500), thinking: false, isError: true, thinkTime: Date.now() - t0 });
+      patchMessageAt(idx, { content: "Error: " + String(err.message || err).slice(0, 500), thinking: false, isError: true, thinkTime: Date.now() - t0, parts: snapshotParts() });
     }).finally(function() {
       clearInterval(speedTimer);
       if (flushTimer) { clearTimeout(flushTimer); flushTimer = null; }
       if (offTodos) { offTodos(); offTodos = null; }
       // Freeze the subagent panel at its final state ("finished").
       if (subAcc.agent) patchMessageAt(idx, { subagent: { agent: subAcc.agent, text: subAcc.text, log: subAcc.log, status: subAcc.status, done: true } });
-      setThinking(false); setThinkStart(null); recomputeTodos(); refreshUsage();
-      flushQueueSoon();
+      // Let the settled assistant message render before the global turn state
+      // changes; otherwise the test renderer can sample the old frame after
+      // thinking() becomes false.
+      setTimeout(function() {
+        setThinking(false); setThinkStart(null); recomputeTodos(); refreshUsage();
+        flushQueueSoon();
+      }, 0);
     });
     } catch (e: any) {
       // A provider that throws synchronously (bad key, malformed config) must
@@ -494,8 +500,10 @@ export function App(props: { initialPrompt?: string; resumeSession?: string; aut
       clearInterval(speedTimer);
       if (flushTimer) { clearTimeout(flushTimer); flushTimer = null; }
       if (offTodos) { offTodos(); offTodos = null; }
-      setThinking(false); setThinkStart(null); recomputeTodos(); refreshUsage();
-      flushQueueSoon();
+      setTimeout(function() {
+        setThinking(false); setThinkStart(null); recomputeTodos(); refreshUsage();
+        flushQueueSoon();
+      }, 0);
     }
   }
 
@@ -1475,6 +1483,12 @@ export function App(props: { initialPrompt?: string; resumeSession?: string; aut
   let _skillToastOff: (() => void) | null = null;
   let _skillDoneOff: (() => void) | null = null;
   onMount(function() {
+    // Keep the renderer's frame pump alive. The engine only runs its
+    // frame callback while there's a non-complete timeline registered;
+    // without one it drops the renderer to "not live" after the first
+    // paint and no further frames are flushed (frozen splash).
+    createTimeline({ duration: Infinity, autoplay: true });
+
     refreshProviderState();
     refreshUsage();
     wireTodoEvents();

package/src/tui/components/ChatArea.tsx

@@ -4,6 +4,7 @@ import { palette } from "../theme.ts";
 import {
   showThinking, userExpandedIdx, setUserExpandedIdx, sidebarVisible,
   thoughtExpanded, setThoughtExpanded, thoughtClosed, setThoughtClosed,
+  thinking,
 } from "../store.ts";
 import { toolDisplay } from "../tool-display.ts";
 import { formatDiffCount } from "../../core/file-diffs.js";
@@ -321,9 +322,9 @@ function PartList(props: { m: any; idx: number }) {
       {parts().map((p: any, i: number) => {
         if (p.type === "reasoning") {
           if (!showThinking()) return null;
-          const live = !!m.thinking && i === lastReasonIdx();
-          const open = live ? !thoughtClosed().has(props.idx) : (thoughtExpanded().get(props.idx)?.has(i) ?? false);
-          blockPrev = open;
+          const live = () => !!m.thinking && thinking() && i === lastReasonIdx();
+          const open = () => live() ? !thoughtClosed().has(props.idx) : (thoughtExpanded().get(props.idx)?.has(i) ?? false);
+          blockPrev = open();
           return <ThoughtPart p={p} i={i} idx={props.idx} live={live} open={open} />;
         }
         if (p.type === "tool") {
@@ -370,9 +371,9 @@ function deriveParts(m: any): any[] {
 // below (click collapses it mid-turn); once the model moves on (a tool or text
 // part arrives, or the turn ends) it settles to a clickable "+ Thought · Ns"
 // line — opencode's minimal mode. Clicking toggles the body in either state.
-function ThoughtPart(props: { p: any; i: number; idx: number; live: boolean; open: boolean }) {
+function ThoughtPart(props: { p: any; i: number; idx: number; live: () => boolean; open: () => boolean }) {
   const toggle = () => {
-    if (props.live) {
+    if (props.live()) {
       const closed = new Set(thoughtClosed());
       if (closed.has(props.idx)) closed.delete(props.idx); else closed.add(props.idx);
       setThoughtClosed(closed);
@@ -392,9 +393,9 @@ function ThoughtPart(props: { p: any; i: number; idx: number; live: boolean; ope
         onMouseUp={() => toggle()}
         onKeyDown={(e: any) => { if (e.name === "return" || e.name === "space") toggle(); }}
       >
-        {props.live ? <ThinkingLabel /> : (props.open ? "- " : "+ ") + "Thought" + (ms() ? " \u00B7 " + ms() : "")}
+        {props.live() ? <ThinkingLabel /> : (props.open() ? "- " : "+ ") + "Thought" + (ms() ? " \u00B7 " + ms() : "")}
       </text>
-      <Show when={props.open}>
+      <Show when={props.open()}>
         <box paddingLeft={2}>
           <MdText md={String(props.p.text || "").slice(0, 20000)} />
         </box>

package/src/tui/components/InputBar.tsx

@@ -345,9 +345,8 @@ export function InputBar() {
         </box>
       </box>
 
-      <box paddingX={1} flexDirection="row" justifyContent="space-between">
-        <text fg={ui.fgMuted}>{statusLine().cwd}</text>
-        <text fg={ui.fgMuted}>{statusLine().right}</text>
+      <box paddingX={1} flexDirection="row">
+        <text fg={ui.fgMuted}>{statusLine().cwd + "  " + statusLine().right}</text>
       </box>
     </box>
   );

package/src/tui/components/SplashScreen.tsx

@@ -1,8 +1,21 @@
 // Splash screen -- logo + embedded InputBar when no messages yet. Signal reads in JSX.
+import fs from "fs";
+import path from "path";
 import { palette, LOOM_LOGO } from "../theme.ts";
 import { providerName, modelName, providerKeyOk } from "../store.ts";
 import { InputBar } from "./InputBar.tsx";
 
+// Read the real version from package.json (same source as `loom --version`),
+// never a hardcoded label that drifts out of sync with releases.
+const LOOM_VERSION = (() => {
+  try {
+    const pkg = fs.readFileSync(path.join(import.meta.dir, "..", "..", "package.json"), "utf8");
+    return "v" + pkg.match(/"version":\s*"([^"]+)"/)[1];
+  } catch {
+    return "";
+  }
+})();
+
 export function SplashScreen() {
   const ui = palette("loom");
 
@@ -27,7 +40,7 @@ export function SplashScreen() {
       </box>
 
       <box marginTop={0}>
-        <text fg={ui.fgMuted}>{"v1.1.0"}</text>
+        <text fg={ui.fgMuted}>{LOOM_VERSION}</text>
       </box>
 
       <box marginY={1} width={74}>

package/src/tui/components/SubagentPanel.tsx

@@ -104,7 +104,7 @@ export function SubagentPanel() {
       // Set the DEFAULT model for the selected agent id ("provider/model-id").
       const cur = all()[sel()];
       if (!cur) return;
-      const { loadConfig, saveConfig } = require("../../../config/settings.js");
+      const { loadConfig, saveConfig } = require("../../config/settings.js");
       const cfg = loadConfig();
       cfg.agents = cfg.agents || {};
       const curModel = (cfg.agents[cur.agentId] && cfg.agents[cur.agentId].model) || "";

package/src/tui-entry.tsx

@@ -0,0 +1,10 @@
+// Compile entry for the standalone executable (bun build --compile).
+// Compiled binaries skip bunfig.toml entirely, so the preload-side effects
+// (Windows VT/console-mode fix, UTF-8 codepage, crash black-box, optional
+// LOOM_START_CWD restore) are imported here explicitly. The dynamic import
+// keeps tui-open.tsx's module graph evaluating AFTER those effects run.
+import "./tui-preload.js";
+// Compiled binaries skip bunfig.toml, so the Solid JSX runtime loader must be
+// registered explicitly before the app graph evaluates.
+import "@opentui/solid/preload";
+await import("./tui-open.tsx");

package/src/tui-open.tsx

@@ -8,6 +8,16 @@ import { defaultMcpInstall } from "./core/plugin-cmd.js";
 globalThis.__loomTrace?.("entry", new Error("module imports evaluated"));
 const args = process.argv.slice(2);
 
+// Restore the user's project directory as the very first module-body
+// statement — i.e. AFTER the entire import graph above has finished
+// evaluating under Bun's original working directory (where bunfig.toml /
+// tsconfig.json were discovered). Doing this any earlier breaks Solid's
+// JSX transform; doing it here means every lazy process.cwd() call in app
+// code still sees the project the user launched from.
+if (process.env.LOOM_START_CWD) {
+  try { process.chdir(process.env.LOOM_START_CWD); } catch {}
+}
+
 // Windows: switch both console codepages to UTF-8 so the box-drawing logo
 // and VT input sequences work even when launched without the bootstrap
 // shim (bun run src/tui-open.tsx). No-op elsewhere / if FFI is unavailable.

package/src/tui-preload.js

@@ -1,51 +1,125 @@
-// Loaded via bunfig.toml preload BEFORE any app code, so this replaces the
-// old CJS bootstrap hop entirely: the launch chain stays a plain direct
-// "bun src/tui-open.tsx" (identical shape to repo runs) while we still get
-// to restore the user's project directory early and keep the crash
-// black-box watching.
-const fs = require("fs");
-const os = require("os");
-const path = require("path");
-
-if (process.platform === "win32") {
-  // UTF-8 console codepage: legacy CPs render the box-drawing logo as "?"
-  // garbage and can mangle VT input sequences.
-  try {
-    const { dlopen } = require("bun:ffi");
-    const k32 = dlopen("kernel32.dll", {
-      SetConsoleOutputCP: { args: ["uint"], returns: "int" },
-      SetConsoleCP: { args: ["uint"], returns: "int" },
-    });
-    k32.symbols.SetConsoleOutputCP(65001);
-    k32.symbols.SetConsoleCP(65001);
-  } catch {}
-}
-
-if (process.env.LOOM_START_CWD) {
-  try { process.chdir(process.env.LOOM_START_CWD); } catch {}
-}
-
-const crashPath = () => path.join(os.homedir(), ".loom", "tui-crash.log");
-function record(kind, err) {
-  try {
-    fs.mkdirSync(path.dirname(crashPath()), { recursive: true });
-    fs.appendFileSync(
-      crashPath(),
-      `[${new Date().toISOString()}] ${kind}: ${(err && (err.stack || err.message)) || String(err)}\n`
-    );
-  } catch {}
-}
-globalThis.__loomTrace = record;
-process.on("uncaughtException", (e) => record("uncaughtException", e));
-process.on("unhandledRejection", (r) => record("unhandledRejection", r));
-
-const __hbStart = Date.now();
-let __hbTick = 0;
-let __hbScheduled = __hbStart;
-const __hbTimer = setInterval(() => {
-  const now = Date.now();
-  record("heartbeat", new Error(`tick=${++__hbTick} lag=${now - __hbScheduled}ms uptime=${now - __hbStart}ms`));
-  __hbScheduled = now + 3000;
-}, 3000);
-try { __hbTimer.unref?.(); } catch {}
-process.on("exit", () => { try { record("exit", new Error(`uptime=${Date.now() - __hbStart}ms ticks=${__hbTick}`)); } catch {} });
+// Loaded via bunfig.toml preload BEFORE any app code, so this replaces the
+// old CJS bootstrap hop entirely: the launch chain stays a plain direct
+// "bun src/tui-open.tsx" (identical shape to repo runs) while we still get
+// to restore the user's project directory early and keep the crash
+// black-box watching.
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+if (process.platform === "win32") {
+  // UTF-8 console codepage: legacy CPs render the box-drawing logo as "?"
+  // garbage and can mangle VT input sequences.
+  try {
+    const { dlopen } = require("bun:ffi");
+    const k32 = dlopen("kernel32.dll", {
+      SetConsoleOutputCP: { args: ["uint"], returns: "int" },
+      SetConsoleCP: { args: ["uint"], returns: "int" },
+    });
+    k32.symbols.SetConsoleOutputCP(65001);
+    k32.symbols.SetConsoleCP(65001);
+  } catch {}
+}
+
+// Windows VT-mode re-enable — OPT-IN via LOOM_FORCE_VT=1.
+// Off by default: OpenTUI manages its own console modes, and forcing flags
+// underneath it can desync its input parsing. Only enable when debugging
+// console-mode issues on a specific terminal.
+if (process.platform === "win32" && process.env.LOOM_FORCE_VT === "1") {
+  try {
+    const { dlopen } = require("bun:ffi");
+    const k32 = dlopen("kernel32.dll", {
+      GetStdHandle: { args: ["int"], returns: "ptr" },
+      GetConsoleMode: { args: ["ptr", "ptr"], returns: "int" },
+      SetConsoleMode: { args: ["ptr", "uint"], returns: "int" },
+    });
+    const STD_INPUT_HANDLE = -10;
+    const STD_OUTPUT_HANDLE = -11;
+
+    // Output: processed + wrap-at-EOL + VT processing (so ANSI repaints work).
+    const ENABLE_PROCESSED_OUTPUT = 0x0001;
+    const ENABLE_WRAP_AT_EOL_OUTPUT = 0x0002;
+    const ENABLE_VIRTUAL_TERMINAL_PROCESSING = 0x0004;
+    // Input: raw-ish mode for OpenTUI — VT input + processed + mouse + window,
+    // with line/echo/quick-edit cleared so keys stream and don't echo.
+    const ENABLE_PROCESSED_INPUT = 0x0001;
+    const ENABLE_MOUSE_INPUT = 0x0010;
+    const ENABLE_WINDOW_INPUT = 0x0008;
+    const ENABLE_VIRTUAL_TERMINAL_INPUT = 0x0200;
+    const ENABLE_QUICK_EDIT_MODE = 0x0040;
+    const ENABLE_LINE_INPUT = 0x0002;
+    const ENABLE_ECHO_INPUT = 0x0004;
+
+    const outH = k32.symbols.GetStdHandle(STD_OUTPUT_HANDLE);
+    const inH = k32.symbols.GetStdHandle(STD_INPUT_HANDLE);
+    const modeBuf = new Uint32Array(1);
+    const modePtr = Bun.ptr(modeBuf);
+
+    if (outH && !outH.isNull && k32.symbols.GetConsoleMode(outH, modePtr)) {
+      const cur = modeBuf[0];
+      const next = cur | ENABLE_PROCESSED_OUTPUT | ENABLE_WRAP_AT_EOL_OUTPUT | ENABLE_VIRTUAL_TERMINAL_PROCESSING;
+      if (next !== cur) k32.symbols.SetConsoleMode(outH, next);
+    }
+    if (inH && !inH.isNull && k32.symbols.GetConsoleMode(inH, modePtr)) {
+      const cur = modeBuf[0];
+      const next = (cur | ENABLE_PROCESSED_INPUT | ENABLE_MOUSE_INPUT | ENABLE_WINDOW_INPUT | ENABLE_VIRTUAL_TERMINAL_INPUT)
+        & ~(ENABLE_LINE_INPUT | ENABLE_ECHO_INPUT | ENABLE_QUICK_EDIT_MODE);
+      if (next !== cur) k32.symbols.SetConsoleMode(inH, next);
+    }
+  } catch {}
+}
+
+// NOTE: LOOM_START_CWD is deliberately NOT applied here. Changing the working
+// directory before the app's module graph loads breaks how Bun resolves the
+// Solid JSX transform (proven: identical entry paints 19KB from repo cwd,
+// 0 bytes from a foreign cwd). The restore happens in tui-open.tsx instead —
+// as a module-body statement, i.e. AFTER every import has finished loading.
+
+const crashPath = () => path.join(os.homedir(), ".loom", "tui-crash.log");
+const MAX_LOG_BYTES = 1024 * 1024; // 1 MB cap, then rotate to .old
+function rotateIfNeeded() {
+  try {
+    const p = crashPath();
+    if (fs.existsSync(p) && fs.statSync(p).size > MAX_LOG_BYTES) {
+      fs.renameSync(p, p + ".old");
+    }
+  } catch {}
+}
+function record(kind, err) {
+  try {
+    fs.mkdirSync(path.dirname(crashPath()), { recursive: true });
+    rotateIfNeeded();
+    fs.appendFileSync(
+      crashPath(),
+      `[${new Date().toISOString()}] ${kind}: ${(err && (err.stack || err.message)) || String(err)}\n`
+    );
+  } catch {}
+}
+globalThis.__loomTrace = record;
+process.on("uncaughtException", (e) => record("uncaughtException", e));
+process.on("unhandledRejection", (r) => record("unhandledRejection", r));
+
+// stdout byte-counter: frames flowing = counter climbs. This splits the two
+// remaining frozen-splash suspects with certainty — if the counter climbs but
+// the screen is frozen, the console is dropping VT repaints (mode flags); if
+// the counter is flat, the renderer flush-loop itself is stalled.
+let __stdoutBytes = 0;
+const __origWrite = process.stdout.write.bind(process.stdout);
+process.stdout.write = function (chunk, ...rest) {
+  try {
+    if (typeof chunk === "string") __stdoutBytes += Buffer.byteLength(chunk, "utf8");
+    else if (chunk && chunk.length) __stdoutBytes += chunk.length;
+  } catch {}
+  return __origWrite(chunk, ...rest);
+};
+
+const __hbStart = Date.now();
+let __hbTick = 0;
+let __hbScheduled = __hbStart;
+const __hbTimer = setInterval(() => {
+  const now = Date.now();
+  record("heartbeat", new Error(`tick=${++__hbTick} lag=${now - __hbScheduled}ms uptime=${now - __hbStart}ms stdoutBytes=${__stdoutBytes}`));
+  __hbScheduled = now + 3000;
+}, 3000);
+try { __hbTimer.unref?.(); } catch {}
+process.on("exit", () => { try { record("exit", new Error(`uptime=${Date.now() - __hbStart}ms ticks=${__hbTick} stdoutBytes=${__stdoutBytes}`)); } catch {} });