@h-rig/cli 0.0.6-alpha.4 → 0.0.6-alpha.41

package/dist/src/commands/_operator-view.js

@@ -1,9 +1,5 @@
 // @bun
-// packages/cli/src/commands/_operator-view.ts
-import { createInterface } from "readline";
-
 // 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";
 
@@ -11,8 +7,6 @@ import { resolve as resolve2 } from "path";
 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";
 
@@ -96,13 +90,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;
@@ -119,25 +113,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 {
@@ -218,6 +200,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",
@@ -234,9 +225,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
-var TERMINAL_RUN_STATUSES = new Set(["completed", "failed", "stopped", "cancelled", "canceled", "closed", "merged", "needs_attention", "needs-attention"]);
+// packages/cli/src/commands/_operator-surface.ts
+import { createInterface } from "readline";
 var CANONICAL_STAGES = [
   "Connect",
   "GitHub/task sync",
@@ -251,18 +302,808 @@ 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")}`);
+          continue;
+        }
+        if (entry.type === "action") {
+          const text = String(entry.detail ?? entry.message ?? entry.title ?? "").trim();
+          if (text)
+            writeLine(`[Rig action] ${text}`);
+          continue;
+        }
+        if (entry.type === "user_message") {
+          const text = String(entry.text ?? entry.message ?? entry.detail ?? "").trim();
+          if (text)
+            writeLine(`[Operator] ${text}`);
+          continue;
+        }
+        const fallback = String(entry.detail ?? entry.message ?? entry.text ?? entry.title ?? "").trim();
+        if (fallback)
+          writeLine(`[${String(entry.type ?? "timeline")}] ${fallback}`);
+      }
+    },
+    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 {
+  createAgentSessionFromServices,
+  createAgentSessionServices,
+  main as runPiMain
+} from "@earendil-works/pi-coding-agent";
+
+// packages/cli/src/commands/_pi-remote-session.ts
+import { AgentSession as PiAgentSession } from "@earendil-works/pi-coding-agent";
+var TERMINAL_RUN_STATUSES = new Set(["completed", "failed", "stopped", "cancelled", "canceled", "closed", "merged", "needs_attention", "needs-attention"]);
+function defaultTransport() {
+  return {
+    getSession: getRunPiSessionViaServer,
+    getMessages: getRunPiMessagesViaServer,
+    getStatus: getRunPiStatusViaServer,
+    getCommands: getRunPiCommandsViaServer,
+    sendPrompt: sendRunPiPromptViaServer,
+    sendShell: sendRunPiShellViaServer,
+    runCommand: runRunPiCommandViaServer,
+    abort: abortRunPiViaServer,
+    buildEventsWebSocketUrl: buildRunPiEventsWebSocketUrl
+  };
+}
+function recordOf(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function emptyRemoteStatus() {
+  return {
+    isStreaming: false,
+    isCompacting: false,
+    isBashRunning: false,
+    pendingMessageCount: 0,
+    steeringMessages: [],
+    followUpMessages: [],
+    model: null,
+    thinkingLevel: null,
+    sessionName: null,
+    cwd: null,
+    stats: null,
+    contextUsage: null
+  };
+}
+function resolveAttachReadyTimeoutMs() {
+  const raw = Number.parseInt(process.env.RIG_PI_ATTACH_TIMEOUT_MS ?? "", 10);
+  return Number.isFinite(raw) && raw > 0 ? raw : 10 * 60000;
+}
+
+class RigRemoteSessionController {
+  context;
+  runId;
+  status = emptyRemoteStatus();
+  transport;
+  hooks = {};
+  session = null;
+  socket = null;
+  closed = false;
+  pendingShells = [];
+  pendingCompactions = [];
+  constructor(input) {
+    this.context = input.context;
+    this.runId = input.runId;
+    this.transport = input.transport ?? defaultTransport();
+  }
+  ingestEnvelope(envelopeValue) {
+    this.applyEnvelope(envelopeValue);
+  }
+  bindSession(session) {
+    this.session = session;
+  }
+  setUiHooks(hooks) {
+    this.hooks = hooks;
+  }
+  async connect() {
+    const ready = await this.waitForReady();
+    if (!ready || this.closed)
+      return;
+    let catchupDone = false;
+    const buffered = [];
+    const wsUrl = await this.transport.buildEventsWebSocketUrl(this.context, this.runId);
+    const socket = new WebSocket(wsUrl);
+    this.socket = socket;
+    socket.onopen = () => {
+      this.hooks.onConnectionChange?.(true);
+      this.hooks.onStatusText?.("worker session live");
+    };
+    socket.onmessage = (message) => {
+      try {
+        const payload = typeof message.data === "string" ? JSON.parse(message.data) : JSON.parse(Buffer.from(message.data).toString("utf8"));
+        if (!catchupDone)
+          buffered.push(payload);
+        else
+          this.applyEnvelope(payload);
+      } catch (error) {
+        this.hooks.onError?.(`Unparseable worker Pi event: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    };
+    socket.onerror = () => socket.close();
+    socket.onclose = () => {
+      this.hooks.onConnectionChange?.(false);
+      if (!this.closed)
+        this.hooks.onStatusText?.("worker Pi WebSocket disconnected");
+    };
+    try {
+      const [messagesPayload, statusPayload, commandsPayload] = await Promise.all([
+        this.transport.getMessages(this.context, this.runId),
+        this.transport.getStatus(this.context, this.runId),
+        this.transport.getCommands(this.context, this.runId)
+      ]);
+      const messages = Array.isArray(messagesPayload.messages) ? messagesPayload.messages : [];
+      this.applyStatusPayload(statusPayload);
+      this.session?.replaceRemoteMessages(messages);
+      const commands = Array.isArray(commandsPayload.commands) ? commandsPayload.commands : [];
+      this.hooks.onCatchUp?.(messages, commands);
+      catchupDone = true;
+      for (const payload of buffered.splice(0))
+        this.applyEnvelope(payload);
+    } catch (error) {
+      catchupDone = true;
+      this.hooks.onError?.(`Worker Pi catch-up failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  close() {
+    this.closed = true;
+    this.socket?.close();
+    for (const shell of this.pendingShells.splice(0))
+      shell.reject(new Error("Remote session closed."));
+    for (const compaction of this.pendingCompactions.splice(0))
+      compaction.reject(new Error("Remote session closed."));
+  }
+  async sendPrompt(text, streamingBehavior) {
+    await this.transport.sendPrompt(this.context, this.runId, text, streamingBehavior);
+  }
+  async sendCommand(text) {
+    const result = await this.transport.runCommand(this.context, this.runId, text);
+    return typeof result.message === "string" ? result.message : "worker command accepted";
+  }
+  async sendShell(text) {
+    await this.transport.sendShell(this.context, this.runId, text);
+  }
+  async abort() {
+    await this.transport.abort(this.context, this.runId);
+  }
+  registerPendingShell(shell) {
+    this.pendingShells.push(shell);
+  }
+  failPendingShell(shell, error) {
+    const index = this.pendingShells.indexOf(shell);
+    if (index !== -1)
+      this.pendingShells.splice(index, 1);
+    shell.reject(error);
+  }
+  registerPendingCompaction(pending) {
+    this.pendingCompactions.push(pending);
+  }
+  async waitForReady() {
+    const startedAt = Date.now();
+    const deadline = startedAt + resolveAttachReadyTimeoutMs();
+    let consecutiveFailures = 0;
+    while (!this.closed) {
+      let requestFailed = false;
+      const session = await this.transport.getSession(this.context, this.runId).catch((error) => {
+        requestFailed = true;
+        return { ready: false, status: error instanceof Error ? error.message : String(error), retryAfterMs: 1000 };
+      });
+      if (session.ready !== false)
+        return true;
+      consecutiveFailures = requestFailed ? consecutiveFailures + 1 : 0;
+      const status = String(session.status ?? "starting");
+      if (TERMINAL_RUN_STATUSES.has(status.toLowerCase())) {
+        this.hooks.onError?.(`Run ended before the worker Pi daemon became ready: ${status}. Inspect with \`rig run show ${this.runId}\`.`);
+        return false;
+      }
+      this.hooks.onStatusText?.(consecutiveFailures >= 5 ? "Rig server unreachable \xB7 retrying \xB7 /detach to exit" : `waiting for worker Pi daemon \xB7 ${status} \xB7 /detach to exit`);
+      if (Date.now() >= deadline) {
+        this.hooks.onError?.(`Worker Pi daemon did not become ready (last status: ${status}). Set RIG_PI_ATTACH_TIMEOUT_MS to wait longer.`);
+        return false;
+      }
+      await Bun.sleep(typeof session.retryAfterMs === "number" ? session.retryAfterMs : 750);
+    }
+    return false;
+  }
+  applyEnvelope(envelopeValue) {
+    const envelope = recordOf(envelopeValue);
+    if (!envelope)
+      return;
+    const type = String(envelope.type ?? "");
+    if (type === "status.update") {
+      this.applyStatusPayload(envelope);
+      return;
+    }
+    if (type === "activity.update") {
+      const activity = recordOf(envelope.activity);
+      this.hooks.onActivity?.(String(activity?.label ?? ""), activity?.detail ? String(activity.detail) : undefined);
+      return;
+    }
+    if (type === "extension_ui_request") {
+      const request = recordOf(envelope.request);
+      if (request)
+        this.hooks.onExtensionUiRequest?.(request);
+      return;
+    }
+    if (type === "pi.ui_event") {
+      this.applyShellUiEvent(envelope.event);
+      return;
+    }
+    if (type === "pi.event") {
+      this.session?.handleRemoteSessionEvent(envelope.event);
+      this.settlePendingCompaction(envelope.event);
+      return;
+    }
+    if (type === "error") {
+      this.hooks.onError?.(String(envelope.message ?? envelope.detail ?? "unknown worker error"));
+    }
+  }
+  applyStatusPayload(payload) {
+    const status = recordOf(payload.status) ?? payload;
+    const next = this.status;
+    next.isStreaming = status.isStreaming === true;
+    next.isCompacting = status.isCompacting === true;
+    next.isBashRunning = status.isBashRunning === true;
+    next.pendingMessageCount = typeof status.pendingMessageCount === "number" ? status.pendingMessageCount : 0;
+    next.steeringMessages = Array.isArray(status.steeringMessages) ? status.steeringMessages.map(String) : [];
+    next.followUpMessages = Array.isArray(status.followUpMessages) ? status.followUpMessages.map(String) : [];
+    next.model = recordOf(status.model) ?? next.model;
+    next.thinkingLevel = typeof status.thinkingLevel === "string" ? status.thinkingLevel : next.thinkingLevel;
+    next.sessionName = typeof status.sessionName === "string" ? status.sessionName : next.sessionName;
+    next.cwd = typeof status.cwd === "string" ? status.cwd : next.cwd;
+    next.stats = recordOf(status.stats) ?? next.stats;
+    next.contextUsage = recordOf(status.contextUsage) ?? next.contextUsage;
+  }
+  applyShellUiEvent(value) {
+    const event = recordOf(value);
+    if (!event)
+      return;
+    const type = String(event.type ?? "");
+    const pending = this.pendingShells[0];
+    if (type === "shell.chunk" && pending) {
+      pending.sawChunk = true;
+      pending.onData(Buffer.from(String(event.chunk ?? "")));
+      return;
+    }
+    if (type === "shell.end" && pending) {
+      const output = String(event.output ?? "");
+      if (output && !pending.sawChunk)
+        pending.onData(Buffer.from(output));
+      const index = this.pendingShells.indexOf(pending);
+      if (index !== -1)
+        this.pendingShells.splice(index, 1);
+      pending.resolve({ exitCode: typeof event.exitCode === "number" ? event.exitCode : event.isError === true ? 1 : 0 });
+    }
+  }
+  settlePendingCompaction(eventValue) {
+    const event = recordOf(eventValue);
+    if (!event)
+      return;
+    const type = String(event.type ?? "");
+    if (type !== "compaction_end" || this.pendingCompactions.length === 0)
+      return;
+    const pending = this.pendingCompactions.shift();
+    const result = recordOf(event.result);
+    if (result)
+      pending.resolve(result);
+    else if (event.aborted === true)
+      pending.reject(new Error("Compaction aborted on the worker."));
+    else
+      pending.resolve({});
+  }
+}
+
+class RigRemoteAgentSession extends PiAgentSession {
+  remote;
+  constructor(config, remote) {
+    super(config);
+    this.remote = remote;
+    remote.bindSession(this);
+  }
+  handleRemoteSessionEvent(eventValue) {
+    const event = recordOf(eventValue);
+    if (!event)
+      return;
+    const type = String(event.type ?? "");
+    if ((type === "message_end" || type === "turn_end") && recordOf(event.message)) {
+      this.agent.state.messages = [...this.agent.state.messages, event.message];
+    }
+    this._emit(eventValue);
+  }
+  replaceRemoteMessages(messages) {
+    this.agent.state.messages = messages;
+  }
+  async prompt(text, options) {
+    const trimmed = text.trim();
+    if (!trimmed)
+      return;
+    if (trimmed.startsWith("/")) {
+      if (await this._tryExecuteExtensionCommand(trimmed))
+        return;
+      await this.remote.sendCommand(trimmed);
+      return;
+    }
+    if (trimmed.startsWith("!")) {
+      await this.remote.sendShell(trimmed);
+      return;
+    }
+    const behavior = options?.streamingBehavior ?? (this.isStreaming || this.isCompacting ? "steer" : undefined);
+    options?.preflightResult?.(true);
+    await this.remote.sendPrompt(trimmed, behavior);
+  }
+  async steer(text) {
+    await this.remote.sendPrompt(text, "steer");
+  }
+  async followUp(text) {
+    await this.remote.sendPrompt(text, "followUp");
+  }
+  async abort() {
+    await this.remote.abort();
+  }
+  async compact(customInstructions) {
+    const pending = new Promise((resolve3, reject) => {
+      this.remote.registerPendingCompaction({ resolve: resolve3, reject });
+    });
+    await this.remote.sendCommand(`/compact${customInstructions ? ` ${customInstructions}` : ""}`);
+    return pending;
+  }
+  clearQueue() {
+    const cleared = {
+      steering: [...this.remote.status.steeringMessages],
+      followUp: [...this.remote.status.followUpMessages]
+    };
+    this.remote.status.steeringMessages = [];
+    this.remote.status.followUpMessages = [];
+    this.remote.status.pendingMessageCount = 0;
+    this.remote.sendCommand("/queue-clear").catch(() => {});
+    return cleared;
+  }
+  get isStreaming() {
+    return this.remote.status.isStreaming;
+  }
+  get isCompacting() {
+    return this.remote.status.isCompacting;
+  }
+  get isBashRunning() {
+    return this.remote.status.isBashRunning;
+  }
+  get pendingMessageCount() {
+    return this.remote.status.pendingMessageCount;
+  }
+  getSteeringMessages() {
+    return this.remote.status.steeringMessages;
+  }
+  getFollowUpMessages() {
+    return this.remote.status.followUpMessages;
+  }
+  get model() {
+    return this.remote.status.model ?? super.model;
+  }
+  async setModel(model) {
+    await this.remote.sendCommand(`/model ${model.provider}/${model.id}`);
+    this.remote.status.model = model;
+  }
+  get thinkingLevel() {
+    return this.remote.status.thinkingLevel ?? super.thinkingLevel;
+  }
+  setThinkingLevel(level) {
+    this.remote.status.thinkingLevel = level;
+    this.remote.sendCommand(`/thinking ${level}`).catch(() => {});
+  }
+  get sessionName() {
+    return this.remote.status.sessionName ?? super.sessionName;
+  }
+  setSessionName(name) {
+    this.remote.status.sessionName = name;
+    this.remote.sendCommand(`/name ${name}`).catch(() => {});
+  }
+  getSessionStats() {
+    return this.remote.status.stats ?? super.getSessionStats();
+  }
+  getContextUsage() {
+    return this.remote.status.contextUsage ?? super.getContextUsage();
+  }
+  dispose() {
+    this.remote.close();
+    super.dispose();
+  }
+}
+function createRemoteBashOperations(controller, excludeFromContext) {
+  return {
+    exec(command, _cwd, execOptions) {
+      return new Promise((resolve3, reject) => {
+        const pending = { onData: execOptions.onData, resolve: resolve3, reject, sawChunk: false };
+        const cleanup = () => {
+          execOptions.signal?.removeEventListener("abort", onAbort);
+          if (timer)
+            clearTimeout(timer);
+        };
+        const onAbort = () => {
+          cleanup();
+          controller.failPendingShell(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();
+          controller.failPendingShell(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 });
+        controller.registerPendingShell(pending);
+        controller.sendShell(`${excludeFromContext ? "!!" : "!"}${command}`).catch((error) => {
+          cleanup();
+          controller.failPendingShell(pending, error instanceof Error ? error : new Error(String(error)));
+        });
+      });
+    }
+  };
+}
+
+// packages/cli/src/commands/_pi-worker-bridge-extension.ts
+function recordOf2(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);
+  }
+}
+async function answerExtensionUiRequest(options, ctx, request) {
+  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 choices = rawOptions.map((option) => {
+    const record = recordOf2(option);
+    return record ? asText(record.label ?? record.value ?? record.name ?? option) : asText(option);
+  }).filter(Boolean);
+  try {
+    if (method === "confirm") {
+      const confirmed = await ctx.ui.confirm("Worker request", prompt);
+      await respondRunPiExtensionUiViaServer(options.context, options.runId, requestId, { value: confirmed, confirmed });
+      return;
+    }
+    if (choices.length > 0) {
+      const selected = await ctx.ui.select(prompt, choices);
+      await respondRunPiExtensionUiViaServer(options.context, options.runId, requestId, selected === undefined ? { cancelled: true } : { value: selected });
+      return;
+    }
+    const value = await ctx.ui.input("Worker request", prompt);
+    await respondRunPiExtensionUiViaServer(options.context, options.runId, requestId, value === undefined ? { cancelled: true } : { value });
+  } catch (error) {
+    ctx.ui.notify(`Failed to answer worker UI request: ${error instanceof Error ? error.message : String(error)}`, "error");
+  }
+}
+var LOCALLY_OWNED_COMMANDS = new Set(["detach", "quit", "q", "stop", "settings", "model", "thinking", "compact", "session", "name", "reload"]);
+function registerDaemonCommands(pi, options, ctx, commands, registered) {
+  for (const command of commands) {
+    const record = recordOf2(command);
+    const name = typeof record?.name === "string" ? record.name : "";
+    const source = typeof record?.source === "string" ? record.source : "worker";
+    if (!name || source === "builtin" || registered.has(name) || LOCALLY_OWNED_COMMANDS.has(name))
+      continue;
+    registered.add(name);
+    const description = typeof record?.description === "string" ? record.description : undefined;
+    try {
+      pi.registerCommand(name, {
+        description: `[worker ${source}] ${description ?? ""}`.trim(),
+        handler: async (args) => {
+          try {
+            const message = await options.controller.sendCommand(`/${name}${args ? ` ${args}` : ""}`);
+            ctx.ui.notify(message, "info");
+          } catch (error) {
+            ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
+          }
+        }
+      });
+    } catch {}
+  }
+}
+function createRigWorkerPiBridgeExtension(options) {
+  return (pi) => {
+    const registeredDaemonCommands = new Set;
+    pi.registerCommand("detach", {
+      description: "Detach from this run; the worker keeps going",
+      handler: async (_args, ctx) => {
+        ctx.ui.notify("Detached locally; the worker Pi daemon continues.", "info");
+        ctx.shutdown();
+      }
+    });
+    pi.registerCommand("stop", {
+      description: "Stop the worker Pi run and detach",
+      handler: async (_args, ctx) => {
+        await options.controller.abort();
+        ctx.ui.notify("Stop requested for the worker Pi daemon.", "info");
+        ctx.shutdown();
+      }
+    });
+    pi.on("user_bash", (event) => ({
+      operations: createRemoteBashOperations(options.controller, event.excludeFromContext === true)
+    }));
+    pi.on("session_start", async (_event, ctx) => {
+      ctx.ui.setTitle("Rig \xB7 worker session");
+      ctx.ui.setStatus("rig-worker-pi", "connecting to worker session");
+      ctx.ui.notify(`Attached to Rig run ${options.runId}. Native Pi, remote brain \u2014 /detach exits, /stop cancels the run.`, "info");
+      if (options.initialMessageSent)
+        ctx.ui.notify("Initial message sent to the worker Pi daemon.", "info");
+      const nativeUi = ctx.ui;
+      options.controller.setUiHooks({
+        onStatusText: (text) => ctx.ui.setStatus("rig-worker-pi", text),
+        onActivity: (label, detail) => ctx.ui.setStatus("rig-worker-pi", [label, detail].filter(Boolean).join(" \u2014 ")),
+        onConnectionChange: (connected) => ctx.ui.setStatus("rig-worker-pi", connected ? "worker session live" : "worker session disconnected"),
+        onError: (message) => ctx.ui.notify(message, "error"),
+        onExtensionUiRequest: (request) => {
+          answerExtensionUiRequest(options, ctx, request);
+        },
+        onCatchUp: (messages, commands) => {
+          if (nativeUi.appendSessionMessages)
+            nativeUi.appendSessionMessages(messages);
+          const cwd = options.controller.status.cwd;
+          if (nativeUi.setDisplayCwd && cwd)
+            nativeUi.setDisplayCwd(cwd);
+          registerDaemonCommands(pi, options, ctx, commands, registeredDaemonCommands);
+        }
+      });
+      options.controller.connect().catch((error) => {
+        ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
+      });
+    });
+    pi.on("session_shutdown", () => {
+      options.controller.close();
+    });
+  };
+}
+
+// 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 tempSessionDir = mkdtempSync(join(tmpdir(), "rig-pi-frontend-sessions-"));
+  const restoreEnv = setTemporaryEnv({
+    PI_CODING_AGENT_SESSION_DIR: tempSessionDir,
+    PI_SKIP_VERSION_CHECK: "1"
+  });
+  const controller = new RigRemoteSessionController({ context, runId: input.runId });
+  const createRemoteRuntime = async ({ cwd, agentDir, sessionManager, sessionStartEvent }) => {
+    const services = await createAgentSessionServices({
+      cwd,
+      agentDir,
+      resourceLoaderOptions: {
+        extensionFactories: [
+          createRigWorkerPiBridgeExtension({
+            context,
+            controller,
+            runId: input.runId,
+            initialMessageSent: input.steered === true
+          })
+        ],
+        noContextFiles: true
+      }
+    });
+    const created = await createAgentSessionFromServices({
+      services,
+      sessionManager,
+      sessionStartEvent,
+      noTools: "all",
+      sessionFactory: (config) => new RigRemoteAgentSession(config, controller)
+    });
+    return { ...created, services, diagnostics: services.diagnostics };
+  };
+  let detached = false;
+  try {
+    await runPiMain([], {
+      createRuntimeOverride: () => createRemoteRuntime
+    });
+    detached = true;
+  } finally {
+    restoreEnv();
+    controller.close();
+    rmSync(tempSessionDir, { 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: "native bundled Pi frontend with remote worker session runtime"
+  };
+}
+
+// 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();
@@ -284,57 +1125,76 @@ 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 };
 }
 export {
   renderOperatorSnapshot,
+  createPiRunStreamRenderer,
   attachRunOperatorView,
   applyOperatorCommand
 };