@h-rig/cli 0.0.6-alpha.13 → 0.0.6-alpha.15

package/dist/bin/rig.js

@@ -2671,17 +2671,17 @@ function resolveSelectedConnection(projectRoot, options = {}) {
 }
 
 // packages/cli/src/commands/_server-client.ts
-import { spawnSync } from "child_process";
 import { existsSync as existsSync5, readFileSync as readFileSync3 } from "fs";
 import { resolve as resolve9 } from "path";
 import { ensureLocalRigServerConnection } from "@rig/runtime/local-server";
-var cachedGitHubBearerToken;
+var scopedGitHubBearerTokens = new Map;
 function cleanToken(value) {
   const trimmed = value?.trim();
   return trimmed ? trimmed : null;
 }
-function setGitHubBearerTokenForCurrentProcess(token) {
-  cachedGitHubBearerToken = cleanToken(token ?? undefined);
+function setGitHubBearerTokenForCurrentProcess(token, projectRoot) {
+  const scopedKey = resolve9(projectRoot ?? process.cwd());
+  scopedGitHubBearerTokens.set(scopedKey, cleanToken(token ?? undefined));
 }
 function readPrivateRemoteSessionToken(projectRoot) {
   const path = resolve9(projectRoot, ".rig", "state", "github-auth.json");
@@ -2695,25 +2695,13 @@ function readPrivateRemoteSessionToken(projectRoot) {
   }
 }
 function readGitHubBearerTokenForRemote(projectRoot) {
-  if (cachedGitHubBearerToken !== undefined)
-    return cachedGitHubBearerToken;
+  const scopedKey = resolve9(projectRoot);
+  if (scopedGitHubBearerTokens.has(scopedKey))
+    return scopedGitHubBearerTokens.get(scopedKey) ?? null;
   const privateSession = readPrivateRemoteSessionToken(projectRoot);
-  if (privateSession) {
-    cachedGitHubBearerToken = privateSession;
-    return cachedGitHubBearerToken;
-  }
-  const envToken = cleanToken(process.env.RIG_GITHUB_TOKEN) ?? cleanToken(process.env.GITHUB_TOKEN) ?? cleanToken(process.env.GH_TOKEN);
-  if (envToken) {
-    cachedGitHubBearerToken = envToken;
-    return cachedGitHubBearerToken;
-  }
-  const result = spawnSync("gh", ["auth", "token"], {
-    encoding: "utf8",
-    timeout: 5000,
-    stdio: ["ignore", "pipe", "ignore"]
-  });
-  cachedGitHubBearerToken = result.status === 0 ? cleanToken(result.stdout) : null;
-  return cachedGitHubBearerToken;
+  if (privateSession)
+    return privateSession;
+  return cleanToken(process.env.RIG_SERVER_AUTH_TOKEN) ?? cleanToken(process.env.RIG_REMOTE_AUTH_TOKEN);
 }
 async function ensureServerForCli(projectRoot) {
   try {
@@ -2911,6 +2899,37 @@ async function getRunLogsViaServer(context, runId, options = {}) {
   const payload = await requestServerJson(context, `${url.pathname}${url.search}`);
   return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { entries: [] };
 }
+async function getRunTimelineViaServer(context, runId, options = {}) {
+  const url = new URL(`http://rig.local/api/runs/${encodeURIComponent(runId)}/timeline`);
+  if (options.limit !== undefined)
+    url.searchParams.set("limit", String(options.limit));
+  if (options.cursor)
+    url.searchParams.set("cursor", options.cursor);
+  const payload = await requestServerJson(context, `${url.pathname}${url.search}`);
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { entries: [] };
+}
+async function ensureTaskLabelsViaServer(context) {
+  const payload = await requestServerJson(context, "/api/workspace/task-labels", { method: "POST" });
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
+}
+async function listGitHubProjectsViaServer(context, owner) {
+  const url = new URL("http://rig.local/api/github/projects");
+  url.searchParams.set("owner", owner);
+  const payload = await requestServerJson(context, `${url.pathname}${url.search}`);
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : { projects: [] };
+}
+async function getGitHubProjectStatusFieldViaServer(context, projectId) {
+  const payload = await requestServerJson(context, `/api/github/projects/${encodeURIComponent(projectId)}/status-field`);
+  return payload && typeof payload === "object" && !Array.isArray(payload) ? 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 };
+}
 async function stopRunViaServer(context, runId) {
   const payload = await requestServerJson(context, "/api/runs/stop", {
     method: "POST",
@@ -3190,6 +3209,9 @@ function permissionAllowsPr(payload) {
   }
   return null;
 }
+function isNotFoundError(error) {
+  return /\b(404|not found)\b/i.test(message(error));
+}
 function projectCheckoutReady(payload) {
   if (!payload || typeof payload !== "object" || Array.isArray(payload))
     return null;
@@ -3222,19 +3244,33 @@ async function runFastTaskRunPreflight(context, options = {}) {
   const checks = [];
   const request = options.requestJson ?? ((pathname, init) => requestServerJson(context, pathname, init));
   const taskId = options.taskId?.trim() || null;
+  const requiresCurrentRunApi = Boolean(taskId);
+  const selectedServer = options.requestJson ? null : await ensureServerForCli(context.projectRoot).catch(() => null);
+  const allowLocalLegacyTaskRunCompatibility = selectedServer?.connectionKind === "local";
+  let legacyServerCompatibility = false;
   try {
     await request("/api/server/status");
     checks.push(preflightCheck("server", "Rig server reachable", "pass"));
   } catch (error) {
-    checks.push(preflightCheck("server", "Rig server reachable", "fail", message(error), "Start or select a reachable Rig server."));
+    if (isNotFoundError(error)) {
+      try {
+        await request("/health");
+        legacyServerCompatibility = !requiresCurrentRunApi || allowLocalLegacyTaskRunCompatibility;
+        checks.push(requiresCurrentRunApi && !allowLocalLegacyTaskRunCompatibility ? preflightCheck("server", "Rig server reachable", "fail", "legacy /health endpoint only; current task-run APIs are required", "Upgrade/select the Rig server before launching a task run.") : preflightCheck("server", "Rig server reachable", "pass", allowLocalLegacyTaskRunCompatibility ? "local legacy /health endpoint; submit endpoint will be authoritative" : "legacy /health endpoint"));
+      } catch (healthError) {
+        checks.push(preflightCheck("server", "Rig server reachable", "fail", message(healthError), "Start or select a reachable Rig server."));
+      }
+    } else {
+      checks.push(preflightCheck("server", "Rig server reachable", "fail", message(error), "Start or select a reachable Rig server."));
+    }
   }
   const repo = readRepoConnection(context.projectRoot);
-  checks.push(repo ? preflightCheck("project-link", "project linked to Rig connection", repo.project ? "pass" : "warn", `${repo.selected}${repo.project ? ` -> ${repo.project}` : ""}`, "Run `rig init --yes --repo owner/repo` to record the GitHub repo slug.") : preflightCheck("project-link", "project linked to Rig connection", "fail", "missing .rig/state/connection.json", "Run `rig init` or `rig connect use <alias|local>`."));
+  checks.push(repo ? preflightCheck("project-link", "project linked to Rig connection", repo.project ? "pass" : "warn", `${repo.selected}${repo.project ? ` -> ${repo.project}` : ""}`, "Run `rig init --yes --repo owner/repo` to record the GitHub repo slug.") : preflightCheck("project-link", "project linked to Rig connection", legacyServerCompatibility ? "warn" : "fail", "missing .rig/state/connection.json", "Run `rig init` or `rig connect use <alias|local>`."));
   try {
     const auth = await request("/api/github/auth/status");
-    checks.push(isAuthenticated(auth) ? preflightCheck("github-auth", "GitHub auth valid", "pass") : preflightCheck("github-auth", "GitHub auth valid", "fail", "not authenticated", "Run `rig github auth import-gh` or `rig github auth token --token <token>`."));
+    checks.push(isAuthenticated(auth) ? preflightCheck("github-auth", "GitHub auth valid", "pass") : preflightCheck("github-auth", "GitHub auth valid", legacyServerCompatibility ? "warn" : "fail", "not authenticated", "Run `rig github auth import-gh` or `rig github auth token --token <token>`."));
   } catch (error) {
-    checks.push(preflightCheck("github-auth", "GitHub auth valid", "fail", message(error), "Fix GitHub auth on the selected Rig server."));
+    checks.push(preflightCheck("github-auth", "GitHub auth valid", legacyServerCompatibility ? "warn" : "fail", message(error), "Fix GitHub auth on the selected Rig server."));
   }
   try {
     const projection = await request("/api/workspace/task-projection");
@@ -3262,9 +3298,9 @@ async function runFastTaskRunPreflight(context, options = {}) {
     try {
       const tasks = await request(`/api/workspace/tasks?limit=200&refresh=1`);
       const found = Array.isArray(tasks) && tasks.some((task) => taskMatchesId(task, taskId));
-      checks.push(found ? preflightCheck("issue", "task/issue accessible", "pass", taskId) : preflightCheck("issue", "task/issue accessible", "fail", taskId, "Confirm the issue exists and matches the configured task filters."));
+      checks.push(found ? preflightCheck("issue", "task/issue accessible", "pass", taskId) : preflightCheck("issue", "task/issue accessible", legacyServerCompatibility ? "warn" : "fail", taskId, "Confirm the issue exists and matches the configured task filters."));
     } catch (error) {
-      checks.push(preflightCheck("issue", "task/issue accessible", "fail", message(error), "Fix the task source before launching a run."));
+      checks.push(preflightCheck("issue", "task/issue accessible", legacyServerCompatibility ? "warn" : "fail", message(error), "Fix the task source before launching a run."));
     }
     try {
       const runs = await request("/api/runs?limit=200");
@@ -4176,9 +4212,10 @@ async function executeInbox(context, args) {
 
 // packages/cli/src/commands/init.ts
 import { appendFileSync as appendFileSync2, existsSync as existsSync10, mkdirSync as mkdirSync7, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
-import { spawnSync as spawnSync2 } from "child_process";
+import { spawnSync } from "child_process";
 import { resolve as resolve17 } from "path";
 import { buildRigInitConfigSource } from "@rig/core";
+import { listGitHubProjects as listGitHubProjectsDirect, resolveProjectStatusField as resolveProjectStatusFieldDirect } from "@rig/server";
 
 // packages/cli/src/commands/_snapshot-upload.ts
 import { mkdir, readdir, readFile, writeFile } from "fs/promises";
@@ -4502,7 +4539,7 @@ function parseRepoSlugFromRemote(remoteUrl) {
   return gitHubMatch ? `${gitHubMatch[1]}/${gitHubMatch[2]}` : null;
 }
 function detectOriginRepoSlug(projectRoot) {
-  const result = spawnSync2("git", ["-C", projectRoot, "remote", "get-url", "origin"], { encoding: "utf8" });
+  const result = spawnSync("git", ["-C", projectRoot, "remote", "get-url", "origin"], { encoding: "utf8" });
   if (result.status !== 0)
     return null;
   return parseRepoSlugFromRemote(result.stdout.trim());
@@ -4558,11 +4595,14 @@ function applyGitHubProjectConfig(source, options) {
     return source;
   const projectId = JSON.stringify(options.githubProject);
   const statusFieldId = JSON.stringify(options.githubProjectStatusField ?? "Status");
+  const statuses = options.githubProjectStatuses && Object.keys(options.githubProjectStatuses).length > 0 ? `
+      statuses: ${JSON.stringify(options.githubProjectStatuses, null, 8).replace(/\n/g, `
+      `)},` : "";
   return source.replace(`    projects: { enabled: false },`, [
     `    projects: {`,
     `      enabled: true,`,
     `      projectId: ${projectId},`,
-    `      statusFieldId: ${statusFieldId},`,
+    `      statusFieldId: ${statusFieldId},${statuses}`,
     `    },`
   ].join(`
 `));
@@ -4583,11 +4623,11 @@ function checkoutForInit(projectRoot, serverKind, strategy) {
   }
 }
 function detectGhLogin() {
-  const result = spawnSync2("gh", ["api", "user", "--jq", ".login"], { encoding: "utf8", timeout: 5000, stdio: ["ignore", "pipe", "ignore"] });
+  const result = spawnSync("gh", ["api", "user", "--jq", ".login"], { encoding: "utf8", timeout: 5000, stdio: ["ignore", "pipe", "ignore"] });
   return result.status === 0 && result.stdout.trim() ? result.stdout.trim() : null;
 }
 function readGhAuthToken() {
-  const result = spawnSync2("gh", ["auth", "token"], { encoding: "utf8" });
+  const result = spawnSync("gh", ["auth", "token"], { encoding: "utf8" });
   if (result.status !== 0 || !result.stdout.trim()) {
     throw new CliError2(result.stderr.trim() || "Could not read GitHub token from `gh auth token`.", result.status || 1);
   }
@@ -4596,8 +4636,15 @@ function readGhAuthToken() {
 async function loadClackPrompts() {
   return await import("@clack/prompts");
 }
+function clackTextOptions(options) {
+  return {
+    message: options.message,
+    ...options.placeholder ? { placeholder: options.placeholder } : {},
+    ...(options.initialValue ?? options.defaultValue)?.trim() ? { initialValue: (options.initialValue ?? options.defaultValue).trim() } : {}
+  };
+}
 async function promptRequiredText(prompts, options) {
-  const value = await prompts.text(options);
+  const value = await prompts.text(clackTextOptions(options));
   if (prompts.isCancel(value))
     throw new CliError2("Init cancelled.", 1);
   const text2 = String(value ?? "").trim();
@@ -4606,7 +4653,7 @@ async function promptRequiredText(prompts, options) {
   return text2;
 }
 async function promptOptionalText(prompts, options) {
-  const value = await prompts.text(options);
+  const value = await prompts.text(clackTextOptions(options));
   if (prompts.isCancel(value))
     throw new CliError2("Init cancelled.", 1);
   return String(value ?? "").trim();
@@ -4617,6 +4664,132 @@ async function promptSelect(prompts, options) {
     throw new CliError2("Init cancelled.", 1);
   return String(value);
 }
+function repoOwnerFromSlug(repoSlug) {
+  return repoSlug.trim().match(/^([^/]+)\/[^/]+$/)?.[1] ?? null;
+}
+function recordArray(value, key) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return [];
+  const raw = value[key];
+  return Array.isArray(raw) ? raw.filter((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry))) : [];
+}
+async function listGitHubProjectsForInit(context, owner, token) {
+  if (token?.trim()) {
+    try {
+      return { ok: true, projects: await listGitHubProjectsDirect({ owner, token: token.trim() }) };
+    } catch (directError) {
+      const serverPayload = await listGitHubProjectsViaServer(context, owner).catch(() => null);
+      if (recordArray(serverPayload, "projects").length > 0)
+        return serverPayload;
+      return { ok: false, error: directError instanceof Error ? directError.message : String(directError), projects: [] };
+    }
+  }
+  return listGitHubProjectsViaServer(context, owner);
+}
+async function getGitHubProjectStatusFieldForInit(context, projectId, token) {
+  if (token?.trim()) {
+    try {
+      return { ok: true, field: await resolveProjectStatusFieldDirect({ projectId, token: token.trim() }) };
+    } catch (directError) {
+      const serverPayload = await getGitHubProjectStatusFieldViaServer(context, projectId).catch(() => null);
+      if (serverPayload && typeof serverPayload === "object" && !Array.isArray(serverPayload) && "field" in serverPayload) {
+        return serverPayload;
+      }
+      return { ok: false, error: directError instanceof Error ? directError.message : String(directError) };
+    }
+  }
+  return getGitHubProjectStatusFieldViaServer(context, projectId);
+}
+var PROJECT_STATUS_PROMPTS = {
+  running: "Running/In progress",
+  prOpen: "PR open/review",
+  ciFixing: "CI/review fixing",
+  merging: "Merging",
+  done: "Done",
+  needsAttention: "Needs attention"
+};
+var DEFAULT_PROJECT_STATUS_OPTIONS = {
+  running: "In Progress",
+  prOpen: "In Review",
+  ciFixing: "In Review",
+  merging: "Merging",
+  done: "Done",
+  needsAttention: "Needs Attention"
+};
+async function promptManualProjectStatusMapping(prompts) {
+  const statuses = {};
+  for (const [key, label] of Object.entries(PROJECT_STATUS_PROMPTS)) {
+    const defaultLabel = DEFAULT_PROJECT_STATUS_OPTIONS[key] ?? label;
+    const value = await promptOptionalText(prompts, {
+      message: `Project status option id/name for ${label} (blank for ${defaultLabel})`,
+      placeholder: defaultLabel
+    });
+    statuses[key] = value || defaultLabel;
+  }
+  return statuses;
+}
+async function promptGitHubProjectConfig(context, prompts, repoSlug, githubToken) {
+  const projectChoice = await promptSelect(prompts, {
+    message: "GitHub Projects status sync",
+    options: [
+      { value: "off", label: "Off" },
+      { value: "select", label: "Select accessible ProjectV2" },
+      { value: "manual", label: "Enter ProjectV2 ids manually" }
+    ]
+  });
+  if (projectChoice === "off")
+    return { githubProject: "off" };
+  if (projectChoice === "manual") {
+    return {
+      githubProject: await promptRequiredText(prompts, { message: "GitHub ProjectV2 id", placeholder: "PVT_..." }),
+      githubProjectStatusField: await promptRequiredText(prompts, { message: "Project Status field id", placeholder: "field_status" }),
+      githubProjectStatuses: await promptManualProjectStatusMapping(prompts)
+    };
+  }
+  const owner = repoOwnerFromSlug(repoSlug);
+  if (!owner)
+    throw new CliError2(`Cannot derive GitHub owner from repo slug ${repoSlug}.`, 1);
+  const projectsPayload = await listGitHubProjectsForInit(context, owner, githubToken).catch((error) => ({ ok: false, error: error instanceof Error ? error.message : String(error), projects: [] }));
+  const projects = recordArray(projectsPayload, "projects");
+  if (projects.length === 0) {
+    const error = typeof projectsPayload.error === "string" ? ` (${projectsPayload.error})` : "";
+    prompts.outro?.(`No accessible GitHub Projects were returned${error}; falling back to manual ProjectV2 ids.`);
+    return {
+      githubProject: await promptRequiredText(prompts, { message: "GitHub ProjectV2 id", placeholder: "PVT_..." }),
+      githubProjectStatusField: await promptRequiredText(prompts, { message: "Project Status field id", placeholder: "field_status" }),
+      githubProjectStatuses: await promptManualProjectStatusMapping(prompts)
+    };
+  }
+  const selectedProjectId = await promptSelect(prompts, {
+    message: "GitHub ProjectV2 project",
+    options: [
+      ...projects.map((project) => ({
+        value: String(project.id),
+        label: `${String(project.title ?? "Untitled project")} (#${String(project.number ?? "?")})`,
+        hint: typeof project.url === "string" ? project.url : undefined
+      })),
+      { value: "manual", label: "Enter ProjectV2 id manually" }
+    ]
+  });
+  const projectId = selectedProjectId === "manual" ? await promptRequiredText(prompts, { message: "GitHub ProjectV2 id", placeholder: "PVT_..." }) : selectedProjectId;
+  const fieldPayload = await getGitHubProjectStatusFieldForInit(context, projectId, githubToken).catch((error) => ({ ok: false, error: error instanceof Error ? error.message : String(error) }));
+  const fieldPayloadRecord = fieldPayload && typeof fieldPayload === "object" && !Array.isArray(fieldPayload) ? fieldPayload : {};
+  const rawField = fieldPayloadRecord.field;
+  const field = rawField && typeof rawField === "object" && !Array.isArray(rawField) ? rawField : null;
+  const fieldId = typeof field?.id === "string" && field.id.trim() ? field.id : await promptRequiredText(prompts, { message: "Project Status field id", placeholder: "field_status" });
+  const options = Array.isArray(field?.options) ? field.options.filter((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry))) : [];
+  if (options.length === 0) {
+    return { githubProject: projectId, githubProjectStatusField: fieldId, githubProjectStatuses: await promptManualProjectStatusMapping(prompts) };
+  }
+  const statuses = {};
+  for (const [key, label] of Object.entries(PROJECT_STATUS_PROMPTS)) {
+    statuses[key] = await promptSelect(prompts, {
+      message: `Project status option for ${label}`,
+      options: options.map((option) => ({ value: String(option.id ?? option.name), label: String(option.name ?? option.id) }))
+    });
+  }
+  return { githubProject: projectId, githubProjectStatusField: fieldId, githubProjectStatuses: Object.keys(statuses).length > 0 ? statuses : undefined };
+}
 function sleep2(ms) {
   return new Promise((resolve18) => setTimeout(resolve18, ms));
 }
@@ -4745,7 +4918,7 @@ async function runControlPlaneInit(context, options) {
   if (token) {
     githubAuth = await postGitHubTokenViaServer(context, token, { selectedRepo: repo.slug });
     const apiSessionToken = apiSessionTokenFrom(githubAuth);
-    setGitHubBearerTokenForCurrentProcess(apiSessionToken ?? token);
+    setGitHubBearerTokenForCurrentProcess(apiSessionToken ?? token, projectRoot);
     if (serverKind === "remote") {
       writeRemoteGitHubAuthState(projectRoot, {
         source: authMethod === "gh" ? "gh" : "init-token",
@@ -4770,7 +4943,7 @@ async function runControlPlaneInit(context, options) {
     if (completed) {
       const apiSessionToken = apiSessionTokenFrom(completed);
       if (apiSessionToken) {
-        setGitHubBearerTokenForCurrentProcess(apiSessionToken);
+        setGitHubBearerTokenForCurrentProcess(apiSessionToken, projectRoot);
         if (serverKind === "remote") {
           writeRemoteGitHubAuthState(projectRoot, { source: "device", selectedRepo: repo.slug, apiSessionToken, authPayload: completed });
         }
@@ -4794,7 +4967,7 @@ async function runControlPlaneInit(context, options) {
   if (serverKind === "remote" && checkoutPath && token) {
     githubAuth = await postGitHubTokenViaServer(context, token, { selectedRepo: repo.slug, projectRoot: checkoutPath });
     const apiSessionToken = apiSessionTokenFrom(githubAuth);
-    setGitHubBearerTokenForCurrentProcess(apiSessionToken ?? token);
+    setGitHubBearerTokenForCurrentProcess(apiSessionToken ?? token, projectRoot);
     writeRemoteGitHubAuthState(projectRoot, { source: authMethod === "gh" ? "gh" : "init-token", selectedRepo: repo.slug, apiSessionToken, authPayload: githubAuth });
   }
   const registered = await registerProjectViaServer(context, {
@@ -4803,6 +4976,12 @@ async function runControlPlaneInit(context, options) {
   });
   const serverRootSwitch = serverKind === "remote" && checkoutPath ? await switchServerProjectRootViaServer(context, checkoutPath) : null;
   const activeProjectRegistration = serverRootSwitch ? await registerProjectViaServer(context, { repoSlug: repo.slug, checkout }) : null;
+  const labelSetup = await ensureTaskLabelsViaServer(context).catch((error) => ({
+    ok: false,
+    ready: false,
+    labelsReady: false,
+    error: error instanceof Error ? error.message : String(error)
+  }));
   const pi = serverKind === "remote" ? await ensureRemotePiRigInstalled({ requestJson: (pathname, init) => requestServerJson(context, pathname, init) }).catch((error) => ({
     remote: true,
     pi: { ok: false, label: "pi", hint: error instanceof Error ? error.message : String(error) },
@@ -4833,6 +5012,7 @@ async function runControlPlaneInit(context, options) {
     githubAuth,
     deviceAuth,
     githubAuthWarning: remoteGhTokenWarning,
+    labelSetup,
     pi,
     doctor
   };
@@ -4987,24 +5167,17 @@ async function runInteractiveControlPlaneInit(context, prompts) {
       throw new CliError2("Remote gh-token import cancelled.", 1);
     }
   }
-  const githubToken = authMethod === "token" ? await promptRequiredText(prompts, { message: "GitHub token", placeholder: "ghp_..." }) : undefined;
-  const projectChoice = await promptSelect(prompts, {
-    message: "GitHub Projects status sync",
-    options: [
-      { value: "off", label: "Off" },
-      { value: "configure", label: "Configure ProjectV2 status field" }
-    ]
-  });
-  const githubProject = projectChoice === "configure" ? await promptRequiredText(prompts, { message: "GitHub ProjectV2 id", placeholder: "PVT_..." }) : "off";
-  const githubProjectStatusField = projectChoice === "configure" ? await promptRequiredText(prompts, { message: "Project Status field id", placeholder: "field_status" }) : undefined;
+  const githubToken = authMethod === "token" ? await promptRequiredText(prompts, { message: "GitHub token", placeholder: "ghp_..." }) : authMethod === "gh" ? readGhAuthToken() : undefined;
+  const projectConfig = await promptGitHubProjectConfig(context, prompts, repoSlug, githubToken);
   const result = await runControlPlaneInit(context, {
     server: serverChoice,
     remoteUrl,
     repoSlug,
     githubToken,
     githubAuthMethod: authMethod,
-    githubProject,
-    githubProjectStatusField,
+    githubProject: projectConfig.githubProject,
+    githubProjectStatusField: projectConfig.githubProjectStatusField,
+    githubProjectStatuses: projectConfig.githubProjectStatuses,
     remoteCheckout,
     repair,
     privateStateOnly
@@ -5103,7 +5276,7 @@ Usage: rig connect <list|add|use|status>`, 1);
 }
 
 // packages/cli/src/commands/github.ts
-import { spawnSync as spawnSync3 } from "child_process";
+import { spawnSync as spawnSync2 } from "child_process";
 function printPayload(context, payload, fallback) {
   if (context.outputMode === "json")
     console.log(JSON.stringify(payload, null, 2));
@@ -5111,7 +5284,7 @@ function printPayload(context, payload, fallback) {
     console.log(fallback);
 }
 function readGhToken() {
-  const result = spawnSync3("gh", ["auth", "token"], { encoding: "utf8" });
+  const result = spawnSync2("gh", ["auth", "token"], { encoding: "utf8" });
   if (result.status !== 0) {
     const detail = result.stderr?.trim() || result.stdout?.trim() || "gh auth token failed";
     throw new CliError2(`Could not import GitHub token from gh: ${detail}`, 1);
@@ -6143,14 +6316,10 @@ async function executeRemote(context, args) {
 }
 
 // packages/cli/src/commands/run.ts
-import { existsSync as existsSync12, readFileSync as readFileSync9 } from "fs";
-import { resolve as resolve20 } from "path";
 import { createInterface as createInterface2 } from "readline/promises";
 import {
   listAuthorityRuns as listAuthorityRuns3,
-  readAuthorityRun as readAuthorityRun4,
-  readJsonlFile as readJsonlFile4,
-  resolveAuthorityRunDir as resolveAuthorityRunDir5
+  readAuthorityRun as readAuthorityRun4
 } from "@rig/runtime/control-plane/authority-files";
 import {
   cleanupRunState,
@@ -6166,9 +6335,9 @@ import {
 } from "@rig/runtime/control-plane/native/run-ops";
 import { loadRuntimeContextFromEnv as loadRuntimeContextFromEnv2 } from "@rig/runtime/control-plane/runtime/context";
 
-// packages/cli/src/commands/_operator-view.ts
+// packages/cli/src/commands/_operator-surface.ts
 import { createInterface } from "readline";
-var TERMINAL_RUN_STATUSES = new Set(["completed", "failed", "stopped", "cancelled", "canceled", "closed", "merged", "needs_attention", "needs-attention"]);
+import { createInterface as createPromptInterface } from "readline/promises";
 var CANONICAL_STAGES = [
   "Connect",
   "GitHub/task sync",
@@ -6183,18 +6352,141 @@ var CANONICAL_STAGES = [
   "Merge",
   "Complete"
 ];
+function logDetail(log3) {
+  return typeof log3.detail === "string" ? log3.detail.trim() : "";
+}
+function entryId(entry, fallback) {
+  return typeof entry.id === "string" && entry.id.trim() ? entry.id : fallback;
+}
 function renderOperatorSnapshot(snapshot) {
   const run = snapshot.run.run && typeof snapshot.run.run === "object" ? snapshot.run.run : snapshot.run;
   const runId = String(run.runId ?? run.id ?? "run");
   const status = String(run.status ?? "unknown");
   const logs = snapshot.logs ?? [];
+  const latestByStage = new Map;
+  for (const log3 of logs) {
+    const title = String(log3.title ?? "").toLowerCase();
+    const stageName = String(log3.stage ?? "").toLowerCase();
+    const stage = CANONICAL_STAGES.find((candidate) => candidate.toLowerCase() === title || candidate.toLowerCase() === stageName);
+    if (stage)
+      latestByStage.set(stage, log3);
+  }
   const stageLines = CANONICAL_STAGES.flatMap((stage) => {
-    const match = logs.find((log3) => String(log3.title ?? "").toLowerCase() === stage.toLowerCase() || String(log3.stage ?? "").toLowerCase() === stage.toLowerCase());
-    return match ? [`${stage}: ${String(match.status ?? status)}`] : [];
+    const match = latestByStage.get(stage);
+    return match ? [`${stage}: ${String(match.status ?? status)}${logDetail(match) ? ` \u2014 ${logDetail(match)}` : ""}`] : [];
   });
   return [`Rig run ${runId}: ${status}`, ...stageLines].join(`
 `);
 }
+function createPiRunStreamRenderer(output = process.stdout) {
+  let lastSnapshot = "";
+  const assistantTextById = new Map;
+  const seenTimeline = new Set;
+  const seenLogs = new Set;
+  const writeLine = (line) => output.write(`${line}
+`);
+  return {
+    renderSnapshot(snapshot) {
+      const rendered = renderOperatorSnapshot(snapshot);
+      if (rendered && rendered !== lastSnapshot) {
+        writeLine(rendered);
+        lastSnapshot = rendered;
+      }
+    },
+    renderTimeline(entries) {
+      for (const [index, entry] of entries.entries()) {
+        const id = entryId(entry, `timeline:${index}:${String(entry.cursor ?? "")}`);
+        if (entry.type === "assistant_message" && typeof entry.text === "string") {
+          const text2 = entry.text;
+          const previousText = assistantTextById.get(id) ?? "";
+          if (text2.startsWith(previousText)) {
+            const delta = text2.slice(previousText.length);
+            if (delta)
+              output.write(delta);
+          } else if (text2.trim() && text2 !== previousText) {
+            writeLine(`
+[Pi assistant]`);
+            output.write(text2);
+          }
+          assistantTextById.set(id, text2);
+          continue;
+        }
+        if (seenTimeline.has(id))
+          continue;
+        seenTimeline.add(id);
+        if (entry.type === "tool_execution_start" || entry.type === "tool_execution_update" || entry.type === "tool_execution_end" || entry.type === "mcp_tool_call") {
+          writeLine(`[Pi tool] ${String(entry.toolName ?? entry.name ?? entry.title ?? entry.type)} ${String(entry.status ?? entry.state ?? "")}`.trim());
+          continue;
+        }
+        if (entry.type === "timeline_warning") {
+          writeLine(`[Rig timeline] ${String(entry.detail ?? entry.message ?? "timeline unavailable")}`);
+        }
+      }
+    },
+    renderLogs(entries) {
+      for (const [index, entry] of entries.entries()) {
+        const id = entryId(entry, `log:${index}:${String(entry.createdAt ?? "")}:${String(entry.title ?? "")}`);
+        if (seenLogs.has(id))
+          continue;
+        seenLogs.add(id);
+        const title = String(entry.title ?? "");
+        if (CANONICAL_STAGES.some((stage) => stage.toLowerCase() === title.toLowerCase()))
+          continue;
+        const detail = logDetail(entry);
+        if (!detail)
+          continue;
+        writeLine(`[${title || "Rig log"}] ${detail}`);
+      }
+    }
+  };
+}
+function createOperatorSurface(options = {}) {
+  const input = options.input ?? process.stdin;
+  const output = options.output ?? process.stdout;
+  const errorOutput = options.errorOutput ?? process.stderr;
+  const renderer = createPiRunStreamRenderer(output);
+  const writeLine = (line) => output.write(`${line}
+`);
+  return {
+    mode: "pi-compatible-text",
+    ...renderer,
+    info: writeLine,
+    error: (message2) => errorOutput.write(`${message2}
+`),
+    attachCommandInput(handler) {
+      if (options.interactive === false || !input.isTTY)
+        return null;
+      const rl = createInterface({ input, output: process.stdout, terminal: false });
+      rl.on("line", (line) => {
+        Promise.resolve(handler(line)).catch((error) => writeLine(`Operator command failed: ${error instanceof Error ? error.message : String(error)}`));
+      });
+      return { close: () => rl.close() };
+    }
+  };
+}
+function taskId(task) {
+  return typeof task.id === "string" && task.id.trim() ? task.id : "<unknown>";
+}
+function taskTitle(task) {
+  return typeof task.title === "string" && task.title.trim() ? task.title : "Untitled task";
+}
+function taskStatus(task) {
+  return typeof task.status === "string" && task.status.trim() ? task.status : "unknown";
+}
+function renderTaskPickerRows(tasks) {
+  return tasks.map((task, index) => `${index + 1}. ${taskId(task)} \xB7 ${taskStatus(task)} \xB7 ${taskTitle(task)}`);
+}
+async function promptForTaskSelection(question) {
+  const rl = createPromptInterface({ input: process.stdin, output: process.stdout });
+  try {
+    return await rl.question(question);
+  } finally {
+    rl.close();
+  }
+}
+
+// packages/cli/src/commands/_operator-view.ts
+var TERMINAL_RUN_STATUSES = new Set(["completed", "failed", "stopped", "cancelled", "canceled", "closed", "merged", "needs_attention", "needs-attention"]);
 function runStatusFromPayload(payload) {
   const run = payload.run && typeof payload.run === "object" && !Array.isArray(payload.run) ? payload.run : payload;
   return String(run.status ?? "unknown").toLowerCase();
@@ -6216,11 +6508,22 @@ async function applyOperatorCommand(context, input, deps = {}) {
   await (deps.steer ?? steerRunViaServer)(context, input.runId, userMessage);
   return { action: "continue", message: "Steering message queued." };
 }
-async function readOperatorSnapshot(context, runId) {
+async function readOperatorSnapshot(context, runId, options = {}) {
   const run = await getRunDetailsViaServer(context, runId);
   const logsPage = await getRunLogsViaServer(context, runId, { limit: 100 });
-  const entries = Array.isArray(logsPage.entries) ? logsPage.entries.filter((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry))) : [];
-  return { run, logs: entries, rendered: renderOperatorSnapshot({ run, logs: entries }) };
+  const timelinePage = await getRunTimelineViaServer(context, runId, { limit: 200, ...options.timelineCursor ? { cursor: options.timelineCursor } : {} }).catch((error) => ({
+    entries: [{
+      id: `timeline-unavailable:${runId}`,
+      type: "timeline_warning",
+      detail: `Selected Rig server did not provide run timeline events: ${error instanceof Error ? error.message : String(error)}`,
+      createdAt: new Date().toISOString()
+    }],
+    nextCursor: options.timelineCursor ?? null
+  }));
+  const logs = Array.isArray(logsPage.entries) ? logsPage.entries.filter((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry))).toReversed() : [];
+  const timeline = Array.isArray(timelinePage.entries) ? timelinePage.entries.filter((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry))) : [];
+  const timelineCursor = typeof timelinePage.nextCursor === "string" ? timelinePage.nextCursor : options.timelineCursor ?? null;
+  return { run, logs, timeline, timelineCursor, rendered: renderOperatorSnapshot({ run, logs, timeline }) };
 }
 async function attachRunOperatorView(context, input) {
   let steered = false;
@@ -6228,40 +6531,41 @@ async function attachRunOperatorView(context, input) {
     await steerRunViaServer(context, input.runId, input.message.trim());
     steered = true;
   }
+  const surface = createOperatorSurface({ interactive: input.interactive !== false });
   let snapshot = await readOperatorSnapshot(context, input.runId);
   if (context.outputMode === "text") {
-    console.log(snapshot.rendered);
+    surface.renderSnapshot(snapshot);
+    surface.renderTimeline(snapshot.timeline);
+    surface.renderLogs(snapshot.logs);
     if (steered)
-      console.log("Steering message queued.");
+      surface.info("Steering message queued.");
   }
   let detached = false;
-  let rl = null;
+  let commandInput = null;
   if (input.follow && !input.once && context.outputMode === "text") {
     if (input.interactive !== false && process.stdin.isTTY) {
-      console.log("Controls: /user <message>, /stop, /detach");
-      rl = createInterface({ input: process.stdin, output: process.stdout, terminal: false });
-      rl.on("line", (line) => {
-        applyOperatorCommand(context, { runId: input.runId, line }).then((result) => {
-          if (result.message)
-            console.log(result.message);
-          if (result.action === "detach" || result.action === "stopped") {
-            detached = true;
-            rl?.close();
-          }
-        }).catch((error) => console.log(`Operator command failed: ${error instanceof Error ? error.message : String(error)}`));
+      surface.info("Controls: /user <message>, /stop, /detach");
+      commandInput = surface.attachCommandInput(async (line) => {
+        const result = await applyOperatorCommand(context, { runId: input.runId, line });
+        if (result.message)
+          surface.info(result.message);
+        if (result.action === "detach" || result.action === "stopped") {
+          detached = true;
+          commandInput?.close();
+        }
       });
     }
-    let lastRendered = snapshot.rendered;
     const pollMs = Math.max(250, Math.trunc(input.pollMs ?? 2000));
+    let timelineCursor = snapshot.timelineCursor;
     while (!detached && !TERMINAL_RUN_STATUSES.has(runStatusFromPayload(snapshot.run))) {
       await Bun.sleep(pollMs);
-      snapshot = await readOperatorSnapshot(context, input.runId);
-      if (snapshot.rendered !== lastRendered) {
-        console.log(snapshot.rendered);
-        lastRendered = snapshot.rendered;
-      }
+      snapshot = await readOperatorSnapshot(context, input.runId, { timelineCursor });
+      timelineCursor = snapshot.timelineCursor;
+      surface.renderSnapshot(snapshot);
+      surface.renderTimeline(snapshot.timeline);
+      surface.renderLogs(snapshot.logs);
     }
-    rl?.close();
+    commandInput?.close();
   }
   return { ...snapshot, steered, detached };
 }
@@ -6435,34 +6739,24 @@ async function executeRun(context, args) {
       if (!run.value) {
         throw new CliError2("run timeline requires --run <id>.");
       }
-      const timelinePath = resolve20(resolveAuthorityRunDir5(context.projectRoot, run.value), "timeline.jsonl");
-      const printEvents = () => {
-        const events2 = readJsonlFile4(timelinePath);
-        if (context.outputMode === "text") {
-          for (const event of events2) {
-            console.log(JSON.stringify(event));
-          }
-        }
-        return events2;
-      };
-      const events = printEvents();
+      const renderer = createPiRunStreamRenderer();
+      let cursor = null;
+      const page = await getRunTimelineViaServer(context, run.value, { limit: 500 });
+      const events = Array.isArray(page.entries) ? page.entries.filter((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry))) : [];
+      cursor = typeof page.nextCursor === "string" ? page.nextCursor : null;
+      if (context.outputMode === "text") {
+        renderer.renderTimeline(events);
+      }
       if (follow.value && context.outputMode === "text") {
-        let lastLength = existsSync12(timelinePath) ? readFileSync9(timelinePath, "utf8").length : 0;
         while (true) {
           await Bun.sleep(1000);
-          if (!existsSync12(timelinePath))
-            continue;
-          const next = readFileSync9(timelinePath, "utf8");
-          if (next.length <= lastLength)
-            continue;
-          const delta = next.slice(lastLength);
-          lastLength = next.length;
-          for (const line of delta.split(/\r?\n/).map((entry) => entry.trim()).filter(Boolean)) {
-            console.log(line);
-          }
+          const nextPage = await getRunTimelineViaServer(context, run.value, { limit: 500, ...cursor ? { cursor } : {} });
+          const nextEvents = Array.isArray(nextPage.entries) ? nextPage.entries.filter((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry))) : [];
+          cursor = typeof nextPage.nextCursor === "string" ? nextPage.nextCursor : cursor;
+          renderer.renderTimeline(nextEvents);
         }
       }
-      return { ok: true, group: "run", command, details: { runId: run.value, events } };
+      return { ok: true, group: "run", command, details: { runId: run.value, events, cursor } };
     }
     case "attach": {
       let pending = rest;
@@ -6752,10 +7046,10 @@ async function executeServer(context, args, options) {
 }
 
 // packages/cli/src/commands/task.ts
-import { readFileSync as readFileSync10 } from "fs";
-import { spawnSync as spawnSync4 } from "child_process";
-import { createInterface as createInterface4 } from "readline/promises";
-import { resolve as resolve21 } from "path";
+import { readFileSync as readFileSync9 } from "fs";
+import { spawnSync as spawnSync3 } from "child_process";
+import { createInterface as createInterface3 } from "readline/promises";
+import { resolve as resolve20 } from "path";
 import {
   taskArtifactDir,
   taskArtifacts,
@@ -6773,19 +7067,9 @@ import {
 } from "@rig/runtime/control-plane/native/task-ops";
 
 // packages/cli/src/commands/_task-picker.ts
-import { createInterface as createInterface3 } from "readline/promises";
-function taskId(task) {
+function taskId2(task) {
   return typeof task.id === "string" && task.id.trim() ? task.id : "<unknown>";
 }
-function taskTitle(task) {
-  return typeof task.title === "string" && task.title.trim() ? task.title : "Untitled task";
-}
-function taskStatus(task) {
-  return typeof task.status === "string" && task.status.trim() ? task.status : "unknown";
-}
-function renderTaskPickerRows(tasks) {
-  return tasks.map((task, index) => `${index + 1}. ${taskId(task)} \xB7 ${taskStatus(task)} \xB7 ${taskTitle(task)}`);
-}
 async function selectTaskWithTextPicker(tasks, io = {}) {
   if (tasks.length === 0)
     return null;
@@ -6795,17 +7079,12 @@ async function selectTaskWithTextPicker(tasks, io = {}) {
   if (!isTty) {
     throw new Error("task run requires an interactive terminal to pick a task; pass --task <id>, --next, or --detach with a task id.");
   }
-  const prompt = io.prompt ?? (async (question) => {
-    const rl = createInterface3({ input: process.stdin, output: process.stdout });
-    try {
-      return await rl.question(question);
-    } finally {
-      rl.close();
-    }
-  });
-  console.log("Select Rig task:");
+  const prompt = io.prompt ?? promptForTaskSelection;
+  const renderer = io.renderer ?? { writeLine: (line) => process.stdout.write(`${line}
+`) };
+  renderer.writeLine("Select Rig task:");
   for (const row of renderTaskPickerRows(tasks))
-    console.log(`  ${row}`);
+    renderer.writeLine(`  ${row}`);
   const answer = (await prompt(`Task [1-${tasks.length}] or id: `)).trim();
   if (!answer)
     return null;
@@ -6813,7 +7092,7 @@ async function selectTaskWithTextPicker(tasks, io = {}) {
     const index = Number.parseInt(answer, 10) - 1;
     return tasks[index] ?? null;
   }
-  return tasks.find((task) => taskId(task) === answer) ?? null;
+  return tasks.find((task) => taskId2(task) === answer) ?? null;
 }
 
 // packages/cli/src/commands/task.ts
@@ -6891,7 +7170,7 @@ function normalizePrMode(value) {
   throw new CliError2("--pr must be auto, ask, or off.", 2);
 }
 function detectLocalDirtyState(projectRoot) {
-  const result = spawnSync4("git", ["-C", projectRoot, "status", "--porcelain"], { encoding: "utf8", timeout: 5000 });
+  const result = spawnSync3("git", ["-C", projectRoot, "status", "--porcelain"], { encoding: "utf8", timeout: 5000 });
   if (result.status !== 0)
     return { dirty: false, modified: 0, untracked: 0, lines: [] };
   const lines = result.stdout.split(/\r?\n/).map((line) => line.trimEnd()).filter(Boolean);
@@ -6925,7 +7204,7 @@ async function resolveDirtyBaselineForTaskRun(context, explicit) {
   if (explicit)
     return { mode: explicit, state };
   if (context.outputMode === "text" && process.stdin.isTTY && process.stdout.isTTY) {
-    const rl = createInterface4({ input: process.stdin, output: process.stdout });
+    const rl = createInterface3({ input: process.stdin, output: process.stdout });
     try {
       const answer = (await rl.question("Include current uncommitted changes in run baseline? [y/N] ")).trim().toLowerCase();
       return { mode: answer === "y" || answer === "yes" ? "dirty-snapshot" : "head", state };
@@ -7010,12 +7289,12 @@ async function executeTask(context, args, options) {
       const positional = taskOption.rest.length > 0 && taskOption.rest[0] && !taskOption.rest[0].startsWith("-") ? taskOption.rest[0] : undefined;
       const remaining = positional ? taskOption.rest.slice(1) : taskOption.rest;
       requireNoExtraArgs(remaining, "bun run rig task show <id>|--task <id>");
-      const taskId2 = normalizeTaskRunTaskId(taskOption.value ?? positional);
-      if (!taskId2)
+      const taskId3 = normalizeTaskRunTaskId(taskOption.value ?? positional);
+      if (!taskId3)
         throw new CliError2("task show requires a task id.", 2);
-      const task = await getWorkspaceTaskViaServer(context, taskId2);
+      const task = await getWorkspaceTaskViaServer(context, taskId3);
       if (!task)
-        throw new CliError2(`Task not found: ${taskId2}`, 3);
+        throw new CliError2(`Task not found: ${taskId3}`, 3);
       const summary = summarizeTask(task, { raw: true });
       if (context.outputMode === "text")
         console.log(JSON.stringify(summary, null, 2));
@@ -7086,7 +7365,7 @@ async function executeTask(context, args, options) {
       const fileFlag = takeOption(rest.slice(1), "--file");
       let content;
       if (fileFlag.value) {
-        content = readFileSync10(resolve21(context.projectRoot, fileFlag.value), "utf-8");
+        content = readFileSync9(resolve20(context.projectRoot, fileFlag.value), "utf-8");
       } else {
         content = await readStdin();
       }
@@ -7307,9 +7586,9 @@ async function executeTask(context, args, options) {
 }
 
 // packages/cli/src/commands/task-run-driver.ts
-import { copyFileSync as copyFileSync3, existsSync as existsSync13, mkdirSync as mkdirSync8, readFileSync as readFileSync11, statSync as statSync2, writeFileSync as writeFileSync6 } from "fs";
-import { resolve as resolve22 } from "path";
-import { spawn as spawn2, spawnSync as spawnSync5 } from "child_process";
+import { copyFileSync as copyFileSync3, existsSync as existsSync12, mkdirSync as mkdirSync8, readFileSync as readFileSync10, statSync as statSync2, writeFileSync as writeFileSync6 } from "fs";
+import { resolve as resolve21 } from "path";
+import { spawn as spawn2, spawnSync as spawnSync4 } from "child_process";
 import { createInterface as createLineInterface } from "readline";
 import { loadConfig as loadConfig2 } from "@rig/core/load-config";
 import {
@@ -7334,8 +7613,7 @@ import {
 import { resolvePreferredShellBinary } from "@rig/runtime/control-plane/native/run-ops";
 import { readAuthorityRun as readAuthorityRun5, readJsonFile as readJsonFile3, resolveTaskArtifactDirs as resolveTaskArtifactDirs2 } from "@rig/runtime/control-plane/authority-files";
 import {
-  buildTaskRunLifecycleComment,
-  updateConfiguredTaskSourceTask
+  buildTaskRunLifecycleComment
 } from "@rig/runtime/control-plane/tasks/source-lifecycle";
 import {
   closeIssueAfterMergedPr,
@@ -7373,7 +7651,7 @@ function buildPiRigBridgeEnv(input) {
   };
 }
 function runGitSync(cwd, args, input) {
-  const result = spawnSync5("git", [...args], {
+  const result = spawnSync4("git", [...args], {
     cwd,
     input,
     encoding: "utf8",
@@ -7391,12 +7669,12 @@ function copyUntrackedDirtyFiles(sourceRoot, targetRoot) {
     return 0;
   let copied = 0;
   for (const relativePath of listed.stdout.split("\x00").filter(Boolean)) {
-    const sourcePath = resolve22(sourceRoot, relativePath);
-    const targetPath = resolve22(targetRoot, relativePath);
+    const sourcePath = resolve21(sourceRoot, relativePath);
+    const targetPath = resolve21(targetRoot, relativePath);
     try {
       if (!statSync2(sourcePath).isFile())
         continue;
-      mkdirSync8(resolve22(targetPath, ".."), { recursive: true });
+      mkdirSync8(resolve21(targetPath, ".."), { recursive: true });
       copyFileSync3(sourcePath, targetPath);
       copied += 1;
     } catch {}
@@ -7435,7 +7713,7 @@ function buildDirtyBaselineHandshakeEnv(input) {
     return { RIG_BASELINE_MODE: input.baselineMode ?? "head" };
   return {
     RIG_BASELINE_MODE: "dirty-snapshot",
-    RIG_DIRTY_BASELINE_READY_FILE: resolve22(input.projectRoot, ".rig", "runs", input.runId, "dirty-baseline.ready.json")
+    RIG_DIRTY_BASELINE_READY_FILE: resolve21(input.projectRoot, ".rig", "runs", input.runId, "dirty-baseline.ready.json")
   };
 }
 function positiveInt(value, fallback) {
@@ -7546,9 +7824,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((resolve23) => {
-      child.once("error", (error) => resolve23({ exitCode: 1, stderr: error.message }));
-      child.once("close", (code) => resolve23({
+    return await new Promise((resolve22) => {
+      child.once("error", (error) => resolve22({ exitCode: 1, stderr: error.message }));
+      child.once("close", (code) => resolve22({
         exitCode: code ?? 1,
         stdout: Buffer.concat(stdoutChunks).toString("utf8"),
         stderr: Buffer.concat(stderrChunks).toString("utf8")
@@ -7568,12 +7846,13 @@ async function resolvePostValidationBranch(input) {
   return input.configuredBranch;
 }
 async function runTaskRunPostValidationLifecycle(input) {
-  const taskId2 = input.taskId?.trim();
-  if (!taskId2) {
+  const taskId3 = input.taskId?.trim();
+  if (!taskId3) {
     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");
@@ -7589,7 +7868,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;
   });
@@ -7607,7 +7886,7 @@ async function runTaskRunPostValidationLifecycle(input) {
   stage("Commit", `Committing changes in ${workspace}.`, "running", "tool");
   const commit = await commitRunChanges({
     cwd: workspace,
-    message: `rig: complete task ${taskId2}`,
+    message: `rig: complete task ${taskId3}`,
     command: gitCommand
   });
   stage("Commit", commit.committed ? "Committed run workspace changes." : "No workspace changes to commit.", "completed", "tool");
@@ -7615,14 +7894,15 @@ async function runTaskRunPostValidationLifecycle(input) {
   stage("Open PR", `Opening PR from ${branch}.`, "running", "tool");
   const pr = await prAutomation({
     projectRoot: workspace,
-    taskId: taskId2,
+    taskId: taskId3,
     runId: input.runId,
     branch,
     config,
     sourceTask: input.sourceTask,
     uploadedSnapshot: input.uploadedSnapshot,
-    artifactRoot: resolve22(input.projectRoot, "artifacts", taskId2),
+    artifactRoot: resolve21(input.projectRoot, "artifacts", taskId3),
     command: ghCommand,
+    gitCommand,
     steerPi,
     lifecycle: {
       onPrOpened: async ({ prUrl }) => {
@@ -7630,7 +7910,7 @@ async function runTaskRunPostValidationLifecycle(input) {
         try {
           if (shouldWriteDriverIssueUpdate(config, "under_review")) {
             await updateTaskSource(input.projectRoot, {
-              taskId: taskId2,
+              taskId: taskId3,
               sourceTask: runSourceTaskIdentity(input.sourceTask),
               update: {
                 status: "under_review",
@@ -7660,7 +7940,7 @@ async function runTaskRunPostValidationLifecycle(input) {
 `), "reviewing", "error");
         if (shouldWriteDriverIssueUpdate(config, "ci_fixing")) {
           await updateTaskSource(input.projectRoot, {
-            taskId: taskId2,
+            taskId: taskId3,
             sourceTask: runSourceTaskIdentity(input.sourceTask),
             update: {
               status: "ci_fixing",
@@ -7671,8 +7951,6 @@ async function runTaskRunPostValidationLifecycle(input) {
                 runtimeWorkspace: input.runtimeWorkspace ?? null
               })
             }
-          }).catch(() => {
-            return;
           });
         }
       },
@@ -7680,7 +7958,7 @@ async function runTaskRunPostValidationLifecycle(input) {
         stage("Merge", prUrl, "running", "tool");
         if (shouldWriteDriverIssueUpdate(config, "merging")) {
           await updateTaskSource(input.projectRoot, {
-            taskId: taskId2,
+            taskId: taskId3,
             sourceTask: runSourceTaskIdentity(input.sourceTask),
             update: {
               status: "merging",
@@ -7691,8 +7969,6 @@ async function runTaskRunPostValidationLifecycle(input) {
                 runtimeWorkspace: input.runtimeWorkspace ?? null
               })
             }
-          }).catch(() => {
-            return;
           });
         }
       },
@@ -7709,7 +7985,7 @@ async function runTaskRunPostValidationLifecycle(input) {
     stage("Needs attention", detail, "needs_attention", "error");
     if (shouldWriteDriverIssueUpdate(config, "needs_attention")) {
       await updateTaskSource(input.projectRoot, {
-        taskId: taskId2,
+        taskId: taskId3,
         sourceTask: runSourceTaskIdentity(input.sourceTask),
         update: {
           status: "needs_attention",
@@ -7721,8 +7997,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 };
@@ -7730,7 +8015,7 @@ async function runTaskRunPostValidationLifecycle(input) {
   if (shouldWriteDriverIssueUpdate(config, "closed")) {
     await closeIssueAfterMergedPr({
       projectRoot: input.projectRoot,
-      taskId: taskId2,
+      taskId: taskId3,
       runId: input.runId,
       prUrl: pr.prUrl,
       sourceTask: input.sourceTask,
@@ -7740,12 +8025,12 @@ async function runTaskRunPostValidationLifecycle(input) {
   stage("Complete", `PR merged and issue closed: ${pr.prUrl}`, "completed", "info");
   return { status: "completed", pr };
 }
-function summarizeValidationFailure(projectRoot, taskId2) {
-  if (!taskId2) {
+function summarizeValidationFailure(projectRoot, taskId3) {
+  if (!taskId3) {
     return null;
   }
-  for (const artifactDir of resolveTaskArtifactDirs2(projectRoot, taskId2)) {
-    const summary = readJsonFile3(resolve22(artifactDir, "validation-summary.json"), null);
+  for (const artifactDir of resolveTaskArtifactDirs2(projectRoot, taskId3)) {
+    const summary = readJsonFile3(resolve21(artifactDir, "validation-summary.json"), null);
     if (!summary || summary.status !== "fail") {
       continue;
     }
@@ -7826,9 +8111,9 @@ function readTaskRunAcceptedArtifactState(input) {
   if (!input.taskId || !input.workspaceDir) {
     return { accepted: false, reason: null };
   }
-  const artifactDir = resolve22(input.workspaceDir, "artifacts", input.taskId);
-  const reviewStatusPath = resolve22(artifactDir, "review-status.txt");
-  const taskResultPath = resolve22(artifactDir, "task-result.json");
+  const artifactDir = resolve21(input.workspaceDir, "artifacts", input.taskId);
+  const reviewStatusPath = resolve21(artifactDir, "review-status.txt");
+  const taskResultPath = resolve21(artifactDir, "task-result.json");
   const reviewStatus = readTaskRunReviewStatus(reviewStatusPath);
   if (reviewStatus !== "APPROVED") {
     return { accepted: false, reason: null };
@@ -7865,12 +8150,12 @@ function resolveTaskRunRetryContext(input) {
   if (!input.taskId || !input.workspaceDir) {
     return { shouldRetry: false, failureDetail: null, nextPrompt: null };
   }
-  const artifactDir = resolve22(input.workspaceDir, "artifacts", input.taskId);
-  const reviewStatePath = resolve22(artifactDir, "review-state.json");
-  const reviewFeedbackPath = resolve22(artifactDir, "review-feedback.md");
-  const reviewStatusPath = resolve22(artifactDir, "review-status.txt");
-  const failedApproachesPath = resolve22(input.workspaceDir, ".rig", "state", "failed_approaches.md");
-  const validationSummaryPath = resolve22(artifactDir, "validation-summary.json");
+  const artifactDir = resolve21(input.workspaceDir, "artifacts", input.taskId);
+  const reviewStatePath = resolve21(artifactDir, "review-state.json");
+  const reviewFeedbackPath = resolve21(artifactDir, "review-feedback.md");
+  const reviewStatusPath = resolve21(artifactDir, "review-status.txt");
+  const failedApproachesPath = resolve21(input.workspaceDir, ".rig", "state", "failed_approaches.md");
+  const validationSummaryPath = resolve21(artifactDir, "validation-summary.json");
   const reviewState = readJsonFile3(reviewStatePath, null);
   const reviewStatus = readTaskRunReviewStatus(reviewStatusPath);
   const reviewRejected = isTaskRunReviewRejected(reviewState);
@@ -7924,12 +8209,60 @@ 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 message2 = input.record.message && typeof input.record.message === "object" ? input.record.message : input.record;
+    const content = Array.isArray(message2.content) ? message2.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 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 (!existsSync13(reviewStatusPath)) {
+  if (!existsSync12(reviewStatusPath)) {
     return null;
   }
   try {
-    const status = readFileSync11(reviewStatusPath, "utf8").trim().toUpperCase();
+    const status = readFileSync10(reviewStatusPath, "utf8").trim().toUpperCase();
     return status === "APPROVED" || status === "REJECTED" ? status : null;
   } catch {
     return null;
@@ -7947,14 +8280,45 @@ function isTaskRunReviewRejected(reviewState) {
 function runSourceTaskIdentity(sourceTask) {
   return sourceTask;
 }
-async function updateTaskSourceAfterDriverRun(projectRoot, runId, taskId2, sourceTask, status, summary, input, updateTaskSource = updateConfiguredTaskSourceTask) {
-  if (!taskId2)
+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, taskId3, sourceTask, status, summary, input, updateTaskSource = updateTaskSourceWithProjectSync) {
+  if (!taskId3)
     return;
   const config = await loadTaskRunAutomationConfig(projectRoot);
   if (!shouldWriteDriverIssueUpdate(config, status))
     return;
   const result = await updateTaskSource(projectRoot, {
-    taskId: taskId2,
+    taskId: taskId3,
     sourceTask: runSourceTaskIdentity(sourceTask),
     update: {
       status,
@@ -7973,14 +8337,14 @@ async function updateTaskSourceAfterDriverRun(projectRoot, runId, taskId2, sourc
     throw new Error(`Configured task source${result.sourceKind ? ` (${result.sourceKind})` : ""} did not accept lifecycle update for ${result.taskId}.`);
   }
 }
-function readRunSourceTaskContract(projectRoot, runId, taskId2) {
+function readRunSourceTaskContract(projectRoot, runId, taskId3) {
   const run = readAuthorityRun5(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() : taskId2?.trim();
+  const id = typeof record.id === "string" && record.id.trim() ? record.id.trim() : taskId3?.trim();
   if (!id) {
     return null;
   }
@@ -8116,15 +8480,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 = resolve22("artifacts", runtimeTaskId, "implementation-plan.md");
+  const planningArtifactPath = resolve21("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()
   };
-  mkdirSync8(resolve22(context.projectRoot, ".rig", "runs", input.runId), { recursive: true });
-  writeFileSync6(resolve22(context.projectRoot, ".rig", "runs", input.runId, "planning-classification.json"), `${JSON.stringify(persistedPlanning, null, 2)}
+  mkdirSync8(resolve21(context.projectRoot, ".rig", "runs", input.runId), { recursive: true });
+  writeFileSync6(resolve21(context.projectRoot, ".rig", "runs", input.runId, "planning-classification.json"), `${JSON.stringify(persistedPlanning, null, 2)}
 `, "utf8");
   patchAuthorityRun(context.projectRoot, input.runId, { planning: persistedPlanning });
   prompt = `${prompt}
@@ -8174,7 +8538,7 @@ ${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" ? resolve22(existingRunRecord.sessionPath, "..") : null;
+  let latestSessionDir = resumeMode && typeof existingRunRecord?.sessionPath === "string" ? resolve21(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;
@@ -8257,10 +8621,10 @@ ${planningClassification.planningRequired ? `Before implementing, write a concis
       patchAuthorityRun(context.projectRoot, input.runId, {
         status: "running",
         worktreePath: latestRuntimeWorkspace,
-        artifactRoot: latestRuntimeWorkspace && input.taskId ? resolve22(latestRuntimeWorkspace, "artifacts", input.taskId) : null,
+        artifactRoot: latestRuntimeWorkspace && input.taskId ? resolve21(latestRuntimeWorkspace, "artifacts", input.taskId) : null,
         logRoot: latestLogsDir,
-        sessionPath: latestSessionDir ? resolve22(latestSessionDir, "session.json") : null,
-        sessionLogPath: latestLogsDir ? resolve22(latestLogsDir, "agent-stdout.log") : null,
+        sessionPath: latestSessionDir ? resolve21(latestSessionDir, "session.json") : null,
+        sessionLogPath: latestLogsDir ? resolve21(latestLogsDir, "agent-stdout.log") : null,
         branch: runtimeId
       });
       if (!dirtyBaselineApplied && input.baselineMode === "dirty-snapshot" && latestRuntimeWorkspace) {
@@ -8268,7 +8632,7 @@ ${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) {
-          mkdirSync8(resolve22(readyFile, ".."), { recursive: true });
+          mkdirSync8(resolve21(readyFile, ".."), { recursive: true });
           writeFileSync6(readyFile, `${JSON.stringify({ ...dirty, workspaceDir: latestRuntimeWorkspace, appliedAt: new Date().toISOString() }, null, 2)}
 `, "utf8");
         }
@@ -8417,7 +8781,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") {
@@ -8575,7 +8942,7 @@ ${planningClassification.planningRequired ? `Before implementing, write a concis
     let acceptedArtifactObservedAt = null;
     let acceptedArtifactPollTimer = null;
     let acceptedArtifactKillTimer = null;
-    const attemptExit = await new Promise((resolve23) => {
+    const attemptExit = await new Promise((resolve22) => {
       let settled = false;
       const settle = (result) => {
         if (settled)
@@ -8583,7 +8950,7 @@ ${planningClassification.planningRequired ? `Before implementing, write a concis
         settled = true;
         if (acceptedArtifactPollTimer)
           clearInterval(acceptedArtifactPollTimer);
-        resolve23(result);
+        resolve22(result);
       };
       const pollAcceptedArtifacts = () => {
         const artifactState = readTaskRunAcceptedArtifactState({
@@ -8656,7 +9023,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) {
@@ -8782,8 +9152,8 @@ Failed to update task source for ${input.taskId ?? runtimeTaskId} to failed: ${e
   }
   if (planningClassification.planningRequired) {
     const planWorkspace = latestRuntimeWorkspace ?? context.projectRoot;
-    const expectedPlanPath = resolve22(planWorkspace, planningArtifactPath);
-    if (!existsSync13(expectedPlanPath)) {
+    const expectedPlanPath = resolve21(planWorkspace, planningArtifactPath);
+    if (!existsSync12(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, {
@@ -8803,6 +9173,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
+    });
+    return;
+  }
   const runPiPrFeedbackFix = async (message2) => {
     appendPiStageLog({
       projectRoot: context.projectRoot,
@@ -8830,11 +9259,45 @@ Failed to update task source for ${input.taskId ?? runtimeTaskId} to failed: ${e
       child.stdin.write(message2);
     }
     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",
@@ -8860,10 +9323,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((resolve23) => {
-      child.once("error", () => resolve23(1));
-      child.once("close", (code) => resolve23(code ?? 1));
+    const exitCode = await new Promise((resolve22) => {
+      child.once("error", () => resolve22(1));
+      child.once("close", (code) => resolve22(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}.`);
     }
@@ -8981,8 +9465,8 @@ async function executeTest(context, args) {
 }
 
 // packages/cli/src/commands/setup.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync9, readdirSync as readdirSync2, writeFileSync as writeFileSync7 } from "fs";
-import { resolve as resolve23 } from "path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync9, readdirSync as readdirSync2, writeFileSync as writeFileSync7 } from "fs";
+import { resolve as resolve22 } from "path";
 import { createPluginHost } from "@rig/core";
 import {
   isSupportedBunVersion as isSupportedBunVersion2,
@@ -9045,8 +9529,8 @@ function runSetupInit(projectRoot) {
   mkdirSync9(stateDir, { recursive: true });
   mkdirSync9(logsDir, { recursive: true });
   mkdirSync9(artifactsDir, { recursive: true });
-  const failuresPath = resolve23(stateDir, "failed_approaches.md");
-  if (!existsSync14(failuresPath)) {
+  const failuresPath = resolve22(stateDir, "failed_approaches.md");
+  if (!existsSync13(failuresPath)) {
     writeFileSync7(failuresPath, `# Failed Approaches
 
 `, "utf-8");
@@ -9064,18 +9548,18 @@ async function runSetupCheck(projectRoot) {
 }
 async function runSetupPreflight(projectRoot) {
   await runSetupCheck(projectRoot);
-  const validationRoot = resolve23(resolveControlPlaneDefinitionRoot(projectRoot), "validation");
-  if (existsSync14(validationRoot)) {
+  const validationRoot = resolve22(resolveControlPlaneDefinitionRoot(projectRoot), "validation");
+  if (existsSync13(validationRoot)) {
     const validators = readdirSync2(validationRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory());
     for (const validator of validators) {
-      const script = resolve23(validationRoot, validator.name, "validate.sh");
-      if (existsSync14(script)) {
+      const script = resolve22(validationRoot, validator.name, "validate.sh");
+      if (existsSync13(script)) {
         console.log(`OK: validator script ${script}`);
       }
     }
   }
-  const hooksRoot = resolve23(resolveControlPlaneDefinitionRoot(projectRoot), "hooks");
-  if (existsSync14(hooksRoot)) {
+  const hooksRoot = resolve22(resolveControlPlaneDefinitionRoot(projectRoot), "hooks");
+  if (existsSync13(hooksRoot)) {
     const hooks = readdirSync2(hooksRoot).filter((name) => name.endsWith(".sh"));
     for (const hook of hooks) {
       console.log(`OK: hook ${hook}`);
@@ -9452,8 +9936,8 @@ async function executeGroup(context, group, args) {
   }
 }
 // packages/cli/src/launcher.ts
-import { existsSync as existsSync15 } from "fs";
-import { basename as basename2, resolve as resolve24 } from "path";
+import { existsSync as existsSync14 } from "fs";
+import { basename as basename2, resolve as resolve23 } from "path";
 import { loadDotEnvSecrets } from "@rig/runtime/baked-secrets";
 import { RIG_DEFINITION_DIRNAME, RIG_STATE_DIRNAME, resolveNearestRigProjectRoot } from "@rig/runtime/layout";
 function parsePolicyMode(value) {
@@ -9466,7 +9950,7 @@ function parsePolicyMode(value) {
   throw new Error(`Invalid --policy-mode value: ${value}. Use off|observe|enforce.`);
 }
 function hasRigProjectMarker(candidate) {
-  return existsSync15(resolve24(candidate, RIG_DEFINITION_DIRNAME)) || existsSync15(resolve24(candidate, RIG_STATE_DIRNAME)) || existsSync15(resolve24(candidate, "rig.config.ts")) || existsSync15(resolve24(candidate, "rig.config.json"));
+  return existsSync14(resolve23(candidate, RIG_DEFINITION_DIRNAME)) || existsSync14(resolve23(candidate, RIG_STATE_DIRNAME)) || existsSync14(resolve23(candidate, "rig.config.ts")) || existsSync14(resolve23(candidate, "rig.config.json"));
 }
 function resolveProjectRoot({
   envProjectRoot,
@@ -9475,19 +9959,19 @@ function resolveProjectRoot({
   cwd = process.cwd()
 }) {
   if (envProjectRoot) {
-    return resolve24(cwd, envProjectRoot);
+    return resolve23(cwd, envProjectRoot);
   }
   const fallbackImportDir = importDir ?? cwd;
   const execName = basename2(execPath).toLowerCase();
-  const execCandidates = execName === "rig" || execName === "rig.exe" ? [resolve24(execPath, "..", "..")] : [];
-  const candidates = [cwd, ...execCandidates, resolve24(fallbackImportDir, "..")];
+  const execCandidates = execName === "rig" || execName === "rig.exe" ? [resolve23(execPath, "..", "..")] : [];
+  const candidates = [cwd, ...execCandidates, resolve23(fallbackImportDir, "..")];
   for (const candidate of candidates) {
     const nearest = resolveNearestRigProjectRoot(candidate);
     if (hasRigProjectMarker(nearest)) {
       return nearest;
     }
   }
-  return resolve24(cwd);
+  return resolve23(cwd);
 }
 function normalizeCliErrorCode(message2, isCliError) {
   if (message2.startsWith("Invalid --policy-mode value:")) {
@@ -9554,7 +10038,7 @@ async function runRigCli(module, options = {}) {
         runId: context.runId,
         outcome,
         eventsFile: context.eventBus.getEventsFile(),
-        policyFile: resolve24(projectRoot, "rig", "policy", "policy.json"),
+        policyFile: resolve23(projectRoot, "rig", "policy", "policy.json"),
         policyMode: context.policyMode ?? policyMode ?? module.loadPolicy(projectRoot).mode
       }, null, 2));
     }