@h-rig/cli 0.0.6-alpha.21 → 0.0.6-alpha.23

package/dist/src/commands/task.js

@@ -1,8 +1,8 @@
 // @bun
 // packages/cli/src/commands/task.ts
-import { readFileSync as readFileSync4 } from "fs";
+import { readFileSync as readFileSync3 } from "fs";
 import { spawnSync } from "child_process";
-import { resolve as resolve4 } from "path";
+import { resolve as resolve3 } from "path";
 import { cancel as cancel2, confirm, isCancel as isCancel2 } from "@clack/prompts";
 
 // packages/cli/src/runner.ts
@@ -13,9 +13,6 @@ import { PluginManager } from "@rig/runtime/control-plane/runtime/plugins";
 import { loadRuntimeContextFromEnv } from "@rig/runtime/control-plane/runtime/context";
 import { buildBinary } from "@rig/runtime/control-plane/runtime/isolation";
 import { CliError as CliError2 } from "@rig/runtime/control-plane/errors";
-function formatCommand(parts) {
-  return parts.map((part) => /[^a-zA-Z0-9_./:-]/.test(part) ? JSON.stringify(part) : part).join(" ");
-}
 function takeFlag(args, flag) {
   const rest = [];
   let value = false;
@@ -362,6 +359,66 @@ 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();
+}
 async function submitTaskRunViaServer(context, input) {
   const isTaskRun = Boolean(input.taskId);
   const endpoint = isTaskRun ? "/api/runs/task" : "/api/runs/adhoc";
@@ -394,85 +451,6 @@ async function submitTaskRunViaServer(context, input) {
   return { runId };
 }
 
-// packages/cli/src/commands/_pi-install.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3, rmSync } from "fs";
-import { homedir as homedir2 } from "os";
-import { resolve as resolve3 } from "path";
-var PI_RIG_PACKAGE_NAME = "@h-rig/pi-rig";
-var LEGACY_PI_RIG_PACKAGE_NAME = "@rig/pi-rig";
-async function defaultCommandRunner(command, options = {}) {
-  const proc = Bun.spawn(command, { cwd: options.cwd, stdout: "pipe", stderr: "pipe" });
-  const [stdout, stderr, exitCode] = await Promise.all([
-    new Response(proc.stdout).text(),
-    new Response(proc.stderr).text(),
-    proc.exited
-  ]);
-  return { exitCode, stdout, stderr };
-}
-function resolvePiRigExtensionPath(homeDir) {
-  return resolve3(homeDir, ".pi", "agent", "extensions", "pi-rig");
-}
-function resolvePiRigPackageSource(projectRoot, exists = existsSync3) {
-  const localPackage = resolve3(projectRoot, "packages", "pi-rig");
-  if (exists(resolve3(localPackage, "package.json")))
-    return localPackage;
-  return `npm:${PI_RIG_PACKAGE_NAME}`;
-}
-function resolvePiHomeDir(inputHomeDir) {
-  return inputHomeDir ?? process.env.RIG_PI_HOME_DIR?.trim() ?? homedir2();
-}
-function piListContainsPiRig(output) {
-  return output.split(/\r?\n/).some((line) => {
-    const normalized = line.trim();
-    return normalized.includes(PI_RIG_PACKAGE_NAME) || normalized.includes(LEGACY_PI_RIG_PACKAGE_NAME) || /(?:^|[\\/])packages[\\/]pi-rig(?:$|\s)/.test(normalized);
-  });
-}
-async function safeRun(runner, command, options) {
-  try {
-    return await runner(command, options);
-  } catch (error) {
-    return { exitCode: 1, stdout: "", stderr: error instanceof Error ? error.message : String(error) };
-  }
-}
-async function checkPiRigInstall(input = {}) {
-  const home = resolvePiHomeDir(input.homeDir);
-  const extensionPath = resolvePiRigExtensionPath(home);
-  if (process.env.RIG_TEST_FAKE_PI_INSTALL === "1") {
-    return {
-      extensionPath,
-      pi: { ok: true, label: "pi", detail: "fake-pi" },
-      piRig: { ok: true, label: "pi-rig global extension", detail: extensionPath }
-    };
-  }
-  const exists = input.exists ?? existsSync3;
-  const runner = input.commandRunner ?? defaultCommandRunner;
-  const piResult = await safeRun(runner, ["pi", "--version"]);
-  const piListResult = piResult.exitCode === 0 ? await safeRun(runner, ["pi", "list"]) : { exitCode: 1, stdout: "", stderr: "" };
-  const listedPiRig = piListResult.exitCode === 0 && piListContainsPiRig(`${piListResult.stdout}
-${piListResult.stderr}`);
-  const legacyBridge = exists(resolve3(extensionPath, "index.ts"));
-  const hasPiRig = listedPiRig;
-  return {
-    extensionPath,
-    pi: {
-      ok: piResult.exitCode === 0,
-      label: "pi",
-      detail: (piResult.stdout || piResult.stderr).trim() || undefined,
-      hint: piResult.exitCode === 0 ? undefined : "Install Pi or run `rig init --yes` to install/update the Pi runtime."
-    },
-    piRig: {
-      ok: hasPiRig,
-      label: "pi-rig global extension",
-      detail: hasPiRig ? piListResult.stdout.trim() || PI_RIG_PACKAGE_NAME : legacyBridge ? `${extensionPath} (legacy bridge; reinstall required)` : undefined,
-      hint: hasPiRig ? undefined : "Run `rig init --yes` to install/enable the global pi-rig package with `pi install`."
-    }
-  };
-}
-async function buildPiSetupChecks(input = {}) {
-  const status = await checkPiRigInstall(input);
-  return [status.pi, status.piRig];
-}
-
 // packages/cli/src/commands/_preflight.ts
 function preflightCheck(id, label, status, detail, remediation) {
   return {
@@ -630,14 +608,7 @@ async function runFastTaskRunPreflight(context, options = {}) {
     }
   }
   if ((options.runtimeAdapter ?? "pi") === "pi") {
-    const piChecks = await (options.piChecks ?? (() => buildPiSetupChecks()))().catch((error) => [{
-      ok: false,
-      label: "pi/pi-rig checks",
-      hint: message(error)
-    }]);
-    for (const pi of piChecks) {
-      checks.push(preflightCheck(pi.label === "pi" ? "pi" : "pi-rig", pi.label, pi.ok ? "pass" : "fail", pi.detail, pi.hint ?? (pi.ok ? undefined : "Run `rig init --yes` to install/update Pi and enable pi-rig.")));
-    }
+    checks.push(preflightCheck("runtime", "worker Pi SDK session daemon", "pass", selectedServer?.connectionKind === "remote" ? "remote worker-owned runtime" : "bundled server-owned runtime"));
   } else {
     checks.push(preflightCheck("runtime", "runtime adapter", "pass", options.runtimeAdapter));
   }
@@ -974,8 +945,477 @@ async function selectTaskWithTextPicker(tasks, io = {}) {
   return Number.isFinite(index) ? tasks[index] ?? null : null;
 }
 
-// packages/cli/src/commands/_operator-view.ts
+// packages/cli/src/commands/_pi-frontend.ts
+import { mkdtempSync, rmSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import { main as runPiMain } from "@earendil-works/pi-coding-agent";
+
+// packages/cli/src/commands/_pi-worker-bridge-extension.ts
 var TERMINAL_RUN_STATUSES = new Set(["completed", "failed", "stopped", "cancelled", "canceled", "closed", "merged", "needs_attention", "needs-attention"]);
+var MAX_TRANSCRIPT_LINES = 120;
+function recordOf(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function asText(value) {
+  if (typeof value === "string")
+    return value;
+  if (value === null || value === undefined)
+    return "";
+  if (typeof value === "number" || typeof value === "boolean")
+    return String(value);
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function textFromContent(content) {
+  if (typeof content === "string")
+    return content;
+  if (!Array.isArray(content))
+    return asText(content);
+  return content.flatMap((part) => {
+    const item = recordOf(part);
+    if (!item)
+      return [];
+    if (typeof item.text === "string")
+      return [item.text];
+    if (typeof item.content === "string")
+      return [item.content];
+    if (item.type === "toolCall")
+      return [`\u23FA ${String(item.name ?? "tool")} ${asText(item.arguments ?? "")}`.trim()];
+    if (item.type === "toolResult")
+      return [`\u21B3 ${asText(item.content ?? item.result ?? "")}`.trim()];
+    return [];
+  }).join(`
+`);
+}
+function appendTranscript(state, label, text) {
+  const trimmed = text.trimEnd();
+  if (!trimmed)
+    return;
+  const lines = trimmed.split(/\r?\n/);
+  state.transcript.push(`${label}: ${lines[0] ?? ""}`);
+  for (const line of lines.slice(1))
+    state.transcript.push(`  ${line}`);
+  if (state.transcript.length > MAX_TRANSCRIPT_LINES) {
+    state.transcript.splice(0, state.transcript.length - MAX_TRANSCRIPT_LINES);
+  }
+}
+function parseExtensionUiRequest(value) {
+  const request = recordOf(value) ?? {};
+  const requestId = String(request.requestId ?? request.id ?? `ui-${Date.now()}`);
+  const method = String(request.method ?? request.type ?? "input");
+  const prompt = asText(request.prompt ?? request.message ?? request.title ?? method);
+  const rawOptions = Array.isArray(request.options) ? request.options : Array.isArray(request.items) ? request.items : [];
+  const options = rawOptions.map((option) => {
+    const record = recordOf(option);
+    return record ? asText(record.label ?? record.value ?? record.name ?? option) : asText(option);
+  }).filter(Boolean);
+  return { requestId, method, prompt, options };
+}
+function renderBridgeWidget(state) {
+  const statusParts = [
+    state.wsConnected ? "live WS" : "WS pending",
+    state.status,
+    state.model,
+    state.cwd
+  ].filter(Boolean);
+  const lines = [`Worker Pi daemon bridge \xB7 ${statusParts.join(" \xB7 ")}`];
+  if (state.activity)
+    lines.push(state.activity);
+  if (state.commands.length > 0) {
+    lines.push(`Worker commands: ${state.commands.slice(0, 10).join(", ")}${state.commands.length > 10 ? ", \u2026" : ""}`);
+  }
+  lines.push("");
+  if (state.transcript.length > 0) {
+    lines.push(...state.transcript.slice(-MAX_TRANSCRIPT_LINES));
+  } else {
+    lines.push("Waiting for worker Pi daemon transcript\u2026");
+  }
+  if (state.pendingUi) {
+    lines.push("");
+    lines.push(`Extension UI request \xB7 ${state.pendingUi.method}`);
+    lines.push(state.pendingUi.prompt);
+    state.pendingUi.options.forEach((option, index) => lines.push(`${index + 1}. ${option}`));
+    lines.push("Reply in the Pi editor. /cancel cancels this request.");
+  }
+  return lines;
+}
+function updatePiUi(ctx, state) {
+  ctx.ui.setTitle("Pi \xB7 Rig worker daemon");
+  ctx.ui.setStatus("rig-worker-pi", state.wsConnected ? "worker Pi WS live" : state.status);
+  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(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";
+    return;
+  }
+  if (type === "agent_end") {
+    state.streaming = false;
+    state.status = "idle";
+    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`));
+    return;
+  }
+  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}`;
+  }
+}
+function applyUiEvent(state, value) {
+  const event = recordOf(value);
+  if (!event)
+    return;
+  const type = String(event.type ?? "ui");
+  if (type === "shell.start")
+    appendTranscript(state, "Tool", `$ ${asText(event.command)}`);
+  else if (type === "shell.chunk")
+    appendTranscript(state, "Tool", asText(event.chunk));
+  else if (type === "shell.end")
+    appendTranscript(state, event.isError === true ? "Error" : "Tool", asText(event.output ?? `exit ${String(event.exitCode ?? "")}`));
+  else
+    appendTranscript(state, "System", `${type}: ${asText(event)}`);
+}
+function applyEnvelope(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";
+    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(state, envelope.event);
+  } else if (type === "error") {
+    appendTranscript(state, "Error", asText(envelope.message ?? envelope.detail ?? "unknown error"));
+  }
+}
+async function waitForWorkerReady(options, ctx, state) {
+  while (true) {
+    const session = await getRunPiSessionViaServer(options.context, options.runId).catch((error) => ({
+      ready: false,
+      status: error instanceof Error ? error.message : String(error),
+      retryAfterMs: 1000
+    }));
+    if (session.ready === false) {
+      const status = String(session.status ?? "starting");
+      state.status = `waiting for worker Pi daemon \xB7 ${status}`;
+      updatePiUi(ctx, state);
+      if (TERMINAL_RUN_STATUSES.has(status.toLowerCase())) {
+        appendTranscript(state, "Error", `Run ended before worker Pi daemon became ready: ${status}`);
+        return false;
+      }
+      await Bun.sleep(typeof session.retryAfterMs === "number" ? session.retryAfterMs : 750);
+      continue;
+    }
+    const sessionRecord = recordOf(session) ?? {};
+    applyEnvelope(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"));
+}
+async function connectWorkerStream(options, ctx, state) {
+  const ready = await waitForWorkerReady(options, ctx, state);
+  if (!ready)
+    return;
+  let catchupDone = false;
+  const buffered = [];
+  const wsUrl = await buildRunPiEventsWebSocketUrl(options.context, options.runId);
+  const socket = new WebSocket(wsUrl);
+  const closePromise = new Promise((resolve3) => {
+    socket.onopen = () => {
+      state.wsConnected = true;
+      state.status = "live worker Pi WebSocket connected";
+      updatePiUi(ctx, state);
+    };
+    socket.onmessage = (message2) => {
+      try {
+        const payload = parseWsPayload(message2);
+        if (!catchupDone)
+          buffered.push(payload);
+        else {
+          applyEnvelope(state, payload);
+          updatePiUi(ctx, state);
+        }
+      } catch (error) {
+        appendTranscript(state, "Error", `Unparseable worker Pi event: ${error instanceof Error ? error.message : String(error)}`);
+        updatePiUi(ctx, state);
+      }
+    };
+    socket.onerror = () => socket.close();
+    socket.onclose = () => {
+      state.wsConnected = false;
+      state.status = "worker Pi WebSocket disconnected";
+      updatePiUi(ctx, state);
+      resolve3();
+    };
+  });
+  try {
+    const [messagesPayload, statusPayload, commandsPayload] = await Promise.all([
+      getRunPiMessagesViaServer(options.context, options.runId),
+      getRunPiStatusViaServer(options.context, options.runId),
+      getRunPiCommandsViaServer(options.context, options.runId)
+    ]);
+    const messages = Array.isArray(messagesPayload.messages) ? messagesPayload.messages : [];
+    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}`] : [];
+    });
+    catchupDone = true;
+    for (const payload of buffered.splice(0))
+      applyEnvelope(state, payload);
+    updatePiUi(ctx, state);
+  } catch (error) {
+    appendTranscript(state, "Error", `Worker Pi catch-up failed: ${error instanceof Error ? error.message : String(error)}`);
+    catchupDone = true;
+    updatePiUi(ctx, state);
+  }
+  await closePromise;
+}
+async function answerPendingUi(options, state, line) {
+  const pending = state.pendingUi;
+  if (!pending)
+    return false;
+  if (line === "/cancel") {
+    await respondRunPiExtensionUiViaServer(options.context, options.runId, pending.requestId, { cancelled: true });
+  } else if (pending.method === "confirm") {
+    const confirmed = /^(y|yes|true|1)$/i.test(line);
+    await respondRunPiExtensionUiViaServer(options.context, options.runId, pending.requestId, { value: confirmed, confirmed });
+  } else if (pending.options.length > 0 && /^\d+$/.test(line)) {
+    const selected = pending.options[Math.max(0, Number(line) - 1)] ?? line;
+    await respondRunPiExtensionUiViaServer(options.context, options.runId, pending.requestId, { value: selected });
+  } else {
+    await respondRunPiExtensionUiViaServer(options.context, options.runId, pending.requestId, { value: line });
+  }
+  appendTranscript(state, "System", `Responded to extension UI request ${pending.requestId}.`);
+  state.pendingUi = null;
+  return true;
+}
+async function routeInput(options, ctx, state, line) {
+  const text = line.trim();
+  if (!text)
+    return;
+  if (await answerPendingUi(options, state, text)) {
+    updatePiUi(ctx, state);
+    return;
+  }
+  if (text === "/detach" || text === "/quit" || text === "/q") {
+    appendTranscript(state, "System", "Detached locally; worker Pi daemon continues.");
+    updatePiUi(ctx, state);
+    ctx.shutdown();
+    return;
+  }
+  if (text === "/stop") {
+    await abortRunPiViaServer(options.context, options.runId);
+    appendTranscript(state, "System", "Stop requested for worker Pi daemon.");
+    updatePiUi(ctx, state);
+    ctx.shutdown();
+    return;
+  }
+  if (text.startsWith("!")) {
+    appendTranscript(state, "You", text);
+    await sendRunPiShellViaServer(options.context, options.runId, text);
+  } else if (text.startsWith("/")) {
+    appendTranscript(state, "You", text);
+    const result = await runRunPiCommandViaServer(options.context, options.runId, text);
+    const message2 = typeof result.message === "string" ? result.message : "worker command accepted";
+    appendTranscript(state, "System", message2);
+  } else {
+    appendTranscript(state, "You", text);
+    await sendRunPiPromptViaServer(options.context, options.runId, text, state.streaming ? "steer" : undefined);
+  }
+  updatePiUi(ctx, state);
+}
+function createRigWorkerPiBridgeExtension(options) {
+  return (pi) => {
+    const state = {
+      transcript: [],
+      status: "starting worker Pi daemon bridge",
+      activity: "",
+      cwd: "",
+      model: "",
+      commands: [],
+      streaming: false,
+      pendingUi: null,
+      wsConnected: false
+    };
+    if (options.initialMessageSent)
+      appendTranscript(state, "System", "Initial message sent to worker Pi daemon.");
+    pi.on("session_start", async (_event, ctx) => {
+      updatePiUi(ctx, state);
+      ctx.ui.notify("Rig worker Pi bridge extension loaded", "info");
+      ctx.ui.onTerminalInput((data) => {
+        if (data.includes("\x04")) {
+          ctx.shutdown();
+          return { consume: true };
+        }
+        if (!data.includes("\r") && !data.includes(`
+`))
+          return;
+        const inlineText = data.replace(/[\r\n]+/g, "").trim();
+        const editorText = ctx.ui.getEditorText().trim();
+        const text = [editorText, inlineText].filter(Boolean).join(" ").trim();
+        if (!text)
+          return;
+        ctx.ui.setEditorText("");
+        routeInput(options, ctx, state, text).catch((error) => {
+          appendTranscript(state, "Error", error instanceof Error ? error.message : String(error));
+          updatePiUi(ctx, state);
+        });
+        return { consume: true };
+      });
+      connectWorkerStream(options, ctx, state).catch((error) => {
+        appendTranscript(state, "Error", error instanceof Error ? error.message : String(error));
+        updatePiUi(ctx, state);
+      });
+    });
+    pi.on("session_shutdown", () => {});
+  };
+}
+
+// packages/cli/src/commands/_pi-frontend.ts
+function setTemporaryEnv(updates) {
+  const previous = new Map;
+  for (const [key, value] of Object.entries(updates)) {
+    previous.set(key, process.env[key]);
+    process.env[key] = value;
+  }
+  return () => {
+    for (const [key, value] of previous) {
+      if (value === undefined)
+        delete process.env[key];
+      else
+        process.env[key] = value;
+    }
+  };
+}
+async function attachRunBundledPiFrontend(context, input) {
+  const tempRoot = mkdtempSync(join(tmpdir(), "rig-pi-frontend-"));
+  const cwd = join(tempRoot, "workspace");
+  const agentDir = join(tempRoot, "agent");
+  const sessionDir = join(tempRoot, "sessions");
+  const previousCwd = process.cwd();
+  const restoreEnv = setTemporaryEnv({
+    PI_CODING_AGENT_DIR: agentDir,
+    PI_CODING_AGENT_SESSION_DIR: sessionDir,
+    PI_OFFLINE: "1",
+    PI_SKIP_VERSION_CHECK: "1"
+  });
+  let detached = false;
+  try {
+    await Bun.$`mkdir -p ${cwd} ${agentDir} ${sessionDir}`.quiet();
+    process.chdir(cwd);
+    await runPiMain([
+      "--offline",
+      "--no-session",
+      "--no-tools",
+      "--no-builtin-tools",
+      "--no-skills",
+      "--no-prompt-templates",
+      "--no-themes",
+      "--no-context-files",
+      "--no-approve"
+    ], {
+      extensionFactories: [
+        createRigWorkerPiBridgeExtension({
+          context,
+          runId: input.runId,
+          initialMessageSent: input.steered === true
+        })
+      ]
+    });
+    detached = true;
+  } finally {
+    process.chdir(previousCwd);
+    restoreEnv();
+    rmSync(tempRoot, { recursive: true, force: true });
+  }
+  let run = { runId: input.runId, status: "unknown" };
+  try {
+    run = await getRunDetailsViaServer(context, input.runId);
+  } catch {}
+  return {
+    run,
+    logs: [],
+    timeline: [],
+    timelineCursor: null,
+    steered: input.steered === true,
+    detached,
+    rendered: "actual bundled Pi frontend hosted Rig worker Pi bridge extension"
+  };
+}
+
+// packages/cli/src/commands/_operator-view.ts
+var TERMINAL_RUN_STATUSES2 = new Set(["completed", "failed", "stopped", "cancelled", "canceled", "closed", "merged", "needs_attention", "needs-attention"]);
 function runStatusFromPayload(payload) {
   const run = payload.run && typeof payload.run === "object" && !Array.isArray(payload.run) ? payload.run : payload;
   return String(run.status ?? "unknown").toLowerCase();
@@ -1017,9 +1457,15 @@ async function readOperatorSnapshot(context, runId, options = {}) {
 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") {
@@ -1027,7 +1473,7 @@ async function attachRunOperatorView(context, input) {
     surface.renderTimeline(snapshot.timeline);
     surface.renderLogs(snapshot.logs);
     if (steered)
-      surface.info("Steering message queued.");
+      surface.info("Message submitted to worker Pi.");
   }
   let detached = false;
   let commandInput = null;
@@ -1046,7 +1492,7 @@ async function attachRunOperatorView(context, input) {
     }
     const pollMs = Math.max(250, Math.trunc(input.pollMs ?? 2000));
     let timelineCursor = snapshot.timelineCursor;
-    while (!detached && !TERMINAL_RUN_STATUSES.has(runStatusFromPayload(snapshot.run))) {
+    while (!detached && !TERMINAL_RUN_STATUSES2.has(runStatusFromPayload(snapshot.run))) {
       await Bun.sleep(pollMs);
       snapshot = await readOperatorSnapshot(context, input.runId, { timelineCursor });
       timelineCursor = snapshot.timelineCursor;
@@ -1137,92 +1583,6 @@ function formatSubmittedRun(input) {
 `);
 }
 
-// packages/cli/src/commands/_pi-session.ts
-import { spawn } from "child_process";
-function buildPiRigSessionEnv(input) {
-  return {
-    RIG_PROJECT_ROOT: input.projectRoot,
-    PROJECT_RIG_ROOT: input.projectRoot,
-    RIG_RUN_ID: input.runId,
-    RIG_SERVER_RUN_ID: input.runId,
-    RIG_RUNTIME_ADAPTER: "pi",
-    RIG_SERVER_URL: input.serverUrl,
-    RIG_SERVER_BASE_URL: input.serverUrl,
-    RIG_STEERING_POLL_MS: process.env.RIG_STEERING_POLL_MS?.trim() || "1000",
-    RIG_PI_OPERATOR_SESSION: "1",
-    ...input.taskId ? { RIG_TASK_ID: input.taskId } : {},
-    ...input.authToken ? { RIG_AUTH_TOKEN: input.authToken } : {}
-  };
-}
-function shellBinary(name) {
-  const explicit = process.env.RIG_PI_BINARY?.trim();
-  if (explicit)
-    return explicit;
-  return Bun.which(name) || name;
-}
-function buildPiRigSessionCommand(input) {
-  const configuredExtension = input.extensionSource ?? process.env.RIG_PI_RIG_EXTENSION_SOURCE?.trim();
-  const extensionSource = configuredExtension && configuredExtension.length > 0 ? configuredExtension : resolvePiRigPackageSource(input.projectRoot);
-  const initialCommand = `/rig attach ${input.runId}`;
-  return [
-    shellBinary("pi"),
-    "--no-extensions",
-    "--extension",
-    extensionSource,
-    initialCommand
-  ];
-}
-async function launchPiRigSession(context, input) {
-  if (context.outputMode !== "text" || !process.stdin.isTTY || !process.stdout.isTTY) {
-    return { launched: false, exitCode: null, command: [] };
-  }
-  if (process.env.RIG_DISABLE_PI_LAUNCH === "1") {
-    return { launched: false, exitCode: null, command: [] };
-  }
-  const server = await ensureServerForCli(context.projectRoot);
-  const command = buildPiRigSessionCommand({ ...input, projectRoot: context.projectRoot });
-  const env = {
-    ...process.env,
-    ...buildPiRigSessionEnv({
-      projectRoot: context.projectRoot,
-      runId: input.runId,
-      taskId: input.taskId,
-      serverUrl: server.baseUrl,
-      authToken: server.authToken
-    })
-  };
-  process.stdout.write(`Launching Pi for Rig run ${input.runId}\u2026
-`);
-  process.stdout.write(`Pi command: ${formatCommand(command)}
-`);
-  const launchedAt = Date.now();
-  const child = spawn(command[0], command.slice(1), {
-    cwd: context.projectRoot,
-    env,
-    stdio: "inherit"
-  });
-  const launchError = await new Promise((resolve4) => {
-    child.once("error", (error) => {
-      resolve4({ error: error.message });
-    });
-    child.once("close", (code) => resolve4({ code }));
-  });
-  if ("error" in launchError) {
-    process.stderr.write(`Failed to launch Pi; falling back to Rig attach view: ${launchError.error}
-`);
-    return { launched: false, exitCode: null, command, error: launchError.error };
-  }
-  const exitCode = launchError.code;
-  const elapsedMs = Date.now() - launchedAt;
-  if (typeof exitCode === "number" && exitCode !== 0 && elapsedMs < 5000) {
-    const error = `Pi exited during startup with code ${exitCode}.`;
-    process.stderr.write(`${error} Falling back to Rig attach view.
-`);
-    return { launched: false, exitCode, command, error };
-  }
-  return { launched: true, exitCode, command };
-}
-
 // packages/cli/src/commands/task.ts
 import { buildPluginHostContext } from "@rig/runtime/control-plane/plugin-host-context";
 import { loadConfig } from "@rig/core/load-config";
@@ -1484,7 +1844,7 @@ async function executeTask(context, args, options) {
       const fileFlag = takeOption(rest.slice(1), "--file");
       let content;
       if (fileFlag.value) {
-        content = readFileSync4(resolve4(context.projectRoot, fileFlag.value), "utf-8");
+        content = readFileSync3(resolve3(context.projectRoot, fileFlag.value), "utf-8");
       } else {
         content = await readStdin();
       }
@@ -1614,20 +1974,7 @@ async function executeTask(context, args, options) {
       let attachDetails = null;
       if (!detachResult.value && context.outputMode === "text") {
         console.log(formatSubmittedRun({ runId: submitted.runId, task: selectedTask ? summarizeTask(selectedTask) : null }));
-        if (runtimeAdapter === "pi") {
-          const piSession = await launchPiRigSession(context, {
-            runId: submitted.runId,
-            taskId: selectedTaskId,
-            title: titleResult.value ?? readTaskString(selectedTask ?? {}, "title"),
-            runtimeAdapter
-          });
-          attachDetails = { mode: "pi", ...piSession };
-          if (!piSession.launched) {
-            attachDetails = await attachRunOperatorView(context, { runId: submitted.runId, follow: true });
-          }
-        } else {
-          attachDetails = await attachRunOperatorView(context, { runId: submitted.runId, follow: true });
-        }
+        attachDetails = await attachRunOperatorView(context, { runId: submitted.runId, follow: true });
       } else if (context.outputMode === "text") {
         console.log(formatSubmittedRun({ runId: submitted.runId, task: selectedTask ? summarizeTask(selectedTask) : null }));
       }