@h-rig/cli 0.0.6-alpha.3 → 0.0.6-alpha.30

package/dist/src/commands/run.js

@@ -1,15 +1,11 @@
 // @bun
 // packages/cli/src/commands/run.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
-import { resolve as resolve3 } from "path";
 import { createInterface as createInterface2 } from "readline/promises";
 
 // packages/cli/src/runner.ts
 import { EventBus } from "@rig/runtime/control-plane/runtime/events";
 import { CliError } from "@rig/runtime/control-plane/errors";
 import { evaluate, loadPolicy, resolveAction } from "@rig/runtime/control-plane/runtime/guard";
-import { PluginManager } from "@rig/runtime/control-plane/runtime/plugins";
-import { loadRuntimeContextFromEnv } from "@rig/runtime/control-plane/runtime/context";
 import { buildBinary } from "@rig/runtime/control-plane/runtime/isolation";
 import { CliError as CliError2 } from "@rig/runtime/control-plane/errors";
 function takeFlag(args, flag) {
@@ -54,9 +50,7 @@ Usage: ${usage}`);
 // packages/cli/src/commands/run.ts
 import {
   listAuthorityRuns,
-  readAuthorityRun,
-  readJsonlFile,
-  resolveAuthorityRunDir
+  readAuthorityRun
 } from "@rig/runtime/control-plane/authority-files";
 import {
   cleanupRunState,
@@ -64,12 +58,13 @@ import {
   listOpenEpics,
   resolveDefaultEpic,
   runResume,
+  runRestart,
   runStatus,
   runStop,
   startRun,
   defaultStartRunOptions
 } from "@rig/runtime/control-plane/native/run-ops";
-import { loadRuntimeContextFromEnv as loadRuntimeContextFromEnv2 } from "@rig/runtime/control-plane/runtime/context";
+import { loadRuntimeContextFromEnv } from "@rig/runtime/control-plane/runtime/context";
 
 // packages/cli/src/commands/_parsers.ts
 function parsePositiveInt(value, option, fallback) {
@@ -84,7 +79,6 @@ function parsePositiveInt(value, option, fallback) {
 }
 
 // packages/cli/src/commands/_server-client.ts
-import { spawnSync } from "child_process";
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
 import { resolve as resolve2 } from "path";
 import { ensureLocalRigServerConnection } from "@rig/runtime/local-server";
@@ -166,13 +160,13 @@ function resolveSelectedConnection(projectRoot, options = {}) {
   const global = readGlobalConnections(options);
   const connection = global.connections[repo.selected];
   if (!connection) {
-    throw new CliError2(`Selected Rig connection "${repo.selected}" was not found. Run \`rig connect list\` or \`rig connect use local\`.`, 1);
+    throw new CliError2(`Selected Rig server "${repo.selected}" was not found. Run \`rig server list\` or \`rig server use local\`.`, 1);
   }
   return { alias: repo.selected, connection };
 }
 
 // packages/cli/src/commands/_server-client.ts
-var cachedGitHubBearerToken;
+var scopedGitHubBearerTokens = new Map;
 function cleanToken(value) {
   const trimmed = value?.trim();
   return trimmed ? trimmed : null;
@@ -189,25 +183,13 @@ function readPrivateRemoteSessionToken(projectRoot) {
   }
 }
 function readGitHubBearerTokenForRemote(projectRoot) {
-  if (cachedGitHubBearerToken !== undefined)
-    return cachedGitHubBearerToken;
+  const scopedKey = resolve2(projectRoot);
+  if (scopedGitHubBearerTokens.has(scopedKey))
+    return scopedGitHubBearerTokens.get(scopedKey) ?? null;
   const privateSession = readPrivateRemoteSessionToken(projectRoot);
-  if (privateSession) {
-    cachedGitHubBearerToken = privateSession;
-    return cachedGitHubBearerToken;
-  }
-  const envToken = cleanToken(process.env.RIG_GITHUB_TOKEN) ?? cleanToken(process.env.GITHUB_TOKEN) ?? cleanToken(process.env.GH_TOKEN);
-  if (envToken) {
-    cachedGitHubBearerToken = envToken;
-    return cachedGitHubBearerToken;
-  }
-  const result = spawnSync("gh", ["auth", "token"], {
-    encoding: "utf8",
-    timeout: 5000,
-    stdio: ["ignore", "pipe", "ignore"]
-  });
-  cachedGitHubBearerToken = result.status === 0 ? cleanToken(result.stdout) : null;
-  return cachedGitHubBearerToken;
+  if (privateSession)
+    return privateSession;
+  return cleanToken(process.env.RIG_SERVER_AUTH_TOKEN) ?? cleanToken(process.env.RIG_REMOTE_AUTH_TOKEN);
 }
 async function ensureServerForCli(projectRoot) {
   try {
@@ -275,6 +257,14 @@ async function requestServerJson(context, pathname, init = {}) {
   }
   return payload;
 }
+async function listRunsViaServer(context, options = {}) {
+  const url = new URL("http://rig.local/api/runs");
+  if (options.limit !== undefined)
+    url.searchParams.set("limit", String(options.limit));
+  const payload = await requestServerJson(context, `${url.pathname}${url.search}`);
+  const runs = Array.isArray(payload) ? payload : payload && typeof payload === "object" && !Array.isArray(payload) && Array.isArray(payload.runs) ? payload.runs : [];
+  return runs.filter((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry)));
+}
 async function getRunDetailsViaServer(context, runId) {
   const payload = await requestServerJson(context, `/api/runs/${encodeURIComponent(runId)}`);
   return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
@@ -288,6 +278,15 @@ async function getRunLogsViaServer(context, runId, options = {}) {
   const payload = await requestServerJson(context, `${url.pathname}${url.search}`);
   return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { entries: [] };
 }
+async function getRunTimelineViaServer(context, runId, options = {}) {
+  const url = new URL(`http://rig.local/api/runs/${encodeURIComponent(runId)}/timeline`);
+  if (options.limit !== undefined)
+    url.searchParams.set("limit", String(options.limit));
+  if (options.cursor)
+    url.searchParams.set("cursor", options.cursor);
+  const payload = await requestServerJson(context, `${url.pathname}${url.search}`);
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { entries: [] };
+}
 async function stopRunViaServer(context, runId) {
   const payload = await requestServerJson(context, "/api/runs/stop", {
     method: "POST",
@@ -304,10 +303,69 @@ async function steerRunViaServer(context, runId, message) {
   });
   return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { ok: true };
 }
+async function getRunPiSessionViaServer(context, runId) {
+  const payload = await requestServerJson(context, `/api/runs/${encodeURIComponent(runId)}/pi`);
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
+}
+async function getRunPiMessagesViaServer(context, runId) {
+  const payload = await requestServerJson(context, `/api/runs/${encodeURIComponent(runId)}/pi/messages`);
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { messages: [] };
+}
+async function getRunPiStatusViaServer(context, runId) {
+  const payload = await requestServerJson(context, `/api/runs/${encodeURIComponent(runId)}/pi/status`);
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
+}
+async function getRunPiCommandsViaServer(context, runId) {
+  const payload = await requestServerJson(context, `/api/runs/${encodeURIComponent(runId)}/pi/commands`);
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { commands: [] };
+}
+async function sendRunPiPromptViaServer(context, runId, text, streamingBehavior) {
+  const payload = await requestServerJson(context, `/api/runs/${encodeURIComponent(runId)}/pi/prompt`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ text, streamingBehavior })
+  });
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { accepted: true };
+}
+async function sendRunPiShellViaServer(context, runId, text) {
+  const payload = await requestServerJson(context, `/api/runs/${encodeURIComponent(runId)}/pi/shell`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ text })
+  });
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { accepted: true };
+}
+async function runRunPiCommandViaServer(context, runId, text) {
+  const payload = await requestServerJson(context, `/api/runs/${encodeURIComponent(runId)}/pi/commands/run`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ text })
+  });
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { type: "done" };
+}
+async function respondRunPiExtensionUiViaServer(context, runId, requestId, valueOrCancel) {
+  const payload = await requestServerJson(context, `/api/runs/${encodeURIComponent(runId)}/pi/extension-ui/respond`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ requestId, ...valueOrCancel })
+  });
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { accepted: true };
+}
+async function abortRunPiViaServer(context, runId) {
+  const payload = await requestServerJson(context, `/api/runs/${encodeURIComponent(runId)}/pi/abort`, { method: "POST" });
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { aborted: true };
+}
+async function buildRunPiEventsWebSocketUrl(context, runId) {
+  const server = await ensureServerForCli(context.projectRoot);
+  const url = new URL(`${server.baseUrl.replace(/\/+$/, "")}/api/runs/${encodeURIComponent(runId)}/pi/events`);
+  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+  if (server.authToken)
+    url.searchParams.set("token", server.authToken);
+  return url.toString();
+}
 
-// packages/cli/src/commands/_operator-view.ts
+// packages/cli/src/commands/_operator-surface.ts
 import { createInterface } from "readline";
-var TERMINAL_RUN_STATUSES = new Set(["completed", "failed", "stopped", "cancelled", "canceled", "closed", "merged", "needs_attention", "needs-attention"]);
 var CANONICAL_STAGES = [
   "Connect",
   "GitHub/task sync",
@@ -322,18 +380,753 @@ var CANONICAL_STAGES = [
   "Merge",
   "Complete"
 ];
+function logDetail(log) {
+  return typeof log.detail === "string" ? log.detail.trim() : "";
+}
+function parseProviderProtocolLog(title, detail) {
+  if (title.trim().toLowerCase() !== "agent output")
+    return null;
+  if (!detail.startsWith("{") || !detail.endsWith("}"))
+    return null;
+  try {
+    const record = JSON.parse(detail);
+    if (!record || typeof record !== "object" || Array.isArray(record))
+      return null;
+    const type = record.type;
+    return typeof type === "string" && [
+      "assistant",
+      "message_start",
+      "message_update",
+      "message_end",
+      "stream_event",
+      "tool_result",
+      "tool_execution_start",
+      "tool_execution_update",
+      "tool_execution_end",
+      "turn_start",
+      "turn_end"
+    ].includes(type) ? record : null;
+  } catch {
+    return null;
+  }
+}
+function renderProviderProtocolLog(record) {
+  const type = typeof record.type === "string" ? record.type : "";
+  if (type === "tool_execution_start" || type === "tool_execution_update" || type === "tool_execution_end") {
+    const toolName = String(record.toolName ?? record.name ?? "tool");
+    const status = type === "tool_execution_start" ? "started" : type === "tool_execution_end" ? record.isError === true || record.result && typeof record.result === "object" && !Array.isArray(record.result) && record.result.isError === true ? "failed" : "completed" : "running";
+    return `[Pi tool] ${toolName} ${status}`;
+  }
+  return null;
+}
+function entryId(entry, fallback) {
+  return typeof entry.id === "string" && entry.id.trim() ? entry.id : fallback;
+}
 function renderOperatorSnapshot(snapshot) {
   const run = snapshot.run.run && typeof snapshot.run.run === "object" ? snapshot.run.run : snapshot.run;
   const runId = String(run.runId ?? run.id ?? "run");
   const status = String(run.status ?? "unknown");
   const logs = snapshot.logs ?? [];
+  const latestByStage = new Map;
+  for (const log of logs) {
+    const title = String(log.title ?? "").toLowerCase();
+    const stageName = String(log.stage ?? "").toLowerCase();
+    const stage = CANONICAL_STAGES.find((candidate) => candidate.toLowerCase() === title || candidate.toLowerCase() === stageName);
+    if (stage)
+      latestByStage.set(stage, log);
+  }
   const stageLines = CANONICAL_STAGES.flatMap((stage) => {
-    const match = logs.find((log) => String(log.title ?? "").toLowerCase() === stage.toLowerCase() || String(log.stage ?? "").toLowerCase() === stage.toLowerCase());
-    return match ? [`${stage}: ${String(match.status ?? status)}`] : [];
+    const match = latestByStage.get(stage);
+    return match ? [`${stage}: ${String(match.status ?? status)}${logDetail(match) ? ` \u2014 ${logDetail(match)}` : ""}`] : [];
   });
   return [`Rig run ${runId}: ${status}`, ...stageLines].join(`
 `);
 }
+function createPiRunStreamRenderer(output = process.stdout) {
+  let lastSnapshot = "";
+  const assistantTextById = new Map;
+  const seenTimeline = new Set;
+  const seenLogs = new Set;
+  const writeLine = (line) => output.write(`${line}
+`);
+  return {
+    renderSnapshot(snapshot) {
+      const rendered = renderOperatorSnapshot(snapshot);
+      if (rendered && rendered !== lastSnapshot) {
+        writeLine(rendered);
+        lastSnapshot = rendered;
+      }
+    },
+    renderTimeline(entries) {
+      for (const [index, entry] of entries.entries()) {
+        const id = entryId(entry, `timeline:${index}:${String(entry.cursor ?? "")}`);
+        if (entry.type === "assistant_message" && typeof entry.text === "string") {
+          const text = entry.text;
+          const previousText = assistantTextById.get(id) ?? "";
+          if (!previousText && text.trim()) {
+            writeLine("[Pi assistant]");
+          }
+          if (text.startsWith(previousText)) {
+            const delta = text.slice(previousText.length);
+            if (delta)
+              output.write(delta);
+          } else if (text.trim() && text !== previousText) {
+            if (previousText)
+              writeLine(`
+[Pi assistant]`);
+            output.write(text);
+          }
+          assistantTextById.set(id, text);
+          continue;
+        }
+        if (seenTimeline.has(id))
+          continue;
+        seenTimeline.add(id);
+        if (entry.type === "tool_execution_start" || entry.type === "tool_execution_update" || entry.type === "tool_execution_end" || entry.type === "mcp_tool_call") {
+          writeLine(`[Pi tool] ${String(entry.toolName ?? entry.name ?? entry.title ?? entry.type)} ${String(entry.status ?? entry.state ?? "")}`.trim());
+          continue;
+        }
+        if (entry.type === "timeline_warning") {
+          writeLine(`[Rig timeline] ${String(entry.detail ?? entry.message ?? "timeline unavailable")}`);
+        }
+      }
+    },
+    renderLogs(entries) {
+      for (const [index, entry] of entries.entries()) {
+        const id = entryId(entry, `log:${index}:${String(entry.createdAt ?? "")}:${String(entry.title ?? "")}`);
+        if (seenLogs.has(id))
+          continue;
+        seenLogs.add(id);
+        const title = String(entry.title ?? "");
+        if (CANONICAL_STAGES.some((stage) => stage.toLowerCase() === title.toLowerCase()))
+          continue;
+        const detail = logDetail(entry);
+        if (!detail)
+          continue;
+        const protocolRecord = parseProviderProtocolLog(title, detail);
+        if (protocolRecord) {
+          const protocolLine = renderProviderProtocolLog(protocolRecord);
+          if (protocolLine)
+            writeLine(protocolLine);
+          continue;
+        }
+        writeLine(`[${title || "Rig log"}] ${detail}`);
+      }
+    }
+  };
+}
+function createOperatorSurface(options = {}) {
+  const input = options.input ?? process.stdin;
+  const output = options.output ?? process.stdout;
+  const errorOutput = options.errorOutput ?? process.stderr;
+  const renderer = createPiRunStreamRenderer(output);
+  const writeLine = (line) => output.write(`${line}
+`);
+  return {
+    mode: "pi-compatible-text",
+    ...renderer,
+    info: writeLine,
+    error: (message) => errorOutput.write(`${message}
+`),
+    attachCommandInput(handler) {
+      if (options.interactive === false || !input.isTTY)
+        return null;
+      const rl = createInterface({ input, output: process.stdout, terminal: false });
+      rl.on("line", (line) => {
+        Promise.resolve(handler(line)).catch((error) => writeLine(`Operator command failed: ${error instanceof Error ? error.message : String(error)}`));
+      });
+      return { close: () => rl.close() };
+    }
+  };
+}
+
+// packages/cli/src/commands/_pi-frontend.ts
+import { mkdtempSync, rmSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import { main as runPiMain } from "@earendil-works/pi-coding-agent";
+
+// packages/cli/src/commands/_pi-worker-bridge-extension.ts
+var TERMINAL_RUN_STATUSES = new Set(["completed", "failed", "stopped", "cancelled", "canceled", "closed", "merged", "needs_attention", "needs-attention"]);
+var MAX_TRANSCRIPT_LINES = 120;
+function recordOf(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function asText(value) {
+  if (typeof value === "string")
+    return value;
+  if (value === null || value === undefined)
+    return "";
+  if (typeof value === "number" || typeof value === "boolean")
+    return String(value);
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function textFromContent(content) {
+  if (typeof content === "string")
+    return content;
+  if (!Array.isArray(content))
+    return asText(content);
+  return content.flatMap((part) => {
+    const item = recordOf(part);
+    if (!item)
+      return [];
+    if (typeof item.text === "string")
+      return [item.text];
+    if (typeof item.content === "string")
+      return [item.content];
+    if (item.type === "toolCall")
+      return [`\u23FA ${String(item.name ?? "tool")} ${asText(item.arguments ?? "")}`.trim()];
+    if (item.type === "toolResult")
+      return [`\u21B3 ${asText(item.content ?? item.result ?? "")}`.trim()];
+    return [];
+  }).join(`
+`);
+}
+function appendTranscript(state, label, text) {
+  const trimmed = text.trimEnd();
+  if (!trimmed)
+    return;
+  const lines = trimmed.split(/\r?\n/);
+  state.transcript.push(`${label}: ${lines[0] ?? ""}`);
+  for (const line of lines.slice(1))
+    state.transcript.push(`  ${line}`);
+  if (state.transcript.length > MAX_TRANSCRIPT_LINES) {
+    state.transcript.splice(0, state.transcript.length - MAX_TRANSCRIPT_LINES);
+  }
+}
+function nativePiUi(ctx) {
+  const ui = ctx.ui;
+  return typeof ui.emitSessionEvent === "function" && typeof ui.appendSessionMessages === "function" ? ui : null;
+}
+function syncNativeDisplayCwd(ctx, state) {
+  const ui = nativePiUi(ctx);
+  if (ui?.setDisplayCwd && state.cwd)
+    ui.setDisplayCwd(state.cwd);
+}
+function parseExtensionUiRequest(value) {
+  const request = recordOf(value) ?? {};
+  const requestId = String(request.requestId ?? request.id ?? `ui-${Date.now()}`);
+  const method = String(request.method ?? request.type ?? "input");
+  const prompt = asText(request.prompt ?? request.message ?? request.title ?? method);
+  const rawOptions = Array.isArray(request.options) ? request.options : Array.isArray(request.items) ? request.items : [];
+  const options = rawOptions.map((option) => {
+    const record = recordOf(option);
+    return record ? asText(record.label ?? record.value ?? record.name ?? option) : asText(option);
+  }).filter(Boolean);
+  return { requestId, method, prompt, options };
+}
+function renderBridgeWidget(state) {
+  const statusParts = [
+    state.wsConnected ? "live WS" : "WS pending",
+    state.status,
+    state.model,
+    state.cwd
+  ].filter(Boolean);
+  const lines = [`Worker Pi daemon bridge \xB7 ${statusParts.join(" \xB7 ")}`];
+  if (state.activity)
+    lines.push(state.activity);
+  if (state.commands.length > 0) {
+    lines.push(`Worker commands: ${state.commands.slice(0, 10).join(", ")}${state.commands.length > 10 ? ", \u2026" : ""}`);
+  }
+  lines.push("");
+  if (state.transcript.length > 0) {
+    lines.push(...state.transcript.slice(-MAX_TRANSCRIPT_LINES));
+  } else {
+    lines.push("Waiting for worker Pi daemon transcript\u2026");
+  }
+  if (state.pendingUi) {
+    lines.push("");
+    lines.push(`Extension UI request \xB7 ${state.pendingUi.method}`);
+    lines.push(state.pendingUi.prompt);
+    state.pendingUi.options.forEach((option, index) => lines.push(`${index + 1}. ${option}`));
+    lines.push("Reply in the Pi editor. /cancel cancels this request.");
+  }
+  return lines;
+}
+function updatePiUi(ctx, state) {
+  ctx.ui.setTitle("Pi \xB7 Rig worker daemon");
+  ctx.ui.setStatus("rig-worker-pi", state.wsConnected ? "worker Pi WS live" : state.status);
+  syncNativeDisplayCwd(ctx, state);
+  if (state.nativeStream && nativePiUi(ctx)) {
+    ctx.ui.setWidget("rig-worker-pi-transcript", undefined);
+    return;
+  }
+  ctx.ui.setWorkingVisible(false);
+  ctx.ui.setWidget("rig-worker-pi-transcript", [`Worker Pi daemon bridge \xB7 degraded widget transcript`, ...renderBridgeWidget(state)], { placement: "aboveEditor" });
+}
+function applyStatus(state, payload) {
+  const status = recordOf(payload.status) ?? payload;
+  state.streaming = status.isStreaming === true || status.isCompacting === true || status.isBashRunning === true;
+  state.cwd = typeof status.cwd === "string" ? status.cwd : state.cwd;
+  state.model = typeof status.model === "string" ? status.model : state.model;
+  const pending = typeof status.pendingMessageCount === "number" ? status.pendingMessageCount : 0;
+  state.status = `${state.streaming ? "streaming" : "idle"}${pending ? ` \xB7 ${pending} queued` : ""}`;
+}
+function applyMessage(state, message) {
+  const record = recordOf(message);
+  if (!record)
+    return;
+  const role = String(record.role ?? "system");
+  const label = role === "assistant" ? "Pi" : role === "user" ? "You" : role === "tool" || role === "toolResult" ? "Tool" : "System";
+  appendTranscript(state, label, textFromContent(record.content ?? record.message ?? record.text ?? ""));
+}
+function applyPiEvent(ctx, state, eventValue) {
+  const event = recordOf(eventValue);
+  if (!event)
+    return;
+  const type = String(event.type ?? "event");
+  if (type === "agent_start") {
+    state.streaming = true;
+    state.status = "streaming";
+  } else if (type === "agent_end") {
+    state.streaming = false;
+    state.status = "idle";
+  } else if (type === "queue_update") {
+    const steering = Array.isArray(event.steering) ? event.steering.length : 0;
+    const followUp = Array.isArray(event.followUp) ? event.followUp.length : 0;
+    state.status = `queued \xB7 steer ${steering} \xB7 follow-up ${followUp}`;
+  }
+  const native = nativePiUi(ctx);
+  if (state.nativeStream && native?.emitSessionEvent) {
+    native.emitSessionEvent(eventValue);
+    return;
+  }
+  if (type === "agent_end") {
+    appendTranscript(state, "System", "Agent turn complete.");
+    return;
+  }
+  if (type === "message_start" || type === "message_end" || type === "turn_end") {
+    applyMessage(state, event.message);
+    return;
+  }
+  if (type === "message_update") {
+    const assistantEvent = recordOf(event.assistantMessageEvent);
+    const delta = typeof assistantEvent?.delta === "string" ? assistantEvent.delta : typeof assistantEvent?.text === "string" ? assistantEvent.text : "";
+    if (delta)
+      appendTranscript(state, assistantEvent?.type === "thinking_delta" ? "Thinking" : "Pi", delta);
+    return;
+  }
+  if (type === "tool_execution_start") {
+    appendTranscript(state, "Tool", `${String(event.toolName ?? "tool")} ${asText(event.args ?? "")}`.trim());
+    return;
+  }
+  if (type === "tool_execution_update") {
+    appendTranscript(state, "Tool", asText(event.partialResult ?? ""));
+    return;
+  }
+  if (type === "tool_execution_end") {
+    appendTranscript(state, event.isError === true ? "Error" : "Tool", asText(event.result ?? `${String(event.toolName ?? "tool")} complete`));
+  }
+}
+function firstPendingShell(state) {
+  return state.pendingShells[0];
+}
+function finishPendingShell(state, shell, result) {
+  const index = state.pendingShells.indexOf(shell);
+  if (index !== -1)
+    state.pendingShells.splice(index, 1);
+  shell.resolve(result);
+}
+function failPendingShell(state, shell, error) {
+  const index = state.pendingShells.indexOf(shell);
+  if (index !== -1)
+    state.pendingShells.splice(index, 1);
+  shell.reject(error);
+}
+function applyUiEvent(state, value) {
+  const event = recordOf(value);
+  if (!event)
+    return;
+  const type = String(event.type ?? "ui");
+  if (type === "shell.chunk") {
+    const pending = firstPendingShell(state);
+    const chunk = asText(event.chunk);
+    if (pending) {
+      pending.sawChunk = true;
+      pending.onData(Buffer.from(chunk));
+    } else {
+      appendTranscript(state, "Tool", chunk);
+    }
+    return;
+  }
+  if (type === "shell.end") {
+    const pending = firstPendingShell(state);
+    const output = asText(event.output ?? "");
+    const exitCode = typeof event.exitCode === "number" ? event.exitCode : event.isError === true ? 1 : 0;
+    if (pending) {
+      if (output && !pending.sawChunk)
+        pending.onData(Buffer.from(output));
+      finishPendingShell(state, pending, { exitCode });
+    } else {
+      appendTranscript(state, event.isError === true ? "Error" : "Tool", output || `exit ${String(exitCode)}`);
+    }
+    return;
+  }
+  if (type === "shell.start") {
+    if (!firstPendingShell(state))
+      appendTranscript(state, "Tool", `$ ${asText(event.command)}`);
+    return;
+  }
+  appendTranscript(state, "System", `${type}: ${asText(event)}`);
+}
+function applyEnvelope(ctx, state, envelopeValue) {
+  const envelope = recordOf(envelopeValue);
+  if (!envelope)
+    return;
+  const type = String(envelope.type ?? "");
+  if (type === "ready") {
+    const metadata = recordOf(envelope.metadata);
+    state.cwd = typeof metadata?.cwd === "string" ? metadata.cwd : state.cwd;
+    state.status = "worker Pi daemon ready";
+    if (!state.nativeStream)
+      appendTranscript(state, "System", "Connected to worker Pi daemon.");
+  } else if (type === "status.update") {
+    applyStatus(state, envelope);
+  } else if (type === "activity.update") {
+    const activity = recordOf(envelope.activity);
+    state.activity = [activity?.label, activity?.detail].map(asText).filter(Boolean).join(" \u2014 ");
+  } else if (type === "extension_ui_request") {
+    state.pendingUi = parseExtensionUiRequest(envelope.request);
+    appendTranscript(state, "System", `Extension UI request: ${state.pendingUi.prompt}`);
+  } else if (type === "pi.ui_event") {
+    applyUiEvent(state, envelope.event);
+  } else if (type === "pi.event") {
+    applyPiEvent(ctx, state, envelope.event);
+  } else if (type === "error") {
+    appendTranscript(state, "Error", asText(envelope.message ?? envelope.detail ?? "unknown error"));
+  }
+  syncNativeDisplayCwd(ctx, state);
+}
+async function waitForWorkerReady(options, ctx, state) {
+  while (true) {
+    const session = await getRunPiSessionViaServer(options.context, options.runId).catch((error) => ({
+      ready: false,
+      status: error instanceof Error ? error.message : String(error),
+      retryAfterMs: 1000
+    }));
+    if (session.ready === false) {
+      const status = String(session.status ?? "starting");
+      state.status = `waiting for worker Pi daemon \xB7 ${status}`;
+      updatePiUi(ctx, state);
+      if (TERMINAL_RUN_STATUSES.has(status.toLowerCase())) {
+        appendTranscript(state, "Error", `Run ended before worker Pi daemon became ready: ${status}`);
+        return false;
+      }
+      await Bun.sleep(typeof session.retryAfterMs === "number" ? session.retryAfterMs : 750);
+      continue;
+    }
+    const sessionRecord = recordOf(session) ?? {};
+    applyEnvelope(ctx, state, { type: "ready", metadata: sessionRecord.metadata ?? sessionRecord });
+    updatePiUi(ctx, state);
+    return true;
+  }
+}
+function parseWsPayload(message) {
+  if (typeof message.data === "string")
+    return JSON.parse(message.data);
+  return JSON.parse(Buffer.from(message.data).toString("utf8"));
+}
+async function connectWorkerStream(options, ctx, state) {
+  const ready = await waitForWorkerReady(options, ctx, state);
+  if (!ready)
+    return;
+  let catchupDone = false;
+  const buffered = [];
+  const wsUrl = await buildRunPiEventsWebSocketUrl(options.context, options.runId);
+  const socket = new WebSocket(wsUrl);
+  const closePromise = new Promise((resolve3) => {
+    socket.onopen = () => {
+      state.wsConnected = true;
+      state.status = "live worker Pi WebSocket connected";
+      updatePiUi(ctx, state);
+    };
+    socket.onmessage = (message) => {
+      try {
+        const payload = parseWsPayload(message);
+        if (!catchupDone)
+          buffered.push(payload);
+        else {
+          applyEnvelope(ctx, state, payload);
+          updatePiUi(ctx, state);
+        }
+      } catch (error) {
+        appendTranscript(state, "Error", `Unparseable worker Pi event: ${error instanceof Error ? error.message : String(error)}`);
+        updatePiUi(ctx, state);
+      }
+    };
+    socket.onerror = () => socket.close();
+    socket.onclose = () => {
+      state.wsConnected = false;
+      state.status = "worker Pi WebSocket disconnected";
+      updatePiUi(ctx, state);
+      resolve3();
+    };
+  });
+  try {
+    const [messagesPayload, statusPayload, commandsPayload] = await Promise.all([
+      getRunPiMessagesViaServer(options.context, options.runId),
+      getRunPiStatusViaServer(options.context, options.runId),
+      getRunPiCommandsViaServer(options.context, options.runId)
+    ]);
+    const messages = Array.isArray(messagesPayload.messages) ? messagesPayload.messages : [];
+    const native = nativePiUi(ctx);
+    if (state.nativeStream && native?.appendSessionMessages)
+      native.appendSessionMessages(messages);
+    else
+      for (const message of messages)
+        applyMessage(state, message);
+    applyStatus(state, statusPayload);
+    const commands = Array.isArray(commandsPayload.commands) ? commandsPayload.commands : [];
+    state.commands = commands.flatMap((command) => {
+      const record = recordOf(command);
+      return typeof record?.name === "string" ? [`/${record.name}`] : [];
+    });
+    catchupDone = true;
+    for (const payload of buffered.splice(0))
+      applyEnvelope(ctx, state, payload);
+    updatePiUi(ctx, state);
+  } catch (error) {
+    appendTranscript(state, "Error", `Worker Pi catch-up failed: ${error instanceof Error ? error.message : String(error)}`);
+    catchupDone = true;
+    updatePiUi(ctx, state);
+  }
+  await closePromise;
+}
+function createRemoteBashOperations(options, state, excludeFromContext) {
+  return {
+    exec(command, _cwd, execOptions) {
+      return new Promise((resolve3, reject) => {
+        const pending = {
+          command,
+          onData: execOptions.onData,
+          resolve: resolve3,
+          reject,
+          sawChunk: false
+        };
+        const cleanup = () => {
+          execOptions.signal?.removeEventListener("abort", onAbort);
+          if (timer)
+            clearTimeout(timer);
+        };
+        const onAbort = () => {
+          cleanup();
+          failPendingShell(state, pending, new Error("Remote worker shell command aborted locally."));
+        };
+        const timeoutMs = typeof execOptions.timeout === "number" && execOptions.timeout > 0 ? execOptions.timeout : 0;
+        const timer = timeoutMs > 0 ? setTimeout(() => {
+          cleanup();
+          failPendingShell(state, pending, new Error(`Remote worker shell command timed out after ${timeoutMs}ms.`));
+        }, timeoutMs) : null;
+        const wrappedResolve = pending.resolve;
+        const wrappedReject = pending.reject;
+        pending.resolve = (result) => {
+          cleanup();
+          wrappedResolve(result);
+        };
+        pending.reject = (error) => {
+          cleanup();
+          wrappedReject(error);
+        };
+        execOptions.signal?.addEventListener("abort", onAbort, { once: true });
+        state.pendingShells.push(pending);
+        sendRunPiShellViaServer(options.context, options.runId, `${excludeFromContext ? "!!" : "!"}${command}`).catch((error) => {
+          cleanup();
+          failPendingShell(state, pending, error instanceof Error ? error : new Error(String(error)));
+        });
+      });
+    }
+  };
+}
+async function answerPendingUi(options, state, line) {
+  const pending = state.pendingUi;
+  if (!pending)
+    return false;
+  if (line === "/cancel") {
+    await respondRunPiExtensionUiViaServer(options.context, options.runId, pending.requestId, { cancelled: true });
+  } else if (pending.method === "confirm") {
+    const confirmed = /^(y|yes|true|1)$/i.test(line);
+    await respondRunPiExtensionUiViaServer(options.context, options.runId, pending.requestId, { value: confirmed, confirmed });
+  } else if (pending.options.length > 0 && /^\d+$/.test(line)) {
+    const selected = pending.options[Math.max(0, Number(line) - 1)] ?? line;
+    await respondRunPiExtensionUiViaServer(options.context, options.runId, pending.requestId, { value: selected });
+  } else {
+    await respondRunPiExtensionUiViaServer(options.context, options.runId, pending.requestId, { value: line });
+  }
+  appendTranscript(state, "System", `Responded to extension UI request ${pending.requestId}.`);
+  state.pendingUi = null;
+  return true;
+}
+async function routeInput(options, ctx, state, line) {
+  const text = line.trim();
+  if (!text)
+    return;
+  if (await answerPendingUi(options, state, text)) {
+    updatePiUi(ctx, state);
+    return;
+  }
+  if (text === "/detach" || text === "/quit" || text === "/q") {
+    appendTranscript(state, "System", "Detached locally; worker Pi daemon continues.");
+    updatePiUi(ctx, state);
+    ctx.shutdown();
+    return;
+  }
+  if (text === "/stop") {
+    await abortRunPiViaServer(options.context, options.runId);
+    appendTranscript(state, "System", "Stop requested for worker Pi daemon.");
+    updatePiUi(ctx, state);
+    ctx.shutdown();
+    return;
+  }
+  if (text.startsWith("!")) {
+    appendTranscript(state, "You", text);
+    await sendRunPiShellViaServer(options.context, options.runId, text);
+  } else if (text.startsWith("/")) {
+    appendTranscript(state, "You", text);
+    const result = await runRunPiCommandViaServer(options.context, options.runId, text);
+    const message = typeof result.message === "string" ? result.message : "worker command accepted";
+    appendTranscript(state, "System", message);
+  } else {
+    appendTranscript(state, "You", text);
+    await sendRunPiPromptViaServer(options.context, options.runId, text, state.streaming ? "steer" : undefined);
+  }
+  updatePiUi(ctx, state);
+}
+function createRigWorkerPiBridgeExtension(options) {
+  return (pi) => {
+    const state = {
+      transcript: [],
+      status: "starting worker Pi daemon bridge",
+      activity: "",
+      cwd: "",
+      model: "",
+      commands: [],
+      streaming: false,
+      pendingUi: null,
+      pendingShells: [],
+      wsConnected: false,
+      nativeStream: false
+    };
+    if (options.initialMessageSent)
+      appendTranscript(state, "System", "Initial message sent to worker Pi daemon.");
+    let nativePiUiContextAvailable = false;
+    pi.on("user_bash", (event) => {
+      state.nativeStream = Boolean(state.nativeStream || nativePiUiContextAvailable);
+      return { operations: createRemoteBashOperations(options, state, event.excludeFromContext === true) };
+    });
+    pi.on("session_start", async (_event, ctx) => {
+      nativePiUiContextAvailable = Boolean(nativePiUi(ctx));
+      state.nativeStream = nativePiUiContextAvailable;
+      updatePiUi(ctx, state);
+      ctx.ui.notify(nativePiUiContextAvailable ? "Rig worker Pi native stream bridge loaded" : "Rig worker Pi bridge extension loaded (degraded widget fallback)", "info");
+      ctx.ui.onTerminalInput((data) => {
+        if (data.includes("\x04")) {
+          ctx.shutdown();
+          return { consume: true };
+        }
+        if (!data.includes("\r") && !data.includes(`
+`))
+          return;
+        const inlineText = data.replace(/[\r\n]+/g, "").trim();
+        const editorText = ctx.ui.getEditorText().trim();
+        const text = [editorText, inlineText].filter(Boolean).join(" ").trim();
+        if (!text)
+          return;
+        if (text.startsWith("!"))
+          return;
+        ctx.ui.setEditorText("");
+        routeInput(options, ctx, state, text).catch((error) => {
+          appendTranscript(state, "Error", error instanceof Error ? error.message : String(error));
+          updatePiUi(ctx, state);
+        });
+        return { consume: true };
+      });
+      connectWorkerStream(options, ctx, state).catch((error) => {
+        appendTranscript(state, "Error", error instanceof Error ? error.message : String(error));
+        updatePiUi(ctx, state);
+      });
+    });
+    pi.on("session_shutdown", () => {});
+  };
+}
+
+// packages/cli/src/commands/_pi-frontend.ts
+function setTemporaryEnv(updates) {
+  const previous = new Map;
+  for (const [key, value] of Object.entries(updates)) {
+    previous.set(key, process.env[key]);
+    process.env[key] = value;
+  }
+  return () => {
+    for (const [key, value] of previous) {
+      if (value === undefined)
+        delete process.env[key];
+      else
+        process.env[key] = value;
+    }
+  };
+}
+async function attachRunBundledPiFrontend(context, input) {
+  const tempRoot = mkdtempSync(join(tmpdir(), "rig-pi-frontend-"));
+  const cwd = join(tempRoot, "workspace");
+  const agentDir = join(tempRoot, "agent");
+  const sessionDir = join(tempRoot, "sessions");
+  const previousCwd = process.cwd();
+  const restoreEnv = setTemporaryEnv({
+    PI_CODING_AGENT_DIR: agentDir,
+    PI_CODING_AGENT_SESSION_DIR: sessionDir,
+    PI_OFFLINE: "1",
+    PI_SKIP_VERSION_CHECK: "1"
+  });
+  let detached = false;
+  try {
+    await Bun.$`mkdir -p ${cwd} ${agentDir} ${sessionDir}`.quiet();
+    process.chdir(cwd);
+    await runPiMain([
+      "--offline",
+      "--no-session",
+      "--no-tools",
+      "--no-builtin-tools",
+      "--no-skills",
+      "--no-prompt-templates",
+      "--no-themes",
+      "--no-context-files",
+      "--no-approve"
+    ], {
+      extensionFactories: [
+        createRigWorkerPiBridgeExtension({
+          context,
+          runId: input.runId,
+          initialMessageSent: input.steered === true
+        })
+      ]
+    });
+    detached = true;
+  } finally {
+    process.chdir(previousCwd);
+    restoreEnv();
+    rmSync(tempRoot, { recursive: true, force: true });
+  }
+  let run = { runId: input.runId, status: "unknown" };
+  try {
+    run = await getRunDetailsViaServer(context, input.runId);
+  } catch {}
+  return {
+    run,
+    logs: [],
+    timeline: [],
+    timelineCursor: null,
+    steered: input.steered === true,
+    detached,
+    rendered: "actual bundled Pi frontend hosted Rig worker Pi bridge extension"
+  };
+}
+
+// packages/cli/src/commands/_operator-view.ts
+var TERMINAL_RUN_STATUSES2 = new Set(["completed", "failed", "stopped", "cancelled", "canceled", "closed", "merged", "needs_attention", "needs-attention"]);
 function runStatusFromPayload(payload) {
   const run = payload.run && typeof payload.run === "object" && !Array.isArray(payload.run) ? payload.run : payload;
   return String(run.status ?? "unknown").toLowerCase();
@@ -355,57 +1148,299 @@ async function applyOperatorCommand(context, input, deps = {}) {
   await (deps.steer ?? steerRunViaServer)(context, input.runId, userMessage);
   return { action: "continue", message: "Steering message queued." };
 }
-async function readOperatorSnapshot(context, runId) {
+async function readOperatorSnapshot(context, runId, options = {}) {
   const run = await getRunDetailsViaServer(context, runId);
   const logsPage = await getRunLogsViaServer(context, runId, { limit: 100 });
-  const entries = Array.isArray(logsPage.entries) ? logsPage.entries.filter((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry))) : [];
-  return { run, logs: entries, rendered: renderOperatorSnapshot({ run, logs: entries }) };
+  const timelinePage = await getRunTimelineViaServer(context, runId, { limit: 200, ...options.timelineCursor ? { cursor: options.timelineCursor } : {} }).catch((error) => ({
+    entries: [{
+      id: `timeline-unavailable:${runId}`,
+      type: "timeline_warning",
+      detail: `Selected Rig server did not provide run timeline events: ${error instanceof Error ? error.message : String(error)}`,
+      createdAt: new Date().toISOString()
+    }],
+    nextCursor: options.timelineCursor ?? null
+  }));
+  const logs = Array.isArray(logsPage.entries) ? logsPage.entries.filter((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry))).toReversed() : [];
+  const timeline = Array.isArray(timelinePage.entries) ? timelinePage.entries.filter((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry))) : [];
+  const timelineCursor = typeof timelinePage.nextCursor === "string" ? timelinePage.nextCursor : options.timelineCursor ?? null;
+  return { run, logs, timeline, timelineCursor, rendered: renderOperatorSnapshot({ run, logs, timeline }) };
 }
 async function attachRunOperatorView(context, input) {
   let steered = false;
   if (input.message?.trim()) {
-    await steerRunViaServer(context, input.runId, input.message.trim());
+    await sendRunPiPromptViaServer(context, input.runId, input.message.trim(), "steer").catch(() => steerRunViaServer(context, input.runId, input.message.trim()));
     steered = true;
   }
+  if (input.follow && !input.once && input.interactive !== false && context.outputMode === "text" && Boolean(process.stdin.isTTY && process.stdout.isTTY)) {
+    return attachRunBundledPiFrontend(context, {
+      runId: input.runId,
+      steered
+    });
+  }
+  const surface = createOperatorSurface({ interactive: input.interactive !== false });
   let snapshot = await readOperatorSnapshot(context, input.runId);
   if (context.outputMode === "text") {
-    console.log(snapshot.rendered);
+    surface.renderSnapshot(snapshot);
+    surface.renderTimeline(snapshot.timeline);
+    surface.renderLogs(snapshot.logs);
     if (steered)
-      console.log("Steering message queued.");
+      surface.info("Message submitted to worker Pi.");
   }
   let detached = false;
-  let rl = null;
+  let commandInput = null;
   if (input.follow && !input.once && context.outputMode === "text") {
     if (input.interactive !== false && process.stdin.isTTY) {
-      console.log("Controls: /user <message>, /stop, /detach");
-      rl = createInterface({ input: process.stdin, output: process.stdout, terminal: false });
-      rl.on("line", (line) => {
-        applyOperatorCommand(context, { runId: input.runId, line }).then((result) => {
-          if (result.message)
-            console.log(result.message);
-          if (result.action === "detach" || result.action === "stopped") {
-            detached = true;
-            rl?.close();
-          }
-        }).catch((error) => console.log(`Operator command failed: ${error instanceof Error ? error.message : String(error)}`));
+      surface.info("Controls: /user <message>, /stop, /detach");
+      commandInput = surface.attachCommandInput(async (line) => {
+        const result = await applyOperatorCommand(context, { runId: input.runId, line });
+        if (result.message)
+          surface.info(result.message);
+        if (result.action === "detach" || result.action === "stopped") {
+          detached = true;
+          commandInput?.close();
+        }
       });
     }
-    let lastRendered = snapshot.rendered;
     const pollMs = Math.max(250, Math.trunc(input.pollMs ?? 2000));
-    while (!detached && !TERMINAL_RUN_STATUSES.has(runStatusFromPayload(snapshot.run))) {
+    let timelineCursor = snapshot.timelineCursor;
+    while (!detached && !TERMINAL_RUN_STATUSES2.has(runStatusFromPayload(snapshot.run))) {
       await Bun.sleep(pollMs);
-      snapshot = await readOperatorSnapshot(context, input.runId);
-      if (snapshot.rendered !== lastRendered) {
-        console.log(snapshot.rendered);
-        lastRendered = snapshot.rendered;
-      }
+      snapshot = await readOperatorSnapshot(context, input.runId, { timelineCursor });
+      timelineCursor = snapshot.timelineCursor;
+      surface.renderSnapshot(snapshot);
+      surface.renderTimeline(snapshot.timeline);
+      surface.renderLogs(snapshot.logs);
     }
-    rl?.close();
+    commandInput?.close();
   }
   return { ...snapshot, steered, detached };
 }
 
+// packages/cli/src/commands/_cli-format.ts
+import { log, note } from "@clack/prompts";
+import pc from "picocolors";
+function stringField(record, key, fallback = "") {
+  const value = record[key];
+  return typeof value === "string" && value.trim() ? value.trim() : fallback;
+}
+function rawObject(record) {
+  const raw = record.raw;
+  return raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
+}
+function truncate(value, width) {
+  if (value.length <= width)
+    return value;
+  if (width <= 1)
+    return "\u2026";
+  return `${value.slice(0, width - 1)}\u2026`;
+}
+function pad(value, width) {
+  return value.length >= width ? value : `${value}${" ".repeat(width - value.length)}`;
+}
+function statusColor(status) {
+  const normalized = status.toLowerCase();
+  if (["completed", "merged", "closed", "done", "accepted", "pass", "selected", "approved"].includes(normalized))
+    return pc.green;
+  if (["failed", "needs_attention", "needs-attention", "blocked", "error", "rejected"].includes(normalized))
+    return pc.red;
+  if (["running", "reviewing", "validating", "in_progress", "in-progress", "remote"].includes(normalized))
+    return pc.cyan;
+  if (["ready", "open", "queued", "created", "preparing", "local", "pending"].includes(normalized))
+    return pc.yellow;
+  return pc.dim;
+}
+function compactDate(value) {
+  if (!value.trim())
+    return "";
+  const parsed = Date.parse(value);
+  if (!Number.isFinite(parsed))
+    return value;
+  return new Date(parsed).toISOString().replace("T", " ").replace(/\.\d{3}Z$/, "Z");
+}
+function firstString(record, keys, fallback = "") {
+  for (const key of keys) {
+    const value = stringField(record, key);
+    if (value)
+      return value;
+  }
+  return fallback;
+}
+function runIdOf(run) {
+  return firstString(run, ["runId", "id"], "(unknown-run)");
+}
+function taskIdOf(run) {
+  return firstString(run, ["taskId", "task", "task_id"]);
+}
+function runTitleOf(run) {
+  return firstString(run, ["title", "summary", "name"], taskIdOf(run) || "(untitled)");
+}
+function shouldUseClackOutput() {
+  return Boolean(process.stdout.isTTY) && process.env.RIG_CLI_PLAIN_HELP !== "1";
+}
+function printFormattedOutput(message, options = {}) {
+  if (!shouldUseClackOutput()) {
+    console.log(message);
+    return;
+  }
+  if (options.title)
+    note(message, options.title);
+  else
+    log.message(message);
+}
+function formatStatusPill(status) {
+  const label = status || "unknown";
+  return statusColor(label)(`\u25CF ${label}`);
+}
+function formatSection(title, subtitle) {
+  return `${pc.bold(pc.cyan("\u25C6"))} ${pc.bold(title)}${subtitle ? pc.dim(` \u2014 ${subtitle}`) : ""}`;
+}
+function formatSuccessCard(title, rows = []) {
+  const body = rows.filter(([, value]) => value !== undefined && value !== null && String(value).length > 0).map(([key, value]) => `${pc.dim("\u2502")} ${pc.dim(key.padEnd(12))} ${value}`);
+  return [formatSection(title), ...body].join(`
+`);
+}
+function formatNextSteps(steps) {
+  if (steps.length === 0)
+    return [];
+  return [pc.bold("Next"), ...steps.map((step) => `${pc.dim("\u203A")} ${step}`)];
+}
+function formatRunList(runs, options = {}) {
+  if (runs.length === 0) {
+    return [
+      formatSection("Runs", "none recorded"),
+      options.source === "server" ? pc.dim("No runs recorded on the selected Rig server.") : pc.dim("No runs recorded in .rig/runs."),
+      "",
+      ...formatNextSteps(["Start one: `rig task run --next`", "Check server: `rig server status`"])
+    ].join(`
+`);
+  }
+  const rows = runs.map((run) => {
+    const runId = stringField(run, "runId", stringField(run, "id", "(unknown-run)"));
+    const status = stringField(run, "status", "unknown");
+    const taskId = stringField(run, "taskId", "");
+    const title = stringField(run, "title", taskId || "(untitled)");
+    const runtime = stringField(run, "runtimeAdapter", "");
+    return { runId, status, title, runtime };
+  });
+  const idWidth = Math.min(36, Math.max(6, ...rows.map((row) => row.runId.length)));
+  const statusWidth = Math.min(16, Math.max(6, ...rows.map((row) => row.status.length)));
+  const header = `${pc.bold(pad("RUN", idWidth))}  ${pc.bold(pad("STATUS", statusWidth))}  ${pc.bold("TITLE")}`;
+  const body = rows.map((row) => [
+    pc.bold(pad(truncate(row.runId, idWidth), idWidth)),
+    statusColor(row.status)(pad(truncate(row.status, statusWidth), statusWidth)),
+    `${row.title}${row.runtime ? pc.dim(`  ${row.runtime}`) : ""}`
+  ].join("  "));
+  return [formatSection("Runs", options.source === "server" ? "selected server" : "local state"), header, ...body, "", ...formatNextSteps(["Follow live: `rig run attach <run-id> --follow`", "Details: `rig run show <run-id>`"])].join(`
+`);
+}
+function formatRunCard(run, options = {}) {
+  const raw = rawObject(run);
+  const merged = { ...raw, ...run };
+  const runId = runIdOf(merged);
+  const status = firstString(merged, ["status"], "unknown");
+  const taskId = taskIdOf(merged);
+  const title = runTitleOf(merged);
+  const runtime = firstString(merged, ["runtimeAdapter", "runtime", "adapter"]);
+  const mode = firstString(merged, ["runtimeMode", "mode"]);
+  const interaction = firstString(merged, ["interactionMode"]);
+  const created = compactDate(firstString(merged, ["createdAt"]));
+  const started = compactDate(firstString(merged, ["startedAt"]));
+  const updated = compactDate(firstString(merged, ["updatedAt"]));
+  const completed = compactDate(firstString(merged, ["completedAt", "finishedAt"]));
+  const worktree = firstString(merged, ["worktreePath", "cwd", "projectRoot"]);
+  const piSession = merged.piSession && typeof merged.piSession === "object" && !Array.isArray(merged.piSession) ? firstString(merged.piSession, ["sessionId", "id"]) : "";
+  const timeline = Array.isArray(merged.timeline) ? merged.timeline.length : null;
+  const approvals = Array.isArray(merged.approvals) ? merged.approvals.length : null;
+  const inputs = Array.isArray(merged.userInputs) ? merged.userInputs.length : null;
+  const rows = [
+    ["run", pc.bold(runId)],
+    ["status", formatStatusPill(status)],
+    ["task", taskId],
+    ["title", title],
+    ["runtime", [runtime, mode, interaction].filter(Boolean).join(" \xB7 ")],
+    ["created", created],
+    ["started", started],
+    ["updated", updated],
+    ["completed", completed],
+    ["worktree", worktree],
+    ["pi", piSession],
+    ["timeline", timeline],
+    ["approvals", approvals],
+    ["inputs", inputs]
+  ];
+  return [
+    formatSuccessCard(options.title ?? "Run details", rows),
+    "",
+    ...formatNextSteps([`Follow live: \`rig run attach ${runId} --follow\``, `Raw payload: \`rig run show ${runId} --raw\``])
+  ].join(`
+`);
+}
+function formatRunStatus(summary, options = {}) {
+  const activeRuns = summary.activeRuns ?? [];
+  const recentRuns = summary.recentRuns ?? [];
+  const lines = [formatSection("Run status", options.source === "server" ? "selected server" : "local state")];
+  lines.push("", pc.bold(`Active runs (${activeRuns.length})`));
+  if (activeRuns.length === 0) {
+    lines.push(pc.dim("No active runs."));
+  } else {
+    for (const run of activeRuns) {
+      lines.push(formatRunSummaryLine(run));
+    }
+  }
+  lines.push("", pc.bold(`Recent runs (${recentRuns.length})`));
+  if (recentRuns.length === 0) {
+    lines.push(pc.dim("No recent terminal runs."));
+  } else {
+    for (const run of recentRuns.slice(0, 10)) {
+      lines.push(formatRunSummaryLine(run));
+    }
+  }
+  lines.push("", ...formatNextSteps(["Start work: `rig task run --next`", "Attach: `rig run attach <run-id> --follow`", "Details: `rig run show <run-id>`"]));
+  return lines.join(`
+`);
+}
+function formatRunSummaryLine(run) {
+  const record = run;
+  const runId = runIdOf(record);
+  const status = firstString(record, ["status"], "unknown");
+  const taskId = taskIdOf(record);
+  const title = runTitleOf(record);
+  const runtime = firstString(record, ["runtimeAdapter", "runtime", "adapter"]);
+  const descriptor = [taskId, title].filter(Boolean).join(" \xB7 ");
+  return `${pc.dim("\u2502")} ${pc.bold(runId)} ${formatStatusPill(status)} ${descriptor}${runtime ? pc.dim(`  ${runtime}`) : ""}`;
+}
+
 // packages/cli/src/commands/run.ts
+function normalizeRemoteRunDetails(payload) {
+  const run = payload.run;
+  if (!run || typeof run !== "object" || Array.isArray(run))
+    return null;
+  return {
+    ...run,
+    ...Array.isArray(payload.timeline) ? { timeline: payload.timeline } : {},
+    ...Array.isArray(payload.approvals) ? { approvals: payload.approvals } : {},
+    ...Array.isArray(payload.userInputs) ? { userInputs: payload.userInputs } : {}
+  };
+}
+var REMOTE_TERMINAL_RUN_STATUSES = new Set(["completed", "failed", "stopped", "cancelled", "canceled", "closed", "merged"]);
+function isRemoteConnectionSelected(projectRoot) {
+  return resolveSelectedConnection(projectRoot)?.connection.kind === "remote";
+}
+async function listRunsForSelectedConnection(context, options = {}) {
+  if (isRemoteConnectionSelected(context.projectRoot)) {
+    return { runs: await listRunsViaServer(context, options), source: "server" };
+  }
+  return { runs: listAuthorityRuns(context.projectRoot), source: "local" };
+}
+function runStringField(run, key, fallback = "") {
+  const value = run[key];
+  return typeof value === "string" && value.trim() ? value : fallback;
+}
+function buildServerRunStatus(runs) {
+  const activeRuns = runs.filter((run) => !REMOTE_TERMINAL_RUN_STATUSES.has(runStringField(run, "status").toLowerCase()));
+  const recentRuns = runs.filter((run) => REMOTE_TERMINAL_RUN_STATUSES.has(runStringField(run, "status").toLowerCase()));
+  return { activeRuns, recentRuns, runs };
+}
 function shouldPromptForEpicSelection(context, command, promptEpic, noEpicPrompt) {
   if (noEpicPrompt) {
     return false;
@@ -467,21 +1502,15 @@ async function promptForEpicSelection(projectRoot, command) {
 }
 async function executeRun(context, args) {
   const [command = "status", ...rest] = args;
-  const runtimeContext = loadRuntimeContextFromEnv2() ?? undefined;
+  const runtimeContext = loadRuntimeContextFromEnv() ?? undefined;
   switch (command) {
     case "list": {
-      requireNoExtraArgs(rest, "bun run rig run list");
-      const runs = listAuthorityRuns(context.projectRoot);
+      requireNoExtraArgs(rest, "rig run list");
+      const { runs, source } = await listRunsForSelectedConnection(context, { limit: 100 });
       if (context.outputMode === "text") {
-        if (runs.length === 0) {
-          console.log("No runs recorded in .rig/runs.");
-        } else {
-          for (const run of runs) {
-            console.log(`- ${run.runId} \xB7 ${run.status} \xB7 ${run.title}`);
-          }
-        }
+        printFormattedOutput(formatRunList(runs, { source }));
       }
-      return { ok: true, group: "run", command, details: { runs } };
+      return { ok: true, group: "run", command, details: { runs, source } };
     }
     case "delete": {
       let pending = rest;
@@ -489,7 +1518,7 @@ async function executeRun(context, args) {
       pending = run.rest;
       const purgeArtifacts = takeFlag(pending, "--purge-artifacts");
       pending = purgeArtifacts.rest;
-      requireNoExtraArgs(pending, "bun run rig run delete --run <id> [--purge-artifacts]");
+      requireNoExtraArgs(pending, "rig run delete --run <id> [--purge-artifacts]");
       if (!run.value) {
         throw new CliError2("run delete requires --run <id>.");
       }
@@ -519,7 +1548,7 @@ async function executeRun(context, args) {
       pending = keepRuntimes.rest;
       const keepQueue = takeFlag(pending, "--keep-queue");
       pending = keepQueue.rest;
-      requireNoExtraArgs(pending, "bun run rig run cleanup --all [--keep-artifacts] [--keep-runtimes] [--keep-queue]");
+      requireNoExtraArgs(pending, "rig run cleanup --all [--keep-artifacts] [--keep-runtimes] [--keep-queue]");
       if (!all.value) {
         throw new CliError2("run cleanup currently requires --all.");
       }
@@ -538,20 +1567,25 @@ async function executeRun(context, args) {
     }
     case "show": {
       let pending = rest;
+      const rawResult = takeFlag(pending, "--raw");
+      pending = rawResult.rest;
       const run = takeOption(pending, "--run");
       pending = run.rest;
-      requireNoExtraArgs(pending, "bun run rig run show --run <id>");
-      if (!run.value) {
-        throw new CliError2("run show requires --run <id>.");
+      const positionalRunId = pending.length > 0 && pending[0] && !pending[0].startsWith("-") ? pending[0] : undefined;
+      const extra = positionalRunId ? pending.slice(1) : pending;
+      requireNoExtraArgs(extra, "rig run show <id>|--run <id> [--raw]");
+      const runId = run.value ?? positionalRunId;
+      if (!runId) {
+        throw new CliError2("run show requires a run id.");
       }
-      const record = readAuthorityRun(context.projectRoot, run.value);
+      const record = readAuthorityRun(context.projectRoot, runId) ?? normalizeRemoteRunDetails(await getRunDetailsViaServer(context, runId).catch(() => ({})));
       if (!record) {
-        throw new CliError2(`Run not found: ${run.value}`, 2);
+        throw new CliError2(`Run not found: ${runId}`, 2);
       }
       if (context.outputMode === "text") {
-        console.log(JSON.stringify(record, null, 2));
+        printFormattedOutput(rawResult.value ? JSON.stringify(record, null, 2) : formatRunCard(record));
       }
-      return { ok: true, group: "run", command, details: record };
+      return { ok: true, group: "run", command, details: { ...record, rawOutput: rawResult.value } };
     }
     case "timeline": {
       let pending = rest;
@@ -559,38 +1593,28 @@ async function executeRun(context, args) {
       pending = run.rest;
       const follow = takeFlag(pending, "--follow");
       pending = follow.rest;
-      requireNoExtraArgs(pending, "bun run rig run timeline --run <id> [--follow]");
+      requireNoExtraArgs(pending, "rig run timeline --run <id> [--follow]");
       if (!run.value) {
         throw new CliError2("run timeline requires --run <id>.");
       }
-      const timelinePath = resolve3(resolveAuthorityRunDir(context.projectRoot, run.value), "timeline.jsonl");
-      const printEvents = () => {
-        const events2 = readJsonlFile(timelinePath);
-        if (context.outputMode === "text") {
-          for (const event of events2) {
-            console.log(JSON.stringify(event));
-          }
-        }
-        return events2;
-      };
-      const events = printEvents();
+      const renderer = createPiRunStreamRenderer();
+      let cursor = null;
+      const page = await getRunTimelineViaServer(context, run.value, { limit: 500 });
+      const events = Array.isArray(page.entries) ? page.entries.filter((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry))) : [];
+      cursor = typeof page.nextCursor === "string" ? page.nextCursor : null;
+      if (context.outputMode === "text") {
+        renderer.renderTimeline(events);
+      }
       if (follow.value && context.outputMode === "text") {
-        let lastLength = existsSync3(timelinePath) ? readFileSync3(timelinePath, "utf8").length : 0;
         while (true) {
           await Bun.sleep(1000);
-          if (!existsSync3(timelinePath))
-            continue;
-          const next = readFileSync3(timelinePath, "utf8");
-          if (next.length <= lastLength)
-            continue;
-          const delta = next.slice(lastLength);
-          lastLength = next.length;
-          for (const line of delta.split(/\r?\n/).map((entry) => entry.trim()).filter(Boolean)) {
-            console.log(line);
-          }
+          const nextPage = await getRunTimelineViaServer(context, run.value, { limit: 500, ...cursor ? { cursor } : {} });
+          const nextEvents = Array.isArray(nextPage.entries) ? nextPage.entries.filter((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry))) : [];
+          cursor = typeof nextPage.nextCursor === "string" ? nextPage.nextCursor : cursor;
+          renderer.renderTimeline(nextEvents);
         }
       }
-      return { ok: true, group: "run", command, details: { runId: run.value, events } };
+      return { ok: true, group: "run", command, details: { runId: run.value, events, cursor } };
     }
     case "attach": {
       let pending = rest;
@@ -606,41 +1630,38 @@ async function executeRun(context, args) {
       pending = pollMs.rest;
       const positionalRunId = pending.length > 0 ? pending[0] : undefined;
       const extra = positionalRunId ? pending.slice(1) : pending;
-      requireNoExtraArgs(extra, "bun run rig run attach <run-id>|--run <run-id> [--message <text>] [--once|--follow] [--poll-ms <ms>]");
+      requireNoExtraArgs(extra, "rig run attach <run-id>|--run <run-id> [--message <text>] [--once|--follow] [--poll-ms <ms>]");
       const runId = runOption.value ?? positionalRunId;
       if (!runId) {
         throw new CliError2("run attach requires a run id.", 2);
       }
+      let steered = false;
+      if (messageOption.value?.trim()) {
+        await steerRunViaServer(context, runId, messageOption.value.trim());
+        steered = true;
+      }
       const attached = await attachRunOperatorView(context, {
         runId,
-        message: messageOption.value ?? null,
+        message: null,
         once: once.value,
         follow: follow.value,
         pollMs: parsePositiveInt(pollMs.value, "--poll-ms", 2000)
       });
-      return { ok: true, group: "run", command, details: attached };
+      return { ok: true, group: "run", command, details: { ...attached, steered: attached.steered || steered } };
     }
     case "status": {
-      requireNoExtraArgs(rest, "bun run rig run status");
+      requireNoExtraArgs(rest, "rig run status");
       if (context.dryRun) {
         if (context.outputMode === "text") {
           console.log("[dry-run] rig run status");
         }
         return { ok: true, group: "run", command };
       }
-      const summary = runStatus(context.projectRoot, runtimeContext);
+      const summary = isRemoteConnectionSelected(context.projectRoot) ? buildServerRunStatus(await listRunsViaServer(context, { limit: 100 })) : runStatus(context.projectRoot, runtimeContext);
+      const activeRuns = Array.isArray(summary.activeRuns) ? summary.activeRuns.filter((run) => Boolean(run && typeof run === "object" && !Array.isArray(run))) : [];
+      const recentRuns = Array.isArray(summary.recentRuns) ? summary.recentRuns.filter((run) => Boolean(run && typeof run === "object" && !Array.isArray(run))) : [];
       if (context.outputMode === "text") {
-        console.log(`Active runs: ${summary.activeRuns.length}`);
-        for (const run of summary.activeRuns) {
-          console.log(`- ${run.runId} \xB7 ${run.status} \xB7 ${run.taskId ?? run.title}`);
-        }
-        if (summary.recentRuns.length > 0) {
-          console.log("");
-          console.log("Recent runs:");
-          for (const run of summary.recentRuns) {
-            console.log(`- ${run.runId} \xB7 ${run.status} \xB7 ${run.taskId ?? run.title}`);
-          }
-        }
+        printFormattedOutput(formatRunStatus({ activeRuns, recentRuns, runs: Array.isArray(summary.runs) ? summary.runs : [...activeRuns, ...recentRuns] }, { source: isRemoteConnectionSelected(context.projectRoot) ? "server" : "local" }));
       }
       return { ok: true, group: "run", command, details: summary };
     }
@@ -664,7 +1685,7 @@ async function executeRun(context, args) {
       pending = pollResult.rest;
       const noServerResult = takeFlag(pending, "--no-server");
       pending = noServerResult.rest;
-      requireNoExtraArgs(pending, "bun run rig run start [--epic <id>] [--prompt-epic|--no-epic-prompt] [--ws-port <n>] [--server-host <host>] [--server-port <n>] [--poll-ms <n>] [--no-server]");
+      requireNoExtraArgs(pending, "rig run start [--epic <id>] [--prompt-epic|--no-epic-prompt] [--ws-port <n>] [--server-host <host>] [--server-port <n>] [--poll-ms <n>] [--no-server]");
       if (promptEpicResult.value && noEpicPromptResult.value) {
         throw new CliError2("Cannot use --prompt-epic and --no-epic-prompt together.");
       }
@@ -712,7 +1733,7 @@ async function executeRun(context, args) {
       };
     }
     case "resume": {
-      requireNoExtraArgs(rest, "bun run rig run resume");
+      requireNoExtraArgs(rest, "rig run resume");
       if (context.dryRun) {
         if (context.outputMode === "text") {
           console.log("[dry-run] rig run resume");
@@ -725,11 +1746,25 @@ async function executeRun(context, args) {
       }
       return { ok: true, group: "run", command, details: resumed };
     }
+    case "restart": {
+      requireNoExtraArgs(rest, "rig run restart");
+      if (context.dryRun) {
+        if (context.outputMode === "text") {
+          console.log("[dry-run] rig run restart");
+        }
+        return { ok: true, group: "run", command };
+      }
+      const restarted = await runRestart(context.projectRoot, runtimeContext);
+      if (context.outputMode === "text") {
+        console.log(`Restarted run: ${restarted.runId}`);
+      }
+      return { ok: true, group: "run", command, details: restarted };
+    }
     case "stop": {
       const runOption = takeOption(rest, "--run");
       const positionalRunId = runOption.rest.length > 0 ? runOption.rest[0] : undefined;
       const extra = positionalRunId ? runOption.rest.slice(1) : runOption.rest;
-      requireNoExtraArgs(extra, "bun run rig run stop [<run-id>|--run <id>]");
+      requireNoExtraArgs(extra, "rig run stop [<run-id>|--run <id>]");
       const runId = runOption.value ?? positionalRunId;
       if (context.dryRun) {
         return {