@h-rig/cli 0.0.6-alpha.83 → 0.0.6-alpha.85

package/dist/src/app-opentui/adapters/tasks.js

@@ -16,15 +16,6 @@ var __export = (target, all) => {
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
 // 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())
@@ -74,6 +65,17 @@ function patchData(ctx, 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];
@@ -93,10 +95,6 @@ function compactRecord(record, keys) {
   }
   return out;
 }
-function payloadString(intent, key) {
-  const value = intent.action.payload?.[key];
-  return typeof value === "string" && value.trim() ? value.trim() : undefined;
-}
 
 // packages/cli/src/runner.ts
 import { EventBus } from "@rig/runtime/control-plane/runtime/events";
@@ -1125,18 +1123,8 @@ import {
   readJsonlFile,
   writeAuthorityRunRecord
 } from "@rig/runtime/control-plane/authority-files";
-function normalizeRuntimeAdapter(value) {
-  const normalized = value?.trim().toLowerCase();
-  if (!normalized) {
-    return "pi";
-  }
-  if (normalized === "codex" || normalized === "codex-cli" || normalized === "codex-app-server" || normalized === "gpt-codex") {
-    return "codex";
-  }
-  if (normalized === "pi" || normalized === "rig-pi" || normalized === "@rig/pi") {
-    return "pi";
-  }
-  return "claude-code";
+function normalizeRuntimeAdapter(_value) {
+  return "pi";
 }
 var init__authority_runs = __esm(() => {
   init__paths();
@@ -1758,6 +1746,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));
@@ -1787,6 +1792,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 };
 }
 function trustDroneCwd(localCwd) {
@@ -1858,10 +1870,17 @@ async function attachRunBundledPiFrontend(context, input) {
     rendered: "stock Pi operator console with the pi-rig extension"
   };
 }
-var RIG_PI_THEME;
+var TERMINAL_RUN_STATUSES, OperatorTranscriptUnavailableError, RIG_PI_THEME;
 var init__pi_frontend = __esm(() => {
   init__server_client();
   init__async_ui();
+  TERMINAL_RUN_STATUSES = new Set(["completed", "failed", "stopped", "cancelled", "canceled", "closed", "merged", "needs_attention", "needs-attention"]);
+  OperatorTranscriptUnavailableError = class OperatorTranscriptUnavailableError extends Error {
+    constructor(message2) {
+      super(message2);
+      this.name = "OperatorTranscriptUnavailableError";
+    }
+  };
   RIG_PI_THEME = {
     $schema: "https://raw.githubusercontent.com/earendil-works/pi/main/packages/coding-agent/src/modes/interactive/theme/theme-schema.json",
     name: "rig",
@@ -2016,7 +2035,7 @@ async function attachRunOperatorView(context, input) {
     }
     const pollMs = Math.max(250, Math.trunc(input.pollMs ?? 2000));
     let timelineCursor = snapshot.timelineCursor;
-    while (!detached && !TERMINAL_RUN_STATUSES.has(runStatusFromPayload(snapshot.run))) {
+    while (!detached && !TERMINAL_RUN_STATUSES2.has(runStatusFromPayload(snapshot.run))) {
       await Bun.sleep(pollMs);
       snapshot = await readOperatorSnapshot(context, input.runId, { timelineCursor });
       timelineCursor = snapshot.timelineCursor;
@@ -2028,13 +2047,13 @@ async function attachRunOperatorView(context, input) {
   }
   return { ...snapshot, steered, detached };
 }
-var TERMINAL_RUN_STATUSES;
+var TERMINAL_RUN_STATUSES2;
 var init__operator_view = __esm(() => {
   init__server_client();
   init__operator_surface();
   init__pi_frontend();
   init__async_ui();
-  TERMINAL_RUN_STATUSES = new Set(["completed", "failed", "stopped", "cancelled", "canceled", "closed", "merged", "needs_attention", "needs-attention"]);
+  TERMINAL_RUN_STATUSES2 = new Set(["completed", "failed", "stopped", "cancelled", "canceled", "closed", "merged", "needs_attention", "needs-attention"]);
 });
 
 // packages/cli/src/commands/_cli-format.ts
@@ -2564,30 +2583,62 @@ var init__help_catalog = __esm(() => {
     }
   ];
   ADVANCED_GROUPS = [
-    { name: "setup", summary: "Bootstrap/check local setup.", usage: ["rig setup <bootstrap|check|preflight>"], commands: [{ command: "bootstrap|check|preflight", description: "Setup helpers." }] },
-    { name: "profile", summary: "Runtime profile/model defaults.", usage: ["rig profile <show|set>"], commands: [{ command: "show", description: "Show active profile." }] },
+    {
+      name: "setup",
+      summary: "Bootstrap/check local setup.",
+      usage: ["rig setup <bootstrap|check|preflight>"],
+      commands: [
+        { command: "bootstrap", description: "Bootstrap local setup dependencies.", primary: true },
+        { command: "check", description: "Check local setup state (toolchain, deps, config).", primary: true },
+        { command: "preflight", description: "Run preflight checks before a run.", primary: true }
+      ]
+    },
+    {
+      name: "profile",
+      summary: "Runtime profile/model defaults.",
+      usage: ["rig profile <show|set>"],
+      commands: [
+        { command: "show", description: "Show the active execution profile.", primary: true },
+        { command: "set [--model <model>] [--runtime <runtime>] [--plugin <plugin>]", description: "Set model/runtime/plugin profile defaults.", primary: true }
+      ]
+    },
     {
       name: "review",
       summary: "Inspect or change completion review gate policy.",
       usage: ["rig review <show|set>"],
       commands: [
         { command: "show", description: "Show current review gate settings." },
-        { command: "set <off|advisory|required> [--provider greptile]", description: "Change review strictness/provider." }
+        { command: "set <off|advisory|required> [--provider <provider>]", description: "Change review strictness/provider (e.g. --provider greptile)." }
       ],
       examples: ["rig review show", "rig review set required --provider greptile"],
       next: ["Use `rig inbox approvals` for blocked run handoffs."]
     },
     {
       name: "browser",
-      summary: "Browser/app diagnostics for browser-required tasks.",
-      usage: ["rig browser <help|explain|demo|app|hp-next> [options]"],
+      summary: "Browser workstation actions for browser-required tasks: launch, check, CDP probe, profile reset, and app-specific smokes.",
+      usage: ["rig browser <help|explain|demo|hp-next|cdp-probe|profile-persistence|profile-lock-check|smoke-test> [options]"],
       commands: [
-        { command: "help", description: "Rich browser command help (canonical: `rig browser help`)." },
-        { command: "explain", description: "Explain the browser-required task contract." },
-        { command: "demo", description: "Run browser demo flows against a local page." },
-        { command: "app", description: "Launch the Rig Browser workstation app." },
-        { command: "hp-next <dev|check|e2e|reset>", description: "Drive the hp-next browser test harness." }
-      ]
+        { command: "help", description: "Rich browser command help (canonical: `rig browser help`).", primary: true },
+        { command: "explain", description: "Explain the browser-required task contract and runtime helper commands.", primary: true },
+        { command: "demo [--port <n>] [--profile <name>] [--state-dir <path>] [--target-url <url>] [--keep-open] [--no-build]", description: "Run a guided real browser/agent demo flow.", primary: true },
+        { command: "hp-next dev", description: "Start hp-next Rig Browser in dev/watch mode.", primary: true },
+        { command: "hp-next start", description: "Build/start the hp-next browser workstation without watch mode.", primary: true },
+        { command: "hp-next check", description: "Validate the hp-next CDP endpoint on the configured port.", primary: true },
+        { command: "hp-next e2e", description: "Run hp-next browser e2e smoke checks through Rig Browser.", primary: true },
+        { command: "hp-next reset", description: "Reset the hp-next browser profile when stale browser state is suspected.", primary: true },
+        { command: "cdp-probe", description: "Run an isolated CDP attach/evaluate/layout probe." },
+        { command: "profile-persistence", description: "Verify a named browser profile persists browser state." },
+        { command: "profile-lock-check", description: "Verify concurrent launches reject the same profile." },
+        { command: "smoke-test", description: "Run the browser package smoke test." }
+      ],
+      examples: [
+        "rig browser help",
+        "rig browser hp-next check",
+        "rig browser hp-next e2e",
+        "rig browser cdp-probe",
+        "rig browser profile-lock-check"
+      ],
+      next: ["Inside a task run, use rig-browser-launch, rig-browser-check, and rig-browser-attach-info from the worker PATH."]
     },
     {
       name: "pi",
@@ -2602,12 +2653,60 @@ var init__help_catalog = __esm(() => {
       examples: ["rig pi search subagents", "rig pi add pi-subagents", "rig pi list"],
       next: ["Config-managed extensions: declare `runtime: { pi: { packages: [...] } }` in rig.config.ts \u2014 workers pick them up automatically."]
     },
-    { name: "queue", summary: "Run task queues locally.", usage: ["rig queue run [options]"], commands: [{ command: "run", description: "Process queue work." }] },
-    { name: "agent", summary: "Runtime agent workspace helpers.", usage: ["rig agent <list|prepare|run|cleanup>"], commands: [{ command: "list", description: "List prepared agents." }] },
+    {
+      name: "queue",
+      summary: "Run task queues locally.",
+      usage: ["rig queue run [--workers <n>] [--max-tasks <n>] [--action validate|verify|pipeline] [--isolation off|worktree] [--no-runtime-reuse] [--fail-fast] [--skip-project-sync]"],
+      commands: [
+        { command: "run [--workers <n>] [--max-tasks <n>] [--action validate|verify|pipeline] [--isolation off|worktree] [--no-runtime-reuse] [--fail-fast] [--skip-project-sync]", description: "Process queue work: drain matching tasks with N workers, optional per-task action and isolation.", primary: true }
+      ]
+    },
+    {
+      name: "agent",
+      summary: "Runtime agent workspace helpers.",
+      usage: ["rig agent <list|prepare|run|cleanup>"],
+      commands: [
+        { command: "list", description: "List prepared agent runtimes.", primary: true },
+        { command: "prepare [--id <id>] [--mode <mode>] [--task <task>]", description: "Prepare an isolated agent runtime workspace.", primary: true },
+        { command: "run [--id <id>] [--mode <mode>] [--task <task>] [--skip-project-sync]", description: "Prepare (if needed) and run an agent in its workspace.", primary: true },
+        { command: "cleanup [--all] [--id <id>]", description: "Remove prepared agent workspaces.", primary: true }
+      ]
+    },
     { name: "inspector", summary: "Event stream and drift scanners.", usage: ["rig inspector <stream|scan-upstream-drift>"], commands: [{ command: "stream", description: "Stream events." }] },
-    { name: "dist", summary: "Build/install packaged Rig CLI.", usage: ["rig dist <build|install|doctor>"], commands: [{ command: "build", description: "Build distribution." }] },
+    {
+      name: "dist",
+      summary: "Build/install packaged Rig CLI.",
+      usage: ["rig dist <build|install|doctor|rebuild-agent>"],
+      commands: [
+        { command: "build [--output-dir <dir>]", description: "Build the distributable Rig CLI.", primary: true },
+        { command: "install [--scope <scope>] [--path <path>]", description: "Install the built CLI to a scope/path.", primary: true },
+        { command: "doctor", description: "Diagnose the dist toolchain and install state.", primary: true },
+        { command: "rebuild-agent", description: "Rebuild the agent runtime image, pruning stale images.", primary: true }
+      ]
+    },
     { name: "workspace", summary: "Workspace topology/service helpers.", usage: ["rig workspace <summary|topology|remote-hosts>"], commands: [{ command: "summary", description: "Show workspace summary." }] },
-    { name: "remote", summary: "Compatibility remote orchestration controls.", usage: ["rig remote <status|watch|pause|resume|...>"], commands: [{ command: "status", description: "Show remote state." }] },
+    {
+      name: "remote",
+      summary: "Compatibility remote orchestration controls.",
+      usage: ["rig remote <status|tasks|watch|pause|resume|continue|stop|refresh|add-iterations|remove-iterations|endpoint ...>"],
+      commands: [
+        { command: "status [--remote <alias>]", description: "Show the remote orchestration state.", primary: true },
+        { command: "tasks [--remote <alias>]", description: "List the remote's tracked tasks.", primary: true },
+        { command: "watch [--remote <alias>] [--seconds <n>] [--event <type>]", description: "Stream remote orchestration events.", primary: true },
+        { command: "pause [--remote <alias>]", description: "Pause the running remote orchestration.", primary: true },
+        { command: "resume [--remote <alias>] [--max-workers <n>] [--max-iterations <n>] [--direct-merge]", description: "Resume the remote with optional tuning.", primary: true },
+        { command: "continue [--remote <alias>]", description: "Continue a paused remote orchestration.", primary: true },
+        { command: "stop [--remote <alias>]", description: "Stop the remote orchestration.", primary: true },
+        { command: "refresh [--remote <alias>]", description: "Refresh remote state.", primary: true },
+        { command: "add-iterations [--count <n>] [--remote <alias>]", description: "Grant the remote more iterations.", primary: true },
+        { command: "remove-iterations [--count <n>] [--remote <alias>]", description: "Reduce the remote's iteration budget.", primary: true },
+        { command: "endpoint list", description: "List configured remote endpoints.", primary: true },
+        { command: "endpoint add --alias <alias> --host <host> --port <n> [--token <token>]", description: "Register a remote endpoint.", primary: true },
+        { command: "endpoint remove --alias <alias>", description: "Remove a remote endpoint.", primary: true },
+        { command: "endpoint test [--alias <alias>]", description: "Test connectivity to a remote endpoint.", primary: true },
+        { command: "endpoint doctor", description: "Diagnose remote endpoint configuration.", primary: true }
+      ]
+    },
     { name: "git", summary: "Pass through to Rig git-flow helper.", usage: ["rig git <args...>"], commands: [{ command: "<args...>", description: "Advanced git flow operations." }] },
     { name: "harness", summary: "Pass through to runtime harness CLI.", usage: ["rig harness <args...>"], commands: [{ command: "<args...>", description: "Advanced harness operations." }] },
     { name: "test", summary: "Project test wrappers.", usage: ["rig test <unit|e2e|all>"], commands: [{ command: "all", description: "Run configured project tests." }] }
@@ -3280,9 +3379,11 @@ class PiPtyHost {
   cols;
   rows;
   message = "starting bundled Pi";
+  lastResizeError = null;
   exitCode;
   signal;
   notifyTimer = null;
+  lastStreamKey = "";
   _disposed = false;
   constructor(options) {
     this.runId = options.runId;
@@ -3299,6 +3400,17 @@ class PiPtyHost {
       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;
@@ -3385,7 +3497,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() {
@@ -3427,7 +3542,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)
@@ -3456,6 +3571,7 @@ class PiPtyHost {
       lines.push("");
       styledLines[lines.length - 1] = new StyledText([{ __isChunk: true, text: "" }]);
     }
+    const resolvedMessage = this.lastResizeError ? `resize degraded: ${this.lastResizeError}` : message2;
     return {
       runId: this.runId,
       status: this.status,
@@ -3463,7 +3579,8 @@ class PiPtyHost {
       rows: this.rows,
       lines,
       styledLines,
-      message: message2,
+      message: resolvedMessage,
+      ...this.lastResizeError ? { resizeError: this.lastResizeError } : {},
       ...this.exitCode !== undefined ? { exitCode: this.exitCode } : {},
       ...this.signal !== undefined ? { signal: this.signal } : {}
     };
@@ -3537,7 +3654,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;
@@ -3548,32 +3665,235 @@ async function refreshFleet(ctx, options = {}) {
 }
 var init_fleet = () => {};
 
+// 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 existsSync4, readFileSync as readFileSync5, readdirSync, statSync } from "fs";
+import { resolve as resolve4 } 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 as resolveMonorepoRoot2, 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 listArtifacts(projectRoot, taskId3) {
+  if (!taskId3)
+    return { artifacts: [], error: "run has no task id \u2014 artifacts are resolved per task" };
+  try {
+    const dirs = resolveTaskArtifactDirs(projectRoot, taskId3).filter((dir) => existsSync4(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 = resolve4(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 readArtifact(projectRoot, taskId3, fileName) {
+  if (!taskId3)
+    return;
+  try {
+    const preview = readTaskArtifactPreview(projectRoot, taskId3, 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 loadGraph(projectRoot) {
+  try {
+    const result = runCapture(["br", "--no-db", "list", "--pretty"], resolveMonorepoRoot2(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 loadAudit(projectRoot) {
+  try {
+    const auditPath = resolve4(resolveHarnessPaths(projectRoot).logsDir, "audit.jsonl");
+    if (!existsSync4(auditPath))
+      return [];
+    return readFileSync5(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 [];
+  }
+}
+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 taskId3 = 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"),
+        ...taskId3 ? { taskId: taskId3 } : {},
+        ...updatedAt ? { updatedAt } : {}
+      }];
+    });
+    patchData(ctx, { inspectRuns: options_, lastRefreshError: undefined });
+    emitCompleted(ctx, label, { count: options_.length });
+    return options_;
+  } catch (error) {
+    emitFailed(ctx, label, error);
+    throw error;
+  }
+}
+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 taskId3 = stringField(run, ["taskId"]) || undefined;
+    const { artifacts, error: artifactsError } = listArtifacts(projectRoot, taskId3);
+    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, taskId3, 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(),
+      ...taskId3 ? { taskId: taskId3 } : {},
+      ...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/adapters/pi-attach.ts
 var exports_pi_attach = {};
 __export(exports_pi_attach, {
   preparePiAttachHandoff: () => preparePiAttachHandoff,
-  createPiAttachAdapter: () => createPiAttachAdapter,
   attachRunWithBundledPi: () => attachRunWithBundledPi
 });
-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();
@@ -3582,7 +3902,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) })),
@@ -3593,13 +3913,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;
@@ -3614,32 +3942,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" } });
+  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",
+          status: failed ? "failed" : snapshot.status === "exited" ? "returned" : "entering-pi",
           message: snapshot.message ?? "bundled Pi running",
-          result: { runId: cleanRunId, status: snapshot.status, exitCode: snapshot.exitCode }
+          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));
@@ -3657,7 +4005,16 @@ async function attachRunWithBundledPi(ctx, runId) {
     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;
   }
@@ -3669,30 +4026,6 @@ var init_pi_attach = __esm(() => {
 
 // packages/cli/src/app-opentui/adapters/tasks.ts
 import { randomUUID } from "crypto";
-function createTasksAdapter() {
-  return {
-    id: "tasks",
-    async handleIntent(runtime, intent) {
-      if (intent.scene !== "tasks" && intent.action.kind !== "task-run-next" && intent.action.kind !== "task-run-id")
-        return false;
-      const ctx = adapterContextFromRuntime(runtime);
-      const detach = intent.action.payload?.detach === true;
-      if (intent.action.kind === "task-run-next") {
-        await submitNextTaskRun(ctx, {}, { detach });
-        return true;
-      }
-      if (intent.action.kind === "task-run-id") {
-        await submitTaskRun(ctx, { taskId: payloadString(intent, "task"), detach });
-        return true;
-      }
-      if (intent.action.kind === "refresh" || intent.action.kind === "navigate") {
-        await refreshTasks(ctx, { limit: 20 });
-        return true;
-      }
-      return false;
-    }
-  };
-}
 function rawRecord(record, key) {
   const direct = record[key];
   if (direct !== undefined && direct !== null)
@@ -4096,7 +4429,7 @@ async function loadTaskPreview(ctx, taskId3) {
     const { getWorkspaceTaskViaServer: getWorkspaceTaskViaServer2 } = await Promise.resolve().then(() => (init__server_client(), exports__server_client));
     const task = await getWorkspaceTaskViaServer2({ projectRoot: projectRootOf(ctx) }, taskId3);
     const normalized = task ? normalizeTaskRecord(task) : null;
-    patchData(ctx, { selectedTaskId: taskId3, taskPreview: normalized, taskPreviewRaw: task ? compactRecord(task, ["id", "title", "status", "body", "url"]) : null });
+    patchData(ctx, { selectedTaskId: taskId3, taskDetailId: taskId3, taskPreview: normalized, taskPreviewRaw: task ? compactRecord(task, ["id", "title", "status", "body", "url"]) : null });
     emitCompleted(ctx, label, { taskId: taskId3, found: Boolean(normalized) });
     return normalized;
   } catch (error) {
@@ -4114,7 +4447,6 @@ export {
   normalizeTaskRecord,
   loadTaskPreview,
   ensureTaskRuntime,
-  createTasksAdapter,
   activeRunIdFromTaskRunError,
   activeRunIdFromTaskLike
 };