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

package/dist/src/commands.js

@@ -6387,6 +6387,50 @@ async function promptForTaskSelection(question) {
 
 // packages/cli/src/commands/_operator-view.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() {
+  try {
+    return await import("@earendil-works/pi-tui");
+  } 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 {
+      Container: tui.Container,
+      TUI: tui.TUI,
+      Input: input.Input,
+      ProcessTerminal: terminal.ProcessTerminal,
+      matchesKey: keys.matchesKey,
+      truncateToWidth: utils.truncateToWidth
+    };
+  }
+}
 function runStatusFromPayload(payload) {
   const run = payload.run && typeof payload.run === "object" && !Array.isArray(payload.run) ? payload.run : payload;
   return String(run.status ?? "unknown").toLowerCase();
@@ -6425,12 +6469,201 @@ 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());
     steered = true;
   }
+  if (input.follow && !input.once && input.interactive !== false && context.outputMode === "text" && Boolean(process.stdin.isTTY && process.stdout.isTTY)) {
+    return attachRunPiTuiFrontend(context, {
+      runId: input.runId,
+      pollMs: input.pollMs,
+      steered
+    });
+  }
   const surface = createOperatorSurface({ interactive: input.interactive !== false });
   let snapshot = await readOperatorSnapshot(context, input.runId);
   if (context.outputMode === "text") {
@@ -6571,92 +6804,6 @@ function formatSubmittedRun(input) {
 `);
 }
 
-// packages/cli/src/commands/_pi-session.ts
-import { spawn as spawn2 } 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 = spawn2(command[0], command.slice(1), {
-    cwd: context.projectRoot,
-    env,
-    stdio: "inherit"
-  });
-  const launchError = await new Promise((resolve19) => {
-    child.once("error", (error) => {
-      resolve19({ error: error.message });
-    });
-    child.once("close", (code) => resolve19({ 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/run.ts
 function normalizeRemoteRunDetails(payload) {
   const run = payload.run;
@@ -6881,20 +7028,13 @@ async function executeRun(context, args) {
         throw new CliError2("run attach requires a run id.", 2);
       }
       let steered = false;
-      const shouldTryPiAttach = context.outputMode === "text" && follow.value && !once.value && Boolean(process.stdin.isTTY && process.stdout.isTTY) && process.env.RIG_DISABLE_PI_LAUNCH !== "1";
-      if (shouldTryPiAttach && messageOption.value?.trim()) {
+      if (messageOption.value?.trim()) {
         await steerRunViaServer(context, runId, messageOption.value.trim());
         steered = true;
       }
-      if (shouldTryPiAttach) {
-        const piSession = await launchPiRigSession(context, { runId });
-        if (piSession.launched) {
-          return { ok: true, group: "run", command, details: { runId, steered, mode: "pi", ...piSession } };
-        }
-      }
       const attached = await attachRunOperatorView(context, {
         runId,
-        message: shouldTryPiAttach ? null : messageOption.value ?? null,
+        message: null,
         once: once.value,
         follow: follow.value,
         pollMs: parsePositiveInt(pollMs.value, "--poll-ms", 2000)
@@ -7621,20 +7761,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 }));
       }
@@ -7721,7 +7848,7 @@ async function executeTask(context, args, options) {
 // packages/cli/src/commands/task-run-driver.ts
 import { copyFileSync as copyFileSync3, existsSync as existsSync11, mkdirSync as mkdirSync7, readFileSync as readFileSync10, statSync as statSync2, writeFileSync as writeFileSync6 } from "fs";
 import { resolve as resolve20 } from "path";
-import { spawn as spawn3, spawnSync as spawnSync4 } from "child_process";
+import { spawn as spawn2, spawnSync as spawnSync4 } from "child_process";
 import { createInterface as createLineInterface } from "readline";
 import { loadConfig as loadConfig2 } from "@rig/core/load-config";
 import {
@@ -7778,6 +7905,7 @@ function buildPiRigBridgeEnv(input) {
     RIG_SERVER_RUN_ID: input.runId,
     RIG_TASK_ID: input.taskId,
     RIG_RUNTIME_ADAPTER: "pi",
+    RIG_STEERING_POLL_MS: "0",
     ...input.serverUrl ? { RIG_SERVER_URL: input.serverUrl } : {},
     ...input.authToken ? { RIG_AUTH_TOKEN: input.authToken } : {},
     ...githubBridgeEnv(githubToken)
@@ -7949,7 +8077,7 @@ async function runCheckedCommand(command, args, cwd, label = "git") {
 }
 function createCommandRunner(binary) {
   return async (args, options) => {
-    const child = spawn3(binary, [...args], {
+    const child = spawn2(binary, [...args], {
       cwd: options?.cwd,
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -8373,6 +8501,69 @@ function appendAssistantTimelineFromRecord(input) {
   }
   return nextAssistantText;
 }
+function appendPiRpcProtocolLogFromRecord(input) {
+  const type = typeof input.record.type === "string" ? input.record.type : "";
+  if (type === "response") {
+    const command = typeof input.record.command === "string" ? input.record.command : "rpc";
+    const success = input.record.success !== false;
+    if (success && command !== "prompt" && command !== "steer" && command !== "follow_up" && command !== "set_session_name") {
+      return true;
+    }
+    appendRunLog(input.projectRoot, input.runId, {
+      id: input.nextRunLogId(),
+      title: success ? "Pi RPC response" : "Pi RPC error",
+      detail: success ? `${command}: accepted` : `${command}: ${String(input.record.error ?? "failed")}`,
+      tone: success ? "tool" : "error",
+      status: input.status,
+      payload: input.record,
+      createdAt: new Date().toISOString()
+    });
+    emitServerRunEvent({ type: "log", runId: input.runId, title: success ? "Pi RPC response" : "Pi RPC error" });
+    return true;
+  }
+  if (type !== "extension_ui_request")
+    return false;
+  const method = typeof input.record.method === "string" ? input.record.method : "ui";
+  let title = "Pi UI event";
+  let detail = method;
+  let tone = "info";
+  if (method === "notify") {
+    title = "Pi notification";
+    detail = String(input.record.message ?? "");
+    tone = input.record.notifyType === "error" ? "error" : "info";
+  } else if (method === "setStatus") {
+    title = "Pi UI status";
+    detail = `${String(input.record.statusKey ?? "status")}: ${String(input.record.statusText ?? "cleared")}`;
+    tone = "tool";
+  } else if (method === "setWidget") {
+    title = "Pi UI widget";
+    const lines = Array.isArray(input.record.widgetLines) ? input.record.widgetLines.map((line) => String(line)).join(" | ") : "cleared";
+    detail = `${String(input.record.widgetKey ?? "widget")}: ${lines}`.slice(0, 500);
+    tone = "tool";
+  } else if (method === "setTitle") {
+    title = "Pi UI title";
+    detail = String(input.record.title ?? "");
+    tone = "tool";
+  } else if (method === "set_editor_text") {
+    title = "Pi editor update";
+    detail = String(input.record.text ?? "").slice(0, 500);
+    tone = "tool";
+  } else {
+    title = "Pi UI request";
+    detail = `${method}: ${String(input.record.title ?? input.record.message ?? "")}`.trim();
+  }
+  appendRunLog(input.projectRoot, input.runId, {
+    id: input.nextRunLogId(),
+    title,
+    detail,
+    tone,
+    status: input.status,
+    payload: input.record,
+    createdAt: new Date().toISOString()
+  });
+  emitServerRunEvent({ type: "log", runId: input.runId, title });
+  return true;
+}
 function appendPiToolTimelineFromRecord(input) {
   const type = typeof input.record.type === "string" ? input.record.type : "";
   if (type !== "tool_execution_start" && type !== "tool_execution_update" && type !== "tool_execution_end")
@@ -8391,7 +8582,7 @@ function appendPiToolTimelineFromRecord(input) {
 }
 function isNonRenderablePiProtocolRecord(record) {
   const type = typeof record.type === "string" ? record.type : "";
-  return type === "message_start" || type === "message_end" || type === "turn_start" || type === "turn_end" || type === "tool_result" || type === "message_update" && (!record.assistantMessageEvent || typeof record.assistantMessageEvent !== "object" || Array.isArray(record.assistantMessageEvent) || record.assistantMessageEvent.type !== "text_delta");
+  return type === "agent_start" || type === "agent_end" || type === "message_start" || type === "message_end" || type === "turn_start" || type === "turn_end" || type === "tool_result" || type === "message_update" && (!record.assistantMessageEvent || typeof record.assistantMessageEvent !== "object" || Array.isArray(record.assistantMessageEvent) || record.assistantMessageEvent.type !== "text_delta");
 }
 function appendToolTimelineFromLog(input) {
   const title = typeof input.log.title === "string" ? input.log.title : "";
@@ -8554,11 +8745,8 @@ async function executeRigOwnedTaskRun(context, input) {
     ...input.model ? ["--model", input.model] : [],
     "--prompt"
   ] : input.runtimeAdapter === "pi" ? [
-    "--print",
-    "--verbose",
     "--mode",
-    "json",
-    "--no-session",
+    "rpc",
     ...input.model ? ["--model", input.model] : []
   ] : [
     "--print",
@@ -8655,7 +8843,7 @@ ${planningClassification.planningRequired ? `Before implementing, write a concis
         projectRoot: context.projectRoot,
         runId: input.runId,
         stage,
-        detail: stage === "Launch Pi" ? "Pi 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" ? "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,
         status: stage === "Implement" || stage === "Launch Pi" ? "running" : "completed"
       });
     }
@@ -8748,6 +8936,7 @@ ${planningClassification.planningRequired ? `Before implementing, write a concis
       detail: detail ?? "Verifier review is running."
     });
   };
+  const nextRunLogId = createRunLogIdFactory(input.runId);
   const handleWrapperEvent = (rawPayload) => {
     let event = null;
     try {
@@ -8882,9 +9071,23 @@ ${planningClassification.planningRequired ? `Before implementing, write a concis
       }
       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")}`;
+      appendRunLog(context.projectRoot, input.runId, {
+        id: nextRunLogId(),
+        title,
+        detail,
+        tone: event.type === "pi.rpc.steering.poll.failed" ? "error" : "info",
+        status: reviewStarted ? "reviewing" : verificationStarted ? "validating" : "running",
+        payload,
+        createdAt: new Date().toISOString()
+      });
+      emitServerRunEvent({ type: "log", runId: input.runId, title });
+      return true;
+    }
     return false;
   };
-  const nextRunLogId = createRunLogIdFactory(input.runId);
   const handleAgentStdoutLine = (line) => {
     const trimmed = line.trim();
     if (!trimmed)
@@ -8918,6 +9121,15 @@ ${planningClassification.planningRequired ? `Before implementing, write a concis
     try {
       const record = JSON.parse(trimmed);
       const liveLogStatus = reviewStarted ? "reviewing" : verificationStarted ? "validating" : "running";
+      if (input.runtimeAdapter === "pi" && appendPiRpcProtocolLogFromRecord({
+        projectRoot: context.projectRoot,
+        runId: input.runId,
+        record,
+        status: liveLogStatus,
+        nextRunLogId
+      })) {
+        return;
+      }
       if (input.runtimeAdapter === "pi" && appendPiToolTimelineFromRecord({ projectRoot: context.projectRoot, runId: input.runId, record })) {
         emitServerRunEvent({ type: "timeline", runId: input.runId });
         return;
@@ -9063,7 +9275,7 @@ ${planningClassification.planningRequired ? `Before implementing, write a concis
   }
   for (let attempt = 1;!exit && attempt <= maxAttempts; attempt += 1) {
     const attemptHostAgentCommand = buildHostAgentCommand(currentPrompt);
-    const child = spawn3(attemptHostAgentCommand[0], attemptHostAgentCommand.slice(1), {
+    const child = spawn2(attemptHostAgentCommand[0], attemptHostAgentCommand.slice(1), {
       cwd: context.projectRoot,
       env: childEnv,
       stdio: ["pipe", "pipe", "pipe"]
@@ -9410,7 +9622,7 @@ Failed to update task source for ${input.taskId ?? runtimeTaskId} to failed: ${e
     });
     emitServerRunEvent({ type: "log", runId: input.runId, title: "Steering Pi from PR feedback" });
     const feedbackCommand = buildHostAgentCommand(message2);
-    const child = spawn3(feedbackCommand[0], feedbackCommand.slice(1), {
+    const child = spawn2(feedbackCommand[0], feedbackCommand.slice(1), {
       cwd: latestRuntimeWorkspace ?? context.projectRoot,
       env: childEnv,
       stdio: ["pipe", "pipe", "pipe"]