@h-rig/cli 0.0.6-alpha.5 → 0.0.6-alpha.51

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

@@ -1,7 +1,7 @@
 // @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";
 
@@ -9,8 +9,6 @@ import { createInterface as createLineInterface } from "readline";
 import { EventBus } from "@rig/runtime/control-plane/runtime/events";
 import { CliError } 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";
 function formatCommand(parts) {
@@ -39,14 +37,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";
 
@@ -60,6 +58,7 @@ import {
   writeJsonFile as writeJsonFile2
 } 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";
 
@@ -317,6 +316,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 +388,253 @@ 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 CliError2(`Invalid Rig connection state at ${path}: ${error instanceof Error ? error.message : String(error)}`, 1);
+  }
+}
+function writeJsonFile3(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) {
+  writeJsonFile3(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 CliError2(`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;
+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") {
+      const authToken = readGitHubBearerTokenForRemote(projectRoot);
+      const serverProjectRoot = selected.serverProjectRoot ?? await backfillRemoteServerProjectRoot(projectRoot, selected.connection.baseUrl, authToken);
+      return {
+        baseUrl: selected.connection.baseUrl,
+        authToken,
+        connectionKind: "remote",
+        serverProjectRoot
+      };
+    }
+    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 CliError2(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;
+}
+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);
+  const response = await fetch(`${server.baseUrl}${pathname}`, {
+    ...init,
+    headers
+  });
+  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 detail = diagnostics ?? (text || response.statusText);
+    throw new CliError2(`Rig server request failed (${response.status}): ${detail}`, 1);
+  }
+  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 };
+}
+
 // packages/cli/src/commands/task-run-driver.ts
 var PI_CANONICAL_RUN_STAGES = [
   "Connect",
@@ -431,6 +678,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 +703,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 +747,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 +755,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 +849,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 +859,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 +885,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 +903,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 +925,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 +935,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 +986,6 @@ async function runTaskRunPostValidationLifecycle(input) {
                 runtimeWorkspace: input.runtimeWorkspace ?? null
               })
             }
-          }).catch(() => {
-            return;
           });
         }
       },
@@ -761,8 +1004,6 @@ async function runTaskRunPostValidationLifecycle(input) {
                 runtimeWorkspace: input.runtimeWorkspace ?? null
               })
             }
-          }).catch(() => {
-            return;
           });
         }
       },
@@ -791,8 +1032,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 +1065,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;
     }
@@ -896,14 +1146,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 +1185,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 +1244,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 === "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 +1398,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);
@@ -1107,11 +1519,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",
@@ -1186,15 +1594,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 +1616,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 +1652,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,
@@ -1301,6 +1710,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 +1726,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,
@@ -1327,10 +1738,10 @@ ${planningClassification.planningRequired ? `Before implementing, write a concis
       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 +1749,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 +1764,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,
@@ -1435,9 +1846,68 @@ ${planningClassification.planningRequired ? `Before implementing, write a concis
       }
       return true;
     }
+    if (event.type === "pi.sessiond.starting" || event.type === "pi.sessiond.ready" || event.type === "pi.session.event_stream.connected" || event.type === "pi.prompt.sent" || event.type === "pi.prompt.waiting" || event.type === "pi.session.agent_end" || event.type === "pi.session.error") {
+      const title = event.type === "pi.sessiond.starting" ? "Starting worker Pi session daemon" : event.type === "pi.sessiond.ready" ? "Worker Pi daemon ready" : event.type === "pi.session.event_stream.connected" ? "Worker Pi event stream connected" : event.type === "pi.prompt.sent" ? "Delivered initial prompt to worker Pi" : event.type === "pi.prompt.waiting" ? "Worker Pi prompt waiting" : event.type === "pi.session.agent_end" ? "Worker Pi turn complete" : "Worker Pi session error";
+      const detail = event.type === "pi.sessiond.ready" ? "Daemon accepted control connection; waiting for SDK session metadata." : event.type === "pi.sessiond.starting" ? String(payload.workspaceDir ?? "worker runtime") : event.type === "pi.prompt.sent" ? `${String(payload.bytes ?? "unknown")} prompt bytes sent.` : event.type === "pi.prompt.waiting" ? String(payload.reason ?? "empty prompt") : event.type === "pi.session.error" ? String(payload.message ?? "session error") : String(payload.sessionId ?? payload.runId ?? "worker Pi session");
+      appendRunLog(context.projectRoot, input.runId, {
+        id: nextRunLogId(),
+        title,
+        detail,
+        tone: event.type === "pi.session.error" ? "error" : "info",
+        status: reviewStarted ? "reviewing" : verificationStarted ? "validating" : "running",
+        payload: {
+          eventType: event.type,
+          runId: typeof payload.runId === "string" ? payload.runId : null,
+          runtimeId: typeof payload.runtimeId === "string" ? payload.runtimeId : null,
+          sessionId: typeof payload.sessionId === "string" ? payload.sessionId : null
+        },
+        createdAt: new Date().toISOString()
+      });
+      emitServerRunEvent({ type: "log", runId: input.runId, title });
+      return true;
+    }
+    if (event.type === "pi.session.ready") {
+      const privateMetadata = payload.privateMetadata && typeof payload.privateMetadata === "object" && !Array.isArray(payload.privateMetadata) ? payload.privateMetadata : null;
+      const publicMetadata = payload.metadata && typeof payload.metadata === "object" && !Array.isArray(payload.metadata) ? payload.metadata : null;
+      if (privateMetadata) {
+        patchAuthorityRun(context.projectRoot, input.runId, {
+          piSession: publicMetadata,
+          piSessionPrivate: privateMetadata
+        });
+        const sessionId = typeof publicMetadata?.sessionId === "string" ? publicMetadata.sessionId : typeof privateMetadata.public === "object" && privateMetadata.public && !Array.isArray(privateMetadata.public) ? String(privateMetadata.public.sessionId ?? "") : "";
+        appendRunLog(context.projectRoot, input.runId, {
+          id: `log:${input.runId}:pi-session-ready`,
+          title: "Worker Pi session ready",
+          detail: sessionId ? `Session ${sessionId} is ready for WebSocket attach.` : "Worker Pi SDK session daemon is ready for WebSocket attach.",
+          tone: "info",
+          status: "running",
+          payload: {
+            sessionId: sessionId || null,
+            runtimeId: typeof payload.runtimeId === "string" ? payload.runtimeId : null
+          },
+          createdAt: new Date().toISOString()
+        });
+        emitServerRunEvent({ type: "log", runId: input.runId, title: "Worker Pi session ready" });
+      }
+      return true;
+    }
+    if (event.type === "pi.rpc.prompt.sent" || event.type === "pi.rpc.steering.delivered" || event.type === "pi.rpc.steering.poll.failed" || event.type === "pi.rpc.extension_ui.cancelled") {
+      const title = event.type === "pi.rpc.prompt.sent" ? "Delivered initial prompt to worker Pi" : event.type === "pi.rpc.steering.delivered" ? "Delivered steering to worker Pi" : event.type === "pi.rpc.steering.poll.failed" ? "Worker Pi steering poll failed" : "Pi RPC UI request auto-cancelled";
+      const detail = event.type === "pi.rpc.prompt.sent" ? `${String(payload.kind ?? "prompt")} prompt (${String(payload.bytes ?? "unknown")} bytes)` : event.type === "pi.rpc.steering.delivered" ? `${String(payload.actor ?? "operator")}: ${String(payload.message ?? "")}`.slice(0, 500) : event.type === "pi.rpc.steering.poll.failed" ? String(payload.error ?? "steering poll failed") : `${String(payload.method ?? "ui")}: ${String(payload.reason ?? "noninteractive worker session")}`;
+      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)
@@ -1471,6 +1941,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 +1970,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 +2025,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 +2134,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 +2142,7 @@ ${planningClassification.planningRequired ? `Before implementing, write a concis
         settled = true;
         if (acceptedArtifactPollTimer)
           clearInterval(acceptedArtifactPollTimer);
-        resolve5(result);
+        resolve7(result);
       };
       const pollAcceptedArtifacts = () => {
         const artifactState = readTaskRunAcceptedArtifactState({
@@ -1726,7 +2215,10 @@ ${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) {
@@ -1852,8 +2344,8 @@ Failed to update task source for ${input.taskId ?? runtimeTaskId} to failed: ${e
   }
   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, {
@@ -1873,6 +2365,65 @@ Failed to update task source for ${input.taskId ?? runtimeTaskId} to failed: ${e
       throw new CliError2(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();
+    patchAuthorityRun(context.projectRoot, input.runId, {
+      status: "reviewing",
+      completedAt: null,
+      errorText: null,
+      serverCloseout: {
+        status: "pending",
+        phase: "queued",
+        requestedAt,
+        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: "reviewing", detail: "Server-owned closeout requested." });
+    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({
       projectRoot: context.projectRoot,
@@ -1900,11 +2451,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 +2515,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}.`);
     }