@h-rig/cli 0.0.6-alpha.22 → 0.0.6-alpha.24

package/dist/src/commands.js

@@ -2747,6 +2747,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, text2, streamingBehavior) {
+  const payload = await requestServerJson(context, `/api/runs/${encodeURIComponent(runId)}/pi/prompt`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ text: text2, streamingBehavior })
+  });
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { accepted: true };
+}
+async function sendRunPiShellViaServer(context, runId, text2) {
+  const payload = await requestServerJson(context, `/api/runs/${encodeURIComponent(runId)}/pi/shell`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ text: text2 })
+  });
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { accepted: true };
+}
+async function runRunPiCommandViaServer(context, runId, text2) {
+  const payload = await requestServerJson(context, `/api/runs/${encodeURIComponent(runId)}/pi/commands/run`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ text: text2 })
+  });
+  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";
@@ -2779,183 +2839,6 @@ async function submitTaskRunViaServer(context, input) {
   return { runId };
 }
 
-// packages/cli/src/commands/_pi-install.ts
-import { existsSync as existsSync5, readFileSync as readFileSync4, rmSync as rmSync3 } from "fs";
-import { homedir as homedir3 } from "os";
-import { resolve as resolve9 } from "path";
-var PI_RIG_PACKAGE_NAME = "@h-rig/pi-rig";
-var LEGACY_PI_RIG_PACKAGE_NAME = "@rig/pi-rig";
-var LEGACY_PI_RIG_MARKER = `// Managed by Rig. Source package: @rig/pi-rig.
-export { default } from '@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 resolve9(homeDir, ".pi", "agent", "extensions", "pi-rig");
-}
-function resolvePiRigPackageSource(projectRoot, exists = existsSync5) {
-  const localPackage = resolve9(projectRoot, "packages", "pi-rig");
-  if (exists(resolve9(localPackage, "package.json")))
-    return localPackage;
-  return `npm:${PI_RIG_PACKAGE_NAME}`;
-}
-function resolvePiHomeDir(inputHomeDir) {
-  return inputHomeDir ?? process.env.RIG_PI_HOME_DIR?.trim() ?? homedir3();
-}
-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) };
-  }
-}
-function splitInstallCommand(value) {
-  return value.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g)?.map((part) => part.replace(/^['"]|['"]$/g, "")) ?? [];
-}
-async function ensurePiBinaryAvailable(input) {
-  const current = await safeRun(input.runner, ["pi", "--version"]);
-  if (current.exitCode === 0) {
-    const updateCommand = process.env.RIG_PI_UPDATE_COMMAND?.trim();
-    if (updateCommand) {
-      const parts2 = splitInstallCommand(updateCommand);
-      if (parts2.length > 0)
-        await safeRun(input.runner, parts2, input.projectRoot ? { cwd: input.projectRoot } : undefined);
-    }
-    return { ok: true, detail: (current.stdout || current.stderr).trim() || undefined };
-  }
-  const installCommand = process.env.RIG_PI_INSTALL_COMMAND?.trim() || "bunx @earendil-works/pi@latest install";
-  const parts = splitInstallCommand(installCommand);
-  if (parts.length === 0) {
-    return { ok: false, error: (current.stderr || current.stdout).trim() || "pi --version failed" };
-  }
-  const install = await safeRun(input.runner, parts, input.projectRoot ? { cwd: input.projectRoot } : undefined);
-  if (install.exitCode !== 0) {
-    return { ok: false, installedOrUpdated: true, error: (install.stderr || install.stdout).trim() || `Pi install command failed (${install.exitCode})` };
-  }
-  const next = await safeRun(input.runner, ["pi", "--version"]);
-  return {
-    ok: next.exitCode === 0,
-    installedOrUpdated: true,
-    detail: (next.stdout || next.stderr).trim() || undefined,
-    ...next.exitCode === 0 ? {} : { error: (next.stderr || next.stdout).trim() || "pi --version failed after install" }
-  };
-}
-function removeManagedLegacyPiRigBridge(homeDir, exists = existsSync5) {
-  const extensionPath = resolvePiRigExtensionPath(homeDir);
-  const indexPath = resolve9(extensionPath, "index.ts");
-  if (!exists(indexPath))
-    return;
-  try {
-    const content = readFileSync4(indexPath, "utf8");
-    if (content === LEGACY_PI_RIG_MARKER || content.includes("Managed by Rig. Source package: @rig/pi-rig")) {
-      rmSync3(extensionPath, { recursive: true, force: true });
-    }
-  } catch {}
-}
-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 ?? existsSync5;
-  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(resolve9(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 ensurePiRigInstalled(input) {
-  const home = resolvePiHomeDir(input.homeDir);
-  if (process.env.RIG_TEST_FAKE_PI_INSTALL === "1") {
-    const status2 = await checkPiRigInstall({ homeDir: home, commandRunner: input.commandRunner });
-    return { ...status2, installedPath: status2.extensionPath };
-  }
-  const runner = input.commandRunner ?? defaultCommandRunner;
-  const piAvailable = await ensurePiBinaryAvailable({ runner, projectRoot: input.projectRoot });
-  const status = piAvailable.ok ? await checkPiRigInstall({ homeDir: home, commandRunner: runner }) : {
-    extensionPath: resolvePiRigExtensionPath(home),
-    pi: { ok: false, label: "pi", detail: piAvailable.error, hint: "Install/update Pi with RIG_PI_INSTALL_COMMAND or install Pi manually." },
-    piRig: { ok: false, label: "pi-rig global extension", hint: "Pi is required before pi-rig can be installed." }
-  };
-  if (!piAvailable.ok) {
-    throw new Error(`Pi install/update failed: ${piAvailable.error ?? "pi unavailable"}`);
-  }
-  const packageSource = resolvePiRigPackageSource(input.projectRoot);
-  removeManagedLegacyPiRigBridge(home);
-  const install = await runner(["pi", "install", packageSource], { cwd: input.projectRoot });
-  if (install.exitCode !== 0) {
-    throw new Error(`pi-rig install failed: ${(install.stderr || install.stdout).trim() || `exit ${install.exitCode}`}`);
-  }
-  const next = await checkPiRigInstall({ homeDir: home, commandRunner: runner });
-  return { ...next, installedPath: packageSource };
-}
-async function ensureRemotePiRigInstalled(input) {
-  const payload = await input.requestJson("/api/pi-rig/install", {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body: JSON.stringify({ package: PI_RIG_PACKAGE_NAME, scope: "global" })
-  });
-  const record = payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
-  const piOk = record.piOk === true || record.ok === true;
-  const piRigOk = record.piRigOk === true || record.installed === true || record.ok === true;
-  const extensionPath = typeof record.extensionPath === "string" ? record.extensionPath : "remote:~/.pi/agent/extensions/pi-rig";
-  return {
-    remote: true,
-    extensionPath,
-    pi: {
-      ok: piOk,
-      label: "pi",
-      detail: typeof record.piVersion === "string" ? record.piVersion : undefined,
-      hint: piOk ? undefined : "Install/update Pi on the selected remote Rig server."
-    },
-    piRig: {
-      ok: piRigOk,
-      label: "pi-rig global extension",
-      detail: extensionPath,
-      hint: piRigOk ? undefined : "Install/enable pi-rig on the selected remote Rig server."
-    }
-  };
-}
-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 {
@@ -3113,14 +2996,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));
   }
@@ -3236,7 +3112,7 @@ async function executeQueue(context, args) {
 }
 
 // packages/cli/src/commands/agent.ts
-import { resolve as resolve11 } from "path";
+import { resolve as resolve10 } from "path";
 import {
   agentId,
   cleanupAgentRuntime,
@@ -3246,8 +3122,8 @@ import {
 } from "@rig/runtime/control-plane/runtime/isolation";
 
 // packages/cli/src/commands/_authority-runs.ts
-import { existsSync as existsSync6 } from "fs";
-import { resolve as resolve10 } from "path";
+import { existsSync as existsSync5 } from "fs";
+import { resolve as resolve9 } from "path";
 import {
   readAuthorityRun,
   readJsonlFile as readJsonlFile2,
@@ -3269,8 +3145,8 @@ function normalizeRuntimeAdapter(value) {
   return "claude-code";
 }
 function readLatestBeadRecord(projectRoot, taskId) {
-  const issuesPath = resolve10(resolveControlPlaneMonorepoRoot(projectRoot), ".beads", "issues.jsonl");
-  if (!existsSync6(issuesPath)) {
+  const issuesPath = resolve9(resolveControlPlaneMonorepoRoot(projectRoot), ".beads", "issues.jsonl");
+  if (!existsSync5(issuesPath)) {
     return null;
   }
   let latest = null;
@@ -3338,7 +3214,7 @@ function upsertAgentAuthorityRun(projectRoot, input) {
   } else if ("errorText" in next) {
     delete next.errorText;
   }
-  writeJsonFile3(resolve10(resolveAuthorityRunDir(projectRoot, input.runId), "run.json"), next);
+  writeJsonFile3(resolve9(resolveAuthorityRunDir(projectRoot, input.runId), "run.json"), next);
   return next;
 }
 
@@ -3459,10 +3335,10 @@ async function executeAgent(context, args) {
           status: "running",
           startedAt: createdAt,
           worktreePath: runtime.workspaceDir,
-          artifactRoot: resolve11(runtime.workspaceDir, "artifacts", taskId),
+          artifactRoot: resolve10(runtime.workspaceDir, "artifacts", taskId),
           logRoot: runtime.logsDir,
-          sessionPath: resolve11(runtime.sessionDir, "session.json"),
-          sessionLogPath: resolve11(runtime.logsDir, "agent-stdout.log"),
+          sessionPath: resolve10(runtime.sessionDir, "session.json"),
+          sessionLogPath: resolve10(runtime.logsDir, "agent-stdout.log"),
           pid: process.pid
         });
         const result = await runInAgentRuntime({
@@ -3482,10 +3358,10 @@ async function executeAgent(context, args) {
             startedAt: createdAt,
             completedAt: failedAt,
             worktreePath: runtime.workspaceDir,
-            artifactRoot: resolve11(runtime.workspaceDir, "artifacts", taskId),
+            artifactRoot: resolve10(runtime.workspaceDir, "artifacts", taskId),
             logRoot: runtime.logsDir,
-            sessionPath: resolve11(runtime.sessionDir, "session.json"),
-            sessionLogPath: resolve11(runtime.logsDir, "agent-stdout.log"),
+            sessionPath: resolve10(runtime.sessionDir, "session.json"),
+            sessionLogPath: resolve10(runtime.logsDir, "agent-stdout.log"),
             pid: process.pid,
             errorText: result.stderr ? result.stderr.trim() : `Agent runtime command failed (${result.exitCode})`
           });
@@ -3502,10 +3378,10 @@ ${result.stderr.trim()}` : ""}`, result.exitCode);
           startedAt: createdAt,
           completedAt,
           worktreePath: runtime.workspaceDir,
-          artifactRoot: resolve11(runtime.workspaceDir, "artifacts", taskId),
+          artifactRoot: resolve10(runtime.workspaceDir, "artifacts", taskId),
           logRoot: runtime.logsDir,
-          sessionPath: resolve11(runtime.sessionDir, "session.json"),
-          sessionLogPath: resolve11(runtime.logsDir, "agent-stdout.log"),
+          sessionPath: resolve10(runtime.sessionDir, "session.json"),
+          sessionLogPath: resolve10(runtime.logsDir, "agent-stdout.log"),
           pid: process.pid
         });
         return {
@@ -3579,17 +3455,17 @@ ${result.stderr.trim()}` : ""}`, result.exitCode);
 import {
   chmodSync,
   copyFileSync as copyFileSync2,
-  existsSync as existsSync7,
+  existsSync as existsSync6,
   mkdirSync as mkdirSync5,
   readdirSync,
   readlinkSync,
-  rmSync as rmSync4,
+  rmSync as rmSync3,
   statSync,
   symlinkSync,
   unlinkSync
 } from "fs";
-import { homedir as homedir4 } from "os";
-import { resolve as resolve12 } from "path";
+import { homedir as homedir3 } from "os";
+import { resolve as resolve11 } from "path";
 import { buildBinary as buildBinary2 } from "@rig/runtime/control-plane/runtime/isolation";
 import {
   computeRuntimeImageFingerprint,
@@ -3608,13 +3484,13 @@ async function runQuietBinaryProbe(binaryPath, args, cwd) {
 
 // packages/cli/src/commands/dist.ts
 function collectRigValidatorBuildTargets(input) {
-  const validatorsRoot = resolve12(input.hostProjectRoot, "packages/runtime/src/control-plane/validators");
-  if (!existsSync7(validatorsRoot))
+  const validatorsRoot = resolve11(input.hostProjectRoot, "packages/runtime/src/control-plane/validators");
+  if (!existsSync6(validatorsRoot))
     return [];
   const targets = [];
   const categories = readdirSync(validatorsRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory());
   for (const category of categories) {
-    const categoryDir = resolve12(validatorsRoot, category.name);
+    const categoryDir = resolve11(validatorsRoot, category.name);
     for (const entry of readdirSync(categoryDir, { withFileTypes: true })) {
       if (!entry.isFile() || !entry.name.endsWith(".ts"))
         continue;
@@ -3623,7 +3499,7 @@ function collectRigValidatorBuildTargets(input) {
         continue;
       targets.push({
         source: `packages/runtime/src/control-plane/validators/${category.name}/${entry.name}`,
-        dest: resolve12(input.imageDir, `bin/validators/${category.name}-${check}`),
+        dest: resolve11(input.imageDir, `bin/validators/${category.name}-${check}`),
         cwd: input.hostProjectRoot
       });
     }
@@ -3632,16 +3508,16 @@ function collectRigValidatorBuildTargets(input) {
 }
 async function findLatestDistBinary(projectRoot) {
   const distRoot = resolveControlPlaneHostDistDir(projectRoot);
-  if (!existsSync7(distRoot)) {
+  if (!existsSync6(distRoot)) {
     return null;
   }
   const entries = readdirSync(distRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name.startsWith("rig-")).map((entry) => ({
     name: entry.name,
-    mtimeMs: statSync(resolve12(distRoot, entry.name)).mtimeMs
+    mtimeMs: statSync(resolve11(distRoot, entry.name)).mtimeMs
   })).sort((a, b) => b.mtimeMs - a.mtimeMs || b.name.localeCompare(a.name));
   for (const { name } of entries) {
-    const candidate = resolve12(distRoot, name, "bin", "rig");
-    if (existsSync7(candidate) && await isRunnableRigBinary(candidate, projectRoot)) {
+    const candidate = resolve11(distRoot, name, "bin", "rig");
+    if (existsSync6(candidate) && await isRunnableRigBinary(candidate, projectRoot)) {
       return candidate;
     }
   }
@@ -3653,7 +3529,7 @@ async function isRunnableRigBinary(binaryPath, projectRoot) {
 async function runDistDoctor(projectRoot) {
   const bunPath = Bun.which("bun");
   const rigPath = Bun.which("rig");
-  const userBinDir = resolve12(homedir4(), ".local/bin");
+  const userBinDir = resolve11(homedir3(), ".local/bin");
   const userBinInPath = (process.env.PATH || "").split(":").filter(Boolean).includes(userBinDir);
   let rigRunnable = false;
   if (rigPath) {
@@ -3701,15 +3577,15 @@ async function executeDist(context, args) {
       let source = await findLatestDistBinary(context.projectRoot);
       let buildDir = null;
       if (!source) {
-        buildDir = resolve12(resolveControlPlaneHostDistDir(context.projectRoot), `rig-install-${Date.now()}`);
+        buildDir = resolve11(resolveControlPlaneHostDistDir(context.projectRoot), `rig-install-${Date.now()}`);
         await context.runCommand(["bun", "run", "packages/cli/bin/build-rig-binaries.ts", "--output-dir", buildDir]);
-        source = resolve12(buildDir, "bin", "rig");
+        source = resolve11(buildDir, "bin", "rig");
       }
-      if (!existsSync7(source)) {
+      if (!existsSync6(source)) {
         throw new CliError2(`Unable to locate rig binary at ${source}.`, 2);
       }
-      const installedPath = resolve12(installDir, "rig");
-      if (existsSync7(installedPath)) {
+      const installedPath = resolve11(installDir, "rig");
+      if (existsSync6(installedPath)) {
         unlinkSync(installedPath);
       }
       copyFileSync2(source, installedPath);
@@ -3751,22 +3627,22 @@ async function executeDist(context, args) {
       requireNoExtraArgs(rest, "bun run rig dist rebuild-agent");
       const fp = await computeRuntimeImageFingerprint(context.projectRoot);
       const currentId = computeRuntimeImageId(fp);
-      const imagesDir = resolve12(resolveControlPlaneMonorepoRuntimeDir(context.projectRoot), "images");
+      const imagesDir = resolve11(resolveControlPlaneMonorepoRuntimeDir(context.projectRoot), "images");
       mkdirSync5(imagesDir, { recursive: true });
       let pruned = 0;
       for (const entry of readdirSync(imagesDir, { withFileTypes: true })) {
         if (entry.isDirectory() && entry.name !== currentId) {
-          rmSync4(resolve12(imagesDir, entry.name), { recursive: true, force: true });
+          rmSync3(resolve11(imagesDir, entry.name), { recursive: true, force: true });
           pruned++;
         }
       }
       if (pruned > 0 && context.outputMode === "text") {
         console.log(`Pruned ${pruned} stale image(s).`);
       }
-      const imageDir = resolve12(imagesDir, currentId);
-      mkdirSync5(resolve12(imageDir, "bin/hooks"), { recursive: true });
-      mkdirSync5(resolve12(imageDir, "bin/plugins"), { recursive: true });
-      mkdirSync5(resolve12(imageDir, "bin/validators"), { recursive: true });
+      const imageDir = resolve11(imagesDir, currentId);
+      mkdirSync5(resolve11(imageDir, "bin/hooks"), { recursive: true });
+      mkdirSync5(resolve11(imageDir, "bin/plugins"), { recursive: true });
+      mkdirSync5(resolve11(imageDir, "bin/validators"), { recursive: true });
       const hookNames = [
         "scope-guard",
         "import-guard",
@@ -3780,25 +3656,25 @@ async function executeDist(context, args) {
       ];
       const targets = [];
       const hostProjectRoot = process.env.RIG_HOST_PROJECT_ROOT?.trim() || context.projectRoot;
-      targets.push({ source: "packages/runtime/bin/rig-agent.ts", dest: resolve12(imageDir, "bin/rig-agent"), cwd: hostProjectRoot });
-      targets.push({ source: "packages/runtime/bin/rig-agent-dispatch.ts", dest: resolve12(resolveControlPlaneHostBinDir(context.projectRoot), "rig-agent"), cwd: hostProjectRoot });
+      targets.push({ source: "packages/runtime/bin/rig-agent.ts", dest: resolve11(imageDir, "bin/rig-agent"), cwd: hostProjectRoot });
+      targets.push({ source: "packages/runtime/bin/rig-agent-dispatch.ts", dest: resolve11(resolveControlPlaneHostBinDir(context.projectRoot), "rig-agent"), cwd: hostProjectRoot });
       for (const hookName of hookNames) {
         const src = `packages/runtime/src/control-plane/hooks/${hookName}.ts`;
-        targets.push({ source: src, dest: resolve12(imageDir, `bin/hooks/${hookName}`), cwd: hostProjectRoot });
-        targets.push({ source: src, dest: resolve12(resolveControlPlaneHostBinDir(context.projectRoot), `hooks/${hookName}`), cwd: hostProjectRoot });
+        targets.push({ source: src, dest: resolve11(imageDir, `bin/hooks/${hookName}`), cwd: hostProjectRoot });
+        targets.push({ source: src, dest: resolve11(resolveControlPlaneHostBinDir(context.projectRoot), `hooks/${hookName}`), cwd: hostProjectRoot });
       }
-      const pluginsDir = resolve12(context.projectRoot, "rig/plugins");
-      const binPluginsDir = resolve12(resolveControlPlaneHostBinDir(context.projectRoot), "plugins");
-      const validatorsRoot = resolve12(hostProjectRoot, "packages/runtime/src/control-plane/validators");
-      const binValidatorsDir = resolve12(resolveControlPlaneHostBinDir(context.projectRoot), "validators");
+      const pluginsDir = resolve11(context.projectRoot, "rig/plugins");
+      const binPluginsDir = resolve11(resolveControlPlaneHostBinDir(context.projectRoot), "plugins");
+      const validatorsRoot = resolve11(hostProjectRoot, "packages/runtime/src/control-plane/validators");
+      const binValidatorsDir = resolve11(resolveControlPlaneHostBinDir(context.projectRoot), "validators");
       mkdirSync5(binPluginsDir, { recursive: true });
       mkdirSync5(binValidatorsDir, { recursive: true });
-      if (existsSync7(pluginsDir)) {
+      if (existsSync6(pluginsDir)) {
         for (const entry of readdirSync(pluginsDir, { withFileTypes: true })) {
           const m = entry.name.match(/^(.+)\.plugin\.(ts|js|mjs|cjs)$/);
           if (!m)
             continue;
-          targets.push({ source: `rig/plugins/${entry.name}`, dest: resolve12(imageDir, `bin/plugins/${m[1]}`), cwd: context.projectRoot });
+          targets.push({ source: `rig/plugins/${entry.name}`, dest: resolve11(imageDir, `bin/plugins/${m[1]}`), cwd: context.projectRoot });
         }
       }
       targets.push(...collectRigValidatorBuildTargets({ contextProjectRoot: context.projectRoot, hostProjectRoot, imageDir }));
@@ -3809,17 +3685,17 @@ async function executeDist(context, args) {
         const isValidator = dest.includes("/bin/validators/");
         await buildBinary2(source, dest, cwd, isValidator ? { AGENT_BUN_PATH: Bun.which("bun") || "bun" } : { AGENT_PROJECT_ROOT: context.projectRoot });
       }
-      if (existsSync7(pluginsDir)) {
+      if (existsSync6(pluginsDir)) {
         for (const entry of readdirSync(pluginsDir, { withFileTypes: true })) {
           const m = entry.name.match(/^(.+)\.plugin\.(ts|js|mjs|cjs)$/);
           if (!m)
             continue;
           const pluginName = m[1];
-          const imageBin = resolve12(imageDir, `bin/plugins/${pluginName}`);
+          const imageBin = resolve11(imageDir, `bin/plugins/${pluginName}`);
           if (!pluginName)
             continue;
-          const symlinkPath = resolve12(binPluginsDir, pluginName);
-          if (existsSync7(imageBin)) {
+          const symlinkPath = resolve11(binPluginsDir, pluginName);
+          if (existsSync6(imageBin)) {
             try {
               unlinkSync(symlinkPath);
             } catch {}
@@ -3827,10 +3703,10 @@ async function executeDist(context, args) {
           }
         }
       }
-      if (existsSync7(validatorsRoot)) {
+      if (existsSync6(validatorsRoot)) {
         const categories = readdirSync(validatorsRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory());
         for (const category of categories) {
-          const categoryDir = resolve12(validatorsRoot, category.name);
+          const categoryDir = resolve11(validatorsRoot, category.name);
           for (const entry of readdirSync(categoryDir, { withFileTypes: true })) {
             if (!entry.isFile() || !entry.name.endsWith(".ts"))
               continue;
@@ -3838,9 +3714,9 @@ async function executeDist(context, args) {
             if (!check || check === "index" || check === "shared")
               continue;
             const validatorName = `${category.name}-${check}`;
-            const imageBin = resolve12(imageDir, `bin/validators/${validatorName}`);
-            const symlinkPath = resolve12(binValidatorsDir, validatorName);
-            if (existsSync7(imageBin)) {
+            const imageBin = resolve11(imageDir, `bin/validators/${validatorName}`);
+            const symlinkPath = resolve11(binValidatorsDir, validatorName);
+            if (existsSync6(imageBin)) {
               try {
                 unlinkSync(symlinkPath);
               } catch {}
@@ -3849,18 +3725,18 @@ async function executeDist(context, args) {
           }
         }
       }
-      const agentsDir = resolve12(resolveControlPlaneMonorepoRuntimeDir(context.projectRoot), "agents");
-      if (existsSync7(agentsDir)) {
+      const agentsDir = resolve11(resolveControlPlaneMonorepoRuntimeDir(context.projectRoot), "agents");
+      if (existsSync6(agentsDir)) {
         let relinkCount = 0;
         for (const agentEntry of readdirSync(agentsDir, { withFileTypes: true })) {
           if (!agentEntry.isDirectory())
             continue;
-          const agentBinDir = resolve12(agentsDir, agentEntry.name, "worktree", ".rig", "bin");
-          if (!existsSync7(agentBinDir))
+          const agentBinDir = resolve11(agentsDir, agentEntry.name, "worktree", ".rig", "bin");
+          if (!existsSync6(agentBinDir))
             continue;
           const walkDir = (dir) => {
             for (const entry of readdirSync(dir, { withFileTypes: true })) {
-              const fullPath = resolve12(dir, entry.name);
+              const fullPath = resolve11(dir, entry.name);
               if (entry.isDirectory()) {
                 walkDir(fullPath);
               } else if (entry.isSymbolicLink()) {
@@ -3894,7 +3770,7 @@ async function executeDist(context, args) {
 
 // packages/cli/src/commands/inbox.ts
 import { writeFileSync as writeFileSync4 } from "fs";
-import { resolve as resolve13 } from "path";
+import { resolve as resolve12 } from "path";
 import {
   listAuthorityRuns,
   readJsonlFile as readJsonlFile3,
@@ -3911,7 +3787,7 @@ async function executeInbox(context, args) {
       pending = task.rest;
       requireNoExtraArgs(pending, "bun run rig inbox approvals [--run <id>] [--task <id>]");
       const runs = listAuthorityRuns(context.projectRoot).filter((entry) => (!run.value || entry.runId === run.value) && (!task.value || entry.taskId === task.value));
-      const approvals = runs.flatMap((entry) => readJsonlFile3(resolve13(resolveAuthorityRunDir2(context.projectRoot, entry.runId), "approvals.jsonl")).map((record) => ({
+      const approvals = runs.flatMap((entry) => readJsonlFile3(resolve12(resolveAuthorityRunDir2(context.projectRoot, entry.runId), "approvals.jsonl")).map((record) => ({
         runId: entry.runId,
         record
       })));
@@ -3939,7 +3815,7 @@ async function executeInbox(context, args) {
       if (decision.value !== "approve" && decision.value !== "reject") {
         throw new CliError2("decision must be approve or reject.");
       }
-      const approvalsPath = resolve13(resolveAuthorityRunDir2(context.projectRoot, run.value), "approvals.jsonl");
+      const approvalsPath = resolve12(resolveAuthorityRunDir2(context.projectRoot, run.value), "approvals.jsonl");
       const approvals = readJsonlFile3(approvalsPath);
       const resolvedAt = new Date().toISOString();
       const next = approvals.map((entry) => entry.requestId === request.value || entry.id === request.value ? { ...entry, status: "resolved", decision: decision.value, note: note3.value ?? null, resolvedAt } : entry);
@@ -3956,7 +3832,7 @@ async function executeInbox(context, args) {
       pending = task.rest;
       requireNoExtraArgs(pending, "bun run rig inbox inputs [--run <id>] [--task <id>]");
       const runs = listAuthorityRuns(context.projectRoot).filter((entry) => (!run.value || entry.runId === run.value) && (!task.value || entry.taskId === task.value));
-      const requests = runs.flatMap((entry) => readJsonlFile3(resolve13(resolveAuthorityRunDir2(context.projectRoot, entry.runId), "user-input.jsonl")).map((record) => ({
+      const requests = runs.flatMap((entry) => readJsonlFile3(resolve12(resolveAuthorityRunDir2(context.projectRoot, entry.runId), "user-input.jsonl")).map((record) => ({
         runId: entry.runId,
         record
       })));
@@ -3998,7 +3874,7 @@ async function executeInbox(context, args) {
         const [key, ...restValue] = entry.split("=");
         return [key, restValue.join("=")];
       }));
-      const requestsPath = resolve13(resolveAuthorityRunDir2(context.projectRoot, run.value), "user-input.jsonl");
+      const requestsPath = resolve12(resolveAuthorityRunDir2(context.projectRoot, run.value), "user-input.jsonl");
       const requests = readJsonlFile3(requestsPath);
       const resolvedAt = new Date().toISOString();
       const next = requests.map((entry) => entry.requestId === request.value || entry.id === request.value ? { ...entry, status: "resolved", answers: parsedAnswers, respondedAt: resolvedAt, resolvedAt } : entry);
@@ -4007,17 +3883,194 @@ async function executeInbox(context, args) {
 `, "utf8");
       return { ok: true, group: "inbox", command, details: { runId: run.value, requestId: request.value, answers: parsedAnswers } };
     }
-    default:
-      throw new CliError2(`Unknown inbox command: ${command}`);
-  }
+    default:
+      throw new CliError2(`Unknown inbox command: ${command}`);
+  }
+}
+
+// packages/cli/src/commands/init.ts
+import { appendFileSync as appendFileSync2, existsSync as existsSync9, mkdirSync as mkdirSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
+import { spawnSync } from "child_process";
+import { resolve as resolve16 } from "path";
+import { buildRigInitConfigSource } from "@rig/core";
+import { listGitHubProjects as listGitHubProjectsDirect, resolveProjectStatusField as resolveProjectStatusFieldDirect } from "@rig/server";
+
+// packages/cli/src/commands/_pi-install.ts
+import { existsSync as existsSync7, readFileSync as readFileSync4, rmSync as rmSync4 } from "fs";
+import { homedir as homedir4 } from "os";
+import { resolve as resolve13 } from "path";
+var PI_RIG_PACKAGE_NAME = "@h-rig/pi-rig";
+var LEGACY_PI_RIG_PACKAGE_NAME = "@rig/pi-rig";
+var LEGACY_PI_RIG_MARKER = `// Managed by Rig. Source package: @rig/pi-rig.
+export { default } from '@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 resolve13(homeDir, ".pi", "agent", "extensions", "pi-rig");
+}
+function resolvePiRigPackageSource(projectRoot, exists = existsSync7) {
+  const localPackage = resolve13(projectRoot, "packages", "pi-rig");
+  if (exists(resolve13(localPackage, "package.json")))
+    return localPackage;
+  return `npm:${PI_RIG_PACKAGE_NAME}`;
+}
+function resolvePiHomeDir(inputHomeDir) {
+  return inputHomeDir ?? process.env.RIG_PI_HOME_DIR?.trim() ?? homedir4();
+}
+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) };
+  }
+}
+function splitInstallCommand(value) {
+  return value.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g)?.map((part) => part.replace(/^['"]|['"]$/g, "")) ?? [];
+}
+async function ensurePiBinaryAvailable(input) {
+  const current = await safeRun(input.runner, ["pi", "--version"]);
+  if (current.exitCode === 0) {
+    const updateCommand = process.env.RIG_PI_UPDATE_COMMAND?.trim();
+    if (updateCommand) {
+      const parts2 = splitInstallCommand(updateCommand);
+      if (parts2.length > 0)
+        await safeRun(input.runner, parts2, input.projectRoot ? { cwd: input.projectRoot } : undefined);
+    }
+    return { ok: true, detail: (current.stdout || current.stderr).trim() || undefined };
+  }
+  const installCommand = process.env.RIG_PI_INSTALL_COMMAND?.trim() || "bunx @earendil-works/pi@latest install";
+  const parts = splitInstallCommand(installCommand);
+  if (parts.length === 0) {
+    return { ok: false, error: (current.stderr || current.stdout).trim() || "pi --version failed" };
+  }
+  const install = await safeRun(input.runner, parts, input.projectRoot ? { cwd: input.projectRoot } : undefined);
+  if (install.exitCode !== 0) {
+    return { ok: false, installedOrUpdated: true, error: (install.stderr || install.stdout).trim() || `Pi install command failed (${install.exitCode})` };
+  }
+  const next = await safeRun(input.runner, ["pi", "--version"]);
+  return {
+    ok: next.exitCode === 0,
+    installedOrUpdated: true,
+    detail: (next.stdout || next.stderr).trim() || undefined,
+    ...next.exitCode === 0 ? {} : { error: (next.stderr || next.stdout).trim() || "pi --version failed after install" }
+  };
+}
+function removeManagedLegacyPiRigBridge(homeDir, exists = existsSync7) {
+  const extensionPath = resolvePiRigExtensionPath(homeDir);
+  const indexPath = resolve13(extensionPath, "index.ts");
+  if (!exists(indexPath))
+    return;
+  try {
+    const content = readFileSync4(indexPath, "utf8");
+    if (content === LEGACY_PI_RIG_MARKER || content.includes("Managed by Rig. Source package: @rig/pi-rig")) {
+      rmSync4(extensionPath, { recursive: true, force: true });
+    }
+  } catch {}
+}
+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 ?? existsSync7;
+  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(resolve13(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 ensurePiRigInstalled(input) {
+  const home = resolvePiHomeDir(input.homeDir);
+  if (process.env.RIG_TEST_FAKE_PI_INSTALL === "1") {
+    const status2 = await checkPiRigInstall({ homeDir: home, commandRunner: input.commandRunner });
+    return { ...status2, installedPath: status2.extensionPath };
+  }
+  const runner = input.commandRunner ?? defaultCommandRunner;
+  const piAvailable = await ensurePiBinaryAvailable({ runner, projectRoot: input.projectRoot });
+  const status = piAvailable.ok ? await checkPiRigInstall({ homeDir: home, commandRunner: runner }) : {
+    extensionPath: resolvePiRigExtensionPath(home),
+    pi: { ok: false, label: "pi", detail: piAvailable.error, hint: "Install/update Pi with RIG_PI_INSTALL_COMMAND or install Pi manually." },
+    piRig: { ok: false, label: "pi-rig global extension", hint: "Pi is required before pi-rig can be installed." }
+  };
+  if (!piAvailable.ok) {
+    throw new Error(`Pi install/update failed: ${piAvailable.error ?? "pi unavailable"}`);
+  }
+  const packageSource = resolvePiRigPackageSource(input.projectRoot);
+  removeManagedLegacyPiRigBridge(home);
+  const install = await runner(["pi", "install", packageSource], { cwd: input.projectRoot });
+  if (install.exitCode !== 0) {
+    throw new Error(`pi-rig install failed: ${(install.stderr || install.stdout).trim() || `exit ${install.exitCode}`}`);
+  }
+  const next = await checkPiRigInstall({ homeDir: home, commandRunner: runner });
+  return { ...next, installedPath: packageSource };
+}
+async function ensureRemotePiRigInstalled(input) {
+  const payload = await input.requestJson("/api/pi-rig/install", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ package: PI_RIG_PACKAGE_NAME, scope: "global" })
+  });
+  const record = payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
+  const piOk = record.piOk === true || record.ok === true;
+  const piRigOk = record.piRigOk === true || record.installed === true || record.ok === true;
+  const extensionPath = typeof record.extensionPath === "string" ? record.extensionPath : "remote:~/.pi/agent/extensions/pi-rig";
+  return {
+    remote: true,
+    extensionPath,
+    pi: {
+      ok: piOk,
+      label: "pi",
+      detail: typeof record.piVersion === "string" ? record.piVersion : undefined,
+      hint: piOk ? undefined : "Install/update Pi on the selected remote Rig server."
+    },
+    piRig: {
+      ok: piRigOk,
+      label: "pi-rig global extension",
+      detail: extensionPath,
+      hint: piRigOk ? undefined : "Install/enable pi-rig on the selected remote Rig server."
+    }
+  };
+}
+async function buildPiSetupChecks(input = {}) {
+  const status = await checkPiRigInstall(input);
+  return [status.pi, status.piRig];
 }
-
-// packages/cli/src/commands/init.ts
-import { appendFileSync as appendFileSync2, existsSync as existsSync9, mkdirSync as mkdirSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
-import { spawnSync } from "child_process";
-import { resolve as resolve16 } from "path";
-import { buildRigInitConfigSource } from "@rig/core";
-import { listGitHubProjects as listGitHubProjectsDirect, resolveProjectStatusField as resolveProjectStatusFieldDirect } from "@rig/server";
 
 // packages/cli/src/commands/_snapshot-upload.ts
 import { mkdir, readdir, readFile, writeFile } from "fs/promises";
@@ -6385,52 +6438,593 @@ async function promptForTaskSelection(question) {
   }
 }
 
-// packages/cli/src/commands/_operator-view.ts
+// packages/cli/src/commands/_pi-frontend.ts
+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";
+
+// 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 CANONICAL_STAGES2 = [
-  "Connect",
-  "GitHub/task sync",
-  "Prepare workspace",
-  "Launch Pi",
-  "Plan",
-  "Implement",
-  "Validate",
-  "Commit",
-  "Open PR",
-  "Review/CI",
-  "Merge",
-  "Complete"
-];
-var GREEN = "\x1B[32m";
-var BLUE = "\x1B[34m";
-var MAGENTA = "\x1B[35m";
-var YELLOW = "\x1B[33m";
-var RED = "\x1B[31m";
-var DIM = "\x1B[2m";
-var BOLD = "\x1B[1m";
-var RESET = "\x1B[0m";
-async function loadPiTuiRuntime() {
+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 await import("@earendil-works/pi-tui");
+    return JSON.stringify(value);
   } catch {
-    const base = new URL("../../../pi/packages/tui/src/", import.meta.url);
-    const [tui, input, terminal, keys, utils] = await Promise.all([
-      import(new URL("tui.ts", base).href),
-      import(new URL("components/input.ts", base).href),
-      import(new URL("terminal.ts", base).href),
-      import(new URL("keys.ts", base).href),
-      import(new URL("utils.ts", base).href)
+    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 WS" : "WS pending",
+    state.status,
+    state.model,
+    state.cwd
+  ].filter(Boolean);
+  const lines = [`Worker Pi daemon bridge \xB7 ${statusParts.join(" \xB7 ")}`];
+  if (state.activity)
+    lines.push(state.activity);
+  if (state.commands.length > 0) {
+    lines.push(`Worker commands: ${state.commands.slice(0, 10).join(", ")}${state.commands.length > 10 ? ", \u2026" : ""}`);
+  }
+  lines.push("");
+  if (state.transcript.length > 0) {
+    lines.push(...state.transcript.slice(-MAX_TRANSCRIPT_LINES));
+  } else {
+    lines.push("Waiting for worker Pi daemon transcript\u2026");
+  }
+  if (state.pendingUi) {
+    lines.push("");
+    lines.push(`Extension UI request \xB7 ${state.pendingUi.method}`);
+    lines.push(state.pendingUi.prompt);
+    state.pendingUi.options.forEach((option, index) => lines.push(`${index + 1}. ${option}`));
+    lines.push("Reply in the Pi editor. /cancel cancels this request.");
+  }
+  return lines;
+}
+function updatePiUi(ctx, state) {
+  ctx.ui.setTitle("Pi \xB7 Rig worker daemon");
+  ctx.ui.setStatus("rig-worker-pi", state.wsConnected ? "worker Pi WS live" : state.status);
+  syncNativeDisplayCwd(ctx, state);
+  if (state.nativeStream && nativePiUi(ctx)) {
+    ctx.ui.setWidget("rig-worker-pi-transcript", undefined);
+    return;
+  }
+  ctx.ui.setWorkingVisible(false);
+  ctx.ui.setWidget("rig-worker-pi-transcript", [`Worker Pi daemon bridge \xB7 degraded widget transcript`, ...renderBridgeWidget(state)], { placement: "aboveEditor" });
+}
+function applyStatus(state, payload) {
+  const status = recordOf(payload.status) ?? payload;
+  state.streaming = status.isStreaming === true || status.isCompacting === true || status.isBashRunning === true;
+  state.cwd = typeof status.cwd === "string" ? status.cwd : state.cwd;
+  state.model = typeof status.model === "string" ? status.model : state.model;
+  const pending = typeof status.pendingMessageCount === "number" ? status.pendingMessageCount : 0;
+  state.status = `${state.streaming ? "streaming" : "idle"}${pending ? ` \xB7 ${pending} queued` : ""}`;
+}
+function applyMessage(state, 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);
+}
+async function waitForWorkerReady(options, ctx, state) {
+  while (true) {
+    const session = await getRunPiSessionViaServer(options.context, options.runId).catch((error) => ({
+      ready: false,
+      status: error instanceof Error ? error.message : String(error),
+      retryAfterMs: 1000
+    }));
+    if (session.ready === false) {
+      const status = String(session.status ?? "starting");
+      state.status = `waiting for worker Pi daemon \xB7 ${status}`;
+      updatePiUi(ctx, state);
+      if (TERMINAL_RUN_STATUSES.has(status.toLowerCase())) {
+        appendTranscript(state, "Error", `Run ended before worker Pi daemon became ready: ${status}`);
+        return false;
+      }
+      await Bun.sleep(typeof session.retryAfterMs === "number" ? session.retryAfterMs : 750);
+      continue;
+    }
+    const sessionRecord = recordOf(session) ?? {};
+    applyEnvelope(ctx, state, { type: "ready", metadata: sessionRecord.metadata ?? sessionRecord });
+    updatePiUi(ctx, state);
+    return true;
+  }
+}
+function parseWsPayload(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((resolve19) => {
+    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(ctx, state, payload);
+          updatePiUi(ctx, state);
+        }
+      } catch (error) {
+        appendTranscript(state, "Error", `Unparseable worker Pi event: ${error instanceof Error ? error.message : String(error)}`);
+        updatePiUi(ctx, state);
+      }
+    };
+    socket.onerror = () => socket.close();
+    socket.onclose = () => {
+      state.wsConnected = false;
+      state.status = "worker Pi WebSocket disconnected";
+      updatePiUi(ctx, state);
+      resolve19();
+    };
+  });
+  try {
+    const [messagesPayload, statusPayload, commandsPayload] = await Promise.all([
+      getRunPiMessagesViaServer(options.context, options.runId),
+      getRunPiStatusViaServer(options.context, options.runId),
+      getRunPiCommandsViaServer(options.context, options.runId)
     ]);
-    return {
-      Container: tui.Container,
-      TUI: tui.TUI,
-      Input: input.Input,
-      ProcessTerminal: terminal.ProcessTerminal,
-      matchesKey: keys.matchesKey,
-      truncateToWidth: utils.truncateToWidth
+    const messages = Array.isArray(messagesPayload.messages) ? messagesPayload.messages : [];
+    const native = nativePiUi(ctx);
+    if (state.nativeStream && native?.appendSessionMessages)
+      native.appendSessionMessages(messages);
+    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}`] : [];
+    });
+    catchupDone = true;
+    for (const payload of buffered.splice(0))
+      applyEnvelope(ctx, state, payload);
+    updatePiUi(ctx, state);
+  } catch (error) {
+    appendTranscript(state, "Error", `Worker Pi catch-up failed: ${error instanceof Error ? error.message : String(error)}`);
+    catchupDone = true;
+    updatePiUi(ctx, state);
+  }
+  await closePromise;
+}
+function createRemoteBashOperations(options, state, excludeFromContext) {
+  return {
+    exec(command, _cwd, execOptions) {
+      return new Promise((resolve19, reject) => {
+        const pending = {
+          command,
+          onData: execOptions.onData,
+          resolve: resolve19,
+          reject,
+          sawChunk: false
+        };
+        const cleanup = () => {
+          execOptions.signal?.removeEventListener("abort", onAbort);
+          if (timer)
+            clearTimeout(timer);
+        };
+        const onAbort = () => {
+          cleanup();
+          failPendingShell(state, pending, new Error("Remote worker shell command aborted locally."));
+        };
+        const timeoutMs = typeof execOptions.timeout === "number" && execOptions.timeout > 0 ? execOptions.timeout : 0;
+        const timer = timeoutMs > 0 ? setTimeout(() => {
+          cleanup();
+          failPendingShell(state, pending, new Error(`Remote worker shell command timed out after ${timeoutMs}ms.`));
+        }, timeoutMs) : null;
+        const wrappedResolve = pending.resolve;
+        const wrappedReject = pending.reject;
+        pending.resolve = (result) => {
+          cleanup();
+          wrappedResolve(result);
+        };
+        pending.reject = (error) => {
+          cleanup();
+          wrappedReject(error);
+        };
+        execOptions.signal?.addEventListener("abort", onAbort, { once: true });
+        state.pendingShells.push(pending);
+        sendRunPiShellViaServer(options.context, options.runId, `${excludeFromContext ? "!!" : "!"}${command}`).catch((error) => {
+          cleanup();
+          failPendingShell(state, pending, error instanceof Error ? error : new Error(String(error)));
+        });
+      });
+    }
+  };
+}
+async function answerPendingUi(options, state, line) {
+  const pending = state.pendingUi;
+  if (!pending)
+    return false;
+  if (line === "/cancel") {
+    await respondRunPiExtensionUiViaServer(options.context, options.runId, pending.requestId, { cancelled: true });
+  } else if (pending.method === "confirm") {
+    const confirmed = /^(y|yes|true|1)$/i.test(line);
+    await respondRunPiExtensionUiViaServer(options.context, options.runId, pending.requestId, { value: confirmed, confirmed });
+  } else if (pending.options.length > 0 && /^\d+$/.test(line)) {
+    const selected = pending.options[Math.max(0, Number(line) - 1)] ?? line;
+    await respondRunPiExtensionUiViaServer(options.context, options.runId, pending.requestId, { value: selected });
+  } else {
+    await respondRunPiExtensionUiViaServer(options.context, options.runId, pending.requestId, { value: line });
+  }
+  appendTranscript(state, "System", `Responded to extension UI request ${pending.requestId}.`);
+  state.pendingUi = null;
+  return true;
+}
+async function routeInput(options, ctx, state, line) {
+  const 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;
+  }
+  if (text2 === "/stop") {
+    await abortRunPiViaServer(options.context, options.runId);
+    appendTranscript(state, "System", "Stop requested for worker Pi daemon.");
+    updatePiUi(ctx, state);
+    ctx.shutdown();
+    return;
+  }
+  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);
+  }
+  updatePiUi(ctx, state);
+}
+function createRigWorkerPiBridgeExtension(options) {
+  return (pi) => {
+    const state = {
+      transcript: [],
+      status: "starting worker Pi daemon bridge",
+      activity: "",
+      cwd: "",
+      model: "",
+      commands: [],
+      streaming: false,
+      pendingUi: null,
+      pendingShells: [],
+      wsConnected: false,
+      nativeStream: false
     };
+    if (options.initialMessageSent)
+      appendTranscript(state, "System", "Initial message sent to worker Pi daemon.");
+    let nativePiUiContextAvailable = false;
+    pi.on("user_bash", (event) => {
+      state.nativeStream = Boolean(state.nativeStream || nativePiUiContextAvailable);
+      return { operations: createRemoteBashOperations(options, state, event.excludeFromContext === true) };
+    });
+    pi.on("session_start", async (_event, ctx) => {
+      nativePiUiContextAvailable = Boolean(nativePiUi(ctx));
+      state.nativeStream = nativePiUiContextAvailable;
+      updatePiUi(ctx, state);
+      ctx.ui.notify(nativePiUiContextAvailable ? "Rig worker Pi native stream bridge loaded" : "Rig worker Pi bridge extension loaded (degraded widget fallback)", "info");
+      ctx.ui.onTerminalInput((data) => {
+        if (data.includes("\x04")) {
+          ctx.shutdown();
+          return { consume: true };
+        }
+        if (!data.includes("\r") && !data.includes(`
+`))
+          return;
+        const inlineText = data.replace(/[\r\n]+/g, "").trim();
+        const editorText = ctx.ui.getEditorText().trim();
+        const 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, 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(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 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();
+    rmSync5(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();
@@ -6469,198 +7063,15 @@ async function readOperatorSnapshot(context, runId, options = {}) {
   const timelineCursor = typeof timelinePage.nextCursor === "string" ? timelinePage.nextCursor : options.timelineCursor ?? null;
   return { run, logs, timeline, timelineCursor, rendered: renderOperatorSnapshot({ run, logs, timeline }) };
 }
-function unwrapRun(runPayload) {
-  return runPayload.run && typeof runPayload.run === "object" && !Array.isArray(runPayload.run) ? runPayload.run : runPayload;
-}
-function logDetail2(log3) {
-  return typeof log3.detail === "string" ? log3.detail.trim() : "";
-}
-function logTitle(log3) {
-  return typeof log3.title === "string" ? log3.title.trim() : "";
-}
-function renderAssistantTextFromTimeline(entries) {
-  const assistant = entries.filter((entry) => entry.type === "assistant_message" && typeof entry.text === "string").at(-1);
-  const text2 = typeof assistant?.text === "string" ? assistant.text.trimEnd() : "";
-  if (!text2)
-    return [];
-  return [`${BLUE}${BOLD}Remote Pi assistant${RESET}`, ...text2.split(/\r?\n/).slice(-18)];
-}
-function renderToolLines(entries) {
-  return entries.filter((entry) => entry.type === "tool_execution_start" || entry.type === "tool_execution_update" || entry.type === "tool_execution_end" || entry.type === "mcp_tool_call").slice(-8).map((entry) => `${DIM}[tool]${RESET} ${String(entry.toolName ?? entry.name ?? entry.title ?? entry.type)} ${String(entry.status ?? entry.state ?? "")}`.trim());
-}
-function renderStageLines(logs) {
-  const latestByStage = new Map;
-  for (const log3 of logs) {
-    const title = logTitle(log3).toLowerCase();
-    const stageName = String(log3.stage ?? "").toLowerCase();
-    const stage = CANONICAL_STAGES2.find((candidate) => candidate.toLowerCase() === title || candidate.toLowerCase() === stageName);
-    if (stage)
-      latestByStage.set(stage, log3);
-  }
-  return CANONICAL_STAGES2.map((stage) => {
-    const log3 = latestByStage.get(stage);
-    const status = String(log3?.status ?? "pending");
-    const detail = log3 ? logDetail2(log3) : "";
-    const color = status === "completed" ? GREEN : status === "failed" || status === "rejected" ? RED : status === "pending" ? DIM : YELLOW;
-    const mark = status === "completed" ? "\u2713" : status === "pending" ? "\xB7" : status === "failed" ? "\u2717" : "\u25B6";
-    return `${color}${mark} ${stage}${RESET}${detail ? ` ${DIM}\u2014 ${detail.slice(0, 140)}${RESET}` : ""}`;
-  });
-}
-function renderEventLines(logs) {
-  return logs.filter((log3) => !CANONICAL_STAGES2.some((stage) => stage.toLowerCase() === logTitle(log3).toLowerCase())).slice(-12).flatMap((log3) => {
-    const title = logTitle(log3) || "Rig event";
-    const detail = logDetail2(log3);
-    if (!detail)
-      return [];
-    const tone = String(log3.tone ?? "");
-    const color = tone === "error" ? RED : tone === "tool" ? MAGENTA : DIM;
-    return [`${color}[${title}]${RESET} ${detail.slice(0, 220)}`];
-  });
-}
-
-class RigRunComponent {
-  truncateToWidth;
-  snapshot = { run: {}, logs: [], timeline: [] };
-  localEvents = [];
-  constructor(truncateToWidth) {
-    this.truncateToWidth = truncateToWidth;
-  }
-  update(snapshot) {
-    this.snapshot = snapshot;
-  }
-  addLocalEvent(message2) {
-    this.localEvents.push(`${new Date().toLocaleTimeString()} ${message2}`);
-    this.localEvents = this.localEvents.slice(-8);
-  }
-  invalidate() {}
-  render(width) {
-    const run = unwrapRun(this.snapshot.run);
-    const runId = String(run.runId ?? run.id ?? "run");
-    const status = String(run.status ?? "unknown");
-    const worker = typeof run.worktreePath === "string" && run.worktreePath.trim() ? run.worktreePath.trim() : typeof run.projectRoot === "string" && run.projectRoot.trim() ? run.projectRoot.trim() : "worker workspace pending";
-    const lines = [
-      `${BOLD}Rig Pi frontend${RESET} ${DIM}(local Pi TUI \u2192 Rig server \u2192 worker Pi backend)${RESET}`,
-      `${BOLD}${runId}${RESET} \xB7 ${status} \xB7 ${DIM}${worker}${RESET}`,
-      "",
-      `${BOLD}Rig flow${RESET}`,
-      ...renderStageLines(this.snapshot.logs ?? []),
-      "",
-      ...renderAssistantTextFromTimeline(this.snapshot.timeline ?? []),
-      ...renderToolLines(this.snapshot.timeline ?? []),
-      "",
-      `${BOLD}Rig / Pi events${RESET}`,
-      ...renderEventLines(this.snapshot.logs ?? []),
-      ...this.localEvents.map((event) => `${GREEN}[frontend]${RESET} ${event}`),
-      ""
-    ];
-    return lines.slice(-42).map((line) => this.truncateToWidth(line, Math.max(10, width)));
-  }
-}
-
-class RigInputComponent {
-  matchesKey;
-  truncateToWidth;
-  input;
-  status = "Type text, /skill:..., or remote Pi slash commands. Local: /stop /detach.";
-  constructor(InputCtor, matchesKey, truncateToWidth, onSubmit, onEscape) {
-    this.matchesKey = matchesKey;
-    this.truncateToWidth = truncateToWidth;
-    this.input = new InputCtor;
-    this.input.onSubmit = (value) => {
-      const text2 = value.trim();
-      this.input.setValue("");
-      if (text2)
-        Promise.resolve(onSubmit(text2));
-    };
-    this.input.onEscape = onEscape;
-  }
-  handleInput(data) {
-    if (this.matchesKey(data, "ctrl+d")) {
-      this.input.onEscape?.();
-      return;
-    }
-    this.input.handleInput?.(data);
-  }
-  setStatus(status) {
-    this.status = status;
-  }
-  invalidate() {
-    this.input.invalidate();
-  }
-  render(width) {
-    return [
-      `${DIM}${this.truncateToWidth(this.status, Math.max(10, width))}${RESET}`,
-      `${GREEN}${BOLD}You \u2192 worker Pi:${RESET}`,
-      ...this.input.render(width)
-    ];
-  }
-}
-async function attachRunPiTuiFrontend(context, input) {
-  const piTui = await loadPiTuiRuntime();
-  const terminal = new piTui.ProcessTerminal;
-  const tui = new piTui.TUI(terminal);
-  const root = new piTui.Container;
-  const runView = new RigRunComponent(piTui.truncateToWidth);
-  let detached = false;
-  let steered = input.steered === true;
-  let latest = await readOperatorSnapshot(context, input.runId);
-  let timelineCursor = latest.timelineCursor;
-  runView.update(latest);
-  if (steered)
-    runView.addLocalEvent("initial message queued to worker Pi.");
-  const stop = () => {
-    detached = true;
-    tui.stop();
-  };
-  const inputView = new RigInputComponent(piTui.Input, piTui.matchesKey, piTui.truncateToWidth, async (line) => {
-    if (line === "/detach" || line === "/quit" || line === "/q") {
-      runView.addLocalEvent("detached from run.");
-      stop();
-      return;
-    }
-    if (line === "/stop") {
-      await stopRunViaServer(context, input.runId);
-      runView.addLocalEvent("stop requested.");
-      stop();
-      return;
-    }
-    await steerRunViaServer(context, input.runId, line);
-    steered = true;
-    runView.addLocalEvent(`queued to worker Pi: ${line.slice(0, 160)}`);
-    tui.requestRender();
-  }, stop);
-  root.addChild(runView);
-  root.addChild(inputView);
-  tui.addChild(root);
-  tui.setFocus(inputView.input);
-  tui.start();
-  tui.requestRender(true);
-  const pollMs = Math.max(250, Math.trunc(input.pollMs ?? 1000));
-  try {
-    while (!detached && !TERMINAL_RUN_STATUSES.has(runStatusFromPayload(latest.run))) {
-      await Bun.sleep(pollMs);
-      latest = await readOperatorSnapshot(context, input.runId, { timelineCursor });
-      timelineCursor = latest.timelineCursor;
-      runView.update(latest);
-      inputView.setStatus(`Remote worker ${runStatusFromPayload(latest.run)}. Input is forwarded to worker Pi; /stop /detach are local controls.`);
-      tui.requestRender();
-    }
-  } finally {
-    if (!detached)
-      tui.stop();
-  }
-  return { ...latest, timelineCursor, steered, detached, rendered: renderOperatorSnapshot(latest) };
-}
 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 attachRunPiTuiFrontend(context, {
+    return attachRunBundledPiFrontend(context, {
       runId: input.runId,
-      pollMs: input.pollMs,
       steered
     });
   }
@@ -6671,7 +7082,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;
@@ -6690,7 +7101,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;
@@ -8745,8 +9156,7 @@ async function executeRigOwnedTaskRun(context, input) {
     ...input.model ? ["--model", input.model] : [],
     "--prompt"
   ] : input.runtimeAdapter === "pi" ? [
-    "--mode",
-    "rpc",
+    "__rig_pi_session_daemon__",
     ...input.model ? ["--model", input.model] : []
   ] : [
     "--print",
@@ -8843,7 +9253,7 @@ ${planningClassification.planningRequired ? `Before implementing, write a concis
         projectRoot: context.projectRoot,
         runId: input.runId,
         stage,
-        detail: stage === "Launch Pi" ? "Pi RPC runtime bridge starting with pi-rig environment." : stage === "Plan" ? `${planningClassification.planningRequired ? "recorded" : "skipped"} (${planningClassification.reason}; size=${planningClassification.size}; risk=${planningClassification.risk})` : stage === "Implement" ? "Pi implementation pass is running." : null,
+        detail: stage === "Launch Pi" ? "Worker Pi SDK session daemon starting; local frontend will attach over Rig-proxied WebSocket." : stage === "Plan" ? `${planningClassification.planningRequired ? "recorded" : "skipped"} (${planningClassification.reason}; size=${planningClassification.size}; risk=${planningClassification.risk})` : stage === "Implement" ? "Pi implementation pass is running in the worker runtime." : null,
         status: stage === "Implement" || stage === "Launch Pi" ? "running" : "completed"
       });
     }
@@ -8884,6 +9294,7 @@ ${planningClassification.planningRequired ? `Before implementing, write a concis
   let latestProviderCommand = null;
   let latestRuntimeBranch = resumeMode && typeof existingRunRecord?.branch === "string" ? existingRunRecord.branch : null;
   let snapshotSidecarPromise = null;
+  let wrapperManagesRuntimeSnapshot = false;
   let dirtyBaselineApplied = false;
   const childEnv = {
     ...process.env,
@@ -8952,6 +9363,7 @@ ${planningClassification.planningRequired ? `Before implementing, write a concis
       latestSessionDir = typeof payload.sessionDir === "string" ? payload.sessionDir : latestSessionDir;
       latestLogsDir = typeof payload.logsDir === "string" ? payload.logsDir : latestLogsDir;
       const runtimeId = typeof payload.runtimeId === "string" ? payload.runtimeId : null;
+      wrapperManagesRuntimeSnapshot = payload.snapshotManaged === true;
       latestRuntimeBranch = runtimeId;
       provisioningAction.complete(latestRuntimeWorkspace ?? "Runtime ready.", {
         runtimeId: runtimeId ?? null,
@@ -8989,7 +9401,7 @@ ${planningClassification.planningRequired ? `Before implementing, write a concis
         });
         emitServerRunEvent({ type: "log", runId: input.runId, title: "Dirty baseline snapshot" });
       }
-      if (!snapshotSidecarPromise && runtimeId && loadRuntimeSnapshotConfig(context.projectRoot).enabled) {
+      if (!wrapperManagesRuntimeSnapshot && !snapshotSidecarPromise && runtimeId && loadRuntimeSnapshotConfig(context.projectRoot).enabled) {
         snapshotSidecarPromise = (async () => {
           const { sidecar, error } = await resolveTaskRunSnapshotSidecar({
             projectRoot: context.projectRoot,
@@ -9071,6 +9483,51 @@ ${planningClassification.planningRequired ? `Before implementing, write a concis
       }
       return true;
     }
+    if (event.type === "pi.sessiond.starting" || event.type === "pi.sessiond.ready" || event.type === "pi.session.event_stream.connected" || event.type === "pi.prompt.sent" || event.type === "pi.prompt.waiting" || event.type === "pi.session.agent_end" || event.type === "pi.session.error") {
+      const title = event.type === "pi.sessiond.starting" ? "Starting worker Pi session daemon" : event.type === "pi.sessiond.ready" ? "Worker Pi daemon ready" : event.type === "pi.session.event_stream.connected" ? "Worker Pi event stream connected" : event.type === "pi.prompt.sent" ? "Delivered initial prompt to worker Pi" : event.type === "pi.prompt.waiting" ? "Worker Pi prompt waiting" : event.type === "pi.session.agent_end" ? "Worker Pi turn complete" : "Worker Pi session error";
+      const detail = event.type === "pi.sessiond.ready" ? "Daemon accepted control connection; waiting for SDK session metadata." : event.type === "pi.sessiond.starting" ? String(payload.workspaceDir ?? "worker runtime") : event.type === "pi.prompt.sent" ? `${String(payload.bytes ?? "unknown")} prompt bytes sent.` : event.type === "pi.prompt.waiting" ? String(payload.reason ?? "empty prompt") : event.type === "pi.session.error" ? String(payload.message ?? "session error") : String(payload.sessionId ?? payload.runId ?? "worker Pi session");
+      appendRunLog(context.projectRoot, input.runId, {
+        id: nextRunLogId(),
+        title,
+        detail,
+        tone: event.type === "pi.session.error" ? "error" : "info",
+        status: reviewStarted ? "reviewing" : verificationStarted ? "validating" : "running",
+        payload: {
+          eventType: event.type,
+          runId: typeof payload.runId === "string" ? payload.runId : null,
+          runtimeId: typeof payload.runtimeId === "string" ? payload.runtimeId : null,
+          sessionId: typeof payload.sessionId === "string" ? payload.sessionId : null
+        },
+        createdAt: new Date().toISOString()
+      });
+      emitServerRunEvent({ type: "log", runId: input.runId, title });
+      return true;
+    }
+    if (event.type === "pi.session.ready") {
+      const privateMetadata = payload.privateMetadata && typeof payload.privateMetadata === "object" && !Array.isArray(payload.privateMetadata) ? payload.privateMetadata : null;
+      const publicMetadata = payload.metadata && typeof payload.metadata === "object" && !Array.isArray(payload.metadata) ? payload.metadata : null;
+      if (privateMetadata) {
+        patchAuthorityRun(context.projectRoot, input.runId, {
+          piSession: publicMetadata,
+          piSessionPrivate: privateMetadata
+        });
+        const sessionId = typeof publicMetadata?.sessionId === "string" ? publicMetadata.sessionId : typeof privateMetadata.public === "object" && privateMetadata.public && !Array.isArray(privateMetadata.public) ? String(privateMetadata.public.sessionId ?? "") : "";
+        appendRunLog(context.projectRoot, input.runId, {
+          id: `log:${input.runId}:pi-session-ready`,
+          title: "Worker Pi session ready",
+          detail: sessionId ? `Session ${sessionId} is ready for WebSocket attach.` : "Worker Pi SDK session daemon is ready for WebSocket attach.",
+          tone: "info",
+          status: "running",
+          payload: {
+            sessionId: sessionId || null,
+            runtimeId: typeof payload.runtimeId === "string" ? payload.runtimeId : null
+          },
+          createdAt: new Date().toISOString()
+        });
+        emitServerRunEvent({ type: "log", runId: input.runId, title: "Worker Pi session ready" });
+      }
+      return true;
+    }
     if (event.type === "pi.rpc.prompt.sent" || event.type === "pi.rpc.steering.delivered" || event.type === "pi.rpc.steering.poll.failed" || event.type === "pi.rpc.extension_ui.cancelled") {
       const title = event.type === "pi.rpc.prompt.sent" ? "Delivered initial prompt to worker Pi" : event.type === "pi.rpc.steering.delivered" ? "Delivered steering to worker Pi" : event.type === "pi.rpc.steering.poll.failed" ? "Worker Pi steering poll failed" : "Pi RPC UI request auto-cancelled";
       const detail = event.type === "pi.rpc.prompt.sent" ? `${String(payload.kind ?? "prompt")} prompt (${String(payload.bytes ?? "unknown")} bytes)` : event.type === "pi.rpc.steering.delivered" ? `${String(payload.actor ?? "operator")}: ${String(payload.message ?? "")}`.slice(0, 500) : event.type === "pi.rpc.steering.poll.failed" ? String(payload.error ?? "steering poll failed") : `${String(payload.method ?? "ui")}: ${String(payload.reason ?? "noninteractive worker session")}`;
@@ -9602,7 +10059,7 @@ Failed to update task source for ${input.taskId ?? runtimeTaskId} to failed: ${e
       startedAt,
       finishedAt: requestedAt
     });
-    return;
+    process.exit(0);
   }
   const runPiPrFeedbackFix = async (message2) => {
     appendPiStageLog({