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

package/dist/src/index.js

@@ -6156,6 +6156,7 @@ import {
   writeJsonFile as writeJsonFile4
 } from "@rig/runtime/control-plane/authority-files";
 import { taskLookup } from "@rig/runtime/control-plane/native/task-ops";
+import { readPriorPrProgressPromptSection } from "@rig/runtime/control-plane/prompt-context";
 import { buildProviderTaskRunInstructionLines } from "@rig/runtime/control-plane/provider/runtime-instructions";
 import { loadRigTaskRunSkillBody } from "@rig/runtime/control-plane/provider/rig-task-run-skill";
 function patchAuthorityRun(projectRoot, runId, patch) {
@@ -6302,7 +6303,7 @@ ${acceptance}` : null,
 ${sourceContractLines.join(`
 `)}` : null,
     scopeText || renderSourceScopeValidation(sourceTask, sourceValidation) || null,
-    readPriorPrProgressForPrompt(input.projectRoot, input.taskId),
+    readPriorPrProgressPromptSection(input.projectRoot, input.taskId),
     initialPrompt ? `Additional operator guidance:
 ${initialPrompt}` : null,
     providerLines.length > 0 ? `Provider-specific runtime tooling:
@@ -6312,26 +6313,6 @@ ${providerLines.join(" ")}` : null,
 
 `);
 }
-function readPriorPrProgressForPrompt(projectRoot, taskId) {
-  for (const candidate of [
-    resolve20(projectRoot, ".worktrees", taskId, "artifacts", taskId, "pr-state.json"),
-    resolve20(projectRoot, "artifacts", taskId, "pr-state.json")
-  ]) {
-    try {
-      const raw = JSON.parse(readFileSync8(candidate, "utf8"));
-      const entries = Array.isArray(raw) ? raw : [raw];
-      const first = entries.find((entry) => entry && typeof entry === "object" && typeof entry.url === "string");
-      if (!first)
-        continue;
-      return [
-        `Prior progress exists for this task: PR ${first.url}${first.branch ? ` (branch ${first.branch})` : ""} was opened by an earlier run.`,
-        "Check its current state first (diff, checks, review). If the work is already complete and checks are green,",
-        "run `rig-agent completion-verification` to merge and close instead of re-implementing anything."
-      ].join(" ");
-    } catch {}
-  }
-  return null;
-}
 function firstPromptString(...values) {
   for (const value of values) {
     const trimmed = typeof value === "string" ? value.trim() : "";
@@ -7398,435 +7379,394 @@ async function promptForTaskSelection(question) {
 import { mkdtempSync, rmSync as rmSync5 } from "fs";
 import { tmpdir } from "os";
 import { join as join2 } from "path";
-import { main as runPiMain } from "@earendil-works/pi-coding-agent";
+import {
+  createAgentSessionFromServices,
+  createAgentSessionServices,
+  main as runPiMain
+} from "@earendil-works/pi-coding-agent";
 
-// packages/cli/src/commands/_pi-worker-bridge-extension.ts
+// 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"]);
-var MAX_TRANSCRIPT_LINES = 120;
+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 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, text2) {
-  const trimmed = text2.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" : "connecting",
-    state.status,
-    state.model,
-    state.cwd
-  ].filter(Boolean);
-  const lines = [`Rig worker session \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 the worker session transcript\u2026 (/detach exits and leaves the worker running)");
-  }
-  if (state.pendingUi) {
-    lines.push("");
-    lines.push(`Worker needs input \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 editor below. /cancel dismisses this request.");
-  }
-  return lines;
-}
-function reportBridgeError(ctx, state, message2) {
-  appendTranscript(state, "Error", message2);
-  state.status = message2;
-  try {
-    ctx.ui.notify(message2, "error");
-  } catch {}
-  updatePiUi(ctx, state);
-}
-function updatePiUi(ctx, state) {
-  ctx.ui.setTitle("Rig \xB7 worker session");
-  ctx.ui.setStatus("rig-worker-pi", state.wsConnected ? "worker session 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", 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, message2) {
-  const record = recordOf(message2);
-  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);
+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;
 }
-function formatElapsed(sinceMs) {
-  const totalSeconds = Math.floor((Date.now() - sinceMs) / 1000);
-  const minutes = Math.floor(totalSeconds / 60);
-  const seconds = totalSeconds % 60;
-  return minutes > 0 ? `${minutes}m${String(seconds).padStart(2, "0")}s` : `${seconds}s`;
-}
-async function waitForWorkerReady(options, ctx, state) {
-  const startedAt = Date.now();
-  const deadline = startedAt + resolveAttachReadyTimeoutMs();
-  let consecutiveFailures = 0;
-  while (true) {
-    let requestFailed = false;
-    const session = await getRunPiSessionViaServer(options.context, options.runId).catch((error) => {
-      requestFailed = true;
-      return {
-        ready: false,
-        status: error instanceof Error ? error.message : String(error),
-        retryAfterMs: 1000
-      };
-    });
-    if (session.ready === false) {
-      consecutiveFailures = requestFailed ? consecutiveFailures + 1 : 0;
-      const status = String(session.status ?? "starting");
-      if (TERMINAL_RUN_STATUSES.has(status.toLowerCase())) {
-        reportBridgeError(ctx, state, `Run ended before worker Pi daemon became ready: ${status}. Inspect with \`rig run show ${options.runId}\`; restart with \`rig task run --task <id>\`.`);
-        return false;
-      }
-      if (consecutiveFailures >= 5) {
-        state.status = `Rig server unreachable \xB7 retrying (${formatElapsed(startedAt)}) \xB7 /detach to exit`;
-      } else {
-        state.status = `waiting for worker Pi daemon \xB7 ${status} \xB7 ${formatElapsed(startedAt)} \xB7 /detach to exit`;
-      }
-      updatePiUi(ctx, state);
-      if (Date.now() >= deadline) {
-        reportBridgeError(ctx, state, `Worker Pi daemon did not become ready within ${formatElapsed(startedAt)} (last status: ${status}). ` + `Check \`rig run show ${options.runId}\` and \`rig doctor\`; the run may have been restarted by a server deploy. ` + "Set RIG_PI_ATTACH_TIMEOUT_MS to wait longer.");
-        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(message2) {
-  if (typeof message2.data === "string")
-    return JSON.parse(message2.data);
-  return JSON.parse(Buffer.from(message2.data).toString("utf8"));
-}
-var BRIDGE_LOCAL_COMMANDS = new Set(["detach", "quit", "q", "stop"]);
-function registerDaemonCommandsNatively(pi, options, ctx, state, commands, registered) {
-  for (const command of commands) {
-    const record = recordOf(command);
-    const name = typeof record?.name === "string" ? record.name : "";
-    if (!name || registered.has(name) || BRIDGE_LOCAL_COMMANDS.has(name))
-      continue;
-    registered.add(name);
-    const description = typeof record?.description === "string" ? record.description : undefined;
-    const source = typeof record?.source === "string" ? record.source : "worker";
-    try {
-      pi.registerCommand(name, {
-        description: `[worker ${source}] ${description ?? ""}`.trim(),
-        handler: async (args) => {
-          const text2 = `/${name}${args ? ` ${args}` : ""}`;
-          appendTranscript(state, "You", text2);
-          try {
-            const result = await runRunPiCommandViaServer(options.context, options.runId, text2);
-            const message2 = typeof result.message === "string" ? result.message : "worker command accepted";
-            appendTranscript(state, "System", message2);
-            if (state.nativeStream)
-              ctx.ui.notify(message2, "info");
-          } catch (error) {
-            reportBridgeError(ctx, state, error instanceof Error ? error.message : String(error));
-          }
-          updatePiUi(ctx, state);
-        }
-      });
-    } catch {}
-  }
-}
-async function connectWorkerStream(options, pi, ctx, state, registeredDaemonCommands) {
-  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((resolve22) => {
+
+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 = () => {
-      state.wsConnected = true;
-      state.status = "live worker Pi WebSocket connected";
-      updatePiUi(ctx, state);
+      this.hooks.onConnectionChange?.(true);
+      this.hooks.onStatusText?.("worker session live");
     };
     socket.onmessage = (message2) => {
       try {
-        const payload = parseWsPayload(message2);
+        const payload = typeof message2.data === "string" ? JSON.parse(message2.data) : JSON.parse(Buffer.from(message2.data).toString("utf8"));
         if (!catchupDone)
           buffered.push(payload);
-        else {
-          applyEnvelope(ctx, state, payload);
-          updatePiUi(ctx, state);
-        }
+        else
+          this.applyEnvelope(payload);
       } catch (error) {
-        appendTranscript(state, "Error", `Unparseable worker Pi event: ${error instanceof Error ? error.message : String(error)}`);
-        updatePiUi(ctx, state);
+        this.hooks.onError?.(`Unparseable worker Pi event: ${error instanceof Error ? error.message : String(error)}`);
       }
     };
     socket.onerror = () => socket.close();
     socket.onclose = () => {
-      state.wsConnected = false;
-      state.status = "worker Pi WebSocket disconnected";
-      updatePiUi(ctx, state);
-      resolve22();
+      this.hooks.onConnectionChange?.(false);
+      if (!this.closed)
+        this.hooks.onStatusText?.("worker Pi WebSocket disconnected");
     };
-  });
-  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);
+    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(text2, streamingBehavior) {
+    await this.transport.sendPrompt(this.context, this.runId, text2, streamingBehavior);
+  }
+  async sendCommand(text2) {
+    const result = await this.transport.runCommand(this.context, this.runId, text2);
+    return typeof result.message === "string" ? result.message : "worker command accepted";
+  }
+  async sendShell(text2) {
+    await this.transport.sendShell(this.context, this.runId, text2);
+  }
+  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
-      for (const message2 of messages)
-        applyMessage(state, message2);
-    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}`] : [];
+      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(text2, options) {
+    const trimmed = text2.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(text2) {
+    await this.remote.sendPrompt(text2, "steer");
+  }
+  async followUp(text2) {
+    await this.remote.sendPrompt(text2, "followUp");
+  }
+  async abort() {
+    await this.remote.abort();
+  }
+  async compact(customInstructions) {
+    const pending = new Promise((resolve22, reject) => {
+      this.remote.registerPendingCompaction({ resolve: resolve22, reject });
     });
-    registerDaemonCommandsNatively(pi, options, ctx, state, commands, registeredDaemonCommands);
-    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 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();
   }
-  await closePromise;
 }
-function createRemoteBashOperations(options, state, excludeFromContext) {
+function createRemoteBashOperations(controller, excludeFromContext) {
   return {
     exec(command, _cwd, execOptions) {
       return new Promise((resolve22, reject) => {
-        const pending = {
-          command,
-          onData: execOptions.onData,
-          resolve: resolve22,
-          reject,
-          sawChunk: false
-        };
+        const pending = { onData: execOptions.onData, resolve: resolve22, reject, sawChunk: false };
         const cleanup = () => {
           execOptions.signal?.removeEventListener("abort", onAbort);
           if (timer)
@@ -7834,12 +7774,12 @@ function createRemoteBashOperations(options, state, excludeFromContext) {
         };
         const onAbort = () => {
           cleanup();
-          failPendingShell(state, pending, new Error("Remote worker shell command aborted locally."));
+          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();
-          failPendingShell(state, pending, new Error(`Remote worker shell command timed out after ${timeoutMs}ms.`));
+          controller.failPendingShell(pending, new Error(`Remote worker shell command timed out after ${timeoutMs}ms.`));
         }, timeoutMs) : null;
         const wrappedResolve = pending.resolve;
         const wrappedReject = pending.reject;
@@ -7852,125 +7792,136 @@ function createRemoteBashOperations(options, state, excludeFromContext) {
           wrappedReject(error);
         };
         execOptions.signal?.addEventListener("abort", onAbort, { once: true });
-        state.pendingShells.push(pending);
-        sendRunPiShellViaServer(options.context, options.runId, `${excludeFromContext ? "!!" : "!"}${command}`).catch((error) => {
+        controller.registerPendingShell(pending);
+        controller.sendShell(`${excludeFromContext ? "!!" : "!"}${command}`).catch((error) => {
           cleanup();
-          failPendingShell(state, pending, error instanceof Error ? error : new Error(String(error)));
+          controller.failPendingShell(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;
+
+// packages/cli/src/commands/_pi-worker-bridge-extension.ts
+function recordOf2(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
-async function routeInput(options, ctx, state, line) {
-  const text2 = line.trim();
-  if (!text2)
-    return;
-  if (await answerPendingUi(options, state, text2)) {
-    updatePiUi(ctx, state);
-    return;
-  }
-  if (text2 === "/detach" || text2 === "/quit" || text2 === "/q") {
-    appendTranscript(state, "System", "Detached locally; worker Pi daemon continues.");
-    updatePiUi(ctx, state);
-    ctx.shutdown();
-    return;
+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);
   }
-  if (text2 === "/stop") {
-    await abortRunPiViaServer(options.context, options.runId);
-    appendTranscript(state, "System", "Stop requested for worker Pi daemon.");
-    updatePiUi(ctx, state);
-    ctx.shutdown();
-    return;
+}
+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");
   }
-  if (text2.startsWith("!")) {
-    appendTranscript(state, "You", text2);
-    await sendRunPiShellViaServer(options.context, options.runId, text2);
-  } else if (text2.startsWith("/")) {
-    appendTranscript(state, "You", text2);
-    const result = await runRunPiCommandViaServer(options.context, options.runId, text2);
-    const message2 = typeof result.message === "string" ? result.message : "worker command accepted";
-    appendTranscript(state, "System", message2);
-  } else {
-    appendTranscript(state, "You", text2);
-    await sendRunPiPromptViaServer(options.context, options.runId, text2, state.streaming ? "steer" : undefined);
+}
+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 message2 = await options.controller.sendCommand(`/${name}${args ? ` ${args}` : ""}`);
+            ctx.ui.notify(message2, "info");
+          } catch (error) {
+            ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
+          }
+        }
+      });
+    } catch {}
   }
-  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.");
     const registeredDaemonCommands = new Set;
-    let nativePiUiContextAvailable = false;
-    pi.on("user_bash", (event) => {
-      state.nativeStream = Boolean(state.nativeStream || nativePiUiContextAvailable);
-      return { operations: createRemoteBashOperations(options, state, event.excludeFromContext === true) };
+    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) => {
-      nativePiUiContextAvailable = Boolean(nativePiUi(ctx));
-      state.nativeStream = nativePiUiContextAvailable;
-      updatePiUi(ctx, state);
-      ctx.ui.notify(nativePiUiContextAvailable ? "Connected to the Rig worker session (native stream). /detach exits, /stop cancels the run." : "Connected to the Rig worker session (transcript view). /detach exits, /stop cancels the run.", "info");
-      ctx.ui.onTerminalInput((data) => {
-        if (data.includes("\x04")) {
-          ctx.shutdown();
-          return { consume: true };
+      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: (text2) => ctx.ui.setStatus("rig-worker-pi", text2),
+        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: (message2) => ctx.ui.notify(message2, "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);
         }
-        if (!data.includes("\r") && !data.includes(`
-`))
-          return;
-        const inlineText = data.replace(/[\r\n]+/g, "").trim();
-        const editorText = ctx.ui.getEditorText().trim();
-        const text2 = [editorText, inlineText].filter(Boolean).join(" ").trim();
-        if (!text2)
-          return;
-        if (text2.startsWith("!"))
-          return;
-        ctx.ui.setEditorText("");
-        routeInput(options, ctx, state, text2).catch((error) => {
-          appendTranscript(state, "Error", error instanceof Error ? error.message : String(error));
-          updatePiUi(ctx, state);
-        });
-        return { consume: true };
       });
-      connectWorkerStream(options, pi, ctx, state, registeredDaemonCommands).catch((error) => {
-        appendTranscript(state, "Error", error instanceof Error ? error.message : String(error));
-        updatePiUi(ctx, state);
+      options.controller.connect().catch((error) => {
+        ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
       });
     });
-    pi.on("session_shutdown", () => {});
+    pi.on("session_shutdown", () => {
+      options.controller.close();
+    });
   };
 }
 
@@ -7991,43 +7942,47 @@ function setTemporaryEnv(updates) {
   };
 }
 async function attachRunBundledPiFrontend(context, input) {
-  const tempRoot = mkdtempSync(join2(tmpdir(), "rig-pi-frontend-"));
-  const cwd = join2(tempRoot, "workspace");
-  const agentDir = join2(tempRoot, "agent");
-  const sessionDir = join2(tempRoot, "sessions");
-  const previousCwd = process.cwd();
+  const tempSessionDir = mkdtempSync(join2(tmpdir(), "rig-pi-frontend-sessions-"));
   const restoreEnv = setTemporaryEnv({
-    PI_CODING_AGENT_DIR: agentDir,
-    PI_CODING_AGENT_SESSION_DIR: sessionDir,
-    PI_OFFLINE: "1",
+    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 Bun.$`mkdir -p ${cwd} ${agentDir} ${sessionDir}`.quiet();
-    process.chdir(cwd);
-    await runPiMain([
-      "--offline",
-      "--no-session",
-      "--no-tools",
-      "--no-builtin-tools",
-      "--no-skills",
-      "--no-context-files",
-      "--no-approve"
-    ], {
-      extensionFactories: [
-        createRigWorkerPiBridgeExtension({
-          context,
-          runId: input.runId,
-          initialMessageSent: input.steered === true
-        })
-      ]
+    await runPiMain([], {
+      createRuntimeOverride: () => createRemoteRuntime
     });
     detached = true;
   } finally {
-    process.chdir(previousCwd);
     restoreEnv();
-    rmSync5(tempRoot, { recursive: true, force: true });
+    controller.close();
+    rmSync5(tempSessionDir, { recursive: true, force: true });
   }
   let run = { runId: input.runId, status: "unknown" };
   try {
@@ -8040,7 +7995,7 @@ async function attachRunBundledPiFrontend(context, input) {
     timelineCursor: null,
     steered: input.steered === true,
     detached,
-    rendered: "actual bundled Pi frontend hosted Rig worker Pi bridge extension"
+    rendered: "native bundled Pi frontend with remote worker session runtime"
   };
 }