@h-rig/cli 0.0.6-alpha.1 → 0.0.6-alpha.11

package/dist/src/commands.js

@@ -2465,6 +2465,8 @@ function resolveSelectedConnection(projectRoot, options = {}) {
 
 // packages/cli/src/commands/_server-client.ts
 import { spawnSync } from "child_process";
+import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+import { resolve as resolve8 } from "path";
 import { ensureLocalRigServerConnection } from "@rig/runtime/local-server";
 var cachedGitHubBearerToken;
 function cleanToken(value) {
@@ -2474,9 +2476,25 @@ function cleanToken(value) {
 function setGitHubBearerTokenForCurrentProcess(token) {
   cachedGitHubBearerToken = cleanToken(token ?? undefined);
 }
-function readGitHubBearerTokenForRemote() {
+function readPrivateRemoteSessionToken(projectRoot) {
+  const path = resolve8(projectRoot, ".rig", "state", "github-auth.json");
+  if (!existsSync4(path))
+    return null;
+  try {
+    const parsed = JSON.parse(readFileSync3(path, "utf8"));
+    return cleanToken(typeof parsed.apiSessionToken === "string" ? parsed.apiSessionToken : typeof parsed.sessionToken === "string" ? parsed.sessionToken : undefined);
+  } catch {
+    return null;
+  }
+}
+function readGitHubBearerTokenForRemote(projectRoot) {
   if (cachedGitHubBearerToken !== undefined)
     return cachedGitHubBearerToken;
+  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;
@@ -2496,7 +2514,7 @@ async function ensureServerForCli(projectRoot) {
     if (selected?.connection.kind === "remote") {
       return {
         baseUrl: selected.connection.baseUrl,
-        authToken: readGitHubBearerTokenForRemote(),
+        authToken: readGitHubBearerTokenForRemote(projectRoot),
         connectionKind: "remote"
       };
     }
@@ -2603,7 +2621,7 @@ async function postGitHubTokenViaServer(context, token, options = {}) {
   const payload = await requestServerJson(context, "/api/github/auth/token", {
     method: "POST",
     headers: { "content-type": "application/json" },
-    body: JSON.stringify({ token, selectedRepo: options.selectedRepo })
+    body: JSON.stringify({ token, selectedRepo: options.selectedRepo, projectRoot: options.projectRoot })
   });
   return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
 }
@@ -2624,18 +2642,38 @@ async function registerProjectViaServer(context, input) {
   return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
 }
 function sleep(ms) {
-  return new Promise((resolve8) => setTimeout(resolve8, ms));
+  return new Promise((resolve9) => setTimeout(resolve9, ms));
+}
+function isRetryableProjectRootSwitchError(error) {
+  if (!(error instanceof Error))
+    return false;
+  const message = error.message.toLowerCase();
+  return message.includes("rig server request failed (401): auth-required") || message.includes("rig server request failed (401): github-token-required") || message.includes("rig server request failed (502)") || message.includes("rig server request failed (503)") || message.includes("bad gateway") || message.includes("fetch failed") || message.includes("econnrefused") || message.includes("connection refused");
 }
 async function switchServerProjectRootViaServer(context, projectRoot, options = {}) {
-  const switched = await requestServerJson(context, "/api/server/project-root", {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body: JSON.stringify({ projectRoot })
-  });
   const timeoutMs = options.timeoutMs ?? 30000;
   const pollMs = options.pollMs ?? 1000;
   const deadline = Date.now() + timeoutMs;
   let lastError;
+  let switched = null;
+  while (Date.now() < deadline) {
+    try {
+      switched = await requestServerJson(context, "/api/server/project-root", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ projectRoot })
+      });
+      break;
+    } catch (error) {
+      lastError = error;
+      if (!isRetryableProjectRootSwitchError(error))
+        throw error;
+      await sleep(pollMs);
+    }
+  }
+  if (!switched) {
+    throw new CliError2(`Rig server did not accept project-root switch to ${projectRoot} before timeout (${lastError instanceof Error ? lastError.message : String(lastError ?? "no response")}).`, 1);
+  }
   while (Date.now() < deadline) {
     try {
       const status = await requestServerJson(context, "/api/server/status");
@@ -2715,9 +2753,9 @@ async function submitTaskRunViaServer(context, input) {
 }
 
 // packages/cli/src/commands/_pi-install.ts
-import { existsSync as existsSync4, readFileSync as readFileSync3, rmSync as rmSync3 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync4, rmSync as rmSync3 } from "fs";
 import { homedir as homedir3 } from "os";
-import { resolve as resolve8 } from "path";
+import { resolve as resolve9 } from "path";
 var PI_RIG_PACKAGE_NAME = "@rig/pi-rig";
 var LEGACY_PI_RIG_MARKER = `// Managed by Rig. Source package: @rig/pi-rig.
 export { default } from '@rig/pi-rig';
@@ -2732,11 +2770,11 @@ async function defaultCommandRunner(command, options = {}) {
   return { exitCode, stdout, stderr };
 }
 function resolvePiRigExtensionPath(homeDir) {
-  return resolve8(homeDir, ".pi", "agent", "extensions", "pi-rig");
+  return resolve9(homeDir, ".pi", "agent", "extensions", "pi-rig");
 }
-function resolvePiRigPackageSource(projectRoot, exists = existsSync4) {
-  const localPackage = resolve8(projectRoot, "packages", "pi-rig");
-  if (exists(resolve8(localPackage, "package.json")))
+function resolvePiRigPackageSource(projectRoot, exists = existsSync5) {
+  const localPackage = resolve9(projectRoot, "packages", "pi-rig");
+  if (exists(resolve9(localPackage, "package.json")))
     return localPackage;
   return `npm:${PI_RIG_PACKAGE_NAME}`;
 }
@@ -2787,13 +2825,13 @@ async function ensurePiBinaryAvailable(input) {
     ...next.exitCode === 0 ? {} : { error: (next.stderr || next.stdout).trim() || "pi --version failed after install" }
   };
 }
-function removeManagedLegacyPiRigBridge(homeDir, exists = existsSync4) {
+function removeManagedLegacyPiRigBridge(homeDir, exists = existsSync5) {
   const extensionPath = resolvePiRigExtensionPath(homeDir);
-  const indexPath = resolve8(extensionPath, "index.ts");
+  const indexPath = resolve9(extensionPath, "index.ts");
   if (!exists(indexPath))
     return;
   try {
-    const content = readFileSync3(indexPath, "utf8");
+    const content = readFileSync4(indexPath, "utf8");
     if (content === LEGACY_PI_RIG_MARKER || content.includes("Managed by Rig. Source package: @rig/pi-rig")) {
       rmSync3(extensionPath, { recursive: true, force: true });
     }
@@ -2809,13 +2847,13 @@ async function checkPiRigInstall(input = {}) {
       piRig: { ok: true, label: "pi-rig global extension", detail: extensionPath }
     };
   }
-  const exists = input.exists ?? existsSync4;
+  const exists = input.exists ?? existsSync5;
   const runner = input.commandRunner ?? defaultCommandRunner;
   const piResult = await safeRun(runner, ["pi", "--version"]);
   const piListResult = piResult.exitCode === 0 ? await safeRun(runner, ["pi", "list"]) : { exitCode: 1, stdout: "", stderr: "" };
   const listedPiRig = piListResult.exitCode === 0 && piListContainsPiRig(`${piListResult.stdout}
 ${piListResult.stderr}`);
-  const legacyBridge = exists(resolve8(extensionPath, "index.ts"));
+  const legacyBridge = exists(resolve9(extensionPath, "index.ts"));
   const hasPiRig = listedPiRig;
   return {
     extensionPath,
@@ -3153,7 +3191,7 @@ async function executeQueue(context, args) {
 }
 
 // packages/cli/src/commands/agent.ts
-import { resolve as resolve10 } from "path";
+import { resolve as resolve11 } from "path";
 import {
   agentId,
   cleanupAgentRuntime,
@@ -3163,8 +3201,8 @@ import {
 } from "@rig/runtime/control-plane/runtime/isolation";
 
 // packages/cli/src/commands/_authority-runs.ts
-import { existsSync as existsSync5 } from "fs";
-import { resolve as resolve9 } from "path";
+import { existsSync as existsSync6 } from "fs";
+import { resolve as resolve10 } from "path";
 import {
   readAuthorityRun,
   readJsonlFile as readJsonlFile2,
@@ -3186,8 +3224,8 @@ function normalizeRuntimeAdapter(value) {
   return "claude-code";
 }
 function readLatestBeadRecord(projectRoot, taskId) {
-  const issuesPath = resolve9(resolveControlPlaneMonorepoRoot(projectRoot), ".beads", "issues.jsonl");
-  if (!existsSync5(issuesPath)) {
+  const issuesPath = resolve10(resolveControlPlaneMonorepoRoot(projectRoot), ".beads", "issues.jsonl");
+  if (!existsSync6(issuesPath)) {
     return null;
   }
   let latest = null;
@@ -3222,6 +3260,7 @@ function upsertAgentAuthorityRun(projectRoot, input) {
   const runtimeAdapter = normalizeRuntimeAdapter(input.runtimeAdapter ?? existing?.runtimeAdapter ?? "claude-code");
   const title = resolveTaskTitleForAuthorityRun(projectRoot, input.taskId) ?? input.taskId;
   const next = {
+    ...existing ?? {},
     runId: input.runId,
     projectRoot,
     workspaceId: existing?.workspaceId ?? RIG_WORKSPACE_ID,
@@ -3254,7 +3293,7 @@ function upsertAgentAuthorityRun(projectRoot, input) {
   } else if ("errorText" in next) {
     delete next.errorText;
   }
-  writeJsonFile3(resolve9(resolveAuthorityRunDir(projectRoot, input.runId), "run.json"), next);
+  writeJsonFile3(resolve10(resolveAuthorityRunDir(projectRoot, input.runId), "run.json"), next);
   return next;
 }
 
@@ -3375,10 +3414,10 @@ async function executeAgent(context, args) {
           status: "running",
           startedAt: createdAt,
           worktreePath: runtime.workspaceDir,
-          artifactRoot: resolve10(runtime.workspaceDir, "artifacts", taskId),
+          artifactRoot: resolve11(runtime.workspaceDir, "artifacts", taskId),
           logRoot: runtime.logsDir,
-          sessionPath: resolve10(runtime.sessionDir, "session.json"),
-          sessionLogPath: resolve10(runtime.logsDir, "agent-stdout.log"),
+          sessionPath: resolve11(runtime.sessionDir, "session.json"),
+          sessionLogPath: resolve11(runtime.logsDir, "agent-stdout.log"),
           pid: process.pid
         });
         const result = await runInAgentRuntime({
@@ -3398,10 +3437,10 @@ async function executeAgent(context, args) {
             startedAt: createdAt,
             completedAt: failedAt,
             worktreePath: runtime.workspaceDir,
-            artifactRoot: resolve10(runtime.workspaceDir, "artifacts", taskId),
+            artifactRoot: resolve11(runtime.workspaceDir, "artifacts", taskId),
             logRoot: runtime.logsDir,
-            sessionPath: resolve10(runtime.sessionDir, "session.json"),
-            sessionLogPath: resolve10(runtime.logsDir, "agent-stdout.log"),
+            sessionPath: resolve11(runtime.sessionDir, "session.json"),
+            sessionLogPath: resolve11(runtime.logsDir, "agent-stdout.log"),
             pid: process.pid,
             errorText: result.stderr ? result.stderr.trim() : `Agent runtime command failed (${result.exitCode})`
           });
@@ -3418,10 +3457,10 @@ ${result.stderr.trim()}` : ""}`, result.exitCode);
           startedAt: createdAt,
           completedAt,
           worktreePath: runtime.workspaceDir,
-          artifactRoot: resolve10(runtime.workspaceDir, "artifacts", taskId),
+          artifactRoot: resolve11(runtime.workspaceDir, "artifacts", taskId),
           logRoot: runtime.logsDir,
-          sessionPath: resolve10(runtime.sessionDir, "session.json"),
-          sessionLogPath: resolve10(runtime.logsDir, "agent-stdout.log"),
+          sessionPath: resolve11(runtime.sessionDir, "session.json"),
+          sessionLogPath: resolve11(runtime.logsDir, "agent-stdout.log"),
           pid: process.pid
         });
         return {
@@ -3495,7 +3534,7 @@ ${result.stderr.trim()}` : ""}`, result.exitCode);
 import {
   chmodSync,
   copyFileSync as copyFileSync2,
-  existsSync as existsSync6,
+  existsSync as existsSync7,
   mkdirSync as mkdirSync5,
   readdirSync,
   readlinkSync,
@@ -3505,7 +3544,7 @@ import {
   unlinkSync
 } from "fs";
 import { homedir as homedir4 } from "os";
-import { resolve as resolve11 } from "path";
+import { resolve as resolve12 } from "path";
 import { buildBinary as buildBinary2 } from "@rig/runtime/control-plane/runtime/isolation";
 import {
   computeRuntimeImageFingerprint,
@@ -3524,13 +3563,13 @@ async function runQuietBinaryProbe(binaryPath, args, cwd) {
 
 // packages/cli/src/commands/dist.ts
 function collectRigValidatorBuildTargets(input) {
-  const validatorsRoot = resolve11(input.hostProjectRoot, "packages/runtime/src/control-plane/validators");
-  if (!existsSync6(validatorsRoot))
+  const validatorsRoot = resolve12(input.hostProjectRoot, "packages/runtime/src/control-plane/validators");
+  if (!existsSync7(validatorsRoot))
     return [];
   const targets = [];
   const categories = readdirSync(validatorsRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory());
   for (const category of categories) {
-    const categoryDir = resolve11(validatorsRoot, category.name);
+    const categoryDir = resolve12(validatorsRoot, category.name);
     for (const entry of readdirSync(categoryDir, { withFileTypes: true })) {
       if (!entry.isFile() || !entry.name.endsWith(".ts"))
         continue;
@@ -3539,7 +3578,7 @@ function collectRigValidatorBuildTargets(input) {
         continue;
       targets.push({
         source: `packages/runtime/src/control-plane/validators/${category.name}/${entry.name}`,
-        dest: resolve11(input.imageDir, `bin/validators/${category.name}-${check}`),
+        dest: resolve12(input.imageDir, `bin/validators/${category.name}-${check}`),
         cwd: input.hostProjectRoot
       });
     }
@@ -3548,16 +3587,16 @@ function collectRigValidatorBuildTargets(input) {
 }
 async function findLatestDistBinary(projectRoot) {
   const distRoot = resolveControlPlaneHostDistDir(projectRoot);
-  if (!existsSync6(distRoot)) {
+  if (!existsSync7(distRoot)) {
     return null;
   }
   const entries = readdirSync(distRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name.startsWith("rig-")).map((entry) => ({
     name: entry.name,
-    mtimeMs: statSync(resolve11(distRoot, entry.name)).mtimeMs
+    mtimeMs: statSync(resolve12(distRoot, entry.name)).mtimeMs
   })).sort((a, b) => b.mtimeMs - a.mtimeMs || b.name.localeCompare(a.name));
   for (const { name } of entries) {
-    const candidate = resolve11(distRoot, name, "bin", "rig");
-    if (existsSync6(candidate) && await isRunnableRigBinary(candidate, projectRoot)) {
+    const candidate = resolve12(distRoot, name, "bin", "rig");
+    if (existsSync7(candidate) && await isRunnableRigBinary(candidate, projectRoot)) {
       return candidate;
     }
   }
@@ -3569,7 +3608,7 @@ async function isRunnableRigBinary(binaryPath, projectRoot) {
 async function runDistDoctor(projectRoot) {
   const bunPath = Bun.which("bun");
   const rigPath = Bun.which("rig");
-  const userBinDir = resolve11(homedir4(), ".local/bin");
+  const userBinDir = resolve12(homedir4(), ".local/bin");
   const userBinInPath = (process.env.PATH || "").split(":").filter(Boolean).includes(userBinDir);
   let rigRunnable = false;
   if (rigPath) {
@@ -3617,15 +3656,15 @@ async function executeDist(context, args) {
       let source = await findLatestDistBinary(context.projectRoot);
       let buildDir = null;
       if (!source) {
-        buildDir = resolve11(resolveControlPlaneHostDistDir(context.projectRoot), `rig-install-${Date.now()}`);
+        buildDir = resolve12(resolveControlPlaneHostDistDir(context.projectRoot), `rig-install-${Date.now()}`);
         await context.runCommand(["bun", "run", "packages/cli/bin/build-rig-binaries.ts", "--output-dir", buildDir]);
-        source = resolve11(buildDir, "bin", "rig");
+        source = resolve12(buildDir, "bin", "rig");
       }
-      if (!existsSync6(source)) {
+      if (!existsSync7(source)) {
         throw new CliError2(`Unable to locate rig binary at ${source}.`, 2);
       }
-      const installedPath = resolve11(installDir, "rig");
-      if (existsSync6(installedPath)) {
+      const installedPath = resolve12(installDir, "rig");
+      if (existsSync7(installedPath)) {
         unlinkSync(installedPath);
       }
       copyFileSync2(source, installedPath);
@@ -3667,22 +3706,22 @@ async function executeDist(context, args) {
       requireNoExtraArgs(rest, "bun run rig dist rebuild-agent");
       const fp = await computeRuntimeImageFingerprint(context.projectRoot);
       const currentId = computeRuntimeImageId(fp);
-      const imagesDir = resolve11(resolveControlPlaneMonorepoRuntimeDir(context.projectRoot), "images");
+      const imagesDir = resolve12(resolveControlPlaneMonorepoRuntimeDir(context.projectRoot), "images");
       mkdirSync5(imagesDir, { recursive: true });
       let pruned = 0;
       for (const entry of readdirSync(imagesDir, { withFileTypes: true })) {
         if (entry.isDirectory() && entry.name !== currentId) {
-          rmSync4(resolve11(imagesDir, entry.name), { recursive: true, force: true });
+          rmSync4(resolve12(imagesDir, entry.name), { recursive: true, force: true });
           pruned++;
         }
       }
       if (pruned > 0 && context.outputMode === "text") {
         console.log(`Pruned ${pruned} stale image(s).`);
       }
-      const imageDir = resolve11(imagesDir, currentId);
-      mkdirSync5(resolve11(imageDir, "bin/hooks"), { recursive: true });
-      mkdirSync5(resolve11(imageDir, "bin/plugins"), { recursive: true });
-      mkdirSync5(resolve11(imageDir, "bin/validators"), { recursive: true });
+      const imageDir = resolve12(imagesDir, currentId);
+      mkdirSync5(resolve12(imageDir, "bin/hooks"), { recursive: true });
+      mkdirSync5(resolve12(imageDir, "bin/plugins"), { recursive: true });
+      mkdirSync5(resolve12(imageDir, "bin/validators"), { recursive: true });
       const hookNames = [
         "scope-guard",
         "import-guard",
@@ -3696,25 +3735,25 @@ async function executeDist(context, args) {
       ];
       const targets = [];
       const hostProjectRoot = process.env.RIG_HOST_PROJECT_ROOT?.trim() || context.projectRoot;
-      targets.push({ source: "packages/runtime/bin/rig-agent.ts", dest: resolve11(imageDir, "bin/rig-agent"), cwd: hostProjectRoot });
-      targets.push({ source: "packages/runtime/bin/rig-agent-dispatch.ts", dest: resolve11(resolveControlPlaneHostBinDir(context.projectRoot), "rig-agent"), cwd: hostProjectRoot });
+      targets.push({ source: "packages/runtime/bin/rig-agent.ts", dest: resolve12(imageDir, "bin/rig-agent"), cwd: hostProjectRoot });
+      targets.push({ source: "packages/runtime/bin/rig-agent-dispatch.ts", dest: resolve12(resolveControlPlaneHostBinDir(context.projectRoot), "rig-agent"), cwd: hostProjectRoot });
       for (const hookName of hookNames) {
         const src = `packages/runtime/src/control-plane/hooks/${hookName}.ts`;
-        targets.push({ source: src, dest: resolve11(imageDir, `bin/hooks/${hookName}`), cwd: hostProjectRoot });
-        targets.push({ source: src, dest: resolve11(resolveControlPlaneHostBinDir(context.projectRoot), `hooks/${hookName}`), cwd: hostProjectRoot });
+        targets.push({ source: src, dest: resolve12(imageDir, `bin/hooks/${hookName}`), cwd: hostProjectRoot });
+        targets.push({ source: src, dest: resolve12(resolveControlPlaneHostBinDir(context.projectRoot), `hooks/${hookName}`), cwd: hostProjectRoot });
       }
-      const pluginsDir = resolve11(context.projectRoot, "rig/plugins");
-      const binPluginsDir = resolve11(resolveControlPlaneHostBinDir(context.projectRoot), "plugins");
-      const validatorsRoot = resolve11(hostProjectRoot, "packages/runtime/src/control-plane/validators");
-      const binValidatorsDir = resolve11(resolveControlPlaneHostBinDir(context.projectRoot), "validators");
+      const pluginsDir = resolve12(context.projectRoot, "rig/plugins");
+      const binPluginsDir = resolve12(resolveControlPlaneHostBinDir(context.projectRoot), "plugins");
+      const validatorsRoot = resolve12(hostProjectRoot, "packages/runtime/src/control-plane/validators");
+      const binValidatorsDir = resolve12(resolveControlPlaneHostBinDir(context.projectRoot), "validators");
       mkdirSync5(binPluginsDir, { recursive: true });
       mkdirSync5(binValidatorsDir, { recursive: true });
-      if (existsSync6(pluginsDir)) {
+      if (existsSync7(pluginsDir)) {
         for (const entry of readdirSync(pluginsDir, { withFileTypes: true })) {
           const m = entry.name.match(/^(.+)\.plugin\.(ts|js|mjs|cjs)$/);
           if (!m)
             continue;
-          targets.push({ source: `rig/plugins/${entry.name}`, dest: resolve11(imageDir, `bin/plugins/${m[1]}`), cwd: context.projectRoot });
+          targets.push({ source: `rig/plugins/${entry.name}`, dest: resolve12(imageDir, `bin/plugins/${m[1]}`), cwd: context.projectRoot });
         }
       }
       targets.push(...collectRigValidatorBuildTargets({ contextProjectRoot: context.projectRoot, hostProjectRoot, imageDir }));
@@ -3725,17 +3764,17 @@ async function executeDist(context, args) {
         const isValidator = dest.includes("/bin/validators/");
         await buildBinary2(source, dest, cwd, isValidator ? { AGENT_BUN_PATH: Bun.which("bun") || "bun" } : { AGENT_PROJECT_ROOT: context.projectRoot });
       }
-      if (existsSync6(pluginsDir)) {
+      if (existsSync7(pluginsDir)) {
         for (const entry of readdirSync(pluginsDir, { withFileTypes: true })) {
           const m = entry.name.match(/^(.+)\.plugin\.(ts|js|mjs|cjs)$/);
           if (!m)
             continue;
           const pluginName = m[1];
-          const imageBin = resolve11(imageDir, `bin/plugins/${pluginName}`);
+          const imageBin = resolve12(imageDir, `bin/plugins/${pluginName}`);
           if (!pluginName)
             continue;
-          const symlinkPath = resolve11(binPluginsDir, pluginName);
-          if (existsSync6(imageBin)) {
+          const symlinkPath = resolve12(binPluginsDir, pluginName);
+          if (existsSync7(imageBin)) {
             try {
               unlinkSync(symlinkPath);
             } catch {}
@@ -3743,10 +3782,10 @@ async function executeDist(context, args) {
           }
         }
       }
-      if (existsSync6(validatorsRoot)) {
+      if (existsSync7(validatorsRoot)) {
         const categories = readdirSync(validatorsRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory());
         for (const category of categories) {
-          const categoryDir = resolve11(validatorsRoot, category.name);
+          const categoryDir = resolve12(validatorsRoot, category.name);
           for (const entry of readdirSync(categoryDir, { withFileTypes: true })) {
             if (!entry.isFile() || !entry.name.endsWith(".ts"))
               continue;
@@ -3754,9 +3793,9 @@ async function executeDist(context, args) {
             if (!check || check === "index" || check === "shared")
               continue;
             const validatorName = `${category.name}-${check}`;
-            const imageBin = resolve11(imageDir, `bin/validators/${validatorName}`);
-            const symlinkPath = resolve11(binValidatorsDir, validatorName);
-            if (existsSync6(imageBin)) {
+            const imageBin = resolve12(imageDir, `bin/validators/${validatorName}`);
+            const symlinkPath = resolve12(binValidatorsDir, validatorName);
+            if (existsSync7(imageBin)) {
               try {
                 unlinkSync(symlinkPath);
               } catch {}
@@ -3765,18 +3804,18 @@ async function executeDist(context, args) {
           }
         }
       }
-      const agentsDir = resolve11(resolveControlPlaneMonorepoRuntimeDir(context.projectRoot), "agents");
-      if (existsSync6(agentsDir)) {
+      const agentsDir = resolve12(resolveControlPlaneMonorepoRuntimeDir(context.projectRoot), "agents");
+      if (existsSync7(agentsDir)) {
         let relinkCount = 0;
         for (const agentEntry of readdirSync(agentsDir, { withFileTypes: true })) {
           if (!agentEntry.isDirectory())
             continue;
-          const agentBinDir = resolve11(agentsDir, agentEntry.name, "worktree", ".rig", "bin");
-          if (!existsSync6(agentBinDir))
+          const agentBinDir = resolve12(agentsDir, agentEntry.name, "worktree", ".rig", "bin");
+          if (!existsSync7(agentBinDir))
             continue;
           const walkDir = (dir) => {
             for (const entry of readdirSync(dir, { withFileTypes: true })) {
-              const fullPath = resolve11(dir, entry.name);
+              const fullPath = resolve12(dir, entry.name);
               if (entry.isDirectory()) {
                 walkDir(fullPath);
               } else if (entry.isSymbolicLink()) {
@@ -3810,7 +3849,7 @@ async function executeDist(context, args) {
 
 // packages/cli/src/commands/inbox.ts
 import { writeFileSync as writeFileSync4 } from "fs";
-import { resolve as resolve12 } from "path";
+import { resolve as resolve13 } from "path";
 import {
   listAuthorityRuns,
   readJsonlFile as readJsonlFile3,
@@ -3827,7 +3866,7 @@ async function executeInbox(context, args) {
       pending = task.rest;
       requireNoExtraArgs(pending, "bun run rig inbox approvals [--run <id>] [--task <id>]");
       const runs = listAuthorityRuns(context.projectRoot).filter((entry) => (!run.value || entry.runId === run.value) && (!task.value || entry.taskId === task.value));
-      const approvals = runs.flatMap((entry) => readJsonlFile3(resolve12(resolveAuthorityRunDir2(context.projectRoot, entry.runId), "approvals.jsonl")).map((record) => ({
+      const approvals = runs.flatMap((entry) => readJsonlFile3(resolve13(resolveAuthorityRunDir2(context.projectRoot, entry.runId), "approvals.jsonl")).map((record) => ({
         runId: entry.runId,
         record
       })));
@@ -3855,7 +3894,7 @@ async function executeInbox(context, args) {
       if (decision.value !== "approve" && decision.value !== "reject") {
         throw new CliError2("decision must be approve or reject.");
       }
-      const approvalsPath = resolve12(resolveAuthorityRunDir2(context.projectRoot, run.value), "approvals.jsonl");
+      const approvalsPath = resolve13(resolveAuthorityRunDir2(context.projectRoot, run.value), "approvals.jsonl");
       const approvals = readJsonlFile3(approvalsPath);
       const resolvedAt = new Date().toISOString();
       const next = approvals.map((entry) => entry.requestId === request.value || entry.id === request.value ? { ...entry, status: "resolved", decision: decision.value, note: note3.value ?? null, resolvedAt } : entry);
@@ -3872,7 +3911,7 @@ async function executeInbox(context, args) {
       pending = task.rest;
       requireNoExtraArgs(pending, "bun run rig inbox inputs [--run <id>] [--task <id>]");
       const runs = listAuthorityRuns(context.projectRoot).filter((entry) => (!run.value || entry.runId === run.value) && (!task.value || entry.taskId === task.value));
-      const requests = runs.flatMap((entry) => readJsonlFile3(resolve12(resolveAuthorityRunDir2(context.projectRoot, entry.runId), "user-input.jsonl")).map((record) => ({
+      const requests = runs.flatMap((entry) => readJsonlFile3(resolve13(resolveAuthorityRunDir2(context.projectRoot, entry.runId), "user-input.jsonl")).map((record) => ({
         runId: entry.runId,
         record
       })));
@@ -3914,7 +3953,7 @@ async function executeInbox(context, args) {
         const [key, ...restValue] = entry.split("=");
         return [key, restValue.join("=")];
       }));
-      const requestsPath = resolve12(resolveAuthorityRunDir2(context.projectRoot, run.value), "user-input.jsonl");
+      const requestsPath = resolve13(resolveAuthorityRunDir2(context.projectRoot, run.value), "user-input.jsonl");
       const requests = readJsonlFile3(requestsPath);
       const resolvedAt = new Date().toISOString();
       const next = requests.map((entry) => entry.requestId === request.value || entry.id === request.value ? { ...entry, status: "resolved", answers: parsedAnswers, respondedAt: resolvedAt, resolvedAt } : entry);
@@ -3929,14 +3968,14 @@ async function executeInbox(context, args) {
 }
 
 // packages/cli/src/commands/init.ts
-import { appendFileSync as appendFileSync2, existsSync as existsSync8, mkdirSync as mkdirSync6, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "fs";
+import { appendFileSync as appendFileSync2, existsSync as existsSync9, mkdirSync as mkdirSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
 import { spawnSync as spawnSync2 } from "child_process";
-import { resolve as resolve15 } from "path";
+import { resolve as resolve16 } from "path";
 import { buildRigInitConfigSource } from "@rig/core";
 
 // packages/cli/src/commands/_snapshot-upload.ts
 import { mkdir, readdir, readFile, writeFile } from "fs/promises";
-import { dirname as dirname2, resolve as resolve13, relative, sep } from "path";
+import { dirname as dirname2, resolve as resolve14, relative, sep } from "path";
 var SNAPSHOT_ARCHIVE_VERSION = 1;
 var SNAPSHOT_ARCHIVE_CONTENT_TYPE = "application/vnd.rig.snapshot+json";
 var DEFAULT_EXCLUDED_DIRECTORIES = new Set([
@@ -3958,15 +3997,15 @@ function assertManifestPath(root, relativePath) {
   if (!relativePath || relativePath.startsWith("/") || relativePath.includes("\x00")) {
     throw new Error(`Invalid snapshot path: ${relativePath}`);
   }
-  const resolved = resolve13(root, relativePath);
+  const resolved = resolve14(root, relativePath);
   const relativeToRoot = relative(root, resolved);
-  if (relativeToRoot.startsWith("..") || relativeToRoot === ".." || resolve13(relativeToRoot) === resolved) {
+  if (relativeToRoot.startsWith("..") || relativeToRoot === ".." || resolve14(relativeToRoot) === resolved) {
     throw new Error(`Snapshot path escapes project root: ${relativePath}`);
   }
   return resolved;
 }
 async function buildSnapshotUploadManifest(projectRoot, options = {}) {
-  const root = resolve13(projectRoot);
+  const root = resolve14(projectRoot);
   const excludedDirectories = [...new Set([
     ...DEFAULT_EXCLUDED_DIRECTORIES,
     ...options.excludedDirectories ?? []
@@ -3978,7 +4017,7 @@ async function buildSnapshotUploadManifest(projectRoot, options = {}) {
     for (const entry of entries) {
       if (entry.isDirectory() && excludedSet.has(entry.name))
         continue;
-      const fullPath = resolve13(dir, entry.name);
+      const fullPath = resolve14(dir, entry.name);
       if (entry.isDirectory()) {
         await visit(fullPath);
         continue;
@@ -4026,8 +4065,8 @@ async function uploadSnapshotArchiveViaServer(context, input) {
 }
 
 // packages/cli/src/commands/_doctor-checks.ts
-import { existsSync as existsSync7, readFileSync as readFileSync4 } from "fs";
-import { resolve as resolve14 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync5 } from "fs";
+import { resolve as resolve15 } from "path";
 import { isSupportedBunVersion, MIN_SUPPORTED_BUN_VERSION } from "@rig/runtime/control-plane/setup-version";
 function check(id, label, status, detail, remediation) {
   return {
@@ -4067,11 +4106,11 @@ function repoSlugFromConfig(config) {
 function loadFallbackConfig(projectRoot) {
   const candidates = ["rig.config.ts", "rig.config.mts", "rig.config.json"];
   for (const name of candidates) {
-    const path = resolve14(projectRoot, name);
-    if (!existsSync7(path))
+    const path = resolve15(projectRoot, name);
+    if (!existsSync8(path))
       continue;
     try {
-      const source = readFileSync4(path, "utf8");
+      const source = readFileSync5(path, "utf8");
       if (name.endsWith(".json"))
         return JSON.parse(source);
       const owner = source.match(/owner\s*:\s*["']([^"']+)["']/)?.[1];
@@ -4150,7 +4189,7 @@ async function runRigDoctorChecks(options) {
   checks.push(check("bun", `bun >= ${MIN_SUPPORTED_BUN_VERSION}`, isSupportedBunVersion(bunVersion) ? "pass" : "fail", `found ${bunVersion}`, `Install Bun ${MIN_SUPPORTED_BUN_VERSION} or newer.`), check("git", "git", which("git") ? "pass" : "fail", which("git") ?? undefined, "Install git and ensure it is on PATH."), check("jq", "jq", which("jq") ? "pass" : "warn", which("jq") ?? undefined, "Install jq (for example `brew install jq`)."));
   const loadedConfig = await loadConfig(projectRoot).catch(() => null);
   const config = loadedConfig ?? loadFallbackConfig(projectRoot);
-  const hasConfigFile = ["rig.config.ts", "rig.config.mts", "rig.config.json"].some((name) => existsSync7(resolve14(projectRoot, name)));
+  const hasConfigFile = ["rig.config.ts", "rig.config.mts", "rig.config.json"].some((name) => existsSync8(resolve15(projectRoot, name)));
   checks.push(config ? check("config", "rig.config loadable", "pass") : check("config", "rig.config loadable", hasConfigFile ? "fail" : "fail", hasConfigFile ? "config file exists but failed to load" : "missing rig.config.ts/json", "Run `rig init` or fix the config error."));
   const taskSourceKind = config?.taskSource?.kind;
   checks.push(taskSourceKind ? check("task-source", "task source configured", "pass", taskSourceKind) : check("task-source", "task source configured", "fail", "missing taskSource", "Configure taskSource in rig.config.ts."));
@@ -4245,10 +4284,10 @@ function countDoctorFailures(checks) {
 }
 
 // packages/cli/src/commands/init.ts
-var RIG_CONFIG_PACKAGE_VERSION = "0.0.6-alpha.1";
+var RIG_CONFIG_PACKAGE_DIST_TAG = "latest";
 var RIG_CONFIG_DEV_DEPENDENCIES = {
-  "@rig/core": `npm:@h-rig/core@${RIG_CONFIG_PACKAGE_VERSION}`,
-  "@rig/standard-plugin": `npm:@h-rig/standard-plugin@${RIG_CONFIG_PACKAGE_VERSION}`
+  "@rig/core": `npm:@h-rig/core@${RIG_CONFIG_PACKAGE_DIST_TAG}`,
+  "@rig/standard-plugin": `npm:@h-rig/standard-plugin@${RIG_CONFIG_PACKAGE_DIST_TAG}`
 };
 function parseRepoSlugFromRemote(remoteUrl) {
   const trimmed = remoteUrl.trim();
@@ -4268,20 +4307,20 @@ function parseRepoSlug(value) {
   return { owner: match[1], repo: match[2], slug: `${match[1]}/${match[2]}` };
 }
 function ensureRigPrivateDirs(projectRoot) {
-  const rigDir = resolve15(projectRoot, ".rig");
-  mkdirSync6(resolve15(rigDir, "state"), { recursive: true });
-  mkdirSync6(resolve15(rigDir, "logs"), { recursive: true });
-  mkdirSync6(resolve15(rigDir, "runs"), { recursive: true });
-  mkdirSync6(resolve15(rigDir, "tmp"), { recursive: true });
-  mkdirSync6(resolve15(projectRoot, "artifacts"), { recursive: true });
-  const taskConfigPath = resolve15(rigDir, "task-config.json");
-  if (!existsSync8(taskConfigPath))
+  const rigDir = resolve16(projectRoot, ".rig");
+  mkdirSync6(resolve16(rigDir, "state"), { recursive: true });
+  mkdirSync6(resolve16(rigDir, "logs"), { recursive: true });
+  mkdirSync6(resolve16(rigDir, "runs"), { recursive: true });
+  mkdirSync6(resolve16(rigDir, "tmp"), { recursive: true });
+  mkdirSync6(resolve16(projectRoot, "artifacts"), { recursive: true });
+  const taskConfigPath = resolve16(rigDir, "task-config.json");
+  if (!existsSync9(taskConfigPath))
     writeFileSync5(taskConfigPath, `{}
 `, "utf-8");
 }
 function ensureGitignoreEntries(projectRoot) {
-  const path = resolve15(projectRoot, ".gitignore");
-  const existing = existsSync8(path) ? readFileSync5(path, "utf8") : "";
+  const path = resolve16(projectRoot, ".gitignore");
+  const existing = existsSync9(path) ? readFileSync6(path, "utf8") : "";
   const entries = [".rig/state/", ".rig/logs/", ".rig/runs/", ".rig/tmp/"];
   const missing = entries.filter((entry) => !existing.split(/\r?\n/).includes(entry));
   if (missing.length === 0)
@@ -4294,14 +4333,14 @@ function ensureGitignoreEntries(projectRoot) {
 `, "utf8");
 }
 function ensureRigConfigPackageDependencies(projectRoot) {
-  const path = resolve15(projectRoot, "package.json");
-  const existing = existsSync8(path) ? JSON.parse(readFileSync5(path, "utf8")) : {};
+  const path = resolve16(projectRoot, "package.json");
+  const existing = existsSync9(path) ? JSON.parse(readFileSync6(path, "utf8")) : {};
   const devDependencies = existing.devDependencies && typeof existing.devDependencies === "object" && !Array.isArray(existing.devDependencies) ? { ...existing.devDependencies } : {};
   for (const [name, spec] of Object.entries(RIG_CONFIG_DEV_DEPENDENCIES)) {
     devDependencies[name] = spec;
   }
   const next = {
-    ...existsSync8(path) ? existing : { name: "rig-project", private: true },
+    ...existsSync9(path) ? existing : { name: "rig-project", private: true },
     devDependencies
   };
   writeFileSync5(path, `${JSON.stringify(next, null, 2)}
@@ -4371,15 +4410,71 @@ async function promptSelect(prompts, options) {
     throw new CliError2("Init cancelled.", 1);
   return String(value);
 }
-async function pollDeviceAuthOnce(context, pollId) {
+function sleep2(ms) {
+  return new Promise((resolve17) => setTimeout(resolve17, ms));
+}
+function positiveIntFromEnv(name, fallback) {
+  const value = Number.parseInt(process.env[name] ?? "", 10);
+  return Number.isFinite(value) && value >= 0 ? value : fallback;
+}
+function apiSessionTokenFrom(payload) {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload))
+    return null;
+  const token = payload.apiSessionToken;
+  return typeof token === "string" && token.trim() ? token.trim() : null;
+}
+function cleanPayloadString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function remoteGitHubAuthMetadata(payload) {
+  if (!payload)
+    return {};
+  const userNamespace = payload.userNamespace && typeof payload.userNamespace === "object" && !Array.isArray(payload.userNamespace) ? payload.userNamespace : null;
+  return {
+    ...cleanPayloadString(payload.login) ? { login: cleanPayloadString(payload.login) } : {},
+    ...cleanPayloadString(payload.userId) ? { userId: cleanPayloadString(payload.userId) } : {},
+    ...cleanPayloadString(userNamespace?.key) ? { userNamespaceKey: cleanPayloadString(userNamespace?.key) } : {},
+    ...cleanPayloadString(userNamespace?.root) ? { userNamespaceRoot: cleanPayloadString(userNamespace?.root) } : {},
+    ...cleanPayloadString(userNamespace?.checkoutBaseDir) ? { checkoutBaseDir: cleanPayloadString(userNamespace?.checkoutBaseDir) } : {},
+    ...cleanPayloadString(userNamespace?.snapshotBaseDir) ? { snapshotBaseDir: cleanPayloadString(userNamespace?.snapshotBaseDir) } : {}
+  };
+}
+function writeRemoteGitHubAuthState(projectRoot, input) {
+  writeFileSync5(resolve16(projectRoot, ".rig", "state", "github-auth.json"), `${JSON.stringify({
+    authenticated: true,
+    source: input.source,
+    storedOnServer: true,
+    selectedRepo: input.selectedRepo,
+    ...remoteGitHubAuthMetadata(input.authPayload ?? null),
+    ...input.apiSessionToken ? { apiSessionToken: input.apiSessionToken } : {},
+    updatedAt: new Date().toISOString()
+  }, null, 2)}
+`, "utf8");
+}
+async function pollDeviceAuthUntilComplete(context, pollId, firstPayload) {
   if (typeof pollId !== "string" || !pollId.trim())
     return null;
-  const payload = await requestServerJson(context, "/api/github/auth/device/poll", {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body: JSON.stringify({ pollId })
-  }).catch(() => null);
-  return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : null;
+  const intervalSeconds = typeof firstPayload.interval === "number" && Number.isFinite(firstPayload.interval) && firstPayload.interval > 0 ? firstPayload.interval : 5;
+  const timeoutMs = positiveIntFromEnv("RIG_DEVICE_AUTH_POLL_TIMEOUT_MS", 300000);
+  const intervalMs = positiveIntFromEnv("RIG_DEVICE_AUTH_POLL_INTERVAL_MS", Math.max(1000, intervalSeconds * 1000));
+  const deadline = Date.now() + timeoutMs;
+  let last = null;
+  do {
+    const payload = await requestServerJson(context, "/api/github/auth/device/poll", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ pollId })
+    }).catch(() => null);
+    last = payload && typeof payload === "object" && !Array.isArray(payload) ? payload : null;
+    const status = typeof last?.status === "string" ? last.status : null;
+    if (status === "signed-in" || status === "expired" || status === "cancelled" || status === "failed") {
+      return last;
+    }
+    if (timeoutMs <= 0)
+      return last;
+    await sleep2(intervalMs);
+  } while (Date.now() < deadline);
+  return last;
 }
 async function runControlPlaneInit(context, options) {
   const projectRoot = context.projectRoot;
@@ -4402,9 +4497,9 @@ async function runControlPlaneInit(context, options) {
   });
   ensureRigPrivateDirs(projectRoot);
   ensureGitignoreEntries(projectRoot);
-  const configTsPath = resolve15(projectRoot, "rig.config.ts");
-  const configJsonPath = resolve15(projectRoot, "rig.config.json");
-  const configExists = existsSync8(configTsPath) || existsSync8(configJsonPath);
+  const configTsPath = resolve16(projectRoot, "rig.config.ts");
+  const configJsonPath = resolve16(projectRoot, "rig.config.json");
+  const configExists = existsSync9(configTsPath) || existsSync9(configJsonPath);
   if (!options.privateStateOnly) {
     if (configExists && !options.repair) {
       if (context.outputMode !== "json")
@@ -4420,7 +4515,7 @@ async function runControlPlaneInit(context, options) {
     }
     ensureRigConfigPackageDependencies(projectRoot);
   }
-  writeFileSync5(resolve15(projectRoot, ".rig", "state", "project-link.json"), `${JSON.stringify({ repoSlug: repo.slug, connection: connectionAlias, linkedAt: new Date().toISOString() }, null, 2)}
+  writeFileSync5(resolve16(projectRoot, ".rig", "state", "project-link.json"), `${JSON.stringify({ repoSlug: repo.slug, connection: connectionAlias, linkedAt: new Date().toISOString() }, null, 2)}
 `, "utf8");
   const checkout = checkoutForInit(projectRoot, serverKind, options.remoteCheckout);
   let uploadedSnapshot = null;
@@ -4442,10 +4537,15 @@ async function runControlPlaneInit(context, options) {
   const token = authMethod === "gh" && !options.githubToken ? readGhAuthToken() : options.githubToken?.trim();
   if (token) {
     githubAuth = await postGitHubTokenViaServer(context, token, { selectedRepo: repo.slug });
-    setGitHubBearerTokenForCurrentProcess(token);
+    const apiSessionToken = apiSessionTokenFrom(githubAuth);
+    setGitHubBearerTokenForCurrentProcess(apiSessionToken ?? token);
     if (serverKind === "remote") {
-      writeFileSync5(resolve15(projectRoot, ".rig", "state", "github-auth.json"), `${JSON.stringify({ authenticated: true, source: authMethod === "gh" ? "gh" : "init-token", storedOnServer: true, selectedRepo: repo.slug, updatedAt: new Date().toISOString() }, null, 2)}
-`, "utf8");
+      writeRemoteGitHubAuthState(projectRoot, {
+        source: authMethod === "gh" ? "gh" : "init-token",
+        selectedRepo: repo.slug,
+        apiSessionToken,
+        authPayload: githubAuth
+      });
     }
   } else if (authMethod === "device") {
     const payload = await requestServerJson(context, "/api/github/auth/device/start", {
@@ -4454,9 +4554,22 @@ async function runControlPlaneInit(context, options) {
       body: JSON.stringify({ repoSlug: repo.slug })
     });
     deviceAuth = payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
-    const completed = await pollDeviceAuthOnce(context, deviceAuth.pollId);
-    if (completed)
+    if (context.outputMode !== "json") {
+      const verificationUri = String(deviceAuth.verificationUri ?? deviceAuth.verification_uri ?? deviceAuth.verification_uri_complete ?? "the verification URL returned by the server");
+      const userCode = String(deviceAuth.userCode ?? deviceAuth.user_code ?? "the returned user code");
+      console.log(`GitHub device flow: open ${verificationUri} and enter ${userCode}. Waiting for authorization...`);
+    }
+    const completed = await pollDeviceAuthUntilComplete(context, deviceAuth.pollId, deviceAuth);
+    if (completed) {
+      const apiSessionToken = apiSessionTokenFrom(completed);
+      if (apiSessionToken) {
+        setGitHubBearerTokenForCurrentProcess(apiSessionToken);
+        if (serverKind === "remote") {
+          writeRemoteGitHubAuthState(projectRoot, { source: "device", selectedRepo: repo.slug, apiSessionToken, authPayload: completed });
+        }
+      }
       deviceAuth = { ...deviceAuth, poll: completed, completed: completed.status === "signed-in" };
+    }
   }
   let remoteCheckoutPreparation = null;
   if (serverKind === "remote" && options.remoteCheckout?.kind !== "uploaded-snapshot") {
@@ -4476,6 +4589,12 @@ async function runControlPlaneInit(context, options) {
   });
   const checkoutPath = typeof checkout.path === "string" ? checkout.path : null;
   const serverRootSwitch = serverKind === "remote" && checkoutPath ? await switchServerProjectRootViaServer(context, checkoutPath) : null;
+  if (serverRootSwitch && token) {
+    githubAuth = await postGitHubTokenViaServer(context, token, { selectedRepo: repo.slug, projectRoot: checkoutPath ?? undefined });
+    const apiSessionToken = apiSessionTokenFrom(githubAuth);
+    setGitHubBearerTokenForCurrentProcess(apiSessionToken ?? token);
+    writeRemoteGitHubAuthState(projectRoot, { source: authMethod === "gh" ? "gh" : "init-token", selectedRepo: repo.slug, apiSessionToken, authPayload: githubAuth });
+  }
   const activeProjectRegistration = serverRootSwitch ? await registerProjectViaServer(context, { repoSlug: repo.slug, checkout }) : null;
   const pi = serverKind === "remote" ? await ensureRemotePiRigInstalled({ requestJson: (pathname, init) => requestServerJson(context, pathname, init) }).catch((error) => ({
     remote: true,
@@ -4585,7 +4704,7 @@ function parseInitOptions(args) {
 async function runInteractiveControlPlaneInit(context, prompts) {
   prompts.intro?.("Initialize a Rig control-plane project");
   const projectRoot = context.projectRoot;
-  const existingConfig = existsSync8(resolve15(projectRoot, "rig.config.ts")) || existsSync8(resolve15(projectRoot, "rig.config.json"));
+  const existingConfig = existsSync9(resolve16(projectRoot, "rig.config.ts")) || existsSync9(resolve16(projectRoot, "rig.config.json"));
   let repair = false;
   let privateStateOnly = false;
   if (existingConfig) {
@@ -4685,7 +4804,7 @@ async function runInteractiveControlPlaneInit(context, prompts) {
   });
   const details = result.details && typeof result.details === "object" && !Array.isArray(result.details) ? result.details : {};
   const deviceAuth = details.deviceAuth && typeof details.deviceAuth === "object" && !Array.isArray(details.deviceAuth) ? details.deviceAuth : null;
-  const deviceMessage = deviceAuth ? ` GitHub device flow: open ${String(deviceAuth.verification_uri ?? deviceAuth.verification_uri_complete ?? "the verification URL returned by the server")} and enter ${String(deviceAuth.user_code ?? "the returned user code")}.` : "";
+  const deviceMessage = deviceAuth ? ` GitHub device flow: open ${String(deviceAuth.verificationUri ?? deviceAuth.verification_uri ?? deviceAuth.verification_uri_complete ?? "the verification URL returned by the server")} and enter ${String(deviceAuth.userCode ?? deviceAuth.user_code ?? "the returned user code")}.` : "";
   prompts.outro?.(`Rig project initialized.${deviceMessage} Next: rig doctor && rig task list`);
   return result;
 }
@@ -4847,8 +4966,8 @@ async function executeDoctor(context, args) {
 }
 
 // packages/cli/src/commands/_run-driver-helpers.ts
-import { readFileSync as readFileSync6 } from "fs";
-import { resolve as resolve16 } from "path";
+import { readFileSync as readFileSync7 } from "fs";
+import { resolve as resolve17 } from "path";
 import {
   appendJsonlRecord as appendJsonlRecord2,
   readAuthorityRun as readAuthorityRun2,
@@ -4868,7 +4987,7 @@ function patchAuthorityRun(projectRoot, runId, patch) {
     ...patch,
     updatedAt: new Date().toISOString()
   };
-  writeJsonFile4(resolve16(resolveAuthorityRunDir3(projectRoot, runId), "run.json"), next);
+  writeJsonFile4(resolve17(resolveAuthorityRunDir3(projectRoot, runId), "run.json"), next);
   return next;
 }
 function touchAuthorityRun(projectRoot, runId) {
@@ -4876,21 +4995,21 @@ function touchAuthorityRun(projectRoot, runId) {
   if (!current) {
     return;
   }
-  writeJsonFile4(resolve16(resolveAuthorityRunDir3(projectRoot, runId), "run.json"), {
+  writeJsonFile4(resolve17(resolveAuthorityRunDir3(projectRoot, runId), "run.json"), {
     ...current,
     updatedAt: new Date().toISOString()
   });
 }
 function appendRunTimeline(projectRoot, runId, value) {
-  appendJsonlRecord2(resolve16(resolveAuthorityRunDir3(projectRoot, runId), "timeline.jsonl"), value);
+  appendJsonlRecord2(resolve17(resolveAuthorityRunDir3(projectRoot, runId), "timeline.jsonl"), value);
   touchAuthorityRun(projectRoot, runId);
 }
 function appendRunLog(projectRoot, runId, value) {
-  appendJsonlRecord2(resolve16(resolveAuthorityRunDir3(projectRoot, runId), "logs.jsonl"), value);
+  appendJsonlRecord2(resolve17(resolveAuthorityRunDir3(projectRoot, runId), "logs.jsonl"), value);
   touchAuthorityRun(projectRoot, runId);
 }
 function appendRunAction(projectRoot, runId, value) {
-  appendJsonlRecord2(resolve16(resolveAuthorityRunDir3(projectRoot, runId), "timeline.jsonl"), {
+  appendJsonlRecord2(resolve17(resolveAuthorityRunDir3(projectRoot, runId), "timeline.jsonl"), {
     id: value.id,
     type: "action",
     actionType: value.actionType,
@@ -4961,7 +5080,7 @@ function buildRunPrompt(input) {
   })();
   const scopeText = (() => {
     try {
-      const parsed = JSON.parse(readFileSync6(resolveControlPlaneTaskConfigPath(input.projectRoot), "utf8"));
+      const parsed = JSON.parse(readFileSync7(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") : [];
@@ -5074,8 +5193,8 @@ function renderSourceScopeValidation(task, validation) {
 }
 
 // packages/cli/src/commands/inspect.ts
-import { existsSync as existsSync9, readFileSync as readFileSync7 } from "fs";
-import { resolve as resolve17 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync8 } from "fs";
+import { resolve as resolve18 } from "path";
 import {
   listAuthorityRuns as listAuthorityRuns2,
   readAuthorityRun as readAuthorityRun3,
@@ -5096,8 +5215,8 @@ async function executeInspect(context, args) {
       if (!latestRun) {
         throw new CliError2(`No runs found for ${requiredTask}.`);
       }
-      const logsPath = resolve17(resolveAuthorityRunDir4(context.projectRoot, latestRun.runId), "logs.jsonl");
-      if (!existsSync9(logsPath)) {
+      const logsPath = resolve18(resolveAuthorityRunDir4(context.projectRoot, latestRun.runId), "logs.jsonl");
+      if (!existsSync10(logsPath)) {
         throw new CliError2(`No logs found for run ${latestRun.runId}.`);
       }
       await context.runCommand(["cat", logsPath]);
@@ -5107,7 +5226,7 @@ async function executeInspect(context, args) {
       const { value: task, rest: remaining } = takeOption(rest, "--task");
       requireNoExtraArgs(remaining, "bun run rig inspect artifacts --task <beads-id>");
       const requiredTask = requireTask(task, "bun run rig inspect artifacts --task <beads-id>");
-      const artifactRoot = resolveTaskArtifactDirs(context.projectRoot, requiredTask).find((path) => existsSync9(path));
+      const artifactRoot = resolveTaskArtifactDirs(context.projectRoot, requiredTask).find((path) => existsSync10(path));
       if (!artifactRoot) {
         throw new CliError2(`No artifacts found for ${requiredTask}.`);
       }
@@ -5164,10 +5283,10 @@ async function executeInspect(context, args) {
     case "failures": {
       requireNoExtraArgs(rest, "bun run rig inspect failures");
       const failed = resolveHarnessPaths2(context.projectRoot).failedApproachesPath;
-      if (!existsSync9(failed)) {
+      if (!existsSync10(failed)) {
         console.log("No failures recorded.");
       } else {
-        process.stdout.write(readFileSync7(failed, "utf-8"));
+        process.stdout.write(readFileSync8(failed, "utf-8"));
       }
       return { ok: true, group: "inspect", command };
     }
@@ -5184,11 +5303,11 @@ async function executeInspect(context, args) {
       return { ok: true, group: "inspect", command };
     case "audit": {
       requireNoExtraArgs(rest, "bun run rig inspect audit");
-      const auditPath = resolve17(resolveHarnessPaths2(context.projectRoot).logsDir, "audit.jsonl");
-      if (!existsSync9(auditPath)) {
+      const auditPath = resolve18(resolveHarnessPaths2(context.projectRoot).logsDir, "audit.jsonl");
+      if (!existsSync10(auditPath)) {
         console.log("No audit log found.");
       } else {
-        const lines = readFileSync7(auditPath, "utf-8").split(/\r?\n/).filter(Boolean).slice(-20);
+        const lines = readFileSync8(auditPath, "utf-8").split(/\r?\n/).filter(Boolean).slice(-20);
         for (const line of lines) {
           console.log(line);
         }
@@ -5817,8 +5936,8 @@ async function executeRemote(context, args) {
 }
 
 // packages/cli/src/commands/run.ts
-import { existsSync as existsSync10, readFileSync as readFileSync8 } from "fs";
-import { resolve as resolve18 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync9 } from "fs";
+import { resolve as resolve19 } from "path";
 import { createInterface as createInterface2 } from "readline/promises";
 import {
   listAuthorityRuns as listAuthorityRuns3,
@@ -5832,6 +5951,7 @@ import {
   listOpenEpics,
   resolveDefaultEpic,
   runResume,
+  runRestart,
   runStatus,
   runStop,
   startRun,
@@ -5940,6 +6060,17 @@ async function attachRunOperatorView(context, input) {
 }
 
 // packages/cli/src/commands/run.ts
+function normalizeRemoteRunDetails(payload) {
+  const run = payload.run;
+  if (!run || typeof run !== "object" || Array.isArray(run))
+    return null;
+  return {
+    ...run,
+    ...Array.isArray(payload.timeline) ? { timeline: payload.timeline } : {},
+    ...Array.isArray(payload.approvals) ? { approvals: payload.approvals } : {},
+    ...Array.isArray(payload.userInputs) ? { userInputs: payload.userInputs } : {}
+  };
+}
 function shouldPromptForEpicSelection(context, command, promptEpic, noEpicPrompt) {
   if (noEpicPrompt) {
     return false;
@@ -6078,7 +6209,7 @@ async function executeRun(context, args) {
       if (!run.value) {
         throw new CliError2("run show requires --run <id>.");
       }
-      const record = readAuthorityRun4(context.projectRoot, run.value);
+      const record = readAuthorityRun4(context.projectRoot, run.value) ?? normalizeRemoteRunDetails(await getRunDetailsViaServer(context, run.value).catch(() => ({})));
       if (!record) {
         throw new CliError2(`Run not found: ${run.value}`, 2);
       }
@@ -6097,7 +6228,7 @@ async function executeRun(context, args) {
       if (!run.value) {
         throw new CliError2("run timeline requires --run <id>.");
       }
-      const timelinePath = resolve18(resolveAuthorityRunDir5(context.projectRoot, run.value), "timeline.jsonl");
+      const timelinePath = resolve19(resolveAuthorityRunDir5(context.projectRoot, run.value), "timeline.jsonl");
       const printEvents = () => {
         const events2 = readJsonlFile4(timelinePath);
         if (context.outputMode === "text") {
@@ -6109,12 +6240,12 @@ async function executeRun(context, args) {
       };
       const events = printEvents();
       if (follow.value && context.outputMode === "text") {
-        let lastLength = existsSync10(timelinePath) ? readFileSync8(timelinePath, "utf8").length : 0;
+        let lastLength = existsSync11(timelinePath) ? readFileSync9(timelinePath, "utf8").length : 0;
         while (true) {
           await Bun.sleep(1000);
-          if (!existsSync10(timelinePath))
+          if (!existsSync11(timelinePath))
             continue;
-          const next = readFileSync8(timelinePath, "utf8");
+          const next = readFileSync9(timelinePath, "utf8");
           if (next.length <= lastLength)
             continue;
           const delta = next.slice(lastLength);
@@ -6259,6 +6390,20 @@ async function executeRun(context, args) {
       }
       return { ok: true, group: "run", command, details: resumed };
     }
+    case "restart": {
+      requireNoExtraArgs(rest, "bun run rig run restart");
+      if (context.dryRun) {
+        if (context.outputMode === "text") {
+          console.log("[dry-run] rig run restart");
+        }
+        return { ok: true, group: "run", command };
+      }
+      const restarted = await runRestart(context.projectRoot, runtimeContext);
+      if (context.outputMode === "text") {
+        console.log(`Restarted run: ${restarted.runId}`);
+      }
+      return { ok: true, group: "run", command, details: restarted };
+    }
     case "stop": {
       const runOption = takeOption(rest, "--run");
       const positionalRunId = runOption.rest.length > 0 ? runOption.rest[0] : undefined;
@@ -6316,7 +6461,7 @@ async function executeServer(context, args, options) {
       const authTokenResult = takeOption(pending, "--auth-token");
       pending = authTokenResult.rest;
       requireNoExtraArgs(pending, "bun run rig server start [--host <host>] [--port <n>] [--poll-ms <n>] [--auth-token <token>]");
-      const commandParts = ["bun", "run", "packages/server/src/server.ts", "start"];
+      const commandParts = ["rig-server", "start"];
       if (hostResult.value) {
         commandParts.push("--host", hostResult.value);
       }
@@ -6339,7 +6484,7 @@ async function executeServer(context, args, options) {
       const eventResult = takeOption(pending, "--event");
       pending = eventResult.rest;
       requireNoExtraArgs(pending, "bun run rig server notify-test [--event <type>]");
-      const commandParts = ["bun", "run", "packages/server/src/server.ts", "notify-test"];
+      const commandParts = ["rig-server", "notify-test"];
       if (eventResult.value) {
         commandParts.push("--event", eventResult.value);
       }
@@ -6400,10 +6545,10 @@ async function executeServer(context, args, options) {
 }
 
 // packages/cli/src/commands/task.ts
-import { readFileSync as readFileSync9 } from "fs";
+import { readFileSync as readFileSync10 } from "fs";
 import { spawnSync as spawnSync4 } from "child_process";
 import { createInterface as createInterface4 } from "readline/promises";
-import { resolve as resolve19 } from "path";
+import { resolve as resolve20 } from "path";
 import {
   taskArtifactDir,
   taskArtifacts,
@@ -6734,7 +6879,7 @@ async function executeTask(context, args, options) {
       const fileFlag = takeOption(rest.slice(1), "--file");
       let content;
       if (fileFlag.value) {
-        content = readFileSync9(resolve19(context.projectRoot, fileFlag.value), "utf-8");
+        content = readFileSync10(resolve20(context.projectRoot, fileFlag.value), "utf-8");
       } else {
         content = await readStdin();
       }
@@ -6955,8 +7100,8 @@ async function executeTask(context, args, options) {
 }
 
 // packages/cli/src/commands/task-run-driver.ts
-import { copyFileSync as copyFileSync3, existsSync as existsSync11, mkdirSync as mkdirSync7, readFileSync as readFileSync10, statSync as statSync2 } from "fs";
-import { resolve as resolve20 } from "path";
+import { copyFileSync as copyFileSync3, existsSync as existsSync12, mkdirSync as mkdirSync7, readFileSync as readFileSync11, statSync as statSync2, writeFileSync as writeFileSync6 } from "fs";
+import { resolve as resolve21 } from "path";
 import { spawn as spawn2, spawnSync as spawnSync5 } from "child_process";
 import { createInterface as createLineInterface } from "readline";
 import { loadConfig as loadConfig2 } from "@rig/core/load-config";
@@ -6990,7 +7135,24 @@ import {
   commitRunChanges,
   runPrAutomation
 } from "@rig/runtime/control-plane/native/pr-automation";
+function looksLikeGitHubToken(value) {
+  const token = value?.trim();
+  if (!token)
+    return false;
+  return /^(gh[opusr]_|github_pat_)/.test(token);
+}
+function githubBridgeEnv(token) {
+  const clean = token?.trim();
+  if (!clean)
+    return {};
+  return {
+    RIG_GITHUB_TOKEN: clean,
+    GITHUB_TOKEN: clean,
+    GH_TOKEN: clean
+  };
+}
 function buildPiRigBridgeEnv(input) {
+  const githubToken = input.githubToken?.trim() || (looksLikeGitHubToken(input.authToken) ? input.authToken.trim() : "");
   return {
     RIG_PROJECT_ROOT: input.projectRoot,
     PROJECT_RIG_ROOT: input.projectRoot,
@@ -7000,7 +7162,7 @@ function buildPiRigBridgeEnv(input) {
     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 } : {}
+    ...githubBridgeEnv(githubToken)
   };
 }
 function runGitSync(cwd, args, input) {
@@ -7022,12 +7184,12 @@ function copyUntrackedDirtyFiles(sourceRoot, targetRoot) {
     return 0;
   let copied = 0;
   for (const relativePath of listed.stdout.split("\x00").filter(Boolean)) {
-    const sourcePath = resolve20(sourceRoot, relativePath);
-    const targetPath = resolve20(targetRoot, relativePath);
+    const sourcePath = resolve21(sourceRoot, relativePath);
+    const targetPath = resolve21(targetRoot, relativePath);
     try {
       if (!statSync2(sourcePath).isFile())
         continue;
-      mkdirSync7(resolve20(targetPath, ".."), { recursive: true });
+      mkdirSync7(resolve21(targetPath, ".."), { recursive: true });
       copyFileSync3(sourcePath, targetPath);
       copied += 1;
     } catch {}
@@ -7061,6 +7223,14 @@ function buildTaskRunReviewEnv(config) {
     ...review?.provider ? { AI_REVIEW_PROVIDER: review.provider } : {}
   };
 }
+function buildDirtyBaselineHandshakeEnv(input) {
+  if (input.baselineMode !== "dirty-snapshot")
+    return { RIG_BASELINE_MODE: input.baselineMode ?? "head" };
+  return {
+    RIG_BASELINE_MODE: "dirty-snapshot",
+    RIG_DIRTY_BASELINE_READY_FILE: resolve21(input.projectRoot, ".rig", "runs", input.runId, "dirty-baseline.ready.json")
+  };
+}
 function positiveInt(value, fallback) {
   return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
 }
@@ -7169,9 +7339,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((resolve21) => {
-      child.once("error", (error) => resolve21({ exitCode: 1, stderr: error.message }));
-      child.once("close", (code) => resolve21({
+    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")
@@ -7367,7 +7537,7 @@ function summarizeValidationFailure(projectRoot, taskId2) {
     return null;
   }
   for (const artifactDir of resolveTaskArtifactDirs2(projectRoot, taskId2)) {
-    const summary = readJsonFile3(resolve20(artifactDir, "validation-summary.json"), null);
+    const summary = readJsonFile3(resolve21(artifactDir, "validation-summary.json"), null);
     if (!summary || summary.status !== "fail") {
       continue;
     }
@@ -7448,9 +7618,9 @@ function readTaskRunAcceptedArtifactState(input) {
   if (!input.taskId || !input.workspaceDir) {
     return { accepted: false, reason: null };
   }
-  const artifactDir = resolve20(input.workspaceDir, "artifacts", input.taskId);
-  const reviewStatusPath = resolve20(artifactDir, "review-status.txt");
-  const taskResultPath = resolve20(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 };
@@ -7487,12 +7657,12 @@ function resolveTaskRunRetryContext(input) {
   if (!input.taskId || !input.workspaceDir) {
     return { shouldRetry: false, failureDetail: null, nextPrompt: null };
   }
-  const artifactDir = resolve20(input.workspaceDir, "artifacts", input.taskId);
-  const reviewStatePath = resolve20(artifactDir, "review-state.json");
-  const reviewFeedbackPath = resolve20(artifactDir, "review-feedback.md");
-  const reviewStatusPath = resolve20(artifactDir, "review-status.txt");
-  const failedApproachesPath = resolve20(input.workspaceDir, ".rig", "state", "failed_approaches.md");
-  const validationSummaryPath = resolve20(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);
@@ -7547,11 +7717,11 @@ function summarizeTaskRunReviewFailure(reviewState) {
   return "Completion verification rejected the task. Read review-feedback.md for required fixes.";
 }
 function readTaskRunReviewStatus(reviewStatusPath) {
-  if (!existsSync11(reviewStatusPath)) {
+  if (!existsSync12(reviewStatusPath)) {
     return null;
   }
   try {
-    const status = readFileSync10(reviewStatusPath, "utf8").trim().toUpperCase();
+    const status = readFileSync11(reviewStatusPath, "utf8").trim().toUpperCase();
     return status === "APPROVED" || status === "REJECTED" ? status : null;
   } catch {
     return null;
@@ -7634,8 +7804,11 @@ function stringArrayField(record, key) {
 }
 async function executeRigOwnedTaskRun(context, input) {
   const runtimeTaskId = input.taskId?.trim() || `adhoc-${input.runId}`;
+  const existingRunRecord = readAuthorityRun5(context.projectRoot, input.runId);
+  const resumeMode = process.env.RIG_RUN_RESUME === "1";
+  const resumePreviousStatus = String(existingRunRecord?.status ?? "").toLowerCase();
   const sourceTask = readRunSourceTaskContract(context.projectRoot, input.runId, input.taskId);
-  const prompt = buildRunPrompt({
+  let prompt = buildRunPrompt({
     projectRoot: context.projectRoot,
     taskId: input.taskId,
     fallbackTitle: input.title,
@@ -7689,14 +7862,14 @@ async function executeRigOwnedTaskRun(context, input) {
     taskId: runtimeTaskId,
     createdAt: startedAt,
     runtimeAdapter: input.runtimeAdapter,
-    status: "created"
+    status: resumeMode ? "preparing" : "created"
   });
   patchAuthorityRun(context.projectRoot, input.runId, {
     status: "preparing",
     startedAt,
     completedAt: null,
     errorText: null,
-    artifactRoot: null,
+    artifactRoot: resumeMode ? existingRunRecord?.artifactRoot ?? null : null,
     runtimeAdapter: input.runtimeAdapter,
     runtimeMode: input.runtimeMode,
     interactionMode: input.interactionMode,
@@ -7712,9 +7885,9 @@ async function executeRigOwnedTaskRun(context, input) {
     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,
+    id: `log:${input.runId}:${resumeMode ? "resume" : "start"}`,
+    title: resumeMode ? "Rig task run resumed" : "Rig task run started",
+    detail: resumeMode ? `Continuing the same run lifecycle for ${input.taskId ?? input.title ?? runtimeTaskId}.` : input.taskId ?? input.title ?? runtimeTaskId,
     tone: "info",
     status: "preparing",
     createdAt: startedAt
@@ -7735,7 +7908,22 @@ 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 });
-  patchAuthorityRun(context.projectRoot, input.runId, { planning: planningClassification });
+  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()
+  };
+  mkdirSync7(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}
+
+Rig planning classification:
+${JSON.stringify(persistedPlanning, null, 2)}
+${planningClassification.planningRequired ? `Before implementing, write a concise implementation plan to ${planningArtifactPath}. Treat that plan artifact as required acceptance evidence for the Plan stage.` : "Planning is not required for this run; briefly state why before implementation."}`;
   if (input.runtimeAdapter === "pi") {
     for (const stage of ["Connect", "GitHub/task sync", "Prepare workspace", "Launch Pi", "Plan", "Implement"]) {
       appendPiStageLog({
@@ -7777,11 +7965,11 @@ async function executeRigOwnedTaskRun(context, input) {
   let reviewAction;
   let verificationStarted = false;
   let reviewStarted = false;
-  let latestRuntimeWorkspace = null;
-  let latestSessionDir = null;
-  let latestLogsDir = null;
+  let latestRuntimeWorkspace = resumeMode && typeof existingRunRecord?.worktreePath === "string" ? existingRunRecord.worktreePath : 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 = null;
+  let latestRuntimeBranch = resumeMode && typeof existingRunRecord?.branch === "string" ? existingRunRecord.branch : null;
   let snapshotSidecarPromise = null;
   let dirtyBaselineApplied = false;
   const childEnv = {
@@ -7799,9 +7987,14 @@ async function executeRigOwnedTaskRun(context, input) {
       RIG_RUNTIME_ADAPTER: input.runtimeAdapter,
       RIG_SERVER_RUN_ID: input.runId
     },
-    ...sourceTask ? { RIG_SOURCE_TASK_JSON: JSON.stringify(sourceTask) } : {}
+    ...sourceTask ? { RIG_SOURCE_TASK_JSON: JSON.stringify(sourceTask) } : {},
+    ...resumeMode ? {
+      RIG_RUN_RESUME: "1",
+      RIG_RUNTIME_ARTIFACT_CLEANUP: "preserve"
+    } : {}
   };
   Object.assign(childEnv, buildTaskRunReviewEnv(automationConfig));
+  Object.assign(childEnv, buildDirtyBaselineHandshakeEnv({ projectRoot: context.projectRoot, runId: input.runId, baselineMode: input.baselineMode }));
   const automationLimits = resolveTaskRunAutomationLimits(automationConfig);
   const maxAttempts = automationLimits.maxValidationAttempts;
   const promoteToValidating = (detail) => {
@@ -7856,22 +8049,29 @@ async function executeRigOwnedTaskRun(context, input) {
       patchAuthorityRun(context.projectRoot, input.runId, {
         status: "running",
         worktreePath: latestRuntimeWorkspace,
-        artifactRoot: latestRuntimeWorkspace && input.taskId ? resolve20(latestRuntimeWorkspace, "artifacts", input.taskId) : null,
+        artifactRoot: latestRuntimeWorkspace && input.taskId ? resolve21(latestRuntimeWorkspace, "artifacts", input.taskId) : null,
         logRoot: latestLogsDir,
-        sessionPath: latestSessionDir ? resolve20(latestSessionDir, "session.json") : null,
-        sessionLogPath: latestLogsDir ? resolve20(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) {
         dirtyBaselineApplied = true;
         const dirty = applyDirtyBaselineSnapshot({ sourceRoot: context.projectRoot, targetRoot: latestRuntimeWorkspace });
+        const readyFile = childEnv.RIG_DIRTY_BASELINE_READY_FILE;
+        if (readyFile) {
+          mkdirSync7(resolve21(readyFile, ".."), { recursive: true });
+          writeFileSync6(readyFile, `${JSON.stringify({ ...dirty, workspaceDir: latestRuntimeWorkspace, appliedAt: new Date().toISOString() }, null, 2)}
+`, "utf8");
+        }
         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()
+          createdAt: new Date().toISOString(),
+          payload: readyFile ? { readyFile } : undefined
         });
         emitServerRunEvent({ type: "log", runId: input.runId, title: "Dirty baseline snapshot" });
       }
@@ -8097,7 +8297,36 @@ async function executeRigOwnedTaskRun(context, input) {
   let reviewFailureDetail = null;
   const stderrLines = [];
   const piAcceptedArtifactExitGraceMs = resolvePiAcceptedArtifactExitGraceMs(childEnv);
-  for (let attempt = 1;attempt <= maxAttempts; attempt += 1) {
+  if (resumeMode && ["validating", "reviewing"].includes(resumePreviousStatus)) {
+    appendRunLog(context.projectRoot, input.runId, {
+      id: `log:${input.runId}:resume-closeout-phase`,
+      title: "Resume continuing from closeout phase",
+      detail: `Previous run status was ${resumePreviousStatus}; skipping agent relaunch and continuing validation/PR/merge closeout for the same run.`,
+      tone: "info",
+      status: resumePreviousStatus,
+      createdAt: new Date().toISOString()
+    });
+    emitServerRunEvent({ type: "log", runId: input.runId, title: "Resume continuing from closeout phase" });
+    exit = { code: 0, signal: null };
+  } else if (resumeMode && latestRuntimeWorkspace) {
+    const acceptedArtifactState = readTaskRunAcceptedArtifactState({
+      taskId: input.taskId ?? runtimeTaskId,
+      workspaceDir: latestRuntimeWorkspace
+    });
+    if (acceptedArtifactState.accepted) {
+      appendRunLog(context.projectRoot, input.runId, {
+        id: `log:${input.runId}:resume-accepted-artifacts`,
+        title: "Resume found accepted artifacts; continuing closeout",
+        detail: acceptedArtifactState.reason ?? "Accepted task artifacts are present from the previous run process.",
+        tone: "info",
+        status: "validating",
+        createdAt: new Date().toISOString()
+      });
+      emitServerRunEvent({ type: "log", runId: input.runId, title: "Resume found accepted artifacts; continuing closeout" });
+      exit = { code: 0, signal: null };
+    }
+  }
+  for (let attempt = 1;!exit && attempt <= maxAttempts; attempt += 1) {
     const attemptHostAgentCommand = buildHostAgentCommand(currentPrompt);
     const child = spawn2(attemptHostAgentCommand[0], attemptHostAgentCommand.slice(1), {
       cwd: context.projectRoot,
@@ -8138,7 +8367,7 @@ async function executeRigOwnedTaskRun(context, input) {
     let acceptedArtifactObservedAt = null;
     let acceptedArtifactPollTimer = null;
     let acceptedArtifactKillTimer = null;
-    const attemptExit = await new Promise((resolve21) => {
+    const attemptExit = await new Promise((resolve22) => {
       let settled = false;
       const settle = (result) => {
         if (settled)
@@ -8146,7 +8375,7 @@ async function executeRigOwnedTaskRun(context, input) {
         settled = true;
         if (acceptedArtifactPollTimer)
           clearInterval(acceptedArtifactPollTimer);
-        resolve21(result);
+        resolve22(result);
       };
       const pollAcceptedArtifacts = () => {
         const artifactState = readTaskRunAcceptedArtifactState({
@@ -8343,6 +8572,29 @@ Failed to update task source for ${input.taskId ?? runtimeTaskId} to failed: ${e
     });
     throw new CliError2(terminalFailureDetail, exit.code ?? 1);
   }
+  if (planningClassification.planningRequired) {
+    const planWorkspace = latestRuntimeWorkspace ?? context.projectRoot;
+    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, {
+        status: "needs_attention",
+        completedAt: failedAt,
+        errorText: failureDetail
+      });
+      appendRunLog(context.projectRoot, input.runId, {
+        id: `log:${input.runId}:plan-artifact-missing`,
+        title: "Required plan artifact missing",
+        detail: failureDetail,
+        tone: "error",
+        status: "needs_attention",
+        createdAt: failedAt
+      });
+      emitServerRunEvent({ type: "failed", runId: input.runId, error: failureDetail });
+      throw new CliError2(failureDetail, 1);
+    }
+  }
   const runPiPrFeedbackFix = async (message2) => {
     appendPiStageLog({
       projectRoot: context.projectRoot,
@@ -8400,9 +8652,9 @@ 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((resolve21) => {
-      child.once("error", () => resolve21(1));
-      child.once("close", (code) => resolve21(code ?? 1));
+    const exitCode = await new Promise((resolve22) => {
+      child.once("error", () => resolve22(1));
+      child.once("close", (code) => resolve22(code ?? 1));
     });
     if (exitCode !== 0) {
       throw new Error(`Pi PR feedback fix failed with exit code ${exitCode}.`);
@@ -8521,8 +8773,8 @@ async function executeTest(context, args) {
 }
 
 // packages/cli/src/commands/setup.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync8, readdirSync as readdirSync2, writeFileSync as writeFileSync6 } from "fs";
-import { resolve as resolve21 } from "path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync8, readdirSync as readdirSync2, writeFileSync as writeFileSync7 } from "fs";
+import { resolve as resolve22 } from "path";
 import { createPluginHost } from "@rig/core";
 import {
   isSupportedBunVersion as isSupportedBunVersion2,
@@ -8585,9 +8837,9 @@ function runSetupInit(projectRoot) {
   mkdirSync8(stateDir, { recursive: true });
   mkdirSync8(logsDir, { recursive: true });
   mkdirSync8(artifactsDir, { recursive: true });
-  const failuresPath = resolve21(stateDir, "failed_approaches.md");
-  if (!existsSync12(failuresPath)) {
-    writeFileSync6(failuresPath, `# Failed Approaches
+  const failuresPath = resolve22(stateDir, "failed_approaches.md");
+  if (!existsSync13(failuresPath)) {
+    writeFileSync7(failuresPath, `# Failed Approaches
 
 `, "utf-8");
   }
@@ -8604,18 +8856,18 @@ async function runSetupCheck(projectRoot) {
 }
 async function runSetupPreflight(projectRoot) {
   await runSetupCheck(projectRoot);
-  const validationRoot = resolve21(resolveControlPlaneDefinitionRoot(projectRoot), "validation");
-  if (existsSync12(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 = resolve21(validationRoot, validator.name, "validate.sh");
-      if (existsSync12(script)) {
+      const script = resolve22(validationRoot, validator.name, "validate.sh");
+      if (existsSync13(script)) {
         console.log(`OK: validator script ${script}`);
       }
     }
   }
-  const hooksRoot = resolve21(resolveControlPlaneDefinitionRoot(projectRoot), "hooks");
-  if (existsSync12(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}`);