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

package/dist/src/app-opentui/adapters/pi-attach.js

@@ -15,6 +15,70 @@ var __export = (target, all) => {
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
+// packages/cli/src/app-opentui/adapters/common.ts
+function projectRootOf(ctx) {
+  const root = ctx.rig?.projectRoot ?? ctx.projectRoot ?? ctx.getState().projectRoot;
+  if (typeof root === "string" && root.trim())
+    return root;
+  throw new Error("App adapter requires a projectRoot.");
+}
+function normalizeAppError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  const rawHint = error instanceof Error ? error.hint : undefined;
+  return {
+    message,
+    ...typeof rawHint === "string" && rawHint.trim() ? { hint: rawHint.trim() } : {}
+  };
+}
+function emitStarted(ctx, label, optimistic) {
+  ctx.emit({ type: "action.started", label, ...optimistic ? { optimistic } : {} });
+}
+function emitProgress(ctx, label, detail, data) {
+  ctx.emit({ type: "action.progress", label, ...detail ? { detail } : {}, ...data ? { data } : {} });
+}
+function emitCompleted(ctx, label, data) {
+  ctx.emit({ type: "action.completed", label, ...data ? { data } : {} });
+}
+function emitFailed(ctx, label, error, data) {
+  if (data)
+    patchData(ctx, data);
+  const normalized = normalizeAppError(error);
+  ctx.emit({
+    type: "action.failed",
+    label,
+    message: normalized.message,
+    ...normalized.hint ? { hint: normalized.hint } : {},
+    cause: error
+  });
+}
+function patchData(ctx, data) {
+  ctx.emit({ type: "data.patch", data });
+}
+function patchFooter(ctx, footer) {
+  ctx.emit({ type: "footer.patch", footer });
+}
+function arrayFromPayload(value) {
+  if (Array.isArray(value)) {
+    return value.filter((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry)));
+  }
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    const entries = value.entries;
+    if (Array.isArray(entries))
+      return arrayFromPayload(entries);
+  }
+  return [];
+}
+function stringField(record, keys, fallback = "") {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim())
+      return value.trim();
+    if (typeof value === "number" && Number.isFinite(value))
+      return String(value);
+  }
+  return fallback;
+}
+
 // packages/cli/src/runner.ts
 import { EventBus } from "@rig/runtime/control-plane/runtime/events";
 import { CliError as RuntimeCliError } from "@rig/runtime/control-plane/errors";
@@ -192,17 +256,21 @@ function setGitHubBearerTokenForCurrentProcess(token, projectRoot) {
   const scopedKey = resolve2(projectRoot ?? process.cwd());
   scopedGitHubBearerTokens.set(scopedKey, cleanToken(token ?? undefined));
 }
-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))
@@ -213,15 +281,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);
@@ -232,7 +310,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,
@@ -261,7 +339,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)
@@ -288,10 +369,23 @@ function appendTaskFilterParams(url, filters) {
   if (filters.limit !== undefined)
     url.searchParams.set("limit", String(filters.limit));
 }
+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;
 }
@@ -351,15 +445,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
     });
@@ -421,11 +534,26 @@ async function getGitHubAuthStatusViaServer(context) {
   return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
 }
 async function postGitHubTokenViaServer(context, token, options = {}) {
-  const payload = await requestServerJson(context, "/api/github/auth/token", {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body: JSON.stringify({ token, selectedRepo: options.selectedRepo, projectRoot: options.projectRoot })
-  });
+  const server = await ensureServerForCli(context.projectRoot);
+  const requestUrl = new URL(`${server.baseUrl}/api/github/auth/token`);
+  reportServerPhase("POST /api/github/auth/token\u2026");
+  let response;
+  try {
+    response = await fetch(requestUrl, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ token, selectedRepo: options.selectedRepo, projectRoot: options.projectRoot ?? server.serverProjectRoot ?? undefined })
+    });
+  } catch (error) {
+    const failure = await buildServerFailureContext(context.projectRoot, server);
+    throw new CliError(`Rig server auth bootstrap failed: ${error instanceof Error ? error.message : String(error)}
+${failure.contextLine}`, 1, { hint: failure.hint });
+  }
+  const payload = await response.json().catch(() => null);
+  if (!response.ok) {
+    const detail = payload && typeof payload === "object" && !Array.isArray(payload) ? String(payload.error ?? JSON.stringify(payload)) : `HTTP ${response.status}`;
+    throw new CliError(`Rig server auth bootstrap failed (${response.status}): ${detail}`, 1, { hint: "Re-run `rig github auth import-gh`, or check the selected server with `rig server status`." });
+  }
   return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
 }
 async function prepareRemoteCheckoutViaServer(context, input) {
@@ -702,72 +830,203 @@ var init__server_client = __esm(() => {
   ]);
 });
 
-// packages/cli/src/app-opentui/adapters/common.ts
-function adapterContextFromRuntime(runtime, renderer) {
-  return {
-    projectRoot: runtime.getState().projectRoot,
-    renderer,
-    ensureRuntime: () => runtime.getRunnerContext(),
-    emit: (event) => runtime.emit(event),
-    getState: () => runtime.getState()
-  };
-}
-function projectRootOf(ctx) {
-  const root = ctx.rig?.projectRoot ?? ctx.projectRoot ?? ctx.getState().projectRoot;
-  if (typeof root === "string" && root.trim())
-    return root;
-  throw new Error("Rig app adapter requires a projectRoot.");
-}
-function normalizeAppError(error) {
-  const message = error instanceof Error ? error.message : String(error);
-  const rawHint = error instanceof Error ? error.hint : undefined;
-  return {
-    message,
-    ...typeof rawHint === "string" && rawHint.trim() ? { hint: rawHint.trim() } : {}
-  };
-}
-function emitStarted(ctx, label, optimistic) {
-  ctx.emit({ type: "action.started", label, ...optimistic ? { optimistic } : {} });
-}
-function emitProgress(ctx, label, detail, data) {
-  ctx.emit({ type: "action.progress", label, ...detail ? { detail } : {}, ...data ? { data } : {} });
+// packages/cli/src/app-opentui/adapters/inspect.ts
+var exports_inspect = {};
+__export(exports_inspect, {
+  loadInspectRuns: () => loadInspectRuns,
+  loadInspect: () => loadInspect,
+  INSPECT_VIEWS: () => INSPECT_VIEWS
+});
+import { execFile } from "child_process";
+import { existsSync as existsSync3, readFileSync as readFileSync3, readdirSync, statSync } from "fs";
+import { resolve as resolve3 } from "path";
+import { promisify } from "util";
+import { resolveTaskArtifactDirs } from "@rig/runtime/control-plane/authority-files";
+import { readTaskArtifactPreview } from "@rig/runtime/control-plane/native/workspace-ops";
+import { resolveHarnessPaths, resolveMonorepoRoot, runCapture } from "@rig/runtime/control-plane/native/utils";
+function isFailureEntry(entry) {
+  const status = `${entry.status ?? entry.level ?? entry.type ?? ""}`.toLowerCase();
+  return status.includes("fail") || status.includes("error");
+}
+async function gitDiff(projectRoot) {
+  try {
+    const { stdout } = await execFileAsync("git", ["diff", "--no-color"], { cwd: projectRoot, maxBuffer: 8 * 1024 * 1024 });
+    return { diff: stdout };
+  } catch (error) {
+    return { diff: "", error: normalizeAppError(error).message };
+  }
 }
-function emitCompleted(ctx, label, data) {
-  ctx.emit({ type: "action.completed", label, ...data ? { data } : {} });
+function listArtifacts(projectRoot, taskId) {
+  if (!taskId)
+    return { artifacts: [], error: "run has no task id \u2014 artifacts are resolved per task" };
+  try {
+    const dirs = resolveTaskArtifactDirs(projectRoot, taskId).filter((dir) => existsSync3(dir));
+    const out = [];
+    const seen = new Set;
+    for (const dir of dirs) {
+      for (const name of readdirSync(dir)) {
+        if (seen.has(name))
+          continue;
+        seen.add(name);
+        const path = resolve3(dir, name);
+        try {
+          const stat = statSync(path);
+          out.push({ name, path, sizeBytes: stat.size, isDir: stat.isDirectory() });
+        } catch {
+          out.push({ name, path, sizeBytes: 0, isDir: false });
+        }
+      }
+    }
+    out.sort((left, right) => left.name.localeCompare(right.name));
+    return { artifacts: out };
+  } catch (error) {
+    return { artifacts: [], error: normalizeAppError(error).message };
+  }
 }
-function emitFailed(ctx, label, error, data) {
-  if (data)
-    patchData(ctx, data);
-  const normalized = normalizeAppError(error);
-  ctx.emit({
-    type: "action.failed",
-    label,
-    message: normalized.message,
-    ...normalized.hint ? { hint: normalized.hint } : {},
-    cause: error
-  });
+function readArtifact(projectRoot, taskId, fileName) {
+  if (!taskId)
+    return;
+  try {
+    const preview = readTaskArtifactPreview(projectRoot, taskId, fileName);
+    return { name: fileName, contents: preview.contents, truncated: preview.truncated, sizeBytes: preview.sizeBytes };
+  } catch (error) {
+    return { name: fileName, contents: `Failed to read artifact: ${normalizeAppError(error).message}`, truncated: false, sizeBytes: 0 };
+  }
 }
-function patchData(ctx, data) {
-  ctx.emit({ type: "data.patch", data });
+function loadGraph(projectRoot) {
+  try {
+    const result = runCapture(["br", "--no-db", "list", "--pretty"], resolveMonorepoRoot(projectRoot));
+    if (result.exitCode !== 0)
+      return { graph: "", error: result.stderr || result.stdout || "failed to inspect graph" };
+    return { graph: result.stdout };
+  } catch (error) {
+    return { graph: "", error: normalizeAppError(error).message };
+  }
 }
-function patchFooter(ctx, footer) {
-  ctx.emit({ type: "footer.patch", footer });
+function loadAudit(projectRoot) {
+  try {
+    const auditPath = resolve3(resolveHarnessPaths(projectRoot).logsDir, "audit.jsonl");
+    if (!existsSync3(auditPath))
+      return [];
+    return readFileSync3(auditPath, "utf-8").split(/\r?\n/).filter(Boolean).slice(-50).flatMap((raw) => {
+      try {
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? [parsed] : [{ detail: raw }];
+      } catch {
+        return [{ detail: raw }];
+      }
+    });
+  } catch {
+    return [];
+  }
 }
-function stringField(record, keys, fallback = "") {
-  for (const key of keys) {
-    const value = record[key];
-    if (typeof value === "string" && value.trim())
-      return value.trim();
-    if (typeof value === "number" && Number.isFinite(value))
-      return String(value);
+async function loadInspectRuns(ctx, options = {}) {
+  const label = "Loading runs to inspect";
+  emitStarted(ctx, label);
+  try {
+    const projectRoot = projectRootOf(ctx);
+    const { listRunsViaServer: listRunsViaServer2 } = await Promise.resolve().then(() => (init__server_client(), exports__server_client));
+    emitProgress(ctx, label, "listing recent runs");
+    const runs = await listRunsViaServer2({ projectRoot }, { limit: options.limit ?? 50 });
+    const options_ = runs.flatMap((record) => {
+      const runId = stringField(record, ["runId", "id"]);
+      if (!runId)
+        return [];
+      const taskId = stringField(record, ["taskId"]);
+      const updatedAt = stringField(record, ["updatedAt", "createdAt"]);
+      return [{
+        runId,
+        status: stringField(record, ["status", "state"], "unknown"),
+        title: stringField(record, ["title", "taskTitle", "taskId"], "untitled run"),
+        ...taskId ? { taskId } : {},
+        ...updatedAt ? { updatedAt } : {}
+      }];
+    });
+    patchData(ctx, { inspectRuns: options_, lastRefreshError: undefined });
+    emitCompleted(ctx, label, { count: options_.length });
+    return options_;
+  } catch (error) {
+    emitFailed(ctx, label, error);
+    throw error;
   }
-  return fallback;
 }
-function payloadString(intent, key) {
-  const value = intent.action.payload?.[key];
-  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+async function loadInspect(ctx, runId) {
+  const cleanRunId = runId.trim();
+  const label = `Inspecting run ${cleanRunId.slice(0, 8)}`;
+  if (!cleanRunId) {
+    await loadInspectRuns(ctx).catch(() => []);
+    const error = new Error("Inspect requires a run id.");
+    throw error;
+  }
+  emitStarted(ctx, label);
+  try {
+    const projectRoot = projectRootOf(ctx);
+    const { getRunDetailsViaServer: getRunDetailsViaServer2, getRunLogsViaServer: getRunLogsViaServer2, getRunTimelineViaServer: getRunTimelineViaServer2 } = await Promise.resolve().then(() => (init__server_client(), exports__server_client));
+    const context = { projectRoot };
+    emitProgress(ctx, label, "loading logs, timeline, diff, artifacts, graph, and audit");
+    const [runPayload, logsPayload, timelinePayload, diffResult] = await Promise.all([
+      getRunDetailsViaServer2(context, cleanRunId).catch((error) => ({ error: normalizeAppError(error).message })),
+      getRunLogsViaServer2(context, cleanRunId, { limit: 500 }).catch(() => []),
+      getRunTimelineViaServer2(context, cleanRunId, { limit: 500 }).catch(() => []),
+      gitDiff(projectRoot)
+    ]);
+    const run = runPayload && typeof runPayload === "object" && "run" in runPayload && runPayload.run && typeof runPayload.run === "object" ? runPayload.run : runPayload;
+    const logs = arrayFromPayload(logsPayload);
+    const timeline = arrayFromPayload(timelinePayload);
+    const taskId = stringField(run, ["taskId"]) || undefined;
+    const { artifacts, error: artifactsError } = listArtifacts(projectRoot, taskId);
+    const { graph, error: graphError } = loadGraph(projectRoot);
+    const audit = loadAudit(projectRoot);
+    const state = ctx.getState();
+    const selectedArtifact = typeof state.data?.inspectArtifact === "string" ? state.data.inspectArtifact : undefined;
+    const artifactView = selectedArtifact ? readArtifact(projectRoot, taskId, selectedArtifact) : undefined;
+    const snapshot = {
+      runId: cleanRunId,
+      status: stringField(run, ["status", "state"], "unknown"),
+      title: stringField(run, ["title", "taskId", "id"], "untitled run"),
+      logs,
+      timeline,
+      diff: diffResult.diff,
+      failures: [...logs, ...timeline].filter(isFailureEntry),
+      artifacts,
+      graph,
+      audit,
+      refreshedAt: Date.now(),
+      ...taskId ? { taskId } : {},
+      ...artifactView ? { artifactView } : {},
+      ...diffResult.error ? { diffError: diffResult.error } : {},
+      ...graphError ? { graphError } : {},
+      ...artifactsError ? { artifactsError } : {}
+    };
+    patchData(ctx, { inspect: snapshot, lastRefreshError: undefined });
+    emitCompleted(ctx, label, {
+      runId: cleanRunId,
+      logs: logs.length,
+      timeline: timeline.length,
+      diffBytes: snapshot.diff.length,
+      artifacts: artifacts.length,
+      audit: audit.length
+    });
+    return snapshot;
+  } catch (error) {
+    emitFailed(ctx, label, error, { runId: cleanRunId });
+    throw error;
+  }
 }
-
+var execFileAsync, INSPECT_VIEWS;
+var init_inspect = __esm(() => {
+  execFileAsync = promisify(execFile);
+  INSPECT_VIEWS = [
+    "logs",
+    "timeline",
+    "artifacts",
+    "artifact",
+    "diff",
+    "failures",
+    "graph",
+    "audit"
+  ];
+});
 // packages/cli/src/app-opentui/pi-pty-host.ts
 import { fileURLToPath } from "url";
 import { basename } from "path";
@@ -777,8 +1036,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) {
@@ -876,17 +1135,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;
@@ -921,9 +1178,11 @@ class PiPtyHost {
   cols;
   rows;
   message = "starting bundled Pi";
+  lastResizeError = null;
   exitCode;
   signal;
   notifyTimer = null;
+  lastStreamKey = "";
   _disposed = false;
   constructor(options) {
     this.runId = options.runId;
@@ -937,9 +1196,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;
@@ -951,7 +1221,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,
@@ -975,7 +1245,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)
@@ -1026,7 +1296,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() {
@@ -1068,7 +1341,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)
@@ -1097,6 +1370,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,
@@ -1104,7 +1378,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 } : {}
     };
@@ -1165,7 +1440,7 @@ async function refreshFleet(ctx, options = {}) {
   try {
     const { listRunsViaServer: listRunsViaServer2, resolveServerConnectionLabel: resolveServerConnectionLabel2 } = await Promise.resolve().then(() => (init__server_client(), exports__server_client));
     const projectRoot = projectRootOf(ctx);
-    emitProgress(ctx, label, "contacting selected Rig server");
+    emitProgress(ctx, label, "contacting selected server");
     const [runs, serverLabel] = await Promise.all([
       listRunsViaServer2({ projectRoot }, { limit: options.limit ?? 50 }),
       resolveServerConnectionLabel2(projectRoot)
@@ -1174,7 +1449,7 @@ async function refreshFleet(ctx, options = {}) {
       const entry = normalizeRunRecord(run);
       return entry ? [entry] : [];
     });
-    patchData(ctx, { fleet: { runs: normalized, refreshedAt: new Date().toISOString() } });
+    patchData(ctx, { fleet: { runs: normalized, refreshedAt: new Date().toISOString() }, lastRefreshError: undefined });
     patchFooter(ctx, { server: serverLabel, runs: String(normalized.length) });
     emitCompleted(ctx, label, { count: normalized.length });
     return normalized;
@@ -1185,25 +1460,31 @@ async function refreshFleet(ctx, options = {}) {
 }
 
 // packages/cli/src/app-opentui/adapters/pi-attach.ts
-function createPiAttachAdapter(renderer) {
-  return {
-    id: "pi-attach",
-    async handleIntent(runtime, intent) {
-      if (intent.scene !== "handoff" && intent.action.kind !== "run-attach")
-        return false;
-      const ctx = adapterContextFromRuntime(runtime, renderer);
-      const runId = payloadString(intent, "runId") ?? runtime.getState().data.selectedRunId;
-      if (intent.action.kind === "run-attach" && runId) {
-        await attachRunWithBundledPi(ctx, runId);
-        return true;
-      }
-      if (runId) {
-        await preparePiAttachHandoff(ctx, runId);
-        return true;
-      }
-      return false;
-    }
-  };
+function currentAttachState(ctx, runId) {
+  const value = ctx.getState().data?.piAttach;
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return null;
+  const state = value;
+  return state.runId === runId ? state : null;
+}
+function recordStep(ctx, runId, label, emitLabel) {
+  const now = Date.now();
+  const previous = currentAttachState(ctx, runId);
+  const priorSteps = previous?.steps ?? [];
+  const settled = priorSteps.map((step) => step.status === "running" ? { ...step, status: "done", endedAtMs: step.endedAtMs ?? now } : step);
+  const steps = [...settled, { label, startedAtMs: now, status: "running" }];
+  patchData(ctx, {
+    piAttach: { ...previous ?? { runId, status: "preparing", message: label }, runId, steps }
+  });
+  emitProgress(ctx, emitLabel, label);
+}
+function settleSteps(ctx, runId) {
+  const now = Date.now();
+  const previous = currentAttachState(ctx, runId);
+  if (!previous?.steps)
+    return;
+  const steps = previous.steps.map((step) => step.status === "running" ? { ...step, status: "done", endedAtMs: step.endedAtMs ?? now } : step);
+  patchData(ctx, { piAttach: { ...previous, steps } });
 }
 async function preparePiAttachHandoff(ctx, runId) {
   const cleanRunId = runId.trim();
@@ -1212,7 +1493,7 @@ async function preparePiAttachHandoff(ctx, runId) {
   try {
     const { getRunDetailsViaServer: getRunDetailsViaServer2, getRunPiStatusViaServer: getRunPiStatusViaServer2, resolveServerConnectionLabel: resolveServerConnectionLabel2 } = await Promise.resolve().then(() => (init__server_client(), exports__server_client));
     const projectRoot = projectRootOf(ctx);
-    emitProgress(ctx, label, "checking run and Pi session readiness");
+    recordStep(ctx, cleanRunId, "connecting to server \xB7 checking run and Pi session readiness", label);
     const [run, piStatus, server] = await Promise.all([
       getRunDetailsViaServer2({ projectRoot }, cleanRunId).catch((error) => ({ error: error instanceof Error ? error.message : String(error) })),
       getRunPiStatusViaServer2({ projectRoot }, cleanRunId).catch((error) => ({ error: error instanceof Error ? error.message : String(error) })),
@@ -1223,13 +1504,21 @@ async function preparePiAttachHandoff(ctx, runId) {
       status: "preparing",
       message: "ready to enter worker Pi",
       result: { run, piStatus, server },
-      ready: true
+      ready: true,
+      ...currentAttachState(ctx, cleanRunId)?.steps ? { steps: currentAttachState(ctx, cleanRunId).steps } : {}
     };
-    patchData(ctx, { piAttach: state });
+    patchData(ctx, { piAttach: state, lastRefreshError: undefined });
     emitCompleted(ctx, label, { runId: cleanRunId, server });
     return state;
   } catch (error) {
-    const state = { runId: cleanRunId, status: "failed", message: error instanceof Error ? error.message : String(error) };
+    const reason = error instanceof Error ? error.message : String(error);
+    const state = {
+      runId: cleanRunId,
+      status: "failed",
+      message: reason,
+      failureReason: reason,
+      ...currentAttachState(ctx, cleanRunId)?.steps ? { steps: currentAttachState(ctx, cleanRunId).steps } : {}
+    };
     patchData(ctx, { piAttach: state });
     emitFailed(ctx, label, error, { runId: cleanRunId });
     throw error;
@@ -1244,32 +1533,52 @@ async function attachRunWithBundledPi(ctx, runId) {
     throw error;
   }
   emitStarted(ctx, label, { piAttach: { runId: cleanRunId, status: "entering-pi" } });
-  patchData(ctx, { piAttach: { runId: cleanRunId, status: "entering-pi", message: "starting bundled Pi inside Rig" } });
+  patchData(ctx, { piAttach: { runId: cleanRunId, status: "entering-pi", message: "starting bundled Pi", steps: [] } });
   try {
-    await preparePiAttachHandoff(ctx, cleanRunId).catch(() => null);
-    emitProgress(ctx, label, "starting Bun PTY host for bundled Pi");
+    recordStep(ctx, cleanRunId, "connecting to server and fetching run transcript", label);
+    await preparePiAttachHandoff(ctx, cleanRunId).catch((error) => {
+      patchData(ctx, { lastRefreshError: normalizeAppError(error).message });
+      return null;
+    });
+    recordStep(ctx, cleanRunId, "spawning Bun PTY host for bundled Pi", label);
     const projectRoot = projectRootOf(ctx);
     const cols = typeof process.stdout.columns === "number" ? process.stdout.columns : 100;
     const rows = Math.max(1, (typeof process.stdout.rows === "number" ? process.stdout.rows : 35) - 1);
     const patchTerminal = (snapshot) => {
+      const previousSteps = currentAttachState(ctx, cleanRunId)?.steps;
+      const failed = snapshot.status === "failed";
+      const reason = failed ? snapshot.message ?? `bundled Pi exited with code ${snapshot.exitCode ?? "unknown"}` : undefined;
       patchData(ctx, {
         piTerminal: snapshot,
         piAttach: {
           runId: cleanRunId,
-          status: snapshot.status === "failed" ? "failed" : snapshot.status === "exited" ? "returned" : "entering-pi",
-          message: snapshot.message ?? "bundled Pi running inside Rig",
-          result: { runId: cleanRunId, status: snapshot.status, exitCode: snapshot.exitCode }
+          status: failed ? "failed" : snapshot.status === "exited" ? "returned" : "entering-pi",
+          message: snapshot.message ?? "bundled Pi running",
+          result: { runId: cleanRunId, status: snapshot.status, exitCode: snapshot.exitCode },
+          ...previousSteps ? { steps: previousSteps } : {},
+          ...reason ? { failureReason: reason } : {}
         }
       });
     };
+    recordStep(ctx, cleanRunId, "starting bundled Pi", label);
     await startPiPtyHost({
       runId: cleanRunId,
       projectRoot,
       cols,
       rows,
-      onSnapshot: patchTerminal,
+      onSnapshot: (snapshot) => {
+        if (snapshot.status === "running" && snapshot.lines.some((entry) => entry.trim().length > 0)) {
+          settleSteps(ctx, cleanRunId);
+        }
+        patchTerminal(snapshot);
+      },
       onExit: (snapshot) => {
         patchTerminal(snapshot);
+        if (snapshot.status === "failed") {
+          Promise.resolve().then(() => (init_inspect(), exports_inspect)).then(({ loadInspect: loadInspect2 }) => loadInspect2(ctx, cleanRunId)).catch(() => null);
+          emitFailed(ctx, label, new Error(snapshot.message ?? `bundled Pi exited with code ${snapshot.exitCode ?? "unknown"}`), { runId: cleanRunId, result: { status: snapshot.status, exitCode: snapshot.exitCode } });
+          return;
+        }
         emitCompleted(ctx, label, { runId: cleanRunId, result: { status: snapshot.status, exitCode: snapshot.exitCode } });
         ctx.emit({ type: "scene.change", scene: "fleet", intent: { scene: "fleet", argv: ["runs"], action: { kind: "refresh", label: "Opening runs" } } });
         refreshFleet(ctx).catch((error) => emitFailed(ctx, "Refresh runs", error));
@@ -1284,16 +1593,24 @@ async function attachRunWithBundledPi(ctx, runId) {
       status: "running",
       rendered: "bundled Pi embedded via Bun.Terminal + @xterm/headless"
     };
-    emitProgress(ctx, label, "bundled Pi is running inside Rig", { piAttach: { runId: cleanRunId, status: "entering-pi", message: "bundled Pi running inside Rig", result: record } });
+    emitProgress(ctx, label, "bundled Pi is running", { piAttach: { runId: cleanRunId, status: "entering-pi", message: "bundled Pi running", result: record } });
     return record;
   } catch (error) {
-    patchData(ctx, { piAttach: { runId: cleanRunId, status: "failed", message: error instanceof Error ? error.message : String(error) } });
+    const reason = error instanceof Error ? error.message : String(error);
+    patchData(ctx, {
+      piAttach: {
+        runId: cleanRunId,
+        status: "failed",
+        message: reason,
+        failureReason: reason,
+        ...currentAttachState(ctx, cleanRunId)?.steps ? { steps: currentAttachState(ctx, cleanRunId).steps } : {}
+      }
+    });
     emitFailed(ctx, label, error, { runId: cleanRunId });
     throw error;
   }
 }
 export {
   preparePiAttachHandoff,
-  createPiAttachAdapter,
   attachRunWithBundledPi
 };