@h-rig/cli 0.0.6-alpha.0

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

@@ -0,0 +1,1933 @@
+// @bun
+// packages/cli/src/commands/task-run-driver.ts
+import { copyFileSync, existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, statSync } from "fs";
+import { resolve as resolve4 } 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 { 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) {
+  return parts.map((part) => /[^a-zA-Z0-9_./:-]/.test(part) ? JSON.stringify(part) : part).join(" ");
+}
+
+// packages/cli/src/commands/task-run-driver.ts
+import { loadConfig } from "@rig/core/load-config";
+import {
+  listAgentRuntimes,
+  startRuntimeSnapshotSidecar
+} from "@rig/runtime/control-plane/runtime/isolation";
+import {
+  finalizeTaskRunSnapshot,
+  resolveTaskRunSnapshotSidecar
+} from "@rig/runtime/control-plane/runtime/snapshot/task-run";
+import { loadRuntimeSnapshotConfig } from "@rig/runtime/control-plane/runtime/guard";
+import {
+  buildClaudeLogsFromRecord,
+  flushPendingClaudeToolUseLogs
+} from "@rig/runtime/control-plane/provider/claude-stream-records";
+import {
+  buildCodexLogsFromRecord,
+  extractCodexAssistantMessageText,
+  flushPendingCodexToolUseLogs,
+  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 {
+  buildTaskRunLifecycleComment,
+  updateConfiguredTaskSourceTask
+} from "@rig/runtime/control-plane/tasks/source-lifecycle";
+import {
+  closeIssueAfterMergedPr,
+  commitRunChanges,
+  runPrAutomation
+} from "@rig/runtime/control-plane/native/pr-automation";
+
+// packages/cli/src/commands/_run-driver-helpers.ts
+import { readFileSync } from "fs";
+import { resolve as resolve3 } from "path";
+import {
+  appendJsonlRecord,
+  readAuthorityRun as readAuthorityRun2,
+  resolveAuthorityRunDir as resolveAuthorityRunDir2,
+  writeJsonFile as writeJsonFile2
+} from "@rig/runtime/control-plane/authority-files";
+import { taskLookup } from "@rig/runtime/control-plane/native/task-ops";
+import { buildProviderTaskRunInstructionLines } from "@rig/runtime/control-plane/provider/runtime-instructions";
+import { loadRigTaskRunSkillBody } from "@rig/runtime/control-plane/provider/rig-task-run-skill";
+
+// packages/cli/src/commands/_authority-runs.ts
+import { existsSync } from "fs";
+import { resolve as resolve2 } from "path";
+import {
+  readAuthorityRun,
+  readJsonlFile,
+  resolveAuthorityRunDir,
+  writeJsonFile
+} from "@rig/runtime/control-plane/authority-files";
+
+// packages/cli/src/commands/_paths.ts
+import { resolve } from "path";
+import { resolveMonorepoRoot } from "@rig/runtime/control-plane/native/utils";
+function resolveControlPlaneMonorepoRoot(projectRoot) {
+  return resolveMonorepoRoot(projectRoot);
+}
+function resolveControlPlaneTaskConfigPath(projectRoot) {
+  return resolve(resolveControlPlaneMonorepoRoot(projectRoot), ".rig", "task-config.json");
+}
+
+// packages/cli/src/commands/_authority-runs.ts
+var RIG_WORKSPACE_ID = "rig-local-workspace";
+function normalizeRuntimeAdapter(value) {
+  const normalized = value?.trim().toLowerCase();
+  if (!normalized) {
+    return "pi";
+  }
+  if (normalized === "codex" || normalized === "codex-cli" || normalized === "codex-app-server" || normalized === "gpt-codex") {
+    return "codex";
+  }
+  if (normalized === "pi" || normalized === "rig-pi" || normalized === "@rig/pi") {
+    return "pi";
+  }
+  return "claude-code";
+}
+function readLatestBeadRecord(projectRoot, taskId) {
+  const issuesPath = resolve2(resolveControlPlaneMonorepoRoot(projectRoot), ".beads", "issues.jsonl");
+  if (!existsSync(issuesPath)) {
+    return null;
+  }
+  let latest = null;
+  for (const issue of readJsonlFile(issuesPath)) {
+    if (!issue || typeof issue !== "object") {
+      continue;
+    }
+    const record = issue;
+    if (record.id === taskId) {
+      latest = record;
+    }
+  }
+  return latest;
+}
+function resolveTaskTitleForAuthorityRun(projectRoot, taskId) {
+  try {
+    const record = readLatestBeadRecord(projectRoot, taskId);
+    const title = record && typeof record.title === "string" ? record.title.trim() : "";
+    if (title) {
+      return title;
+    }
+  } catch {}
+  return null;
+}
+function upsertAgentAuthorityRun(projectRoot, input) {
+  const current = readAuthorityRun(projectRoot, input.runId);
+  const existing = current;
+  const createdAt = existing?.createdAt ?? input.createdAt;
+  const runtimeMode = typeof existing?.runtimeMode === "string" ? existing.runtimeMode : "full-access";
+  const interactionMode = typeof existing?.interactionMode === "string" ? existing.interactionMode : "default";
+  const runMode = typeof existing?.runMode === "string" ? existing.runMode : "autonomous";
+  const runtimeAdapter = normalizeRuntimeAdapter(input.runtimeAdapter ?? existing?.runtimeAdapter ?? "claude-code");
+  const title = resolveTaskTitleForAuthorityRun(projectRoot, input.taskId) ?? input.taskId;
+  const next = {
+    runId: input.runId,
+    projectRoot,
+    workspaceId: existing?.workspaceId ?? RIG_WORKSPACE_ID,
+    taskId: input.taskId,
+    threadId: existing?.threadId ?? null,
+    mode: "local",
+    runtimeAdapter,
+    status: input.status,
+    createdAt,
+    startedAt: input.startedAt ?? existing?.startedAt ?? null,
+    completedAt: input.completedAt ?? existing?.completedAt ?? null,
+    endpointId: existing?.endpointId ?? null,
+    hostId: existing?.hostId ?? null,
+    worktreePath: input.worktreePath ?? existing?.worktreePath ?? null,
+    artifactRoot: input.artifactRoot ?? existing?.artifactRoot ?? null,
+    logRoot: input.logRoot ?? existing?.logRoot ?? null,
+    sessionPath: input.sessionPath ?? existing?.sessionPath ?? null,
+    sessionLogPath: input.sessionLogPath ?? existing?.sessionLogPath ?? null,
+    pid: input.pid ?? existing?.pid ?? null,
+    updatedAt: input.createdAt,
+    title,
+    model: typeof existing?.model === "string" ? existing.model : null,
+    runtimeMode,
+    interactionMode,
+    runMode,
+    initialPrompt: typeof existing?.initialPrompt === "string" ? existing.initialPrompt : null
+  };
+  if (input.errorText !== undefined) {
+    next.errorText = input.errorText;
+  } else if ("errorText" in next) {
+    delete next.errorText;
+  }
+  writeJsonFile(resolve2(resolveAuthorityRunDir(projectRoot, input.runId), "run.json"), 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 = {
+    ...current,
+    ...patch,
+    updatedAt: new Date().toISOString()
+  };
+  writeJsonFile2(resolve3(resolveAuthorityRunDir2(projectRoot, runId), "run.json"), next);
+  return next;
+}
+function touchAuthorityRun(projectRoot, runId) {
+  const current = readAuthorityRun2(projectRoot, runId);
+  if (!current) {
+    return;
+  }
+  writeJsonFile2(resolve3(resolveAuthorityRunDir2(projectRoot, runId), "run.json"), {
+    ...current,
+    updatedAt: new Date().toISOString()
+  });
+}
+function appendRunTimeline(projectRoot, runId, value) {
+  appendJsonlRecord(resolve3(resolveAuthorityRunDir2(projectRoot, runId), "timeline.jsonl"), value);
+  touchAuthorityRun(projectRoot, runId);
+}
+function appendRunLog(projectRoot, runId, value) {
+  appendJsonlRecord(resolve3(resolveAuthorityRunDir2(projectRoot, runId), "logs.jsonl"), value);
+  touchAuthorityRun(projectRoot, runId);
+}
+function appendRunAction(projectRoot, runId, value) {
+  appendJsonlRecord(resolve3(resolveAuthorityRunDir2(projectRoot, runId), "timeline.jsonl"), {
+    id: value.id,
+    type: "action",
+    actionType: value.actionType,
+    title: value.title,
+    detail: value.detail ?? null,
+    state: value.state,
+    createdAt: value.startedAt,
+    completedAt: value.completedAt ?? null,
+    payload: value.payload ?? {}
+  });
+}
+function startRunAction(projectRoot, runId, input) {
+  const startedAt = new Date().toISOString();
+  appendRunAction(projectRoot, runId, {
+    id: input.actionId,
+    actionType: input.actionType,
+    title: input.title,
+    detail: input.detail,
+    state: "running",
+    startedAt,
+    payload: input.payload
+  });
+  emitServerRunEvent({ type: "timeline", runId });
+  return {
+    startedAt,
+    complete: (detail, payload) => {
+      appendRunAction(projectRoot, runId, {
+        id: input.actionId,
+        actionType: input.actionType,
+        title: input.title,
+        detail: detail ?? input.detail ?? null,
+        state: "completed",
+        startedAt,
+        completedAt: new Date().toISOString(),
+        payload: payload ?? input.payload
+      });
+      emitServerRunEvent({ type: "timeline", runId });
+    },
+    fail: (detail, payload) => {
+      appendRunAction(projectRoot, runId, {
+        id: input.actionId,
+        actionType: input.actionType,
+        title: input.title,
+        detail,
+        state: "failed",
+        startedAt,
+        completedAt: new Date().toISOString(),
+        payload: payload ?? input.payload
+      });
+      emitServerRunEvent({ type: "timeline", runId });
+    }
+  };
+}
+function emitServerRunEvent(event) {
+  console.log(`__RIG_RUN_EVENT__${JSON.stringify({ ...event, at: new Date().toISOString() })}`);
+}
+function buildRunPrompt(input) {
+  const initialPrompt = input.initialPrompt?.trim() || null;
+  if (!input.taskId) {
+    return initialPrompt ?? input.fallbackTitle?.trim() ?? "Continue the requested Rig run and complete the work.";
+  }
+  const issues = (() => {
+    try {
+      return taskLookup(input.projectRoot, input.taskId);
+    } catch {
+      return "";
+    }
+  })();
+  const scopeText = (() => {
+    try {
+      const parsed = JSON.parse(readFileSync(resolveControlPlaneTaskConfigPath(input.projectRoot), "utf8"));
+      const entry = parsed[input.taskId] ?? {};
+      const scope = Array.isArray(entry.scope) ? entry.scope.filter((item) => typeof item === "string") : [];
+      const validation = Array.isArray(entry.validation) ? entry.validation.filter((item) => typeof item === "string") : [];
+      const lines = [];
+      if (scope.length > 0)
+        lines.push(`Scope:
+- ${scope.join(`
+- `)}`);
+      if (validation.length > 0)
+        lines.push(`Validation:
+- ${validation.join(`
+- `)}`);
+      return lines.join(`
+
+`);
+    } catch {
+      return "";
+    }
+  })();
+  const bead = readLatestBeadRecord(input.projectRoot, input.taskId);
+  const sourceTask = input.sourceTask ?? null;
+  const sourceDescription = firstPromptString(sourceTask?.description, sourceTask?.body);
+  const sourceAcceptance = firstPromptString(sourceTask?.acceptanceCriteria, sourceTask?.acceptance_criteria);
+  const sourceValidation = uniqueStrings([...sourceTask?.validation ?? [], ...sourceTask?.validators ?? []]);
+  const title = (bead && typeof bead === "object" && typeof bead.title === "string" ? bead.title : null) ?? firstPromptString(sourceTask?.title) ?? input.fallbackTitle ?? issues ?? input.taskId;
+  const description = (bead && typeof bead === "object" && typeof bead.description === "string" ? bead.description : null) ?? sourceDescription ?? input.fallbackDescription ?? "";
+  const acceptance = bead && typeof bead === "object" && typeof bead.acceptance_criteria === "string" ? bead.acceptance_criteria : sourceAcceptance ?? input.fallbackAcceptanceCriteria ?? "";
+  const sourceContractLines = renderSourceTaskContract(sourceTask, sourceValidation);
+  const providerLines = buildProviderTaskRunInstructionLines(input.runtimeAdapter);
+  const skillBody = loadRigTaskRunSkillBody();
+  return [
+    `You are working on task ${input.taskId}: ${title}.`,
+    description ? `Description:
+${description}` : null,
+    acceptance ? `Acceptance criteria:
+${acceptance}` : null,
+    sourceContractLines.length > 0 ? `Source task contract:
+${sourceContractLines.join(`
+`)}` : null,
+    scopeText || renderSourceScopeValidation(sourceTask, sourceValidation) || null,
+    initialPrompt ? `Additional operator guidance:
+${initialPrompt}` : null,
+    providerLines.length > 0 ? `Provider-specific runtime tooling:
+${providerLines.join(" ")}` : null,
+    skillBody || null
+  ].filter((value) => Boolean(value)).join(`
+
+`);
+}
+function firstPromptString(...values) {
+  for (const value of values) {
+    const trimmed = typeof value === "string" ? value.trim() : "";
+    if (trimmed.length > 0) {
+      return trimmed;
+    }
+  }
+  return null;
+}
+function uniqueStrings(values) {
+  return Array.from(new Set(values.map((value) => value.trim()).filter(Boolean)));
+}
+function renderSourceTaskContract(task, validation) {
+  if (!task) {
+    return [];
+  }
+  const lines = [];
+  const sourceIssueId = firstPromptString(task.sourceIssueId);
+  if (sourceIssueId)
+    lines.push(`Source issue: ${sourceIssueId}`);
+  const status = firstPromptString(task.status);
+  if (status)
+    lines.push(`Source status: ${status}`);
+  const issueType = firstPromptString(task.issueType);
+  if (issueType)
+    lines.push(`Issue type: ${issueType}`);
+  const role = firstPromptString(task.role);
+  if (role)
+    lines.push(`Role: ${role}`);
+  const externalRef = firstPromptString(task.externalRef);
+  if (externalRef)
+    lines.push(`External ref: ${externalRef}`);
+  const labels = uniqueStrings(task.labels ?? []);
+  if (labels.length > 0)
+    lines.push(`Labels:
+- ${labels.join(`
+- `)}`);
+  if (validation.length > 0)
+    lines.push(`Validators:
+- ${validation.join(`
+- `)}`);
+  return lines;
+}
+function renderSourceScopeValidation(task, validation) {
+  if (!task) {
+    return "";
+  }
+  const lines = [];
+  const scope = uniqueStrings(task.scope ?? []);
+  if (scope.length > 0)
+    lines.push(`Scope:
+- ${scope.join(`
+- `)}`);
+  if (validation.length > 0)
+    lines.push(`Validation:
+- ${validation.join(`
+- `)}`);
+  return lines.join(`
+
+`);
+}
+
+// packages/cli/src/commands/task-run-driver.ts
+var PI_CANONICAL_RUN_STAGES = [
+  "Connect",
+  "GitHub/task sync",
+  "Prepare workspace",
+  "Launch Pi",
+  "Plan",
+  "Implement",
+  "Validate",
+  "Commit",
+  "Open PR",
+  "Review/CI",
+  "Merge",
+  "Complete"
+];
+function canonicalPiRunStages() {
+  return [...PI_CANONICAL_RUN_STAGES];
+}
+function buildPiRigBridgeEnv(input) {
+  return {
+    RIG_PROJECT_ROOT: input.projectRoot,
+    PROJECT_RIG_ROOT: input.projectRoot,
+    RIG_RUN_ID: input.runId,
+    RIG_SERVER_RUN_ID: input.runId,
+    RIG_TASK_ID: input.taskId,
+    RIG_RUNTIME_ADAPTER: "pi",
+    ...input.serverUrl ? { RIG_SERVER_URL: input.serverUrl } : {},
+    ...input.authToken ? { RIG_AUTH_TOKEN: input.authToken } : {},
+    ...input.githubToken ? { RIG_GITHUB_TOKEN: input.githubToken } : {}
+  };
+}
+function runGitSync(cwd, args, input) {
+  const result = spawnSync("git", [...args], {
+    cwd,
+    input,
+    encoding: "utf8",
+    stdio: input === undefined ? ["ignore", "pipe", "pipe"] : ["pipe", "pipe", "pipe"]
+  });
+  return {
+    ok: result.status === 0,
+    stdout: result.stdout || "",
+    stderr: result.stderr || (result.error instanceof Error ? result.error.message : "")
+  };
+}
+function copyUntrackedDirtyFiles(sourceRoot, targetRoot) {
+  const listed = runGitSync(sourceRoot, ["ls-files", "--others", "--exclude-standard", "-z"]);
+  if (!listed.ok || !listed.stdout)
+    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);
+    try {
+      if (!statSync(sourcePath).isFile())
+        continue;
+      mkdirSync(resolve4(targetPath, ".."), { recursive: true });
+      copyFileSync(sourcePath, targetPath);
+      copied += 1;
+    } catch {}
+  }
+  return copied;
+}
+function applyDirtyBaselineSnapshot(input) {
+  const diff = runGitSync(input.sourceRoot, ["diff", "--binary", "HEAD"]);
+  if (!diff.ok) {
+    return { applied: false, copiedUntracked: 0, detail: diff.stderr || "git diff failed" };
+  }
+  let applied = false;
+  if (diff.stdout.trim()) {
+    const apply = runGitSync(input.targetRoot, ["apply", "--whitespace=nowarn", "-"], diff.stdout);
+    if (!apply.ok) {
+      return { applied: false, copiedUntracked: 0, detail: apply.stderr || "git apply failed" };
+    }
+    applied = true;
+  }
+  const copiedUntracked = copyUntrackedDirtyFiles(input.sourceRoot, input.targetRoot);
+  return {
+    applied: applied || copiedUntracked > 0,
+    copiedUntracked,
+    detail: applied || copiedUntracked > 0 ? `Applied dirty baseline snapshot (${copiedUntracked} untracked files).` : "No dirty baseline changes to apply."
+  };
+}
+function buildTaskRunReviewEnv(config) {
+  const review = config?.review;
+  return {
+    ...review?.mode ? { AI_REVIEW_MODE: review.mode } : {},
+    ...review?.provider ? { AI_REVIEW_PROVIDER: review.provider } : {}
+  };
+}
+function positiveInt(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
+}
+function resolveTaskRunAutomationLimits(config, env = process.env) {
+  const configuredValidationAttempts = positiveInt(config?.automation?.maxValidationAttempts, 30);
+  const configuredPrFixIterations = positiveInt(config?.automation?.maxPrFixIterations, 30);
+  return {
+    maxValidationAttempts: parsePositiveInt(env.RIG_TASK_RUN_MAX_ATTEMPTS, "RIG_TASK_RUN_MAX_ATTEMPTS", configuredValidationAttempts),
+    maxPrFixIterations: configuredPrFixIterations
+  };
+}
+function classifyPlanningNeed(input) {
+  const planning = input.config?.planning ?? {};
+  const mode = planning.mode ?? "auto";
+  const labels = new Set((input.sourceTask?.labels ?? []).map((label) => label.trim().toLowerCase()).filter(Boolean));
+  const requireLabels = planning.requireForLabels ?? ["needs-plan", "epic", "large", "risk:high"];
+  const skipLabels = planning.skipForLabels ?? ["no-plan", "small", "trivial"];
+  const bodyLength = `${input.sourceTask?.description ?? ""}
+${input.sourceTask?.body ?? ""}
+${input.sourceTask?.acceptanceCriteria ?? input.sourceTask?.acceptance_criteria ?? ""}`.trim().length;
+  const forcedLabel = requireLabels.find((label) => labels.has(label.toLowerCase()));
+  const skippedLabel = skipLabels.find((label) => labels.has(label.toLowerCase()));
+  const highRisk = labels.has("risk:high") || labels.has("security") || labels.has("migration");
+  const size = labels.has("large") || bodyLength > 4000 ? "large" : bodyLength > 1000 ? "medium" : "small";
+  const risk = highRisk ? "high" : labels.has("risk:medium") || size !== "small" ? "medium" : "low";
+  if (mode === "always") {
+    return { planningRequired: true, size, risk, reason: "planning.mode=always", policy: "always" };
+  }
+  if (mode === "off") {
+    return { planningRequired: false, size, risk, reason: "planning.mode=off", policy: "off" };
+  }
+  if (forcedLabel) {
+    return { planningRequired: true, size, risk, reason: `label:${forcedLabel}`, policy: "auto" };
+  }
+  if (skippedLabel && !highRisk) {
+    return { planningRequired: false, size, risk, reason: `label:${skippedLabel}`, policy: "auto" };
+  }
+  const planningRequired = size !== "small" || risk === "high";
+  return {
+    planningRequired,
+    size,
+    risk,
+    reason: planningRequired ? `auto:${size}/${risk}` : "auto:small/low",
+    policy: "auto"
+  };
+}
+function buildPiValidationRetrySteeringPrompt(input) {
+  return [
+    `Retry attempt ${input.attempt + 1}/${input.maxAttempts} for task ${input.taskId}.`,
+    "The previous attempt failed Rig validation. Continue from the existing runtime workspace and PR state instead of starting over.",
+    "",
+    `Latest blocker: ${input.failureDetail}`,
+    ...input.validationOutput?.trim() ? ["", "Validation output:", input.validationOutput.trim()] : [],
+    "",
+    "Fix the concrete failure, rerun the relevant validation, and only report completion when the task is accepted."
+  ].join(`
+`);
+}
+function classifyValidationRetryOutcome(input) {
+  return {
+    stage: "Validate failed",
+    status: input.attempt >= input.maxAttempts ? "needs_attention" : "retry",
+    failureDetail: input.failureDetail
+  };
+}
+function configuredIssueUpdatesMode(config) {
+  const github = config?.github;
+  const mode = github && typeof github === "object" && !Array.isArray(github) ? github.issueUpdates : null;
+  return mode === "off" || mode === "minimal" || mode === "lifecycle" ? mode : "lifecycle";
+}
+function shouldWriteDriverIssueUpdate(config, status) {
+  const mode = configuredIssueUpdatesMode(config);
+  if (mode === "off")
+    return false;
+  if (mode === "lifecycle")
+    return true;
+  return ["closed", "failed", "needs_attention"].includes(status);
+}
+async function loadTaskRunAutomationConfig(projectRoot) {
+  try {
+    return await loadConfig(projectRoot);
+  } catch {
+    return null;
+  }
+}
+function taskRunStageLogId(runId, stage) {
+  return `log:${runId}:stage:${stage.toLowerCase().replace(/[^a-z0-9]+/g, "-")}`;
+}
+function appendPiStageLog(input) {
+  appendRunLog(input.projectRoot, input.runId, {
+    id: taskRunStageLogId(input.runId, input.stage),
+    title: input.stage,
+    detail: input.detail ?? null,
+    tone: input.tone ?? "info",
+    status: input.status ?? "running",
+    createdAt: new Date().toISOString()
+  });
+  emitServerRunEvent({ type: "log", runId: input.runId, title: input.stage });
+}
+function createCommandRunner(binary) {
+  return async (args, options) => {
+    const child = spawn(binary, [...args], {
+      cwd: options?.cwd,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const stdoutChunks = [];
+    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({
+        exitCode: code ?? 1,
+        stdout: Buffer.concat(stdoutChunks).toString("utf8"),
+        stderr: Buffer.concat(stderrChunks).toString("utf8")
+      }));
+    });
+  };
+}
+async function resolvePostValidationBranch(input) {
+  if (!input.configuredBranch.startsWith("task-")) {
+    return input.configuredBranch;
+  }
+  const current = await input.gitCommand(["rev-parse", "--abbrev-ref", "HEAD"], { cwd: input.workspace });
+  const currentBranch = current.stdout?.trim();
+  if (current.exitCode === 0 && currentBranch && currentBranch !== "HEAD") {
+    return currentBranch;
+  }
+  return input.configuredBranch;
+}
+async function runTaskRunPostValidationLifecycle(input) {
+  const taskId = input.taskId?.trim();
+  if (!taskId) {
+    return { status: "skipped" };
+  }
+  const config = input.config ?? {};
+  const prMode = config.pr?.mode ?? "auto";
+  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");
+    return { status: "skipped" };
+  }
+  const workspace = input.runtimeWorkspace || input.projectRoot;
+  const ghCommand = input.ghCommand ?? createCommandRunner("gh");
+  const gitCommand = input.gitCommand ?? createCommandRunner("git");
+  const configuredBranch = input.branch || `rig/${input.runtimeTaskId}-${input.runId}`;
+  const branch = await resolvePostValidationBranch({
+    workspace,
+    configuredBranch,
+    gitCommand
+  });
+  const prAutomation = input.prAutomation ?? runPrAutomation;
+  const updateTaskSource = input.updateTaskSource ?? updateConfiguredTaskSourceTask;
+  const stage = input.appendStage ?? (() => {
+    return;
+  });
+  const steerPi = input.steerPi ?? (async (message) => {
+    appendRunLog(input.projectRoot, input.runId, {
+      id: `log:${input.runId}:pr-steering:${Date.now()}`,
+      title: "Steering Pi from PR feedback",
+      detail: message,
+      tone: "info",
+      status: "reviewing",
+      createdAt: new Date().toISOString()
+    });
+    emitServerRunEvent({ type: "log", runId: input.runId, title: "Steering Pi from PR feedback" });
+  });
+  stage("Commit", `Committing changes in ${workspace}.`, "running", "tool");
+  const commit = await commitRunChanges({
+    cwd: workspace,
+    message: `rig: complete task ${taskId}`,
+    command: gitCommand
+  });
+  stage("Commit", commit.committed ? "Committed run workspace changes." : "No workspace changes to commit.", "completed", "tool");
+  stage("Open PR", `Opening PR from ${branch}.`, "running", "tool");
+  const pr = await prAutomation({
+    projectRoot: workspace,
+    taskId,
+    runId: input.runId,
+    branch,
+    config,
+    sourceTask: input.sourceTask,
+    uploadedSnapshot: input.uploadedSnapshot,
+    command: ghCommand,
+    gitCommand,
+    steerPi,
+    lifecycle: {
+      onPrOpened: async ({ prUrl }) => {
+        stage("Open PR", prUrl, "completed", "tool");
+        try {
+          if (shouldWriteDriverIssueUpdate(config, "under_review")) {
+            await updateTaskSource(input.projectRoot, {
+              taskId,
+              sourceTask: runSourceTaskIdentity(input.sourceTask),
+              update: {
+                status: "under_review",
+                comment: buildTaskRunLifecycleComment({
+                  runId: input.runId,
+                  status: "under_review",
+                  summary: "Rig opened a pull request for this task.",
+                  runtimeWorkspace: input.runtimeWorkspace ?? null
+                })
+              }
+            });
+          }
+        } catch (error) {
+          appendRunLog(input.projectRoot, input.runId, {
+            id: `log:${input.runId}:task-source-under-review-update`,
+            title: "Task source PR status update failed",
+            detail: error instanceof Error ? error.message : String(error),
+            tone: "error",
+            status: "reviewing",
+            createdAt: new Date().toISOString()
+          });
+        }
+      },
+      onReviewCiStarted: ({ prUrl, iteration }) => stage("Review/CI", `${prUrl} (iteration ${iteration})`, "running", "info"),
+      onFeedback: async ({ feedback }) => {
+        stage("Review/CI", feedback.join(`
+`), "reviewing", "error");
+        if (shouldWriteDriverIssueUpdate(config, "ci_fixing")) {
+          await updateTaskSource(input.projectRoot, {
+            taskId,
+            sourceTask: runSourceTaskIdentity(input.sourceTask),
+            update: {
+              status: "ci_fixing",
+              comment: buildTaskRunLifecycleComment({
+                runId: input.runId,
+                status: "ci_fixing",
+                summary: "Rig is fixing CI/review feedback for this task.",
+                runtimeWorkspace: input.runtimeWorkspace ?? null
+              })
+            }
+          }).catch(() => {
+            return;
+          });
+        }
+      },
+      onMergeStarted: async ({ prUrl }) => {
+        stage("Merge", prUrl, "running", "tool");
+        if (shouldWriteDriverIssueUpdate(config, "merging")) {
+          await updateTaskSource(input.projectRoot, {
+            taskId,
+            sourceTask: runSourceTaskIdentity(input.sourceTask),
+            update: {
+              status: "merging",
+              comment: buildTaskRunLifecycleComment({
+                runId: input.runId,
+                status: "merging",
+                summary: "Rig is merging the pull request for this task.",
+                runtimeWorkspace: input.runtimeWorkspace ?? null
+              })
+            }
+          }).catch(() => {
+            return;
+          });
+        }
+      },
+      onMerged: ({ prUrl }) => stage("Merge", prUrl, "completed", "tool")
+    }
+  });
+  if (pr.status === "opened" && pr.prUrl) {
+    stage("Complete", `PR ready without merge: ${pr.prUrl}`, "completed", "info");
+    return { status: "completed", pr };
+  }
+  if (pr.status !== "merged" || !pr.prUrl) {
+    const detail = pr.actionableFeedback.join(`
+`) || "PR automation did not merge the PR.";
+    stage("Needs attention", detail, "needs_attention", "error");
+    if (shouldWriteDriverIssueUpdate(config, "needs_attention")) {
+      await updateTaskSource(input.projectRoot, {
+        taskId,
+        sourceTask: runSourceTaskIdentity(input.sourceTask),
+        update: {
+          status: "needs_attention",
+          comment: buildTaskRunLifecycleComment({
+            runId: input.runId,
+            status: "needs_attention",
+            summary: "Rig needs operator attention before this task can proceed.",
+            runtimeWorkspace: input.runtimeWorkspace ?? null,
+            errorText: detail
+          })
+        }
+      }).catch(() => {
+        return;
+      });
+    }
+    return { status: "needs_attention", pr };
+  }
+  if (shouldWriteDriverIssueUpdate(config, "closed")) {
+    await closeIssueAfterMergedPr({
+      projectRoot: input.projectRoot,
+      taskId,
+      runId: input.runId,
+      prUrl: pr.prUrl,
+      sourceTask: input.sourceTask,
+      updateTaskSource: async (projectRoot, closeInput) => updateTaskSource(projectRoot, closeInput)
+    });
+  }
+  stage("Complete", `PR merged and issue closed: ${pr.prUrl}`, "completed", "info");
+  return { status: "completed", pr };
+}
+function summarizeValidationFailure(projectRoot, taskId) {
+  if (!taskId) {
+    return null;
+  }
+  for (const artifactDir of resolveTaskArtifactDirs(projectRoot, taskId)) {
+    const summary = readJsonFile(resolve4(artifactDir, "validation-summary.json"), null);
+    if (!summary || summary.status !== "fail") {
+      continue;
+    }
+    const failedCategories = Array.isArray(summary.categories) ? summary.categories.filter((entry) => String(entry?.status ?? "") !== "pass").map((entry) => String(entry?.category ?? "").trim()).filter(Boolean) : [];
+    if (failedCategories.length > 0) {
+      return `Task validation failed: ${failedCategories.join(", ")}`;
+    }
+    return "Task validation failed.";
+  }
+  return null;
+}
+function classifyCompletionVerificationLine(line) {
+  const trimmed = line.trim();
+  if (/^=== Completion Verification: /.test(trimmed)) {
+    return { isCompletionLine: true, isVerifierReview: false };
+  }
+  if (/^\[\d+\/\d+\]/.test(trimmed)) {
+    return {
+      isCompletionLine: true,
+      isVerifierReview: /Verifier review/i.test(trimmed)
+    };
+  }
+  return { isCompletionLine: false, isVerifierReview: false };
+}
+function createRunLogIdFactory(runId) {
+  let sequence = 0;
+  return () => {
+    sequence += 1;
+    return `log:${runId}:${Date.now()}:${sequence}`;
+  };
+}
+function summarizeTaskRunProcessFailure(input) {
+  const fallback = `Task run failed (${String(input.exitCode ?? "unknown")}${input.signal ? ` ${input.signal}` : ""})`;
+  const stderrLines = input.stderrLines ?? [];
+  const meaningfulLines = [...stderrLines].map((line) => line.trim()).filter(Boolean).filter((line) => !/^Task run failed \([^)]*\)$/i.test(line));
+  const taskSourceFailure = meaningfulLines.find((line) => /failed to update task source/i.test(line));
+  if (taskSourceFailure) {
+    return `Task source update failed: ${taskSourceFailure}`;
+  }
+  const moduleFailure = meaningfulLines.find((line) => /cannot find module/i.test(line));
+  if (moduleFailure) {
+    return `Runtime module resolution failed: ${moduleFailure}`;
+  }
+  for (const line of [...meaningfulLines].reverse()) {
+    const trimmed = line.trim();
+    if (/server-managed task run cannot finish successfully/i.test(trimmed)) {
+      return `Task source remained open: ${trimmed}`;
+    }
+    if (/no api key found/i.test(trimmed)) {
+      return `Missing provider credentials: ${trimmed}`;
+    }
+    if (/no claude credentials found/i.test(trimmed)) {
+      return `Missing provider credentials: ${trimmed}`;
+    }
+    if (/unauthorized|authentication failed|invalid api key|api key is invalid/i.test(trimmed)) {
+      return `Provider authentication failed: ${trimmed}`;
+    }
+    if (/command not found|no such file or directory|enoent/i.test(trimmed)) {
+      return `Missing runtime executable: ${trimmed}`;
+    }
+    if (/bubblewrap|\bbwrap\b|sandbox-exec|sandbox/i.test(trimmed) && /missing|not found|failed|denied/i.test(trimmed)) {
+      return `Sandbox backend unavailable: ${trimmed}`;
+    }
+  }
+  return fallback;
+}
+function parsePositiveInt(value, option, fallback) {
+  if (!value) {
+    return fallback;
+  }
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new CliError2(`Invalid ${option} value: ${value}`);
+  }
+  return parsed;
+}
+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 reviewStatus = readTaskRunReviewStatus(reviewStatusPath);
+  if (reviewStatus !== "APPROVED") {
+    return { accepted: false, reason: null };
+  }
+  const taskResult = readJsonFile(taskResultPath, null);
+  if (taskResult?.status !== "completed") {
+    return { accepted: false, reason: null };
+  }
+  if (typeof input.artifactNotBeforeMs === "number" && Number.isFinite(input.artifactNotBeforeMs)) {
+    try {
+      const reviewStatusMtime = statSync(reviewStatusPath).mtimeMs;
+      if (reviewStatusMtime + 1000 < input.artifactNotBeforeMs) {
+        return { accepted: false, reason: null };
+      }
+    } catch {
+      return { accepted: false, reason: null };
+    }
+  }
+  return {
+    accepted: true,
+    reason: `task-result.json is completed and review-status.txt is APPROVED for task ${input.taskId}`
+  };
+}
+function resolvePiAcceptedArtifactExitGraceMs(env = process.env) {
+  const raw = env.RIG_PI_ACCEPTED_ARTIFACT_EXIT_GRACE_MS;
+  if (raw === undefined || raw.trim() === "")
+    return 30000;
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed < 0)
+    return 30000;
+  return parsed;
+}
+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 reviewStatus = readTaskRunReviewStatus(reviewStatusPath);
+  const reviewRejected = isTaskRunReviewRejected(reviewState);
+  if (reviewStatus === "APPROVED") {
+    return { shouldRetry: false, failureDetail: null, nextPrompt: null };
+  }
+  if (reviewStatus !== "REJECTED" && !reviewRejected) {
+    return { shouldRetry: false, failureDetail: null, nextPrompt: null };
+  }
+  const failureDetail = summarizeTaskRunReviewFailure(reviewState);
+  if (input.attempt >= input.maxAttempts) {
+    return { shouldRetry: false, failureDetail, nextPrompt: null };
+  }
+  return {
+    shouldRetry: true,
+    failureDetail,
+    nextPrompt: [
+      input.basePrompt,
+      "",
+      `Retry attempt ${input.attempt + 1}/${input.maxAttempts} for task ${input.taskId}.`,
+      "The previous attempt did not satisfy completion verification. Continue from the existing runtime workspace and PR state instead of starting over.",
+      "",
+      `Latest blocker: ${failureDetail}`,
+      "",
+      "Inspect these artifacts first:",
+      `- ${reviewStatusPath}`,
+      `- ${reviewStatePath}`,
+      `- ${reviewFeedbackPath}`,
+      `- ${failedApproachesPath}`,
+      `- ${validationSummaryPath}`,
+      "",
+      "Resolve the concrete issues recorded there, refresh the task artifacts if needed, rerun validation and completion verification, and do not stop until the task is actually accepted. When Greptile review is required, keep iterating until the review verdict is APPROVE with no unresolved comments."
+    ].join(`
+`)
+  };
+}
+function summarizeTaskRunReviewFailure(reviewState) {
+  if (!reviewState) {
+    return "Completion verification rejected the task. Read review-feedback.md for required fixes.";
+  }
+  const reasons = [
+    ...reviewState.local_reasons ?? [],
+    ...reviewState.ai_reasons ?? [],
+    ...reviewState.ai_warnings ?? []
+  ].map((value) => value.trim()).filter(Boolean);
+  if (reasons.length > 0) {
+    return reasons[0];
+  }
+  if (reviewState.mode === "required" && reviewState.verdict && reviewState.verdict !== "APPROVE") {
+    return `[AI Review] Required mode needs a completed Greptile approval; current verdict is ${reviewState.verdict}.`;
+  }
+  return "Completion verification rejected the task. Read review-feedback.md for required fixes.";
+}
+function readTaskRunReviewStatus(reviewStatusPath) {
+  if (!existsSync2(reviewStatusPath)) {
+    return null;
+  }
+  try {
+    const status = readFileSync2(reviewStatusPath, "utf8").trim().toUpperCase();
+    return status === "APPROVED" || status === "REJECTED" ? status : null;
+  } catch {
+    return null;
+  }
+}
+function isTaskRunReviewRejected(reviewState) {
+  if (!reviewState) {
+    return false;
+  }
+  if (reviewState.approved === false) {
+    return true;
+  }
+  return reviewState.mode === "required" && !!reviewState.verdict && reviewState.verdict !== "APPROVE";
+}
+function runSourceTaskIdentity(sourceTask) {
+  return sourceTask;
+}
+async function updateTaskSourceAfterDriverRun(projectRoot, runId, taskId, sourceTask, status, summary, input, updateTaskSource = updateConfiguredTaskSourceTask) {
+  if (!taskId)
+    return;
+  const config = await loadTaskRunAutomationConfig(projectRoot);
+  if (!shouldWriteDriverIssueUpdate(config, status))
+    return;
+  const result = await updateTaskSource(projectRoot, {
+    taskId,
+    sourceTask: runSourceTaskIdentity(sourceTask),
+    update: {
+      status,
+      comment: buildTaskRunLifecycleComment({
+        runId,
+        status,
+        summary,
+        runtimeWorkspace: input.latestRuntimeWorkspace,
+        logsDir: input.latestLogsDir,
+        sessionDir: input.latestSessionDir,
+        errorText: input.errorText
+      })
+    }
+  });
+  if (!result.updated && (result.source === "plugin" || result.sourceKind)) {
+    throw new Error(`Configured task source${result.sourceKind ? ` (${result.sourceKind})` : ""} did not accept lifecycle update for ${result.taskId}.`);
+  }
+}
+function readRunSourceTaskContract(projectRoot, runId, taskId) {
+  const run = readAuthorityRun3(projectRoot, runId);
+  const raw = run?.sourceTask;
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    return null;
+  }
+  const record = raw;
+  const id = typeof record.id === "string" && record.id.trim() ? record.id.trim() : taskId?.trim();
+  if (!id) {
+    return null;
+  }
+  return {
+    id,
+    ...optionalStringField(record, "title"),
+    ...optionalStringField(record, "description"),
+    ...optionalStringField(record, "body"),
+    ...optionalStringField(record, "acceptanceCriteria"),
+    ...optionalStringField(record, "acceptance_criteria"),
+    ...optionalStringField(record, "sourceIssueId"),
+    ...optionalStringField(record, "status"),
+    ...optionalStringField(record, "issueType"),
+    ...optionalStringField(record, "role"),
+    ...optionalStringField(record, "externalRef"),
+    scope: stringArrayField(record, "scope"),
+    validation: stringArrayField(record, "validation"),
+    validators: stringArrayField(record, "validators"),
+    labels: stringArrayField(record, "labels")
+  };
+}
+function optionalStringField(record, key) {
+  const value = record[String(key)];
+  return typeof value === "string" ? { [key]: value } : {};
+}
+function stringArrayField(record, key) {
+  const value = record[key];
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+}
+async function executeRigOwnedTaskRun(context, input) {
+  const runtimeTaskId = input.taskId?.trim() || `adhoc-${input.runId}`;
+  const sourceTask = readRunSourceTaskContract(context.projectRoot, input.runId, input.taskId);
+  const prompt = buildRunPrompt({
+    projectRoot: context.projectRoot,
+    taskId: input.taskId,
+    fallbackTitle: input.title,
+    fallbackDescription: sourceTask?.description ?? sourceTask?.body ?? null,
+    fallbackAcceptanceCriteria: sourceTask?.acceptanceCriteria ?? sourceTask?.acceptance_criteria ?? null,
+    sourceTask,
+    initialPrompt: input.initialPrompt,
+    runtimeAdapter: input.runtimeAdapter
+  });
+  const startedAt = new Date().toISOString();
+  const hostAgentBinary = await resolvePreferredShellBinary(context.projectRoot);
+  const baseAgentArgs = input.runtimeAdapter === "codex" ? [
+    "__rig_codex_app_server_task_run__",
+    "--runtime-mode",
+    input.runtimeMode,
+    "--interaction-mode",
+    input.interactionMode,
+    ...input.model ? ["--model", input.model] : [],
+    "--prompt"
+  ] : input.runtimeAdapter === "pi" ? [
+    "--print",
+    "--verbose",
+    "--mode",
+    "json",
+    "--no-session",
+    ...input.model ? ["--model", input.model] : []
+  ] : [
+    "--print",
+    "--verbose",
+    "--output-format",
+    "stream-json",
+    "--dangerously-skip-permissions"
+  ];
+  const buildHostAgentCommand = (attemptPrompt) => input.runtimeAdapter === "codex" ? [hostAgentBinary, ...baseAgentArgs, attemptPrompt] : [hostAgentBinary, ...baseAgentArgs];
+  const hostAgentCommand = buildHostAgentCommand(prompt);
+  const hostAgentCommandText = formatCommand(hostAgentCommand);
+  const provisioningAction = startRunAction(context.projectRoot, input.runId, {
+    actionId: `action:${input.runId}:runtime-provision`,
+    actionType: "engine.runtime.provision",
+    title: "Provision dedicated runtime",
+    detail: input.taskId ? `Preparing isolated worktree for ${input.taskId}` : "Preparing isolated runtime",
+    payload: {
+      hostAgentCommand,
+      formattedCommand: hostAgentCommandText,
+      taskId: input.taskId ?? null,
+      mode: "worktree"
+    }
+  });
+  upsertAgentAuthorityRun(context.projectRoot, {
+    runId: input.runId,
+    taskId: runtimeTaskId,
+    createdAt: startedAt,
+    runtimeAdapter: input.runtimeAdapter,
+    status: "created"
+  });
+  patchAuthorityRun(context.projectRoot, input.runId, {
+    status: "preparing",
+    startedAt,
+    completedAt: null,
+    errorText: null,
+    artifactRoot: null,
+    runtimeAdapter: input.runtimeAdapter,
+    runtimeMode: input.runtimeMode,
+    interactionMode: input.interactionMode,
+    runMode: input.runtimeMode === "full-access" ? "autonomous" : "interactive",
+    initialPrompt: input.initialPrompt ?? null,
+    title: input.taskId ? undefined : input.title ?? `Run ${input.runId}`,
+    pid: process.pid
+  });
+  emitServerRunEvent({
+    type: "status",
+    runId: input.runId,
+    status: "preparing",
+    detail: input.taskId ?? input.title ?? runtimeTaskId
+  });
+  appendRunLog(context.projectRoot, input.runId, {
+    id: `log:${input.runId}:start`,
+    title: "Rig task run started",
+    detail: input.taskId ?? input.title ?? runtimeTaskId,
+    tone: "info",
+    status: "preparing",
+    createdAt: startedAt
+  });
+  appendRunLog(context.projectRoot, input.runId, {
+    id: `log:${input.runId}:wrapper-command`,
+    title: "Agent wrapper command",
+    detail: hostAgentCommandText,
+    tone: "tool",
+    status: "preparing",
+    payload: {
+      command: hostAgentCommand,
+      formattedCommand: hostAgentCommandText
+    },
+    createdAt: new Date().toISOString()
+  });
+  emitServerRunEvent({ type: "log", runId: input.runId, title: "Agent wrapper command" });
+  const loadedAutomationConfig = await loadTaskRunAutomationConfig(context.projectRoot);
+  const automationConfig = input.prMode ? { ...loadedAutomationConfig ?? {}, pr: { ...loadedAutomationConfig?.pr ?? {}, mode: input.prMode } } : loadedAutomationConfig;
+  const planningClassification = classifyPlanningNeed({ config: automationConfig, sourceTask });
+  patchAuthorityRun(context.projectRoot, input.runId, { planning: planningClassification });
+  if (input.runtimeAdapter === "pi") {
+    for (const stage of ["Connect", "GitHub/task sync", "Prepare workspace", "Launch Pi", "Plan", "Implement"]) {
+      appendPiStageLog({
+        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,
+        status: stage === "Implement" || stage === "Launch Pi" ? "running" : "completed"
+      });
+    }
+  }
+  appendRunTimeline(context.projectRoot, input.runId, {
+    id: `message:${input.runId}:user`,
+    type: "user_message",
+    text: prompt,
+    createdAt: startedAt,
+    state: "completed",
+    completedAt: startedAt
+  });
+  emitServerRunEvent({ type: "timeline", runId: input.runId });
+  await context.emitEvent("command.started", {
+    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}`)}`,
+    startedAt,
+    dryRun: false
+  });
+  const assistantMessageId = `message:${input.runId}:assistant`;
+  let assistantText = "";
+  const pendingClaudeToolUses = new Map;
+  const pendingCodexToolUses = new Map;
+  let launchAction;
+  let verificationAction;
+  let reviewAction;
+  let verificationStarted = false;
+  let reviewStarted = false;
+  let latestRuntimeWorkspace = null;
+  let latestSessionDir = null;
+  let latestLogsDir = null;
+  let latestProviderCommand = null;
+  let latestRuntimeBranch = null;
+  let snapshotSidecarPromise = null;
+  let dirtyBaselineApplied = false;
+  const childEnv = {
+    ...process.env,
+    ...input.runtimeAdapter === "pi" ? buildPiRigBridgeEnv({
+      projectRoot: context.projectRoot,
+      runId: input.runId,
+      taskId: runtimeTaskId,
+      serverUrl: process.env.RIG_SERVER_URL ?? null,
+      authToken: process.env.RIG_AUTH_TOKEN ?? null,
+      githubToken: process.env.RIG_GITHUB_TOKEN ?? process.env.GITHUB_TOKEN ?? process.env.GH_TOKEN ?? null
+    }) : {
+      PROJECT_RIG_ROOT: context.projectRoot,
+      RIG_TASK_ID: runtimeTaskId,
+      RIG_RUNTIME_ADAPTER: input.runtimeAdapter,
+      RIG_SERVER_RUN_ID: input.runId
+    },
+    ...sourceTask ? { RIG_SOURCE_TASK_JSON: JSON.stringify(sourceTask) } : {}
+  };
+  Object.assign(childEnv, buildTaskRunReviewEnv(automationConfig));
+  const automationLimits = resolveTaskRunAutomationLimits(automationConfig);
+  const maxAttempts = automationLimits.maxValidationAttempts;
+  const promoteToValidating = (detail) => {
+    if (verificationStarted)
+      return;
+    verificationStarted = true;
+    patchAuthorityRun(context.projectRoot, input.runId, { status: "validating" });
+    emitServerRunEvent({ type: "status", runId: input.runId, status: "validating", detail: detail ?? null });
+    verificationAction = startRunAction(context.projectRoot, input.runId, {
+      actionId: `action:${input.runId}:completion-verification`,
+      actionType: "completion-verification",
+      title: "Run completion verification",
+      detail: detail ?? "Rig completion-verification hook is running."
+    });
+  };
+  const promoteToReviewing = (detail) => {
+    if (reviewStarted)
+      return;
+    reviewStarted = true;
+    patchAuthorityRun(context.projectRoot, input.runId, { status: "reviewing" });
+    emitServerRunEvent({ type: "status", runId: input.runId, status: "reviewing", detail: detail ?? null });
+    reviewAction = startRunAction(context.projectRoot, input.runId, {
+      actionId: `action:${input.runId}:review-closeout`,
+      actionType: "run.review",
+      title: "Finalize run review",
+      detail: detail ?? "Verifier review is running."
+    });
+  };
+  const handleWrapperEvent = (rawPayload) => {
+    let event = null;
+    try {
+      event = JSON.parse(rawPayload);
+    } catch {
+      return false;
+    }
+    if (!event?.type)
+      return false;
+    const payload = event.payload ?? {};
+    if (event.type === "runtime.provision.completed") {
+      latestRuntimeWorkspace = typeof payload.workspaceDir === "string" ? payload.workspaceDir : latestRuntimeWorkspace;
+      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;
+      latestRuntimeBranch = runtimeId;
+      provisioningAction.complete(latestRuntimeWorkspace ?? "Runtime ready.", {
+        runtimeId: runtimeId ?? null,
+        workspaceDir: latestRuntimeWorkspace,
+        sessionDir: latestSessionDir,
+        logsDir: latestLogsDir,
+        contextFile: payload.contextFile ?? null
+      });
+      patchAuthorityRun(context.projectRoot, input.runId, {
+        status: "running",
+        worktreePath: latestRuntimeWorkspace,
+        artifactRoot: latestRuntimeWorkspace && input.taskId ? resolve4(latestRuntimeWorkspace, "artifacts", input.taskId) : null,
+        logRoot: latestLogsDir,
+        sessionPath: latestSessionDir ? resolve4(latestSessionDir, "session.json") : null,
+        sessionLogPath: latestLogsDir ? resolve4(latestLogsDir, "agent-stdout.log") : null,
+        branch: runtimeId
+      });
+      if (!dirtyBaselineApplied && input.baselineMode === "dirty-snapshot" && latestRuntimeWorkspace) {
+        dirtyBaselineApplied = true;
+        const dirty = applyDirtyBaselineSnapshot({ sourceRoot: context.projectRoot, targetRoot: latestRuntimeWorkspace });
+        appendRunLog(context.projectRoot, input.runId, {
+          id: `log:${input.runId}:dirty-baseline`,
+          title: "Dirty baseline snapshot",
+          detail: dirty.detail,
+          tone: dirty.applied ? "tool" : "info",
+          status: dirty.applied ? "completed" : "skipped",
+          createdAt: new Date().toISOString()
+        });
+        emitServerRunEvent({ type: "log", runId: input.runId, title: "Dirty baseline snapshot" });
+      }
+      if (!snapshotSidecarPromise && runtimeId && loadRuntimeSnapshotConfig(context.projectRoot).enabled) {
+        snapshotSidecarPromise = (async () => {
+          const { sidecar, error } = await resolveTaskRunSnapshotSidecar({
+            projectRoot: context.projectRoot,
+            runtimeId,
+            workspaceDir: latestRuntimeWorkspace,
+            listRuntimes: listAgentRuntimes,
+            startSidecar: (runtime) => startRuntimeSnapshotSidecar(runtime, { instanceId: `${runtime.id}-run-${input.runId}` })
+          });
+          if (!sidecar) {
+            appendRunLog(context.projectRoot, input.runId, {
+              id: `log:${input.runId}:snapshot-unavailable`,
+              title: "Runtime snapshotting unavailable",
+              detail: error ?? `Could not locate runtime metadata for ${runtimeId}.`,
+              tone: "error",
+              status: "running",
+              createdAt: new Date().toISOString()
+            });
+            emitServerRunEvent({ type: "log", runId: input.runId, title: "Runtime snapshotting unavailable" });
+            return null;
+          }
+          return sidecar;
+        })();
+      }
+      emitServerRunEvent({
+        type: "status",
+        runId: input.runId,
+        status: "running",
+        detail: latestRuntimeWorkspace
+      });
+      return true;
+    }
+    if (event.type === "runtime.provision.failed") {
+      const detail = typeof payload.error === "string" ? payload.error : "Runtime provisioning failed.";
+      provisioningAction.fail(detail, payload);
+      emitServerRunEvent({ type: "failed", runId: input.runId, error: detail });
+      return true;
+    }
+    if (event.type === "provider.launch") {
+      const command = Array.isArray(payload.command) ? payload.command.filter((value) => typeof value === "string") : [];
+      latestProviderCommand = command.length > 0 ? command : null;
+      const commandText = command.length > 0 ? formatCommand(command) : String(payload.provider ?? "provider");
+      launchAction = startRunAction(context.projectRoot, input.runId, {
+        actionId: `action:${input.runId}:provider-launch`,
+        actionType: "agent.launch",
+        title: "Launch agent runtime",
+        detail: commandText,
+        payload: {
+          runtimeAdapter: input.runtimeAdapter,
+          runtimeMode: input.runtimeMode,
+          interactionMode: input.interactionMode,
+          workspaceDir: payload.workspaceDir ?? latestRuntimeWorkspace,
+          command,
+          formattedCommand: commandText
+        }
+      });
+      appendRunLog(context.projectRoot, input.runId, {
+        id: `log:${input.runId}:provider-command`,
+        title: "Agent launch command",
+        detail: commandText,
+        tone: "tool",
+        status: "running",
+        payload: {
+          command,
+          formattedCommand: commandText
+        },
+        createdAt: new Date().toISOString()
+      });
+      emitServerRunEvent({ type: "log", runId: input.runId, title: "Agent launch command" });
+      return true;
+    }
+    if (event.type === "provider.completed") {
+      const exitCode = typeof payload.exitCode === "number" ? payload.exitCode : null;
+      if (launchAction) {
+        if (exitCode === 0) {
+          launchAction.complete("Agent runtime finished.");
+        } else {
+          launchAction.fail(`Agent runtime failed (${String(exitCode ?? "unknown")})`, payload);
+        }
+      }
+      return true;
+    }
+    return false;
+  };
+  const nextRunLogId = createRunLogIdFactory(input.runId);
+  const handleAgentStdoutLine = (line) => {
+    const trimmed = line.trim();
+    if (!trimmed)
+      return;
+    if (trimmed.startsWith("__RIG_WRAPPER_EVENT__")) {
+      if (handleWrapperEvent(trimmed.slice("__RIG_WRAPPER_EVENT__".length))) {
+        emitServerRunEvent({ type: "timeline", runId: input.runId });
+        return;
+      }
+    }
+    const completionLine = classifyCompletionVerificationLine(trimmed);
+    if (completionLine.isCompletionLine) {
+      promoteToValidating(trimmed);
+      if (completionLine.isVerifierReview) {
+        if (verificationAction) {
+          verificationAction.complete("Completion verification checks finished.");
+        }
+        promoteToReviewing(trimmed);
+      }
+      appendRunLog(context.projectRoot, input.runId, {
+        id: nextRunLogId(),
+        title: verificationStarted ? "Completion verification" : "Agent output",
+        detail: trimmed,
+        tone: "info",
+        status: reviewStarted ? "reviewing" : verificationStarted ? "validating" : "running",
+        createdAt: new Date().toISOString()
+      });
+      emitServerRunEvent({ type: "log", runId: input.runId, title: verificationStarted ? "Completion verification" : "Agent output" });
+      return;
+    }
+    try {
+      const record = JSON.parse(trimmed);
+      const liveLogStatus = reviewStarted ? "reviewing" : verificationStarted ? "validating" : "running";
+      const providerLogs = input.runtimeAdapter === "codex" ? buildCodexLogsFromRecord({
+        runId: input.runId,
+        record,
+        createdAtFallback: new Date().toISOString(),
+        status: liveLogStatus,
+        pendingToolUses: pendingCodexToolUses
+      }) : buildClaudeLogsFromRecord({
+        runId: input.runId,
+        record,
+        createdAtFallback: new Date().toISOString(),
+        status: liveLogStatus,
+        pendingToolUses: pendingClaudeToolUses
+      });
+      if (providerLogs.length > 0) {
+        for (const providerLog of providerLogs) {
+          appendRunLog(context.projectRoot, input.runId, providerLog);
+          emitServerRunEvent({ type: "log", runId: input.runId, title: providerLog.title });
+        }
+      }
+      if (input.runtimeAdapter === "codex") {
+        const nextAssistantText = extractCodexAssistantMessageText(record);
+        if (nextAssistantText) {
+          assistantText = nextAssistantText;
+          appendRunTimeline(context.projectRoot, input.runId, {
+            id: assistantMessageId,
+            type: "assistant_message",
+            text: assistantText,
+            state: "streaming",
+            createdAt: new Date().toISOString()
+          });
+          emitServerRunEvent({ type: "timeline", runId: input.runId });
+          return;
+        }
+        if (providerLogs.length > 0 || isCodexExecRecord(record)) {
+          return;
+        }
+      }
+      if (record.type === "message_update") {
+        const assistantMessageEvent = record.assistantMessageEvent && typeof record.assistantMessageEvent === "object" ? record.assistantMessageEvent : null;
+        if (assistantMessageEvent?.type === "text_delta" && typeof assistantMessageEvent.delta === "string") {
+          assistantText += assistantMessageEvent.delta;
+          appendRunTimeline(context.projectRoot, input.runId, {
+            id: assistantMessageId,
+            type: "assistant_message",
+            text: assistantText,
+            state: "streaming",
+            createdAt: new Date().toISOString()
+          });
+          emitServerRunEvent({ type: "timeline", runId: input.runId });
+          return;
+        }
+      }
+      if (record.type === "stream_event") {
+        const event = record.event && typeof record.event === "object" ? record.event : null;
+        const delta = event?.delta && typeof event.delta === "object" ? event.delta : null;
+        if (delta?.type === "text_delta" && typeof delta.text === "string") {
+          assistantText += delta.text;
+          appendRunTimeline(context.projectRoot, input.runId, {
+            id: assistantMessageId,
+            type: "assistant_message",
+            text: assistantText,
+            state: "streaming",
+            createdAt: new Date().toISOString()
+          });
+          emitServerRunEvent({ type: "timeline", runId: input.runId });
+          return;
+        }
+      }
+      if (record.type === "assistant") {
+        const message = record.message && typeof record.message === "object" ? record.message : record;
+        const content = Array.isArray(message.content) ? message.content : [];
+        const nextText = content.map((entry) => entry && typeof entry === "object" && entry.type === "text" ? String(entry.text ?? "") : "").join("");
+        if (nextText.length > assistantText.length) {
+          assistantText = nextText;
+          appendRunTimeline(context.projectRoot, input.runId, {
+            id: assistantMessageId,
+            type: "assistant_message",
+            text: assistantText,
+            state: "streaming",
+            createdAt: new Date().toISOString()
+          });
+          emitServerRunEvent({ type: "timeline", runId: input.runId });
+        }
+        return;
+      }
+      if (providerLogs.length > 0) {
+        return;
+      }
+    } catch {}
+    appendRunLog(context.projectRoot, input.runId, {
+      id: nextRunLogId(),
+      title: verificationStarted ? "Completion verification" : "Agent output",
+      detail: trimmed,
+      tone: "info",
+      status: reviewStarted ? "reviewing" : verificationStarted ? "validating" : "running",
+      createdAt: new Date().toISOString()
+    });
+    emitServerRunEvent({ type: "log", runId: input.runId, title: verificationStarted ? "Completion verification" : "Agent output" });
+  };
+  let currentPrompt = prompt;
+  let exit = null;
+  let reviewFailureDetail = null;
+  const stderrLines = [];
+  const piAcceptedArtifactExitGraceMs = resolvePiAcceptedArtifactExitGraceMs(childEnv);
+  for (let attempt = 1;attempt <= maxAttempts; attempt += 1) {
+    const attemptHostAgentCommand = buildHostAgentCommand(currentPrompt);
+    const child = spawn(attemptHostAgentCommand[0], attemptHostAgentCommand.slice(1), {
+      cwd: context.projectRoot,
+      env: childEnv,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const forwardSigterm = () => {
+      try {
+        child.kill("SIGTERM");
+      } catch {}
+    };
+    process.once("SIGTERM", forwardSigterm);
+    if (input.runtimeAdapter === "claude-code" || input.runtimeAdapter === "pi") {
+      child.stdin.write(currentPrompt);
+      child.stdin.end();
+    } else {
+      child.stdin.end();
+    }
+    const stdout = createLineInterface({ input: child.stdout });
+    stdout.on("line", handleAgentStdoutLine);
+    const stderr = createLineInterface({ input: child.stderr });
+    stderr.on("line", (line) => {
+      const trimmed = line.trim();
+      if (!trimmed)
+        return;
+      stderrLines.push(trimmed);
+      appendRunLog(context.projectRoot, input.runId, {
+        id: nextRunLogId(),
+        title: "Agent stderr",
+        detail: trimmed,
+        tone: "error",
+        status: reviewStarted ? "reviewing" : verificationStarted ? "validating" : "running",
+        createdAt: new Date().toISOString()
+      });
+      emitServerRunEvent({ type: "log", runId: input.runId, title: "Agent stderr" });
+    });
+    let acceptedArtifactExit = false;
+    let acceptedArtifactObservedAt = null;
+    let acceptedArtifactPollTimer = null;
+    let acceptedArtifactKillTimer = null;
+    const attemptExit = await new Promise((resolve5) => {
+      let settled = false;
+      const settle = (result) => {
+        if (settled)
+          return;
+        settled = true;
+        if (acceptedArtifactPollTimer)
+          clearInterval(acceptedArtifactPollTimer);
+        resolve5(result);
+      };
+      const pollAcceptedArtifacts = () => {
+        const artifactState = readTaskRunAcceptedArtifactState({
+          taskId: input.taskId ?? runtimeTaskId,
+          workspaceDir: latestRuntimeWorkspace,
+          artifactNotBeforeMs: Date.parse(startedAt)
+        });
+        if (!artifactState.accepted) {
+          acceptedArtifactObservedAt = null;
+          return;
+        }
+        acceptedArtifactObservedAt ??= Date.now();
+        if (Date.now() - acceptedArtifactObservedAt < piAcceptedArtifactExitGraceMs || acceptedArtifactExit) {
+          return;
+        }
+        acceptedArtifactExit = true;
+        const detail = [
+          artifactState.reason ?? "Rig accepted task artifacts are present.",
+          `Pi has not exited after ${piAcceptedArtifactExitGraceMs}ms; terminating the stale Pi process so Rig can continue PR/issue closeout.`
+        ].join(" ");
+        appendRunLog(context.projectRoot, input.runId, {
+          id: `log:${input.runId}:pi-accepted-artifacts-exit`,
+          title: "Pi accepted artifacts; continuing closeout",
+          detail,
+          tone: "info",
+          status: "running",
+          createdAt: new Date().toISOString()
+        });
+        emitServerRunEvent({ type: "log", runId: input.runId, title: "Pi accepted artifacts; continuing closeout" });
+        try {
+          child.kill("SIGTERM");
+        } catch {}
+        acceptedArtifactKillTimer = setTimeout(() => {
+          try {
+            child.kill("SIGKILL");
+          } catch {}
+          settle({ code: 0, signal: "SIGKILL" });
+        }, 5000);
+      };
+      child.once("error", (error) => {
+        if (acceptedArtifactKillTimer)
+          clearTimeout(acceptedArtifactKillTimer);
+        console.error(`[rig] agent process error: ${error.message}`);
+        settle({ code: 1, signal: null, error });
+      });
+      child.once("close", (code, signal) => {
+        if (acceptedArtifactKillTimer)
+          clearTimeout(acceptedArtifactKillTimer);
+        settle(acceptedArtifactExit ? { code: 0, signal: signal ?? "SIGTERM" } : { code, signal });
+      });
+      if (input.runtimeAdapter === "pi") {
+        acceptedArtifactPollTimer = setInterval(pollAcceptedArtifacts, 5000);
+        acceptedArtifactPollTimer.unref?.();
+      }
+    });
+    await finalizeTaskRunSnapshot({
+      snapshotSidecarPromise,
+      latestProviderCommand,
+      hostAgentCommand: attemptHostAgentCommand,
+      exit: attemptExit
+    });
+    const pendingLogs = input.runtimeAdapter === "codex" ? flushPendingCodexToolUseLogs({
+      runId: input.runId,
+      status: typeof attemptExit.code === "number" && attemptExit.code === 0 ? "completed" : "failed",
+      pendingToolUses: pendingCodexToolUses
+    }) : flushPendingClaudeToolUseLogs({
+      runId: input.runId,
+      status: typeof attemptExit.code === "number" && attemptExit.code === 0 ? "completed" : "failed",
+      pendingToolUses: pendingClaudeToolUses
+    });
+    for (const pendingLog of pendingLogs) {
+      appendRunLog(context.projectRoot, input.runId, pendingLog);
+      emitServerRunEvent({ type: "log", runId: input.runId, title: pendingLog.title });
+    }
+    process.off("SIGTERM", forwardSigterm);
+    if (attemptExit.error) {
+      throw new CliError2(`Task run failed to start: ${attemptExit.error.message}`, 1);
+    }
+    const retryContext = resolveTaskRunRetryContext({
+      projectRoot: context.projectRoot,
+      taskId: input.taskId ?? null,
+      workspaceDir: latestRuntimeWorkspace,
+      attempt,
+      maxAttempts,
+      basePrompt: prompt
+    });
+    if (retryContext.shouldRetry && retryContext.nextPrompt) {
+      const failureDetail = retryContext.failureDetail ?? summarizeValidationFailure(context.projectRoot, input.taskId ?? null) ?? "Rig validation failed.";
+      const retrySteering = buildPiValidationRetrySteeringPrompt({
+        taskId: input.taskId ?? runtimeTaskId,
+        attempt,
+        maxAttempts,
+        failureDetail,
+        validationOutput: summarizeValidationFailure(context.projectRoot, input.taskId ?? null)
+      });
+      currentPrompt = [retryContext.nextPrompt, "", "Rig Pi steering message:", retrySteering].join(`
+`);
+      reviewFailureDetail = failureDetail;
+      patchAuthorityRun(context.projectRoot, input.runId, {
+        status: "validating",
+        completedAt: null,
+        errorText: null
+      });
+      appendPiStageLog({
+        projectRoot: context.projectRoot,
+        runId: input.runId,
+        stage: "Validate",
+        detail: failureDetail,
+        tone: "error",
+        status: "validating"
+      });
+      appendRunLog(context.projectRoot, input.runId, {
+        id: `log:${input.runId}:retry:${attempt + 1}`,
+        title: `Steering Pi to retry validation (attempt ${attempt + 1}/${maxAttempts})`,
+        detail: retrySteering,
+        tone: "info",
+        status: "running",
+        createdAt: new Date().toISOString()
+      });
+      emitServerRunEvent({
+        type: "status",
+        runId: input.runId,
+        status: "validating",
+        detail: failureDetail
+      });
+      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})` });
+      continue;
+    }
+    exit = attemptExit;
+    reviewFailureDetail = retryContext.failureDetail;
+    break;
+  }
+  if (!exit) {
+    throw new CliError2(`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);
+  }
+  if (assistantText.trim()) {
+    appendRunTimeline(context.projectRoot, input.runId, {
+      id: assistantMessageId,
+      type: "assistant_message",
+      text: assistantText,
+      state: "completed",
+      createdAt: new Date().toISOString(),
+      completedAt: new Date().toISOString()
+    });
+    emitServerRunEvent({ type: "timeline", runId: input.runId });
+  }
+  if (exit.code !== 0 || reviewFailureDetail) {
+    const failedAt = new Date().toISOString();
+    const failureDetail = reviewFailureDetail ?? summarizeValidationFailure(context.projectRoot, input.taskId ?? null) ?? summarizeTaskRunProcessFailure({
+      exitCode: exit.code,
+      signal: exit.signal,
+      stderrLines
+    });
+    if (verificationAction && !reviewStarted) {
+      verificationAction.fail(failureDetail);
+    }
+    if (reviewAction) {
+      reviewAction.fail(failureDetail);
+    }
+    let terminalFailureDetail = failureDetail;
+    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.", {
+        latestRuntimeWorkspace,
+        latestLogsDir,
+        latestSessionDir,
+        errorText: failureDetail
+      });
+    } catch (error) {
+      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,
+      errorText: terminalFailureDetail
+    });
+    appendRunLog(context.projectRoot, input.runId, {
+      id: `log:${input.runId}:${terminalRunStatus}`,
+      title: terminalRunStatus === "needs_attention" ? "Task run needs attention" : "Task run failed",
+      detail: terminalFailureDetail,
+      tone: "error",
+      status: terminalRunStatus,
+      createdAt: failedAt
+    });
+    emitServerRunEvent({
+      type: "failed",
+      runId: input.runId,
+      error: terminalFailureDetail
+    });
+    throw new CliError2(terminalFailureDetail, exit.code ?? 1);
+  }
+  const runPiPrFeedbackFix = async (message) => {
+    appendPiStageLog({
+      projectRoot: context.projectRoot,
+      runId: input.runId,
+      stage: "Implement",
+      detail: "Pi is applying PR review/CI feedback.",
+      status: "running"
+    });
+    appendRunLog(context.projectRoot, input.runId, {
+      id: `log:${input.runId}:pr-feedback-pi:${Date.now()}`,
+      title: "Steering Pi from PR feedback",
+      detail: message,
+      tone: "info",
+      status: "reviewing",
+      createdAt: new Date().toISOString()
+    });
+    emitServerRunEvent({ type: "log", runId: input.runId, title: "Steering Pi from PR feedback" });
+    const feedbackCommand = buildHostAgentCommand(message);
+    const child = spawn(feedbackCommand[0], feedbackCommand.slice(1), {
+      cwd: latestRuntimeWorkspace ?? context.projectRoot,
+      env: childEnv,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    if (input.runtimeAdapter === "claude-code" || input.runtimeAdapter === "pi") {
+      child.stdin.write(message);
+    }
+    child.stdin.end();
+    const stdout = createLineInterface({ input: child.stdout });
+    stdout.on("line", (line) => {
+      const trimmed = line.trim();
+      if (!trimmed)
+        return;
+      appendRunLog(context.projectRoot, input.runId, {
+        id: nextRunLogId(),
+        title: "Pi PR feedback fix output",
+        detail: trimmed,
+        tone: "info",
+        status: "reviewing",
+        createdAt: new Date().toISOString()
+      });
+      emitServerRunEvent({ type: "log", runId: input.runId, title: "Pi PR feedback fix output" });
+    });
+    const stderr = createLineInterface({ input: child.stderr });
+    stderr.on("line", (line) => {
+      const trimmed = line.trim();
+      if (!trimmed)
+        return;
+      appendRunLog(context.projectRoot, input.runId, {
+        id: nextRunLogId(),
+        title: "Pi PR feedback fix stderr",
+        detail: trimmed,
+        tone: "error",
+        status: "reviewing",
+        createdAt: new Date().toISOString()
+      });
+      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));
+    });
+    if (exitCode !== 0) {
+      throw new Error(`Pi PR feedback fix failed with exit code ${exitCode}.`);
+    }
+  };
+  try {
+    appendPiStageLog({
+      projectRoot: context.projectRoot,
+      runId: input.runId,
+      stage: "Validate",
+      detail: "Rig validation accepted the task run.",
+      status: "completed"
+    });
+    const postValidation = await runTaskRunPostValidationLifecycle({
+      projectRoot: context.projectRoot,
+      runId: input.runId,
+      taskId: input.taskId,
+      runtimeTaskId,
+      runtimeWorkspace: latestRuntimeWorkspace,
+      branch: latestRuntimeBranch,
+      config: automationConfig,
+      sourceTask,
+      steerPi: input.runtimeAdapter === "pi" ? runPiPrFeedbackFix : undefined,
+      appendStage: (stage, detail, status, tone) => appendPiStageLog({
+        projectRoot: context.projectRoot,
+        runId: input.runId,
+        stage,
+        detail,
+        status,
+        tone
+      })
+    });
+    if (postValidation.status === "needs_attention") {
+      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,
+        errorText: failureDetail
+      });
+      emitServerRunEvent({ type: "failed", runId: input.runId, error: failureDetail });
+      throw new CliError2(failureDetail, 1);
+    }
+  } catch (error) {
+    if (error instanceof CliError2) {
+      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,
+      errorText: failureDetail
+    });
+    appendRunLog(context.projectRoot, input.runId, {
+      id: `log:${input.runId}:pr-closeout-failed`,
+      title: "PR/issue closeout failed",
+      detail: failureDetail,
+      tone: "error",
+      status: "failed",
+      createdAt: failedAt
+    });
+    emitServerRunEvent({ type: "failed", runId: input.runId, error: failureDetail });
+    throw new CliError2(failureDetail, 1);
+  }
+  if (verificationAction && !reviewStarted) {
+    verificationAction.complete("Completion verification checks finished.");
+  }
+  if (!reviewAction) {
+    promoteToReviewing("Task finished; finalizing run state.");
+  }
+  if (reviewAction) {
+    reviewAction.complete("Run marked completed.");
+  }
+  patchAuthorityRun(context.projectRoot, input.runId, {
+    status: "completed",
+    completedAt: new Date().toISOString()
+  });
+  emitServerRunEvent({ type: "completed", runId: input.runId });
+  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: new Date().toISOString()
+  });
+}
+export {
+  taskRunStageLogId,
+  summarizeTaskRunProcessFailure,
+  runTaskRunPostValidationLifecycle,
+  resolveTaskRunAutomationLimits,
+  readTaskRunAcceptedArtifactState,
+  executeRigOwnedTaskRun,
+  createRunLogIdFactory,
+  classifyValidationRetryOutcome,
+  classifyPlanningNeed,
+  classifyCompletionVerificationLine,
+  canonicalPiRunStages,
+  buildTaskRunReviewEnv,
+  buildPiValidationRetrySteeringPrompt,
+  buildPiRigBridgeEnv,
+  applyDirtyBaselineSnapshot
+};