@h-rig/cli 0.0.6-alpha.82 → 0.0.6-alpha.84

package/dist/src/app-opentui/launch-routing.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Interactive CLI is app-shell first.
+ *
+ * Native scenes handle the common surfaces (project menu, runs, tasks, inbox,
+ * server, init, doctor, Pi attach). Every other interactive command still
+ * enters OpenTUI and is executed inside an embedded plain-CLI PTY, preserving
+ * the exact existing options/actions/wizards without pretending unsupported
+ * commands were handled by a read-only scene. Machine/internal paths stay plain.
+ */
+export declare function isOpenTuiAppCommand(argv: readonly string[], env?: NodeJS.ProcessEnv): boolean;
+export declare function shouldLaunchTtyApp(input: {
+    readonly argv: readonly string[];
+    readonly stdoutIsTty?: boolean;
+    readonly stdinIsTty?: boolean;
+    readonly env?: NodeJS.ProcessEnv;
+}): boolean;

package/dist/src/app-opentui/launch-routing.js

@@ -0,0 +1,55 @@
+// @bun
+// packages/cli/src/app-opentui/launch-routing.ts
+var GLOBAL_OPTIONS_WITH_VALUE = new Set(["--project", "--policy-mode", "--run-id"]);
+var GLOBAL_FLAGS = new Set(["--dry-run"]);
+function envTruthy(value) {
+  if (!value)
+    return false;
+  const normalized = value.trim().toLowerCase();
+  return normalized !== "0" && normalized !== "false" && normalized !== "no";
+}
+function stripGlobalAppOptions(argv) {
+  const rest = [];
+  for (let index = 0;index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (GLOBAL_FLAGS.has(arg))
+      continue;
+    if (GLOBAL_OPTIONS_WITH_VALUE.has(arg)) {
+      index += 1;
+      continue;
+    }
+    rest.push(arg);
+  }
+  return rest;
+}
+function isOpenTuiAppCommand(argv, env = process.env) {
+  const commandArgv = stripGlobalAppOptions(argv);
+  const [group = "", command = ""] = commandArgv;
+  const normalizedGroup = group.toLowerCase();
+  const normalizedCommand = command.toLowerCase();
+  if (!normalizedGroup)
+    return true;
+  if (normalizedGroup === "__opentui-pi-host" || normalizedGroup === "__rig-server")
+    return false;
+  if (normalizedGroup === "server" && normalizedCommand === "task-run")
+    return false;
+  if (normalizedGroup === "server" && normalizedCommand === "start" && env.RIG_SERVER_INTERNAL_EXEC === "1")
+    return false;
+  return true;
+}
+function shouldLaunchTtyApp(input) {
+  const env = input.env ?? process.env;
+  if (input.argv.includes("--json"))
+    return false;
+  if (env.RIG_CLI_PLAIN_HELP === "1" || env.RIG_PLAIN === "1")
+    return false;
+  if (envTruthy(env.CI))
+    return false;
+  if (!isOpenTuiAppCommand(input.argv, env))
+    return false;
+  return Boolean(input.stdoutIsTty && input.stdinIsTty);
+}
+export {
+  shouldLaunchTtyApp,
+  isOpenTuiAppCommand
+};

package/dist/src/app-opentui/layout.d.ts

@@ -8,7 +8,14 @@ export type StageLayout = {
     readonly typeBarTop: number;
     readonly footerTop: number;
     readonly compact: boolean;
+    /** Raw terminal is below the usable threshold; render a guidance message
+     * instead of a scene that would clip into nothing (#18). */
+    readonly tooSmall: boolean;
 };
+/** Below these raw dimensions, ad-terminal panels collapse below their 4×4
+ * floor and the UI would blank silently. We show a "resize me" card instead. */
+export declare const MIN_TERMINAL_WIDTH = 48;
+export declare const MIN_TERMINAL_HEIGHT = 16;
 export declare function computeStageLayout(width: number, height: number): StageLayout;
 export declare function visibleWidth(text: string): number;
 export declare function alignText(text: string, width: number, align?: "left" | "center" | "right"): string;

package/dist/src/app-opentui/layout.js

@@ -1,17 +1,22 @@
 // @bun
 // packages/cli/src/app-opentui/layout.ts
+var MIN_TERMINAL_WIDTH = 48;
+var MIN_TERMINAL_HEIGHT = 16;
 function computeStageLayout(width, height) {
-  const safeWidth = Math.max(40, Math.trunc(width || 80));
-  const safeHeight = Math.max(18, Math.trunc(height || 24));
+  const rawWidth = Math.trunc(width || 80);
+  const rawHeight = Math.trunc(height || 24);
+  const tooSmall = rawWidth < MIN_TERMINAL_WIDTH || rawHeight < MIN_TERMINAL_HEIGHT;
+  const safeWidth = Math.max(40, rawWidth);
+  const safeHeight = Math.max(18, rawHeight);
   const compact = safeWidth < 92 || safeHeight < 30;
   const horizontalGutter = compact ? 1 : 2;
   const centerWidth = Math.max(36, safeWidth - horizontalGutter * 2);
   const centerLeft = horizontalGutter;
-  const typeBarTop = Math.max(0, safeHeight - 3);
   const footerTop = Math.max(0, safeHeight - 1);
+  const typeBarTop = Math.max(0, footerTop - 1);
   const centerTop = compact ? 1 : Math.max(1, Math.floor(safeHeight * 0.055));
-  const centerHeight = Math.max(8, typeBarTop - centerTop - 1);
-  return { width: safeWidth, height: safeHeight, centerWidth, centerLeft, centerTop, centerHeight, typeBarTop, footerTop, compact };
+  const centerHeight = Math.max(6, typeBarTop - centerTop);
+  return { width: safeWidth, height: safeHeight, centerWidth, centerLeft, centerTop, centerHeight, typeBarTop, footerTop, compact, tooSmall };
 }
 function visibleWidth(text) {
   return [...text].length;
@@ -40,5 +45,7 @@ export {
   visibleWidth,
   truncateText,
   computeStageLayout,
-  alignText
+  alignText,
+  MIN_TERMINAL_WIDTH,
+  MIN_TERMINAL_HEIGHT
 };

package/dist/src/app-opentui/list-search.d.ts

@@ -6,3 +6,27 @@ export declare function listSearchQuery(state: AppState): string;
 export declare function filterRunsForSearch(runs: readonly AppRunRecord[], query: string): AppRunRecord[];
 export declare function filterTasksForSearch(tasks: readonly AppTaskRecord[], query: string): AppTaskRecord[];
 export declare function searchSummary(kind: "runs" | "tasks", query: string, visible: number, total: number): string;
+export type SortDir = "asc" | "desc";
+export type RunSortKey = "status" | "runId" | "title" | "age";
+export type RunSortSpec = {
+    readonly key: RunSortKey;
+    readonly dir: SortDir;
+};
+export type TaskSortKey = "status" | "id" | "priority" | "assignee" | "title";
+export type TaskSortSpec = {
+    readonly key: TaskSortKey;
+    readonly dir: SortDir;
+};
+/** Read a typed run sort spec off the data bag, narrowing the `unknown` slice. */
+export declare function runSortSpec(value: unknown): RunSortSpec | null;
+/** Read a typed task sort spec off the data bag, narrowing the `unknown` slice. */
+export declare function taskSortSpec(value: unknown): TaskSortSpec | null;
+/** Cycle a column's sort: clicking the active column flips asc→desc→default;
+ * clicking a new column starts it ascending. `null` means "back to default". */
+export declare function cycleRunSort(current: RunSortSpec | null, key: RunSortKey): RunSortSpec | null;
+export declare function cycleTaskSort(current: TaskSortSpec | null, key: TaskSortKey): TaskSortSpec | null;
+/** Sort runs by a column. `spec === null` returns the input order unchanged. */
+export declare function sortRuns(runs: readonly AppRunRecord[], spec: RunSortSpec | null): AppRunRecord[];
+/** Sort tasks by a column, client-side over already-fetched records. `spec ===
+ * null` returns the input order unchanged (server/adapter order is preserved). */
+export declare function sortTasks(tasks: readonly AppTaskRecord[], spec: TaskSortSpec | null): AppTaskRecord[];

package/dist/src/app-opentui/list-search.js

@@ -34,10 +34,97 @@ function filterTasksForSearch(tasks, query) {
 function searchSummary(kind, query, visible, total) {
   return query.trim() ? `search ${JSON.stringify(query)} \xB7 ${visible}/${total} ${kind}` : `${total} ${kind}`;
 }
+function runSortSpec(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return null;
+  const record = value;
+  const key = record.key;
+  const dir = record.dir;
+  if ((key === "status" || key === "runId" || key === "title" || key === "age") && (dir === "asc" || dir === "desc")) {
+    return { key, dir };
+  }
+  return null;
+}
+function taskSortSpec(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return null;
+  const record = value;
+  const key = record.key;
+  const dir = record.dir;
+  if ((key === "status" || key === "id" || key === "priority" || key === "assignee" || key === "title") && (dir === "asc" || dir === "desc")) {
+    return { key, dir };
+  }
+  return null;
+}
+function cycleRunSort(current, key) {
+  if (!current || current.key !== key)
+    return { key, dir: "asc" };
+  if (current.dir === "asc")
+    return { key, dir: "desc" };
+  return null;
+}
+function cycleTaskSort(current, key) {
+  if (!current || current.key !== key)
+    return { key, dir: "asc" };
+  if (current.dir === "asc")
+    return { key, dir: "desc" };
+  return null;
+}
+function ageValue(updatedAt) {
+  const parsed = Date.parse(updatedAt ?? "");
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+function applyDir(rows, compare, dir) {
+  const sorted = [...rows].sort(compare);
+  return dir === "desc" ? sorted.reverse() : sorted;
+}
+function sortRuns(runs, spec) {
+  if (!spec)
+    return [...runs];
+  const { key, dir } = spec;
+  if (key === "age") {
+    const byNewest = applyDir(runs, (a, b) => ageValue(b.updatedAt) - ageValue(a.updatedAt) || a.runId.localeCompare(b.runId), "asc");
+    return dir === "asc" ? byNewest : [...byNewest].reverse();
+  }
+  const compare = (a, b) => {
+    if (key === "status")
+      return a.status.localeCompare(b.status) || a.runId.localeCompare(b.runId);
+    if (key === "title")
+      return a.title.localeCompare(b.title, undefined, { sensitivity: "base" }) || a.runId.localeCompare(b.runId);
+    return a.runId.localeCompare(b.runId, undefined, { numeric: true });
+  };
+  return applyDir(runs, compare, dir);
+}
+function sortTasks(tasks, spec) {
+  if (!spec)
+    return [...tasks];
+  const { key, dir } = spec;
+  const compare = (a, b) => {
+    if (key === "status")
+      return a.status.localeCompare(b.status) || a.id.localeCompare(b.id, undefined, { numeric: true });
+    if (key === "priority") {
+      const left = a.priority ?? Number.NEGATIVE_INFINITY;
+      const right = b.priority ?? Number.NEGATIVE_INFINITY;
+      return right - left || a.id.localeCompare(b.id, undefined, { numeric: true });
+    }
+    if (key === "assignee")
+      return (a.assignees[0] ?? "").localeCompare(b.assignees[0] ?? "") || a.id.localeCompare(b.id, undefined, { numeric: true });
+    if (key === "title")
+      return a.title.localeCompare(b.title, undefined, { sensitivity: "base" }) || a.id.localeCompare(b.id, undefined, { numeric: true });
+    return a.id.localeCompare(b.id, undefined, { numeric: true });
+  };
+  return applyDir(tasks, compare, dir);
+}
 export {
+  taskSortSpec,
+  sortTasks,
+  sortRuns,
   searchSummary,
+  runSortSpec,
   listSearchQuery,
   isListSearchScene,
   filterTasksForSearch,
-  filterRunsForSearch
+  filterRunsForSearch,
+  cycleTaskSort,
+  cycleRunSort
 };

package/dist/src/app-opentui/pi-host-child.js

@@ -143,17 +143,21 @@ function cleanToken(value) {
   const trimmed = value?.trim();
   return trimmed ? trimmed : null;
 }
-function readPrivateRemoteSessionToken(projectRoot) {
+function readRemoteAuthState(projectRoot) {
   const path = resolve2(projectRoot, ".rig", "state", "github-auth.json");
   if (!existsSync2(path))
     return null;
   try {
     const parsed = JSON.parse(readFileSync2(path, "utf8"));
-    return cleanToken(typeof parsed.apiSessionToken === "string" ? parsed.apiSessionToken : typeof parsed.sessionToken === "string" ? parsed.sessionToken : undefined);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
   } catch {
     return null;
   }
 }
+function readPrivateRemoteSessionToken(projectRoot) {
+  const parsed = readRemoteAuthState(projectRoot);
+  return parsed ? cleanToken(typeof parsed.apiSessionToken === "string" ? parsed.apiSessionToken : typeof parsed.sessionToken === "string" ? parsed.sessionToken : undefined) : null;
+}
 function readGitHubBearerTokenForRemote(projectRoot) {
   const scopedKey = resolve2(projectRoot);
   if (scopedGitHubBearerTokens.has(scopedKey))
@@ -164,15 +168,25 @@ function readGitHubBearerTokenForRemote(projectRoot) {
   return cleanToken(process.env.RIG_SERVER_AUTH_TOKEN) ?? cleanToken(process.env.RIG_REMOTE_AUTH_TOKEN);
 }
 function readStoredGitHubAuthToken(projectRoot) {
-  const path = resolve2(projectRoot, ".rig", "state", "github-auth.json");
-  if (!existsSync2(path))
+  const parsed = readRemoteAuthState(projectRoot);
+  return parsed ? cleanToken(typeof parsed.token === "string" ? parsed.token : undefined) : null;
+}
+function inferRemoteServerProjectRootFromAuthState(projectRoot) {
+  const repo = readRepoConnection(projectRoot);
+  const slug = repo?.project?.trim();
+  if (!slug || !/^[^/]+\/[^/]+$/.test(slug))
     return null;
-  try {
-    const parsed = JSON.parse(readFileSync2(path, "utf8"));
-    return cleanToken(typeof parsed.token === "string" ? parsed.token : undefined);
-  } catch {
+  const auth = readRemoteAuthState(projectRoot);
+  const authUpdatedAt = typeof auth?.updatedAt === "string" ? Date.parse(auth.updatedAt) : Number.NaN;
+  const repoLinkedAt = typeof repo?.linkedAt === "string" ? Date.parse(repo.linkedAt) : Number.NaN;
+  if (Number.isFinite(authUpdatedAt) && Number.isFinite(repoLinkedAt) && authUpdatedAt + 1000 < repoLinkedAt)
     return null;
-  }
+  const checkoutBaseDir = typeof auth?.checkoutBaseDir === "string" && auth.checkoutBaseDir.trim() ? auth.checkoutBaseDir.trim() : null;
+  if (!checkoutBaseDir)
+    return null;
+  const inferred = `${checkoutBaseDir.replace(/\/+$/, "")}/${slug}`;
+  writeRepoServerProjectRoot(projectRoot, inferred);
+  return inferred;
 }
 function readLocalConnectionFallbackToken(projectRoot) {
   return readGitHubBearerTokenForRemote(projectRoot) ?? cleanToken(process.env.RIG_GITHUB_TOKEN) ?? readStoredGitHubAuthToken(projectRoot);
@@ -183,7 +197,7 @@ async function ensureServerForCli(projectRoot) {
     if (selected?.connection.kind === "remote") {
       reportServerPhase(`Connecting to ${selected.alias}\u2026`);
       const authToken = readGitHubBearerTokenForRemote(projectRoot);
-      const serverProjectRoot = selected.serverProjectRoot ?? await backfillRemoteServerProjectRoot(projectRoot, selected.connection.baseUrl, authToken);
+      const serverProjectRoot = selected.serverProjectRoot ?? inferRemoteServerProjectRootFromAuthState(projectRoot) ?? await backfillRemoteServerProjectRoot(projectRoot, selected.connection.baseUrl, authToken);
       return {
         baseUrl: selected.connection.baseUrl,
         authToken,
@@ -212,7 +226,10 @@ async function backfillRemoteServerProjectRoot(projectRoot, baseUrl, authToken)
   if (!slug)
     return null;
   try {
-    const response = await fetch(`${baseUrl}/api/projects/${encodeURIComponent(slug)}`, {
+    const url = new URL(`${baseUrl}/api/projects/${encodeURIComponent(slug)}`);
+    if (authToken && queryAuthFallbackEnabled())
+      url.searchParams.set("rt", authToken);
+    const response = await fetch(url, {
       headers: mergeHeaders(undefined, authToken)
     });
     if (!response.ok)
@@ -229,10 +246,23 @@ async function backfillRemoteServerProjectRoot(projectRoot, baseUrl, authToken)
     return null;
   }
 }
+function mergeCookie(existing, name, value) {
+  const encoded = `${name}=${encodeURIComponent(value)}`;
+  if (!existing?.trim())
+    return encoded;
+  const parts = existing.split(";").map((part) => part.trim()).filter((part) => part && !part.startsWith(`${name}=`));
+  return [...parts, encoded].join("; ");
+}
+function queryAuthFallbackEnabled(env = process.env) {
+  return env.RIG_ENABLE_QUERY_AUTH_FALLBACK === "1" || env.RIG_QUERY_AUTH_FALLBACK === "1";
+}
 function mergeHeaders(headers, authToken) {
   const merged = new Headers(headers);
   if (authToken) {
-    merged.set("authorization", `Bearer ${authToken}`);
+    const bearer = `Bearer ${authToken}`;
+    merged.set("authorization", bearer);
+    merged.set("x-auth", bearer);
+    merged.set("cookie", mergeCookie(merged.get("cookie"), "rig_auth", authToken));
   }
   return merged;
 }
@@ -293,15 +323,34 @@ async function buildServerFailureContext(projectRoot, server) {
     hint: "Check the selected server with `rig server status`, or switch with `rig server use <alias|local>`."
   };
 }
+function isLoopbackRemoteBaseUrl(baseUrl) {
+  try {
+    const host = new URL(baseUrl).hostname.toLowerCase();
+    return host === "localhost" || host === "127.0.0.1" || host === "::1" || host === "[::1]";
+  } catch {
+    return false;
+  }
+}
+function canUseRemoteWithoutProjectRoot(pathname) {
+  return pathname === "/health" || pathname === "/api/health" || pathname === "/api/server/status" || pathname === "/api/server/project-root" || pathname.startsWith("/api/github/auth/") || pathname === "/api/projects" || pathname.startsWith("/api/projects/");
+}
 async function requestServerJson(context, pathname, init = {}) {
   const server = await ensureServerForCli(context.projectRoot);
+  const requestUrl = new URL(`${server.baseUrl}${pathname}`);
+  if (server.connectionKind === "remote" && !server.serverProjectRoot && !canUseRemoteWithoutProjectRoot(requestUrl.pathname) && (server.authToken || !isLoopbackRemoteBaseUrl(server.baseUrl))) {
+    const repo = readRepoConnection(context.projectRoot);
+    throw new CliError(`Remote server is selected for ${repo?.project ?? "this repo"}, but this checkout has no server-host project root link.`, 1, { hint: "Run `rig init --repair` or `rig init --yes --repo owner/repo --server remote` to repair the remote project link before task/run commands." });
+  }
   const headers = mergeHeaders(init.headers, server.authToken);
   if (server.serverProjectRoot)
     headers.set("x-rig-project-root", server.serverProjectRoot);
+  if (server.connectionKind === "remote" && server.authToken && queryAuthFallbackEnabled()) {
+    requestUrl.searchParams.set("rt", server.authToken);
+  }
   reportServerPhase(`${(init.method ?? "GET").toUpperCase()} ${pathname.split("?")[0]}\u2026`);
   let response;
   try {
-    response = await fetch(`${server.baseUrl}${pathname}`, {
+    response = await fetch(requestUrl, {
       ...init,
       headers
     });
@@ -538,6 +587,14 @@ async function withSpinner(label, work, options = {}) {
 }
 
 // packages/cli/src/commands/_pi-frontend.ts
+var TERMINAL_RUN_STATUSES = new Set(["completed", "failed", "stopped", "cancelled", "canceled", "closed", "merged", "needs_attention", "needs-attention"]);
+
+class OperatorTranscriptUnavailableError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "OperatorTranscriptUnavailableError";
+  }
+}
 function setTemporaryEnv(updates) {
   const previous = new Map;
   for (const [key, value] of Object.entries(updates)) {
@@ -565,6 +622,23 @@ function buildOperatorPiEnv(input) {
     ...input.serverProjectRoot ? { RIG_PROJECT_ROOT: input.serverProjectRoot } : {}
   };
 }
+function shouldRequireOperatorTranscript(status) {
+  return typeof status === "string" && TERMINAL_RUN_STATUSES.has(status.trim().toLowerCase());
+}
+function missingOperatorTranscriptMessage(runId, status) {
+  const shortRun = runId.trim().slice(0, 8) || "unknown";
+  const statusText = typeof status === "string" && status.trim() ? status.trim() : "terminal";
+  return `Run ${shortRun} is ${statusText}, but no worker Pi session transcript is recorded for this run. It likely failed before Pi started or predates full-session capture. Use \`rig run show ${runId}\` and \`rig run logs ${runId}\` for the lifecycle details.`;
+}
+function statusFromRunDetails(run) {
+  if (!run || typeof run !== "object" || Array.isArray(run))
+    return;
+  const record = run;
+  if (typeof record.status === "string")
+    return record.status;
+  const nested = record.run;
+  return nested && typeof nested === "object" && !Array.isArray(nested) ? nested.status : undefined;
+}
 async function prepareOperatorConsole(context, runId, tempSessionDir) {
   const server = await ensureServerForCli(context.projectRoot);
   const localCwd = join(homedir2(), ".rig", "drones", runId.slice(0, 8));
@@ -594,6 +668,13 @@ async function prepareOperatorConsole(context, runId, tempSessionDir) {
       sessionFileArg = ["--session", localSessionPath];
     }
   } catch {}
+  if (sessionFileArg.length === 0) {
+    const run = await getRunDetailsViaServer(context, runId).catch(() => null);
+    const status = statusFromRunDetails(run);
+    if (shouldRequireOperatorTranscript(status)) {
+      throw new OperatorTranscriptUnavailableError(missingOperatorTranscriptMessage(runId, status));
+    }
+  }
   return { server, sessionFileArg };
 }
 var RIG_PI_THEME = {
@@ -711,6 +792,7 @@ async function attachRunBundledPiFrontend(context, input) {
   let detached = false;
   try {
     await runPiMain([
+      "--offline",
       "--no-extensions",
       "--no-skills",
       "--no-prompt-templates",
@@ -751,9 +833,9 @@ function parseArgs(argv) {
   const runId = takeOption(argv, "--run-id")?.trim();
   const projectRoot = takeOption(argv, "--project-root")?.trim();
   if (!runId)
-    throw new Error("Missing --run-id for Rig Pi host child.");
+    throw new Error("Missing --run-id for Pi host child.");
   if (!projectRoot)
-    throw new Error("Missing --project-root for Rig Pi host child.");
+    throw new Error("Missing --project-root for Pi host child.");
   return { runId, projectRoot };
 }
 async function runOpenTuiPiHostChild(argv = process.argv.slice(2)) {
@@ -765,9 +847,9 @@ if (import.meta.main) {
   try {
     await runOpenTuiPiHostChild();
   } catch (error) {
-    const message = error instanceof Error ? error.stack || error.message : String(error);
+    const message = error instanceof Error ? error.name === "OperatorTranscriptUnavailableError" ? error.message : error.stack || error.message : String(error);
     process.stderr.write(`
-Rig Pi host failed:
+Pi host failed:
 ${message}
 `);
     process.exit(1);

package/dist/src/app-opentui/pi-pty-host.d.ts

@@ -1,5 +1,14 @@
 import { StyledText } from "@opentui/core";
 export type PiPtyHostStatus = "starting" | "running" | "exited" | "failed";
+/**
+ * Temporary embedded-Pi presentation contract.
+ *
+ * The worker/remote Pi daemon still owns tools, skills, cwd, model, session and
+ * context. This local host only mirrors a PTY/xterm viewport into selectable
+ * OpenTUI text. Keep this snapshot path explicit until Rig grows a dedicated
+ * PTY/xterm viewport renderable or deliberately suspends OpenTUI for direct Pi
+ * terminal ownership.
+ */
 export type PiPtyHostSnapshot = {
     readonly runId: string;
     readonly status: PiPtyHostStatus;
@@ -8,6 +17,7 @@ export type PiPtyHostSnapshot = {
     readonly lines: readonly string[];
     readonly styledLines?: readonly StyledText[];
     readonly message?: string;
+    readonly resizeError?: string;
     readonly exitCode?: number;
     readonly signal?: string | null;
 };
@@ -40,9 +50,13 @@ export declare class PiPtyHost {
     private cols;
     private rows;
     private message;
+    private lastResizeError;
     private exitCode;
     private signal;
     private notifyTimer;
+    /** Last streamed buffer content, so the onWriteParsed handler only emits a
+     * snapshot when the rendered content actually changed. */
+    private lastStreamKey;
     private _disposed;
     constructor(options: PiPtyHostOptions);
     get disposed(): boolean;

package/dist/src/app-opentui/pi-pty-host.js

@@ -8,8 +8,8 @@ var MIN_COLS = 40;
 var MIN_ROWS = 12;
 var MAX_ROWS = 300;
 var MAX_SNAPSHOT_LINES = 360;
-var STYLED_SNAPSHOT_MARGIN = 24;
-var SNAPSHOT_DELAY_MS = 33;
+var STYLED_SNAPSHOT_MARGIN = 6;
+var SNAPSHOT_DELAY_MS = 120;
 var fallbackChildScriptPath = fileURLToPath(new URL("./pi-host-child.ts", import.meta.url));
 var activeHost = null;
 function clampCols(cols) {
@@ -107,17 +107,15 @@ function lineToStyledText(line, cols) {
 function childCommandPrefix() {
   const execName = basename(process.execPath).toLowerCase();
   const currentEntry = process.argv[1];
-  if ((execName === "bun" || execName === "bun.exe") && currentEntry) {
-    return [process.execPath, currentEntry, "__opentui-pi-host"];
+  if (execName === "bun" || execName === "bun.exe") {
+    return currentEntry ? [process.execPath, currentEntry, "__opentui-pi-host"] : [process.execPath, fallbackChildScriptPath];
   }
-  if (currentEntry)
-    return [process.execPath, "__opentui-pi-host"];
-  return [process.execPath, fallbackChildScriptPath];
+  return [process.execPath, "__opentui-pi-host"];
 }
 function withEnv(base) {
   const env = {};
   for (const [key, value] of Object.entries(base ?? process.env)) {
-    if (key === "RIG_PLAIN" || key === "RIG_CLI_PLAIN_HELP")
+    if (key === "RIG_PLAIN" || key === "RIG_CLI_PLAIN_HELP" || key === "NO_COLOR")
       continue;
     if (typeof value === "string")
       env[key] = value;
@@ -160,9 +158,11 @@ class PiPtyHost {
   cols;
   rows;
   message = "starting bundled Pi";
+  lastResizeError = null;
   exitCode;
   signal;
   notifyTimer = null;
+  lastStreamKey = "";
   _disposed = false;
   constructor(options) {
     this.runId = options.runId;
@@ -176,9 +176,20 @@ class PiPtyHost {
       allowProposedApi: true,
       cols: this.cols,
       rows: this.rows,
-      scrollback: 5000
+      scrollback: 1000
     });
     this.registerTerminalResponders();
+    this.disposables.push(this.terminal.onWriteParsed(() => {
+      if (this._disposed)
+        return;
+      const snapshot = this.createSnapshot();
+      const key = snapshot.lines.join(`
+`);
+      if (key === this.lastStreamKey)
+        return;
+      this.lastStreamKey = key;
+      this.onSnapshot?.(snapshot);
+    }));
   }
   get disposed() {
     return this._disposed;
@@ -190,7 +201,7 @@ class PiPtyHost {
     if (this._disposed)
       throw new Error("Pi PTY host is disposed.");
     if (typeof Bun.Terminal !== "function") {
-      throw new Error("Bun native PTY is unavailable in this runtime. Rig OpenTUI Pi host requires Bun.Terminal.");
+      throw new Error("Bun native PTY is unavailable in this runtime. Pi host requires Bun.Terminal.");
     }
     const spawnOptions = {
       cwd: this.projectRoot,
@@ -214,7 +225,7 @@ class PiPtyHost {
     this.proc = proc;
     this.pty = proc.terminal;
     this.status = "running";
-    this.message = "bundled Pi running inside Rig";
+    this.message = "bundled Pi running inside this app";
     this.emitSnapshotSoon(0);
     proc.exited.then((exitCode) => {
       if (this._disposed)
@@ -265,7 +276,10 @@ class PiPtyHost {
     this.terminal.resize(nextCols, nextRows);
     try {
       this.pty?.resize(nextCols, nextRows);
-    } catch {}
+      this.lastResizeError = null;
+    } catch (error) {
+      this.lastResizeError = error instanceof Error ? error.message : String(error);
+    }
     this.emitSnapshotSoon(0);
   }
   detach() {
@@ -307,7 +321,7 @@ class PiPtyHost {
       return;
     const text = this.decoder.decode(data, { stream: true });
     this.respondToRawTerminalQueries(text);
-    this.terminal.write(data, () => this.emitSnapshotSoon());
+    this.terminal.write(data);
   }
   emitSnapshotSoon(delayMs = SNAPSHOT_DELAY_MS) {
     if (this._disposed || this.notifyTimer)
@@ -336,6 +350,7 @@ class PiPtyHost {
       lines.push("");
       styledLines[lines.length - 1] = new StyledText([{ __isChunk: true, text: "" }]);
     }
+    const resolvedMessage = this.lastResizeError ? `resize degraded: ${this.lastResizeError}` : message;
     return {
       runId: this.runId,
       status: this.status,
@@ -343,7 +358,8 @@ class PiPtyHost {
       rows: this.rows,
       lines,
       styledLines,
-      message,
+      message: resolvedMessage,
+      ...this.lastResizeError ? { resizeError: this.lastResizeError } : {},
       ...this.exitCode !== undefined ? { exitCode: this.exitCode } : {},
       ...this.signal !== undefined ? { signal: this.signal } : {}
     };

package/dist/src/app-opentui/react/App.d.ts

@@ -0,0 +1,9 @@
+import { computeStageLayout } from "../layout";
+import { entryIntentForScene } from "../runtime";
+import { PRIMARY_NAV } from "./nav";
+import type { AppSceneFrame, AppSceneId, AppState } from "../types";
+type SceneRenderer = (state: AppState, layout: ReturnType<typeof computeStageLayout>) => AppSceneFrame;
+export declare function App(props: {
+    sceneRenderers?: Partial<Record<AppSceneId, SceneRenderer>>;
+}): React.ReactNode;
+export { PRIMARY_NAV, entryIntentForScene };