@h-rig/cli 0.0.6-alpha.9 → 0.0.6-alpha.90

package/dist/src/commands/task-run-driver.js

@@ -1,18 +1,25 @@
 // @bun
 // packages/cli/src/commands/task-run-driver.ts
-import { copyFileSync, existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, statSync, writeFileSync } from "fs";
-import { resolve as resolve4 } from "path";
+import { copyFileSync, existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync4, statSync, writeFileSync as writeFileSync2 } from "fs";
+import { resolve as resolve6 } from "path";
 import { spawn, spawnSync } from "child_process";
 import { createInterface as createLineInterface } from "readline";
 
 // packages/cli/src/runner.ts
 import { EventBus } from "@rig/runtime/control-plane/runtime/events";
-import { CliError } from "@rig/runtime/control-plane/errors";
+import { CliError as RuntimeCliError } from "@rig/runtime/control-plane/errors";
 import { evaluate, loadPolicy, resolveAction } from "@rig/runtime/control-plane/runtime/guard";
-import { PluginManager } from "@rig/runtime/control-plane/runtime/plugins";
-import { loadRuntimeContextFromEnv } from "@rig/runtime/control-plane/runtime/context";
 import { buildBinary } from "@rig/runtime/control-plane/runtime/isolation";
-import { CliError as CliError2 } from "@rig/runtime/control-plane/errors";
+
+class CliError extends RuntimeCliError {
+  hint;
+  constructor(message, exitCode = 1, options = {}) {
+    super(message, exitCode);
+    if (options.hint?.trim()) {
+      this.hint = options.hint.trim();
+    }
+  }
+}
 function formatCommand(parts) {
   return parts.map((part) => /[^a-zA-Z0-9_./:-]/.test(part) ? JSON.stringify(part) : part).join(" ");
 }
@@ -39,14 +46,14 @@ import {
   isCodexExecRecord
 } from "@rig/runtime/control-plane/provider/codex-exec-records";
 import { resolvePreferredShellBinary } from "@rig/runtime/control-plane/native/run-ops";
-import { readAuthorityRun as readAuthorityRun3, readJsonFile, resolveTaskArtifactDirs } from "@rig/runtime/control-plane/authority-files";
+import { readAuthorityRun as readAuthorityRun3, readJsonFile as readJsonFile2, resolveTaskArtifactDirs } from "@rig/runtime/control-plane/authority-files";
 import {
-  buildTaskRunLifecycleComment,
-  updateConfiguredTaskSourceTask
+  buildTaskRunLifecycleComment
 } from "@rig/runtime/control-plane/tasks/source-lifecycle";
 import {
   closeIssueAfterMergedPr,
   commitRunChanges,
+  pushBranchSyncedWithOrigin,
   runPrAutomation
 } from "@rig/runtime/control-plane/native/pr-automation";
 
@@ -54,12 +61,17 @@ import {
 import { readFileSync } from "fs";
 import { resolve as resolve3 } from "path";
 import {
-  appendJsonlRecord,
+  appendRunJournalEvent,
+  appendRunLogEntry,
+  appendRunTimelineEntry,
+  patchAuthorityRunRecord,
   readAuthorityRun as readAuthorityRun2,
-  resolveAuthorityRunDir as resolveAuthorityRunDir2,
-  writeJsonFile as writeJsonFile2
+  resolveAuthorityRunDir,
+  setAuthorityRunStatus,
+  writeJsonFile
 } from "@rig/runtime/control-plane/authority-files";
 import { taskLookup } from "@rig/runtime/control-plane/native/task-ops";
+import { readPriorPrProgressPromptSection } from "@rig/runtime/control-plane/prompt-context";
 import { buildProviderTaskRunInstructionLines } from "@rig/runtime/control-plane/provider/runtime-instructions";
 import { loadRigTaskRunSkillBody } from "@rig/runtime/control-plane/provider/rig-task-run-skill";
 
@@ -69,8 +81,7 @@ import { resolve as resolve2 } from "path";
 import {
   readAuthorityRun,
   readJsonlFile,
-  resolveAuthorityRunDir,
-  writeJsonFile
+  writeAuthorityRunRecord
 } from "@rig/runtime/control-plane/authority-files";
 
 // packages/cli/src/commands/_paths.ts
@@ -168,22 +179,26 @@ function upsertAgentAuthorityRun(projectRoot, input) {
   } else if ("errorText" in next) {
     delete next.errorText;
   }
-  writeJsonFile(resolve2(resolveAuthorityRunDir(projectRoot, input.runId), "run.json"), next);
+  writeAuthorityRunRecord(projectRoot, input.runId, next);
   return next;
 }
 
 // packages/cli/src/commands/_run-driver-helpers.ts
 function patchAuthorityRun(projectRoot, runId, patch) {
-  const current = readAuthorityRun2(projectRoot, runId);
-  if (!current) {
-    throw new CliError2(`Run not found: ${runId}`, 2);
+  const next = patchAuthorityRunRecord(projectRoot, runId, patch);
+  if (!next) {
+    throw new CliError(`Run not found: ${runId}`, 2, { hint: "Run `rig run list` to see recorded runs." });
+  }
+  return next;
+}
+function setRunStatusOrFail(projectRoot, runId, to, options = {}) {
+  const next = setAuthorityRunStatus(projectRoot, runId, to, {
+    ...options,
+    actor: { kind: "agent" }
+  });
+  if (!next) {
+    throw new CliError(`Run not found: ${runId}`, 2, { hint: "Run `rig run list` to see recorded runs." });
   }
-  const next = {
-    ...current,
-    ...patch,
-    updatedAt: new Date().toISOString()
-  };
-  writeJsonFile2(resolve3(resolveAuthorityRunDir2(projectRoot, runId), "run.json"), next);
   return next;
 }
 function touchAuthorityRun(projectRoot, runId) {
@@ -191,21 +206,21 @@ function touchAuthorityRun(projectRoot, runId) {
   if (!current) {
     return;
   }
-  writeJsonFile2(resolve3(resolveAuthorityRunDir2(projectRoot, runId), "run.json"), {
+  writeJsonFile(resolve3(resolveAuthorityRunDir(projectRoot, runId), "run.json"), {
     ...current,
     updatedAt: new Date().toISOString()
   });
 }
 function appendRunTimeline(projectRoot, runId, value) {
-  appendJsonlRecord(resolve3(resolveAuthorityRunDir2(projectRoot, runId), "timeline.jsonl"), value);
+  appendRunTimelineEntry(projectRoot, runId, value);
   touchAuthorityRun(projectRoot, runId);
 }
 function appendRunLog(projectRoot, runId, value) {
-  appendJsonlRecord(resolve3(resolveAuthorityRunDir2(projectRoot, runId), "logs.jsonl"), value);
+  appendRunLogEntry(projectRoot, runId, value);
   touchAuthorityRun(projectRoot, runId);
 }
 function appendRunAction(projectRoot, runId, value) {
-  appendJsonlRecord(resolve3(resolveAuthorityRunDir2(projectRoot, runId), "timeline.jsonl"), {
+  appendRunTimelineEntry(projectRoot, runId, {
     id: value.id,
     type: "action",
     actionType: value.actionType,
@@ -259,8 +274,43 @@ function startRunAction(projectRoot, runId, input) {
     }
   };
 }
+var runEventSinkProjectRoot = null;
+function configureRunEventSink(projectRoot) {
+  runEventSinkProjectRoot = projectRoot;
+}
+var lastDoorbellRangAt = 0;
+function ringServerRunDoorbell(runId) {
+  const serverUrl = process.env.RIG_SERVER_URL?.trim();
+  if (!serverUrl)
+    return;
+  const now = Date.now();
+  if (now - lastDoorbellRangAt < 250)
+    return;
+  lastDoorbellRangAt = now;
+  const token = process.env.RIG_AUTH_TOKEN || process.env.RIG_GITHUB_TOKEN || "";
+  fetch(`${serverUrl.replace(/\/+$/, "")}/api/runs/doorbell`, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${token}`
+    },
+    body: JSON.stringify({ runId }),
+    signal: AbortSignal.timeout(1000)
+  }).catch(() => {});
+}
 function emitServerRunEvent(event) {
   console.log(`__RIG_RUN_EVENT__${JSON.stringify({ ...event, at: new Date().toISOString() })}`);
+  if (runEventSinkProjectRoot) {
+    try {
+      if (event.type === "status" || event.type === "completed" || event.type === "failed") {
+        appendRunJournalEvent(runEventSinkProjectRoot, event.runId, {
+          type: "timeline-entry",
+          payload: { kind: "driver-event", ...event }
+        });
+      }
+    } catch {}
+    ringServerRunDoorbell(event.runId);
+  }
 }
 function buildRunPrompt(input) {
   const initialPrompt = input.initialPrompt?.trim() || null;
@@ -317,6 +367,7 @@ ${acceptance}` : null,
 ${sourceContractLines.join(`
 `)}` : null,
     scopeText || renderSourceScopeValidation(sourceTask, sourceValidation) || null,
+    readPriorPrProgressPromptSection(input.projectRoot, input.taskId),
     initialPrompt ? `Additional operator guidance:
 ${initialPrompt}` : null,
     providerLines.length > 0 ? `Provider-specific runtime tooling:
@@ -388,6 +439,324 @@ function renderSourceScopeValidation(task, validation) {
 `);
 }
 
+// packages/cli/src/commands/_server-client.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
+import { resolve as resolve5 } from "path";
+import { ensureLocalRigServerConnection } from "@rig/runtime/local-server";
+
+// packages/cli/src/commands/_connection-state.ts
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, resolve as resolve4 } from "path";
+function resolveGlobalConnectionsPath(env = process.env) {
+  const explicit = env.RIG_CONNECTIONS_FILE?.trim();
+  if (explicit)
+    return resolve4(explicit);
+  const stateDir = env.RIG_GLOBAL_STATE_DIR?.trim();
+  if (stateDir)
+    return resolve4(stateDir, "connections.json");
+  return resolve4(homedir(), ".rig", "connections.json");
+}
+function resolveRepoConnectionPath(projectRoot) {
+  return resolve4(projectRoot, ".rig", "state", "connection.json");
+}
+function readJsonFile(path) {
+  if (!existsSync2(path))
+    return null;
+  try {
+    return JSON.parse(readFileSync2(path, "utf8"));
+  } catch (error) {
+    throw new CliError(`Invalid Rig connection state at ${path}: ${error instanceof Error ? error.message : String(error)}`, 1, { hint: "Fix or delete that file, then re-select a server with `rig server use <alias|local>`." });
+  }
+}
+function writeJsonFile2(path, value) {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+}
+function normalizeConnection(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return null;
+  const record = value;
+  if (record.kind === "local")
+    return { kind: "local", mode: "auto" };
+  if (record.kind === "remote" && typeof record.baseUrl === "string" && record.baseUrl.trim()) {
+    const baseUrl = record.baseUrl.trim().replace(/\/+$/, "");
+    return { kind: "remote", baseUrl };
+  }
+  return null;
+}
+function readGlobalConnections(options = {}) {
+  const path = resolveGlobalConnectionsPath(options.env ?? process.env);
+  const payload = readJsonFile(path);
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    return { connections: {} };
+  }
+  const rawConnections = payload.connections;
+  const connections = {};
+  if (rawConnections && typeof rawConnections === "object" && !Array.isArray(rawConnections)) {
+    for (const [alias, raw] of Object.entries(rawConnections)) {
+      const connection = normalizeConnection(raw);
+      if (connection)
+        connections[alias] = connection;
+    }
+  }
+  return { connections };
+}
+function readRepoConnection(projectRoot) {
+  const payload = readJsonFile(resolveRepoConnectionPath(projectRoot));
+  if (!payload || typeof payload !== "object" || Array.isArray(payload))
+    return null;
+  const record = payload;
+  const selected = typeof record.selected === "string" ? record.selected.trim() : "";
+  if (!selected)
+    return null;
+  return {
+    selected,
+    project: typeof record.project === "string" ? record.project : undefined,
+    linkedAt: typeof record.linkedAt === "string" ? record.linkedAt : undefined,
+    serverProjectRoot: typeof record.serverProjectRoot === "string" && record.serverProjectRoot.trim() ? record.serverProjectRoot.trim() : undefined
+  };
+}
+function writeRepoConnection(projectRoot, state) {
+  writeJsonFile2(resolveRepoConnectionPath(projectRoot), state);
+}
+function resolveSelectedConnection(projectRoot, options = {}) {
+  const repo = readRepoConnection(projectRoot);
+  if (!repo)
+    return null;
+  if (repo.selected === "local")
+    return { alias: "local", connection: { kind: "local", mode: "auto" }, serverProjectRoot: repo.serverProjectRoot };
+  const global = readGlobalConnections(options);
+  const connection = global.connections[repo.selected];
+  if (!connection) {
+    throw new CliError(`Selected Rig server "${repo.selected}" was not found. Run \`rig server list\` or \`rig server use local\`.`, 1);
+  }
+  return { alias: repo.selected, connection, serverProjectRoot: repo.serverProjectRoot };
+}
+function writeRepoServerProjectRoot(projectRoot, serverProjectRoot) {
+  const repo = readRepoConnection(projectRoot);
+  if (!repo)
+    return;
+  writeRepoConnection(projectRoot, { ...repo, serverProjectRoot });
+}
+
+// packages/cli/src/commands/_server-client.ts
+var scopedGitHubBearerTokens = new Map;
+var serverPhaseListener = null;
+function reportServerPhase(label) {
+  serverPhaseListener?.(label);
+}
+function cleanToken(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : null;
+}
+function readPrivateRemoteSessionToken(projectRoot) {
+  const path = resolve5(projectRoot, ".rig", "state", "github-auth.json");
+  if (!existsSync3(path))
+    return null;
+  try {
+    const parsed = JSON.parse(readFileSync3(path, "utf8"));
+    return cleanToken(typeof parsed.apiSessionToken === "string" ? parsed.apiSessionToken : typeof parsed.sessionToken === "string" ? parsed.sessionToken : undefined);
+  } catch {
+    return null;
+  }
+}
+function readGitHubBearerTokenForRemote(projectRoot) {
+  const scopedKey = resolve5(projectRoot);
+  if (scopedGitHubBearerTokens.has(scopedKey))
+    return scopedGitHubBearerTokens.get(scopedKey) ?? null;
+  const privateSession = readPrivateRemoteSessionToken(projectRoot);
+  if (privateSession)
+    return privateSession;
+  return cleanToken(process.env.RIG_SERVER_AUTH_TOKEN) ?? cleanToken(process.env.RIG_REMOTE_AUTH_TOKEN);
+}
+function readStoredGitHubAuthToken(projectRoot) {
+  const path = resolve5(projectRoot, ".rig", "state", "github-auth.json");
+  if (!existsSync3(path))
+    return null;
+  try {
+    const parsed = JSON.parse(readFileSync3(path, "utf8"));
+    return cleanToken(typeof parsed.token === "string" ? parsed.token : undefined);
+  } catch {
+    return null;
+  }
+}
+function readLocalConnectionFallbackToken(projectRoot) {
+  return readGitHubBearerTokenForRemote(projectRoot) ?? cleanToken(process.env.RIG_GITHUB_TOKEN) ?? readStoredGitHubAuthToken(projectRoot);
+}
+async function ensureServerForCli(projectRoot) {
+  try {
+    const selected = resolveSelectedConnection(projectRoot);
+    if (selected?.connection.kind === "remote") {
+      reportServerPhase(`Connecting to ${selected.alias}\u2026`);
+      const authToken = readGitHubBearerTokenForRemote(projectRoot);
+      const serverProjectRoot = selected.serverProjectRoot ?? await backfillRemoteServerProjectRoot(projectRoot, selected.connection.baseUrl, authToken);
+      return {
+        baseUrl: selected.connection.baseUrl,
+        authToken,
+        connectionKind: "remote",
+        serverProjectRoot
+      };
+    }
+    reportServerPhase("Starting local Rig server\u2026");
+    const connection = await ensureLocalRigServerConnection(projectRoot);
+    return {
+      baseUrl: connection.baseUrl,
+      authToken: connection.authToken ?? readLocalConnectionFallbackToken(projectRoot),
+      connectionKind: "local",
+      serverProjectRoot: resolve5(projectRoot)
+    };
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new CliError(error.message, 1);
+    }
+    throw error;
+  }
+}
+async function backfillRemoteServerProjectRoot(projectRoot, baseUrl, authToken) {
+  const repo = readRepoConnection(projectRoot);
+  const slug = repo?.project?.trim();
+  if (!slug)
+    return null;
+  try {
+    const response = await fetch(`${baseUrl}/api/projects/${encodeURIComponent(slug)}`, {
+      headers: mergeHeaders(undefined, authToken)
+    });
+    if (!response.ok)
+      return null;
+    const payload = await response.json();
+    const project = payload.project && typeof payload.project === "object" && !Array.isArray(payload.project) ? payload.project : null;
+    const checkouts = Array.isArray(project?.checkouts) ? project.checkouts : [];
+    const latestCheckout = [...checkouts].reverse().find((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry) && typeof entry.path === "string"));
+    const path = typeof latestCheckout?.path === "string" && latestCheckout.path.trim() ? latestCheckout.path.trim() : null;
+    if (path)
+      writeRepoServerProjectRoot(projectRoot, path);
+    return path;
+  } catch {
+    return null;
+  }
+}
+function mergeHeaders(headers, authToken) {
+  const merged = new Headers(headers);
+  if (authToken) {
+    merged.set("authorization", `Bearer ${authToken}`);
+  }
+  return merged;
+}
+function diagnosticMessage(payload) {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload))
+    return null;
+  const record = payload;
+  const diagnostics = Array.isArray(record.diagnostics) ? record.diagnostics : [];
+  const messages = diagnostics.flatMap((entry) => {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry))
+      return [];
+    const diagnostic = entry;
+    const kind = typeof diagnostic.kind === "string" ? diagnostic.kind : "task-source";
+    const message = typeof diagnostic.message === "string" ? diagnostic.message : null;
+    return message ? [`${kind}: ${message}`] : [];
+  });
+  return messages.length > 0 ? messages.join("; ") : null;
+}
+var serverReachabilityCache = new Map;
+async function probeServerReachability(baseUrl, authToken) {
+  try {
+    const response = await fetch(`${baseUrl.replace(/\/+$/, "")}/api/server/status`, {
+      headers: mergeHeaders(undefined, authToken),
+      signal: AbortSignal.timeout(1500)
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+function cachedServerReachability(projectRoot, baseUrl, authToken) {
+  const key = resolve5(projectRoot);
+  const cached = serverReachabilityCache.get(key);
+  if (cached)
+    return cached;
+  const probe = probeServerReachability(baseUrl, authToken);
+  serverReachabilityCache.set(key, probe);
+  return probe;
+}
+function describeSelectedServer(projectRoot, server) {
+  try {
+    const selected = resolveSelectedConnection(projectRoot);
+    if (selected) {
+      return {
+        alias: selected.alias,
+        target: selected.connection.kind === "remote" ? selected.connection.baseUrl : server.baseUrl
+      };
+    }
+  } catch {}
+  return { alias: server.connectionKind === "remote" ? "remote" : "local", target: server.baseUrl };
+}
+async function buildServerFailureContext(projectRoot, server) {
+  const { alias, target } = describeSelectedServer(projectRoot, server);
+  const reachable = await cachedServerReachability(projectRoot, server.baseUrl, server.authToken);
+  const reachability = reachable ? "server is reachable" : "server is unreachable";
+  return {
+    contextLine: `Currently connected to: ${alias} at ${target} (${reachability}).`,
+    hint: "Check the selected server with `rig server status`, or switch with `rig server use <alias|local>`."
+  };
+}
+async function requestServerJson(context, pathname, init = {}) {
+  const server = await ensureServerForCli(context.projectRoot);
+  const headers = mergeHeaders(init.headers, server.authToken);
+  if (server.serverProjectRoot)
+    headers.set("x-rig-project-root", server.serverProjectRoot);
+  reportServerPhase(`${(init.method ?? "GET").toUpperCase()} ${pathname.split("?")[0]}\u2026`);
+  let response;
+  try {
+    response = await fetch(`${server.baseUrl}${pathname}`, {
+      ...init,
+      headers
+    });
+  } catch (error) {
+    const failure = await buildServerFailureContext(context.projectRoot, server);
+    throw new CliError(`Rig server request failed: ${error instanceof Error ? error.message : String(error)}
+${failure.contextLine}`, 1, { hint: failure.hint });
+  }
+  const text = await response.text();
+  const payload = text.trim().length > 0 ? (() => {
+    try {
+      return JSON.parse(text);
+    } catch {
+      return null;
+    }
+  })() : null;
+  if (!response.ok) {
+    const diagnostics = diagnosticMessage(payload);
+    const rawDetail = diagnostics ?? (text || response.statusText);
+    const detail = diagnostics ? rawDetail : rawDetail.split(`
+`).map((line) => line.trim()).find((line) => line.length > 0)?.slice(0, 200) ?? response.statusText;
+    const failure = await buildServerFailureContext(context.projectRoot, server);
+    throw new CliError(`Rig server request failed (${response.status}): ${detail}
+${failure.contextLine}`, 1, { hint: failure.hint });
+  }
+  return payload;
+}
+async function updateWorkspaceTaskViaServer(context, input) {
+  const payload = await requestServerJson(context, "/api/tasks/update", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(input)
+  });
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { ok: true };
+}
+var RESUMABLE_RUN_STATUSES = new Set([
+  "created",
+  "preparing",
+  "running",
+  "validating",
+  "reviewing",
+  "stopped",
+  "failed",
+  "needs-attention",
+  "needs_attention"
+]);
+
 // packages/cli/src/commands/task-run-driver.ts
 var PI_CANONICAL_RUN_STAGES = [
   "Connect",
@@ -412,6 +781,19 @@ function looksLikeGitHubToken(value) {
     return false;
   return /^(gh[opusr]_|github_pat_)/.test(token);
 }
+function isSensitivePayloadKey(key) {
+  return /token|secret|password|authorization|credential/i.test(key);
+}
+function redactSensitivePayload(value) {
+  if (Array.isArray(value))
+    return value.map(redactSensitivePayload);
+  if (!value || typeof value !== "object")
+    return value;
+  return Object.fromEntries(Object.entries(value).map(([key, child]) => [
+    key,
+    isSensitivePayloadKey(key) && typeof child === "string" && child.trim() ? "[redacted]" : redactSensitivePayload(child)
+  ]));
+}
 function githubBridgeEnv(token) {
   const clean = token?.trim();
   if (!clean)
@@ -431,6 +813,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)
@@ -455,12 +838,12 @@ function copyUntrackedDirtyFiles(sourceRoot, targetRoot) {
     return 0;
   let copied = 0;
   for (const relativePath of listed.stdout.split("\x00").filter(Boolean)) {
-    const sourcePath = resolve4(sourceRoot, relativePath);
-    const targetPath = resolve4(targetRoot, relativePath);
+    const sourcePath = resolve6(sourceRoot, relativePath);
+    const targetPath = resolve6(targetRoot, relativePath);
     try {
       if (!statSync(sourcePath).isFile())
         continue;
-      mkdirSync(resolve4(targetPath, ".."), { recursive: true });
+      mkdirSync2(resolve6(targetPath, ".."), { recursive: true });
       copyFileSync(sourcePath, targetPath);
       copied += 1;
     } catch {}
@@ -499,7 +882,7 @@ function buildDirtyBaselineHandshakeEnv(input) {
     return { RIG_BASELINE_MODE: input.baselineMode ?? "head" };
   return {
     RIG_BASELINE_MODE: "dirty-snapshot",
-    RIG_DIRTY_BASELINE_READY_FILE: resolve4(input.projectRoot, ".rig", "runs", input.runId, "dirty-baseline.ready.json")
+    RIG_DIRTY_BASELINE_READY_FILE: resolve6(input.projectRoot, ".rig", "runs", input.runId, "dirty-baseline.ready.json")
   };
 }
 function positiveInt(value, fallback) {
@@ -507,7 +890,7 @@ function positiveInt(value, fallback) {
 }
 function resolveTaskRunAutomationLimits(config, env = process.env) {
   const configuredValidationAttempts = positiveInt(config?.automation?.maxValidationAttempts, 30);
-  const configuredPrFixIterations = positiveInt(config?.automation?.maxPrFixIterations, 30);
+  const configuredPrFixIterations = positiveInt(config?.automation?.maxPrFixIterations, 100500);
   return {
     maxValidationAttempts: parsePositiveInt(env.RIG_TASK_RUN_MAX_ATTEMPTS, "RIG_TASK_RUN_MAX_ATTEMPTS", configuredValidationAttempts),
     maxPrFixIterations: configuredPrFixIterations
@@ -601,12 +984,6 @@ function appendPiStageLog(input) {
   });
   emitServerRunEvent({ type: "log", runId: input.runId, title: input.stage });
 }
-async function runCheckedCommand(command, args, cwd, label = "git") {
-  const result = await command(args, { cwd });
-  if (result.exitCode !== 0) {
-    throw new Error(`${label} ${args.join(" ")} failed (${result.exitCode}): ${result.stderr ?? result.stdout ?? ""}`.trim());
-  }
-}
 function createCommandRunner(binary) {
   return async (args, options) => {
     const child = spawn(binary, [...args], {
@@ -617,9 +994,9 @@ function createCommandRunner(binary) {
     const stderrChunks = [];
     child.stdout.on("data", (chunk) => stdoutChunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk))));
     child.stderr.on("data", (chunk) => stderrChunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk))));
-    return await new Promise((resolve5) => {
-      child.once("error", (error) => resolve5({ exitCode: 1, stderr: error.message }));
-      child.once("close", (code) => resolve5({
+    return await new Promise((resolve7) => {
+      child.once("error", (error) => resolve7({ exitCode: 1, stderr: error.message }));
+      child.once("close", (code) => resolve7({
         exitCode: code ?? 1,
         stdout: Buffer.concat(stdoutChunks).toString("utf8"),
         stderr: Buffer.concat(stderrChunks).toString("utf8")
@@ -643,8 +1020,9 @@ async function runTaskRunPostValidationLifecycle(input) {
   if (!taskId) {
     return { status: "skipped" };
   }
-  const config = input.config ?? {};
-  const prMode = config.pr?.mode ?? "auto";
+  const configInput = input.config ?? null;
+  const config = configInput ?? {};
+  const prMode = configInput ? configInput.pr?.mode ?? "auto" : "off";
   if (prMode === "off" || prMode === "ask") {
     input.appendStage?.("Open PR", prMode === "off" ? "PR automation disabled by pr.mode=off." : "PR creation awaiting operator approval by pr.mode=ask.", "skipped", "info");
     input.appendStage?.("Complete", "Validation completed; no PR was opened and the issue was left open.", "completed", "info");
@@ -660,7 +1038,7 @@ async function runTaskRunPostValidationLifecycle(input) {
     gitCommand
   });
   const prAutomation = input.prAutomation ?? runPrAutomation;
-  const updateTaskSource = input.updateTaskSource ?? updateConfiguredTaskSourceTask;
+  const updateTaskSource = input.updateTaskSource ?? updateTaskSourceWithProjectSync;
   const stage = input.appendStage ?? (() => {
     return;
   });
@@ -682,7 +1060,7 @@ async function runTaskRunPostValidationLifecycle(input) {
     command: gitCommand
   });
   stage("Commit", commit.committed ? "Committed run workspace changes." : "No workspace changes to commit.", "completed", "tool");
-  await runCheckedCommand(gitCommand, ["push", "--set-upstream", "origin", branch], workspace, "git");
+  await pushBranchSyncedWithOrigin({ projectRoot: workspace, branch, gitCommand });
   stage("Open PR", `Opening PR from ${branch}.`, "running", "tool");
   const pr = await prAutomation({
     projectRoot: workspace,
@@ -692,7 +1070,9 @@ async function runTaskRunPostValidationLifecycle(input) {
     config,
     sourceTask: input.sourceTask,
     uploadedSnapshot: input.uploadedSnapshot,
+    artifactRoot: resolve6(input.projectRoot, "artifacts", taskId),
     command: ghCommand,
+    gitCommand,
     steerPi,
     lifecycle: {
       onPrOpened: async ({ prUrl }) => {
@@ -741,8 +1121,6 @@ async function runTaskRunPostValidationLifecycle(input) {
                 runtimeWorkspace: input.runtimeWorkspace ?? null
               })
             }
-          }).catch(() => {
-            return;
           });
         }
       },
@@ -761,8 +1139,6 @@ async function runTaskRunPostValidationLifecycle(input) {
                 runtimeWorkspace: input.runtimeWorkspace ?? null
               })
             }
-          }).catch(() => {
-            return;
           });
         }
       },
@@ -791,8 +1167,17 @@ async function runTaskRunPostValidationLifecycle(input) {
             errorText: detail
           })
         }
-      }).catch(() => {
-        return;
+      }).catch((error) => {
+        try {
+          appendRunLog(input.projectRoot, input.runId, {
+            id: `log:${input.runId}:task-source-needs-attention-update`,
+            title: "Task source needs-attention update failed",
+            detail: error instanceof Error ? error.message : String(error),
+            tone: "error",
+            status: "needs_attention",
+            createdAt: new Date().toISOString()
+          });
+        } catch {}
       });
     }
     return { status: "needs_attention", pr };
@@ -815,7 +1200,7 @@ function summarizeValidationFailure(projectRoot, taskId) {
     return null;
   }
   for (const artifactDir of resolveTaskArtifactDirs(projectRoot, taskId)) {
-    const summary = readJsonFile(resolve4(artifactDir, "validation-summary.json"), null);
+    const summary = readJsonFile2(resolve6(artifactDir, "validation-summary.json"), null);
     if (!summary || summary.status !== "fail") {
       continue;
     }
@@ -888,7 +1273,7 @@ function parsePositiveInt(value, option, fallback) {
   }
   const parsed = Number.parseInt(value, 10);
   if (!Number.isFinite(parsed) || parsed <= 0) {
-    throw new CliError2(`Invalid ${option} value: ${value}`);
+    throw new CliError(`Invalid ${option} value: ${value}`, 1, { hint: `Pass a positive integer, e.g. \`${option} 10\`.` });
   }
   return parsed;
 }
@@ -896,14 +1281,14 @@ function readTaskRunAcceptedArtifactState(input) {
   if (!input.taskId || !input.workspaceDir) {
     return { accepted: false, reason: null };
   }
-  const artifactDir = resolve4(input.workspaceDir, "artifacts", input.taskId);
-  const reviewStatusPath = resolve4(artifactDir, "review-status.txt");
-  const taskResultPath = resolve4(artifactDir, "task-result.json");
+  const artifactDir = resolve6(input.workspaceDir, "artifacts", input.taskId);
+  const reviewStatusPath = resolve6(artifactDir, "review-status.txt");
+  const taskResultPath = resolve6(artifactDir, "task-result.json");
   const reviewStatus = readTaskRunReviewStatus(reviewStatusPath);
   if (reviewStatus !== "APPROVED") {
     return { accepted: false, reason: null };
   }
-  const taskResult = readJsonFile(taskResultPath, null);
+  const taskResult = readJsonFile2(taskResultPath, null);
   if (taskResult?.status !== "completed") {
     return { accepted: false, reason: null };
   }
@@ -935,13 +1320,13 @@ function resolveTaskRunRetryContext(input) {
   if (!input.taskId || !input.workspaceDir) {
     return { shouldRetry: false, failureDetail: null, nextPrompt: null };
   }
-  const artifactDir = resolve4(input.workspaceDir, "artifacts", input.taskId);
-  const reviewStatePath = resolve4(artifactDir, "review-state.json");
-  const reviewFeedbackPath = resolve4(artifactDir, "review-feedback.md");
-  const reviewStatusPath = resolve4(artifactDir, "review-status.txt");
-  const failedApproachesPath = resolve4(input.workspaceDir, ".rig", "state", "failed_approaches.md");
-  const validationSummaryPath = resolve4(artifactDir, "validation-summary.json");
-  const reviewState = readJsonFile(reviewStatePath, null);
+  const artifactDir = resolve6(input.workspaceDir, "artifacts", input.taskId);
+  const reviewStatePath = resolve6(artifactDir, "review-state.json");
+  const reviewFeedbackPath = resolve6(artifactDir, "review-feedback.md");
+  const reviewStatusPath = resolve6(artifactDir, "review-status.txt");
+  const failedApproachesPath = resolve6(input.workspaceDir, ".rig", "state", "failed_approaches.md");
+  const validationSummaryPath = resolve6(artifactDir, "validation-summary.json");
+  const reviewState = readJsonFile2(reviewStatePath, null);
   const reviewStatus = readTaskRunReviewStatus(reviewStatusPath);
   const reviewRejected = isTaskRunReviewRejected(reviewState);
   if (reviewStatus === "APPROVED") {
@@ -994,12 +1379,143 @@ function summarizeTaskRunReviewFailure(reviewState) {
   }
   return "Completion verification rejected the task. Read review-feedback.md for required fixes.";
 }
+function appendAssistantTimelineFromRecord(input) {
+  let nextAssistantText = input.assistantText;
+  if (input.record.type === "message_update") {
+    const assistantMessageEvent = input.record.assistantMessageEvent && typeof input.record.assistantMessageEvent === "object" ? input.record.assistantMessageEvent : null;
+    if (assistantMessageEvent?.type === "text_delta" && typeof assistantMessageEvent.delta === "string") {
+      nextAssistantText += assistantMessageEvent.delta;
+    }
+  } else if (input.record.type === "stream_event") {
+    const event = input.record.event && typeof input.record.event === "object" ? input.record.event : null;
+    const delta = event?.delta && typeof event.delta === "object" ? event.delta : null;
+    if (delta?.type === "text_delta" && typeof delta.text === "string") {
+      nextAssistantText += delta.text;
+    }
+  } else if (input.record.type === "assistant") {
+    const message = input.record.message && typeof input.record.message === "object" ? input.record.message : input.record;
+    const content = Array.isArray(message.content) ? message.content : [];
+    const fullText = content.map((entry) => entry && typeof entry === "object" && entry.type === "text" ? String(entry.text ?? "") : "").join("");
+    if (fullText.length > nextAssistantText.length)
+      nextAssistantText = fullText;
+  }
+  if (nextAssistantText !== input.assistantText) {
+    appendRunTimeline(input.projectRoot, input.runId, {
+      id: input.messageId,
+      type: "assistant_message",
+      text: nextAssistantText,
+      state: "streaming",
+      createdAt: new Date().toISOString()
+    });
+  }
+  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")
+    return false;
+  const toolCallId = typeof input.record.toolCallId === "string" && input.record.toolCallId.trim() ? input.record.toolCallId.trim() : `${Date.now()}`;
+  const toolName = typeof input.record.toolName === "string" && input.record.toolName.trim() ? input.record.toolName.trim() : "tool";
+  const result = input.record.result && typeof input.record.result === "object" && !Array.isArray(input.record.result) ? input.record.result : null;
+  appendRunTimeline(input.projectRoot, input.runId, {
+    id: `tool:${toolCallId}:${type}`,
+    type,
+    toolName,
+    status: type === "tool_execution_end" ? input.record.isError === true || result?.isError === true ? "failed" : "completed" : "running",
+    createdAt: new Date().toISOString()
+  });
+  return true;
+}
+function isNonRenderablePiProtocolRecord(record) {
+  const type = typeof record.type === "string" ? record.type : "";
+  return type === "pi.event" || type === "status.update" || type === "activity.update" || type === "ready" || 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 : "";
+  if (title !== "Tool activity")
+    return;
+  const payload = input.log.payload && typeof input.log.payload === "object" && !Array.isArray(input.log.payload) ? input.log.payload : {};
+  const toolName = typeof payload.toolName === "string" && payload.toolName.trim() ? payload.toolName.trim() : typeof payload.tool_name === "string" && payload.tool_name.trim() ? payload.tool_name.trim() : null;
+  const logId = typeof input.log.id === "string" && input.log.id.trim() ? input.log.id.trim() : `${Date.now()}`;
+  appendRunTimeline(input.projectRoot, input.runId, {
+    id: `tool:${logId}`,
+    type: "tool_execution_update",
+    toolName,
+    status: typeof input.log.status === "string" ? input.log.status : "running",
+    detail: typeof input.log.detail === "string" ? input.log.detail : null,
+    payload,
+    createdAt: typeof input.log.createdAt === "string" ? input.log.createdAt : new Date().toISOString()
+  });
+}
 function readTaskRunReviewStatus(reviewStatusPath) {
-  if (!existsSync2(reviewStatusPath)) {
+  if (!existsSync4(reviewStatusPath)) {
     return null;
   }
   try {
-    const status = readFileSync2(reviewStatusPath, "utf8").trim().toUpperCase();
+    const status = readFileSync4(reviewStatusPath, "utf8").trim().toUpperCase();
     return status === "APPROVED" || status === "REJECTED" ? status : null;
   } catch {
     return null;
@@ -1017,7 +1533,38 @@ function isTaskRunReviewRejected(reviewState) {
 function runSourceTaskIdentity(sourceTask) {
   return sourceTask;
 }
-async function updateTaskSourceAfterDriverRun(projectRoot, runId, taskId, sourceTask, status, summary, input, updateTaskSource = updateConfiguredTaskSourceTask) {
+function sourceTaskIssueNodeId(sourceTask) {
+  if (!sourceTask || typeof sourceTask !== "object" || Array.isArray(sourceTask))
+    return null;
+  const record = sourceTask;
+  const direct = typeof record.issueNodeId === "string" ? record.issueNodeId : typeof record.nodeId === "string" ? record.nodeId : typeof record.node_id === "string" ? record.node_id : null;
+  if (direct?.trim())
+    return direct.trim();
+  const raw = record.raw && typeof record.raw === "object" && !Array.isArray(record.raw) ? record.raw : null;
+  return typeof raw?.id === "string" && raw.id.trim() ? raw.id.trim() : null;
+}
+var updateTaskSourceWithProjectSync = async (projectRoot, input) => {
+  const serverResult = await updateWorkspaceTaskViaServer({ projectRoot }, {
+    id: input.taskId,
+    ...input.update.status ? { status: input.update.status } : {},
+    ...input.update.comment ? { comment: input.update.comment } : {},
+    ...input.update.title ? { title: input.update.title } : {},
+    ...typeof input.update.body === "string" ? { body: input.update.body } : {},
+    issueNodeId: sourceTaskIssueNodeId(input.sourceTask)
+  });
+  if (serverResult.ok === false) {
+    throw new Error(typeof serverResult.error === "string" ? serverResult.error : "Rig server task update failed.");
+  }
+  return {
+    updated: serverResult.ok !== false,
+    taskId: input.taskId,
+    status: input.update.status,
+    source: "server",
+    sourceKind: "server",
+    projectSync: serverResult.projectSync
+  };
+};
+async function updateTaskSourceAfterDriverRun(projectRoot, runId, taskId, sourceTask, status, summary, input, updateTaskSource = updateTaskSourceWithProjectSync) {
   if (!taskId)
     return;
   const config = await loadTaskRunAutomationConfig(projectRoot);
@@ -1081,9 +1628,14 @@ function stringArrayField(record, key) {
   return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
 }
 async function executeRigOwnedTaskRun(context, input) {
+  process.stdout.on("error", () => {});
+  process.stderr.on("error", () => {});
+  configureRunEventSink(context.projectRoot);
   const runtimeTaskId = input.taskId?.trim() || `adhoc-${input.runId}`;
   const existingRunRecord = readAuthorityRun3(context.projectRoot, input.runId);
   const resumeMode = process.env.RIG_RUN_RESUME === "1";
+  let latestPiSessionId = typeof existingRunRecord?.piSession?.sessionId === "string" && existingRunRecord.piSession.sessionId.trim() ? existingRunRecord.piSession.sessionId : null;
+  const sessionAnchor = () => latestPiSessionId ? { sessionId: latestPiSessionId } : {};
   const resumePreviousStatus = String(existingRunRecord?.status ?? "").toLowerCase();
   const sourceTask = readRunSourceTaskContract(context.projectRoot, input.runId, input.taskId);
   let prompt = buildRunPrompt({
@@ -1107,11 +1659,7 @@ async function executeRigOwnedTaskRun(context, input) {
     ...input.model ? ["--model", input.model] : [],
     "--prompt"
   ] : input.runtimeAdapter === "pi" ? [
-    "--print",
-    "--verbose",
-    "--mode",
-    "json",
-    "--no-session",
+    "__rig_pi_session_daemon__",
     ...input.model ? ["--model", input.model] : []
   ] : [
     "--print",
@@ -1142,8 +1690,8 @@ async function executeRigOwnedTaskRun(context, input) {
     runtimeAdapter: input.runtimeAdapter,
     status: resumeMode ? "preparing" : "created"
   });
+  setRunStatusOrFail(context.projectRoot, input.runId, "preparing", { reason: "driver-start" });
   patchAuthorityRun(context.projectRoot, input.runId, {
-    status: "preparing",
     startedAt,
     completedAt: null,
     errorText: null,
@@ -1160,7 +1708,8 @@ async function executeRigOwnedTaskRun(context, input) {
     type: "status",
     runId: input.runId,
     status: "preparing",
-    detail: input.taskId ?? input.title ?? runtimeTaskId
+    detail: input.taskId ?? input.title ?? runtimeTaskId,
+    ...sessionAnchor()
   });
   appendRunLog(context.projectRoot, input.runId, {
     id: `log:${input.runId}:${resumeMode ? "resume" : "start"}`,
@@ -1186,15 +1735,15 @@ async function executeRigOwnedTaskRun(context, input) {
   const loadedAutomationConfig = await loadTaskRunAutomationConfig(context.projectRoot);
   const automationConfig = input.prMode ? { ...loadedAutomationConfig ?? {}, pr: { ...loadedAutomationConfig?.pr ?? {}, mode: input.prMode } } : loadedAutomationConfig;
   const planningClassification = classifyPlanningNeed({ config: automationConfig, sourceTask });
-  const planningArtifactPath = resolve4("artifacts", runtimeTaskId, "implementation-plan.md");
+  const planningArtifactPath = resolve6("artifacts", runtimeTaskId, "implementation-plan.md");
   const persistedPlanning = {
     ...planningClassification,
     classifier: input.runtimeAdapter === "pi" ? "pi-rig-structured-policy" : "rig-structured-policy",
     artifactPath: planningClassification.planningRequired ? planningArtifactPath : null,
     classifiedAt: new Date().toISOString()
   };
-  mkdirSync(resolve4(context.projectRoot, ".rig", "runs", input.runId), { recursive: true });
-  writeFileSync(resolve4(context.projectRoot, ".rig", "runs", input.runId, "planning-classification.json"), `${JSON.stringify(persistedPlanning, null, 2)}
+  mkdirSync2(resolve6(context.projectRoot, ".rig", "runs", input.runId), { recursive: true });
+  writeFileSync2(resolve6(context.projectRoot, ".rig", "runs", input.runId, "planning-classification.json"), `${JSON.stringify(persistedPlanning, null, 2)}
 `, "utf8");
   patchAuthorityRun(context.projectRoot, input.runId, { planning: persistedPlanning });
   prompt = `${prompt}
@@ -1208,7 +1757,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" ? "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"
       });
     }
@@ -1244,11 +1793,12 @@ ${planningClassification.planningRequired ? `Before implementing, write a concis
   let verificationStarted = false;
   let reviewStarted = false;
   let latestRuntimeWorkspace = resumeMode && typeof existingRunRecord?.worktreePath === "string" ? existingRunRecord.worktreePath : null;
-  let latestSessionDir = resumeMode && typeof existingRunRecord?.sessionPath === "string" ? resolve4(existingRunRecord.sessionPath, "..") : null;
+  let latestSessionDir = resumeMode && typeof existingRunRecord?.sessionPath === "string" ? resolve6(existingRunRecord.sessionPath, "..") : null;
   let latestLogsDir = resumeMode && typeof existingRunRecord?.logRoot === "string" ? existingRunRecord.logRoot : null;
   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,
@@ -1279,8 +1829,8 @@ ${planningClassification.planningRequired ? `Before implementing, write a concis
     if (verificationStarted)
       return;
     verificationStarted = true;
-    patchAuthorityRun(context.projectRoot, input.runId, { status: "validating" });
-    emitServerRunEvent({ type: "status", runId: input.runId, status: "validating", detail: detail ?? null });
+    setRunStatusOrFail(context.projectRoot, input.runId, "validating");
+    emitServerRunEvent({ type: "status", runId: input.runId, status: "validating", detail: detail ?? null, ...sessionAnchor() });
     verificationAction = startRunAction(context.projectRoot, input.runId, {
       actionId: `action:${input.runId}:completion-verification`,
       actionType: "completion-verification",
@@ -1292,8 +1842,8 @@ ${planningClassification.planningRequired ? `Before implementing, write a concis
     if (reviewStarted)
       return;
     reviewStarted = true;
-    patchAuthorityRun(context.projectRoot, input.runId, { status: "reviewing" });
-    emitServerRunEvent({ type: "status", runId: input.runId, status: "reviewing", detail: detail ?? null });
+    setRunStatusOrFail(context.projectRoot, input.runId, "reviewing");
+    emitServerRunEvent({ type: "status", runId: input.runId, status: "reviewing", detail: detail ?? null, ...sessionAnchor() });
     reviewAction = startRunAction(context.projectRoot, input.runId, {
       actionId: `action:${input.runId}:review-closeout`,
       actionType: "run.review",
@@ -1301,6 +1851,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 {
@@ -1316,6 +1867,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,
@@ -1324,13 +1876,13 @@ ${planningClassification.planningRequired ? `Before implementing, write a concis
         logsDir: latestLogsDir,
         contextFile: payload.contextFile ?? null
       });
+      setRunStatusOrFail(context.projectRoot, input.runId, "running");
       patchAuthorityRun(context.projectRoot, input.runId, {
-        status: "running",
         worktreePath: latestRuntimeWorkspace,
-        artifactRoot: latestRuntimeWorkspace && input.taskId ? resolve4(latestRuntimeWorkspace, "artifacts", input.taskId) : null,
+        artifactRoot: latestRuntimeWorkspace && input.taskId ? resolve6(latestRuntimeWorkspace, "artifacts", input.taskId) : null,
         logRoot: latestLogsDir,
-        sessionPath: latestSessionDir ? resolve4(latestSessionDir, "session.json") : null,
-        sessionLogPath: latestLogsDir ? resolve4(latestLogsDir, "agent-stdout.log") : null,
+        sessionPath: latestSessionDir ? resolve6(latestSessionDir, "session.json") : null,
+        sessionLogPath: latestLogsDir ? resolve6(latestLogsDir, "agent-stdout.log") : null,
         branch: runtimeId
       });
       if (!dirtyBaselineApplied && input.baselineMode === "dirty-snapshot" && latestRuntimeWorkspace) {
@@ -1338,8 +1890,8 @@ ${planningClassification.planningRequired ? `Before implementing, write a concis
         const dirty = applyDirtyBaselineSnapshot({ sourceRoot: context.projectRoot, targetRoot: latestRuntimeWorkspace });
         const readyFile = childEnv.RIG_DIRTY_BASELINE_READY_FILE;
         if (readyFile) {
-          mkdirSync(resolve4(readyFile, ".."), { recursive: true });
-          writeFileSync(readyFile, `${JSON.stringify({ ...dirty, workspaceDir: latestRuntimeWorkspace, appliedAt: new Date().toISOString() }, null, 2)}
+          mkdirSync2(resolve6(readyFile, ".."), { recursive: true });
+          writeFileSync2(readyFile, `${JSON.stringify({ ...dirty, workspaceDir: latestRuntimeWorkspace, appliedAt: new Date().toISOString() }, null, 2)}
 `, "utf8");
         }
         appendRunLog(context.projectRoot, input.runId, {
@@ -1353,7 +1905,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,
@@ -1381,7 +1933,8 @@ ${planningClassification.planningRequired ? `Before implementing, write a concis
         type: "status",
         runId: input.runId,
         status: "running",
-        detail: latestRuntimeWorkspace
+        detail: latestRuntimeWorkspace,
+        ...sessionAnchor()
       });
       return true;
     }
@@ -1435,9 +1988,79 @@ ${planningClassification.planningRequired ? `Before implementing, write a concis
       }
       return true;
     }
-    return false;
+    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 ?? "") : "";
+        if (sessionId) {
+          latestPiSessionId = 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")}`;
+      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;
+    }
+    appendRunTimeline(context.projectRoot, input.runId, {
+      id: `timeline:${input.runId}:${Date.now()}:wrapper:${event.type}`,
+      type: "wrapper-event",
+      eventType: event.type,
+      payload: redactSensitivePayload(payload),
+      createdAt: new Date().toISOString()
+    });
+    emitServerRunEvent({ type: "timeline", runId: input.runId });
+    return true;
   };
-  const nextRunLogId = createRunLogIdFactory(input.runId);
   const handleAgentStdoutLine = (line) => {
     const trimmed = line.trim();
     if (!trimmed)
@@ -1471,6 +2094,19 @@ ${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;
+      }
       const providerLogs = input.runtimeAdapter === "codex" ? buildCodexLogsFromRecord({
         runId: input.runId,
         record,
@@ -1487,7 +2123,10 @@ ${planningClassification.planningRequired ? `Before implementing, write a concis
       if (providerLogs.length > 0) {
         for (const providerLog of providerLogs) {
           appendRunLog(context.projectRoot, input.runId, providerLog);
+          appendToolTimelineFromLog({ projectRoot: context.projectRoot, runId: input.runId, log: providerLog });
           emitServerRunEvent({ type: "log", runId: input.runId, title: providerLog.title });
+          if (providerLog.title === "Tool activity")
+            emitServerRunEvent({ type: "timeline", runId: input.runId });
         }
       }
       if (input.runtimeAdapter === "codex") {
@@ -1539,6 +2178,9 @@ ${planningClassification.planningRequired ? `Before implementing, write a concis
           return;
         }
       }
+      if (input.runtimeAdapter === "pi" && isNonRenderablePiProtocolRecord(record)) {
+        return;
+      }
       if (record.type === "assistant") {
         const message = record.message && typeof record.message === "object" ? record.message : record;
         const content = Array.isArray(message.content) ? message.content : [];
@@ -1645,7 +2287,7 @@ ${planningClassification.planningRequired ? `Before implementing, write a concis
     let acceptedArtifactObservedAt = null;
     let acceptedArtifactPollTimer = null;
     let acceptedArtifactKillTimer = null;
-    const attemptExit = await new Promise((resolve5) => {
+    const attemptExit = await new Promise((resolve7) => {
       let settled = false;
       const settle = (result) => {
         if (settled)
@@ -1653,7 +2295,7 @@ ${planningClassification.planningRequired ? `Before implementing, write a concis
         settled = true;
         if (acceptedArtifactPollTimer)
           clearInterval(acceptedArtifactPollTimer);
-        resolve5(result);
+        resolve7(result);
       };
       const pollAcceptedArtifacts = () => {
         const artifactState = readTaskRunAcceptedArtifactState({
@@ -1726,11 +2368,14 @@ ${planningClassification.planningRequired ? `Before implementing, write a concis
     });
     for (const pendingLog of pendingLogs) {
       appendRunLog(context.projectRoot, input.runId, pendingLog);
+      appendToolTimelineFromLog({ projectRoot: context.projectRoot, runId: input.runId, log: pendingLog });
       emitServerRunEvent({ type: "log", runId: input.runId, title: pendingLog.title });
+      if (pendingLog.title === "Tool activity")
+        emitServerRunEvent({ type: "timeline", runId: input.runId });
     }
     process.off("SIGTERM", forwardSigterm);
     if (attemptExit.error) {
-      throw new CliError2(`Task run failed to start: ${attemptExit.error.message}`, 1);
+      throw new CliError(`Task run failed to start: ${attemptExit.error.message}`, 1);
     }
     const retryContext = resolveTaskRunRetryContext({
       projectRoot: context.projectRoot,
@@ -1752,8 +2397,8 @@ ${planningClassification.planningRequired ? `Before implementing, write a concis
       currentPrompt = [retryContext.nextPrompt, "", "Rig Pi steering message:", retrySteering].join(`
 `);
       reviewFailureDetail = failureDetail;
+      setRunStatusOrFail(context.projectRoot, input.runId, "validating", { reason: "validation-retry" });
       patchAuthorityRun(context.projectRoot, input.runId, {
-        status: "validating",
         completedAt: null,
         errorText: null
       });
@@ -1777,7 +2422,8 @@ ${planningClassification.planningRequired ? `Before implementing, write a concis
         type: "status",
         runId: input.runId,
         status: "validating",
-        detail: failureDetail
+        detail: failureDetail,
+        ...sessionAnchor()
       });
       emitServerRunEvent({ type: "log", runId: input.runId, title: "Validate failed" });
       emitServerRunEvent({ type: "log", runId: input.runId, title: `Steering Pi to retry validation (attempt ${attempt + 1}/${maxAttempts})` });
@@ -1788,10 +2434,10 @@ ${planningClassification.planningRequired ? `Before implementing, write a concis
     break;
   }
   if (!exit) {
-    throw new CliError2(`Task run for ${runtimeTaskId} exhausted ${maxAttempts} attempts without a terminal result.`, 1);
+    throw new CliError(`Task run for ${runtimeTaskId} exhausted ${maxAttempts} attempts without a terminal result.`, 1);
   }
   if (exit.error) {
-    throw new CliError2(`Task run failed to start: ${exit.error.message}`, 1);
+    throw new CliError(`Task run failed to start: ${exit.error.message}`, 1);
   }
   if (assistantText.trim()) {
     appendRunTimeline(context.projectRoot, input.runId, {
@@ -1818,9 +2464,9 @@ ${planningClassification.planningRequired ? `Before implementing, write a concis
       reviewAction.fail(failureDetail);
     }
     let terminalFailureDetail = failureDetail;
-    const terminalRunStatus = reviewFailureDetail ? "needs_attention" : "failed";
+    const terminalRunStatus = reviewFailureDetail ? "needs-attention" : "failed";
     try {
-      await updateTaskSourceAfterDriverRun(context.projectRoot, input.runId, input.taskId, sourceTask, "failed", terminalRunStatus === "needs_attention" ? "Rig task run needs attention." : "Rig task run failed.", {
+      await updateTaskSourceAfterDriverRun(context.projectRoot, input.runId, input.taskId, sourceTask, "failed", terminalRunStatus === "needs-attention" ? "Rig task run needs attention." : "Rig task run failed.", {
         latestRuntimeWorkspace,
         latestLogsDir,
         latestSessionDir,
@@ -1830,14 +2476,14 @@ ${planningClassification.planningRequired ? `Before implementing, write a concis
       terminalFailureDetail = `${failureDetail}
 Failed to update task source for ${input.taskId ?? runtimeTaskId} to failed: ${error instanceof Error ? error.message : String(error)}`;
     }
-    patchAuthorityRun(context.projectRoot, input.runId, {
-      status: terminalRunStatus,
-      completedAt: failedAt,
+    setRunStatusOrFail(context.projectRoot, input.runId, terminalRunStatus, {
+      reason: "driver-terminal-failure",
       errorText: terminalFailureDetail
     });
+    patchAuthorityRun(context.projectRoot, input.runId, { completedAt: failedAt });
     appendRunLog(context.projectRoot, input.runId, {
       id: `log:${input.runId}:${terminalRunStatus}`,
-      title: terminalRunStatus === "needs_attention" ? "Task run needs attention" : "Task run failed",
+      title: terminalRunStatus === "needs-attention" ? "Task run needs attention" : "Task run failed",
       detail: terminalFailureDetail,
       tone: "error",
       status: terminalRunStatus,
@@ -1848,19 +2494,19 @@ Failed to update task source for ${input.taskId ?? runtimeTaskId} to failed: ${e
       runId: input.runId,
       error: terminalFailureDetail
     });
-    throw new CliError2(terminalFailureDetail, exit.code ?? 1);
+    throw new CliError(terminalFailureDetail, exit.code ?? 1);
   }
   if (planningClassification.planningRequired) {
     const planWorkspace = latestRuntimeWorkspace ?? context.projectRoot;
-    const expectedPlanPath = resolve4(planWorkspace, planningArtifactPath);
-    if (!existsSync2(expectedPlanPath)) {
+    const expectedPlanPath = resolve6(planWorkspace, planningArtifactPath);
+    if (!existsSync4(expectedPlanPath)) {
       const failedAt = new Date().toISOString();
       const failureDetail = `Planning was required (${planningClassification.reason}) but ${planningArtifactPath} was not written before implementation completed.`;
-      patchAuthorityRun(context.projectRoot, input.runId, {
-        status: "needs_attention",
-        completedAt: failedAt,
+      setRunStatusOrFail(context.projectRoot, input.runId, "needs-attention", {
+        reason: "plan-artifact-missing",
         errorText: failureDetail
       });
+      patchAuthorityRun(context.projectRoot, input.runId, { completedAt: failedAt });
       appendRunLog(context.projectRoot, input.runId, {
         id: `log:${input.runId}:plan-artifact-missing`,
         title: "Required plan artifact missing",
@@ -1870,8 +2516,66 @@ Failed to update task source for ${input.taskId ?? runtimeTaskId} to failed: ${e
         createdAt: failedAt
       });
       emitServerRunEvent({ type: "failed", runId: input.runId, error: failureDetail });
-      throw new CliError2(failureDetail, 1);
+      throw new CliError(failureDetail, 1);
+    }
+  }
+  if (process.env.RIG_SERVER_OWNS_CLOSEOUT === "1") {
+    appendPiStageLog({
+      projectRoot: context.projectRoot,
+      runId: input.runId,
+      stage: "Validate",
+      detail: "Rig validation accepted the task run; server will continue PR/review/merge closeout.",
+      status: "completed"
+    });
+    if (verificationAction && !reviewStarted) {
+      verificationAction.complete("Completion verification checks finished.");
+    }
+    if (!reviewAction) {
+      promoteToReviewing("Server-owned closeout is queued.");
     }
+    if (reviewAction) {
+      reviewAction.complete("Provider work accepted; server-owned closeout requested.");
+    }
+    const requestedAt = new Date().toISOString();
+    setRunStatusOrFail(context.projectRoot, input.runId, "closing-out", { reason: "server-closeout-requested" });
+    patchAuthorityRun(context.projectRoot, input.runId, {
+      completedAt: null,
+      errorText: null,
+      serverCloseout: {
+        status: "pending",
+        phase: "queued",
+        updatedAt: requestedAt,
+        runtimeWorkspace: latestRuntimeWorkspace,
+        branch: latestRuntimeBranch,
+        taskId: input.taskId ?? runtimeTaskId
+      }
+    });
+    appendRunLog(context.projectRoot, input.runId, {
+      id: `log:${input.runId}:server-closeout-requested`,
+      title: "Server-owned closeout requested",
+      detail: "The CLI provider worker finished validation and handed commit/PR/review/merge closeout back to the Rig server.",
+      tone: "info",
+      status: "reviewing",
+      createdAt: requestedAt,
+      payload: { runtimeWorkspace: latestRuntimeWorkspace, branch: latestRuntimeBranch }
+    });
+    emitServerRunEvent({ type: "log", runId: input.runId, title: "Server-owned closeout requested" });
+    emitServerRunEvent({ type: "status", runId: input.runId, status: "closing-out", detail: "Server-owned closeout requested.", ...sessionAnchor() });
+    await context.emitEvent("command.finished", {
+      command: [
+        "rig",
+        "server",
+        "task-run",
+        ...input.taskId ? ["--task", input.taskId] : [],
+        ...input.title ? ["--title", input.title] : []
+      ],
+      formattedCommand: input.taskId ? `rig server task-run --task ${input.taskId}` : `rig server task-run --title ${JSON.stringify(input.title ?? `Run ${input.runId}`)}`,
+      exitCode: 0,
+      durationMs: 0,
+      startedAt,
+      finishedAt: requestedAt
+    });
+    process.exit(0);
   }
   const runPiPrFeedbackFix = async (message) => {
     appendPiStageLog({
@@ -1900,11 +2604,45 @@ Failed to update task source for ${input.taskId ?? runtimeTaskId} to failed: ${e
       child.stdin.write(message);
     }
     child.stdin.end();
+    const feedbackAssistantMessageId = `message:${input.runId}:pr-feedback:${Date.now()}:assistant`;
+    let feedbackAssistantText = "";
+    const feedbackPendingToolUses = new Map;
     const stdout = createLineInterface({ input: child.stdout });
     stdout.on("line", (line) => {
       const trimmed = line.trim();
       if (!trimmed)
         return;
+      try {
+        const record = JSON.parse(trimmed);
+        const providerLogs = buildClaudeLogsFromRecord({
+          runId: input.runId,
+          record,
+          createdAtFallback: new Date().toISOString(),
+          status: "reviewing",
+          pendingToolUses: feedbackPendingToolUses
+        });
+        for (const providerLog of providerLogs) {
+          appendRunLog(context.projectRoot, input.runId, providerLog);
+          appendToolTimelineFromLog({ projectRoot: context.projectRoot, runId: input.runId, log: providerLog });
+          emitServerRunEvent({ type: "log", runId: input.runId, title: providerLog.title });
+          if (providerLog.title === "Tool activity")
+            emitServerRunEvent({ type: "timeline", runId: input.runId });
+        }
+        const nextFeedbackAssistantText = appendAssistantTimelineFromRecord({
+          projectRoot: context.projectRoot,
+          runId: input.runId,
+          messageId: feedbackAssistantMessageId,
+          record,
+          assistantText: feedbackAssistantText
+        });
+        const hadAssistantDelta = nextFeedbackAssistantText !== feedbackAssistantText;
+        if (hadAssistantDelta) {
+          feedbackAssistantText = nextFeedbackAssistantText;
+          emitServerRunEvent({ type: "timeline", runId: input.runId });
+        }
+        if (providerLogs.length > 0 || hadAssistantDelta)
+          return;
+      } catch {}
       appendRunLog(context.projectRoot, input.runId, {
         id: nextRunLogId(),
         title: "Pi PR feedback fix output",
@@ -1930,10 +2668,31 @@ Failed to update task source for ${input.taskId ?? runtimeTaskId} to failed: ${e
       });
       emitServerRunEvent({ type: "log", runId: input.runId, title: "Pi PR feedback fix stderr" });
     });
-    const exitCode = await new Promise((resolve5) => {
-      child.once("error", () => resolve5(1));
-      child.once("close", (code) => resolve5(code ?? 1));
+    const exitCode = await new Promise((resolve7) => {
+      child.once("error", () => resolve7(1));
+      child.once("close", (code) => resolve7(code ?? 1));
     });
+    for (const pendingLog of flushPendingClaudeToolUseLogs({
+      runId: input.runId,
+      status: exitCode === 0 ? "completed" : "failed",
+      pendingToolUses: feedbackPendingToolUses
+    })) {
+      appendRunLog(context.projectRoot, input.runId, pendingLog);
+      appendToolTimelineFromLog({ projectRoot: context.projectRoot, runId: input.runId, log: pendingLog });
+      emitServerRunEvent({ type: "log", runId: input.runId, title: pendingLog.title });
+      emitServerRunEvent({ type: "timeline", runId: input.runId });
+    }
+    if (feedbackAssistantText.trim()) {
+      appendRunTimeline(context.projectRoot, input.runId, {
+        id: feedbackAssistantMessageId,
+        type: "assistant_message",
+        text: feedbackAssistantText,
+        state: "completed",
+        createdAt: new Date().toISOString(),
+        completedAt: new Date().toISOString()
+      });
+      emitServerRunEvent({ type: "timeline", runId: input.runId });
+    }
     if (exitCode !== 0) {
       throw new Error(`Pi PR feedback fix failed with exit code ${exitCode}.`);
     }
@@ -1969,25 +2728,25 @@ Failed to update task source for ${input.taskId ?? runtimeTaskId} to failed: ${e
       const failureDetail = postValidation.pr?.actionableFeedback.join(`
 `) || "PR automation needs attention.";
       const failedAt = new Date().toISOString();
-      patchAuthorityRun(context.projectRoot, input.runId, {
-        status: "needs_attention",
-        completedAt: failedAt,
+      setRunStatusOrFail(context.projectRoot, input.runId, "needs-attention", {
+        reason: "pr-automation-needs-attention",
         errorText: failureDetail
       });
+      patchAuthorityRun(context.projectRoot, input.runId, { completedAt: failedAt });
       emitServerRunEvent({ type: "failed", runId: input.runId, error: failureDetail });
-      throw new CliError2(failureDetail, 1);
+      throw new CliError(failureDetail, 1);
     }
   } catch (error) {
-    if (error instanceof CliError2) {
+    if (error instanceof CliError) {
       throw error;
     }
     const failureDetail = `Failed to complete PR/issue closeout for ${input.taskId ?? runtimeTaskId}: ${error instanceof Error ? error.message : String(error)}`;
     const failedAt = new Date().toISOString();
-    patchAuthorityRun(context.projectRoot, input.runId, {
-      status: "failed",
-      completedAt: failedAt,
+    setRunStatusOrFail(context.projectRoot, input.runId, "failed", {
+      reason: "pr-closeout-failed",
       errorText: failureDetail
     });
+    patchAuthorityRun(context.projectRoot, input.runId, { completedAt: failedAt });
     appendRunLog(context.projectRoot, input.runId, {
       id: `log:${input.runId}:pr-closeout-failed`,
       title: "PR/issue closeout failed",
@@ -1997,7 +2756,7 @@ Failed to update task source for ${input.taskId ?? runtimeTaskId} to failed: ${e
       createdAt: failedAt
     });
     emitServerRunEvent({ type: "failed", runId: input.runId, error: failureDetail });
-    throw new CliError2(failureDetail, 1);
+    throw new CliError(failureDetail, 1);
   }
   if (verificationAction && !reviewStarted) {
     verificationAction.complete("Completion verification checks finished.");
@@ -2008,10 +2767,7 @@ Failed to update task source for ${input.taskId ?? runtimeTaskId} to failed: ${e
   if (reviewAction) {
     reviewAction.complete("Run marked completed.");
   }
-  patchAuthorityRun(context.projectRoot, input.runId, {
-    status: "completed",
-    completedAt: new Date().toISOString()
-  });
+  setRunStatusOrFail(context.projectRoot, input.runId, "completed", { reason: "driver-completed" });
   emitServerRunEvent({ type: "completed", runId: input.runId });
   await context.emitEvent("command.finished", {
     command: [