@h-rig/cli 0.0.6-alpha.30 → 0.0.6-alpha.31

package/dist/src/commands.js

@@ -165,6 +165,8 @@ __export(exports_plugin, {
   resolvePluginCliCommand: () => resolvePluginCliCommand,
   executePlugin: () => executePlugin
 });
+import { existsSync as existsSync3 } from "fs";
+import { resolve as resolve7 } from "path";
 import { buildPluginHostContext } from "@rig/runtime/control-plane/plugin-host-context";
 async function executePlugin(context, args) {
   const [command = "list", ...rest] = args;
@@ -192,7 +194,8 @@ async function executePlugin(context, args) {
       }
       if (context.outputMode === "text") {
         if (declarative.length === 0) {
-          console.log("No plugins loaded. Declare plugins in rig.config.ts.");
+          const configExists = ["rig.config.ts", "rig.config.mts", "rig.config.json"].some((name) => existsSync3(resolve7(context.projectRoot, name)));
+          console.log(configExists ? "rig.config found but no plugins could be loaded. If the config imports @rig/* packages, run `bun install` in this project first." : "No plugins loaded. Declare plugins in rig.config.ts.");
         } else {
           console.log("Plugins (rig.config.ts):");
           for (const p of declarative) {
@@ -334,9 +337,9 @@ var init_plugin = __esm(() => {
 // packages/cli/src/commands.ts
 init_runner();
 import {
-  existsSync as existsSync13
+  existsSync as existsSync14
 } from "fs";
-import { resolve as resolve22 } from "path";
+import { resolve as resolve23 } from "path";
 import { readBuildConfig } from "@rig/runtime/build-time-config";
 
 // packages/cli/src/commands/browser.ts
@@ -2458,23 +2461,23 @@ import { ensureProjectMainFreshBeforeRun } from "@rig/runtime/control-plane/proj
 
 // packages/cli/src/commands/_connection-state.ts
 init_runner();
-import { existsSync as existsSync3, mkdirSync as mkdirSync4, readFileSync as readFileSync2, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync2, writeFileSync as writeFileSync3 } from "fs";
 import { homedir as homedir2 } from "os";
-import { dirname, resolve as resolve7 } from "path";
+import { dirname, resolve as resolve8 } from "path";
 function resolveGlobalConnectionsPath(env = process.env) {
   const explicit = env.RIG_CONNECTIONS_FILE?.trim();
   if (explicit)
-    return resolve7(explicit);
+    return resolve8(explicit);
   const stateDir = env.RIG_GLOBAL_STATE_DIR?.trim();
   if (stateDir)
-    return resolve7(stateDir, "connections.json");
-  return resolve7(homedir2(), ".rig", "connections.json");
+    return resolve8(stateDir, "connections.json");
+  return resolve8(homedir2(), ".rig", "connections.json");
 }
 function resolveRepoConnectionPath(projectRoot) {
-  return resolve7(projectRoot, ".rig", "state", "connection.json");
+  return resolve8(projectRoot, ".rig", "state", "connection.json");
 }
 function readJsonFile2(path) {
-  if (!existsSync3(path))
+  if (!existsSync4(path))
     return null;
   try {
     return JSON.parse(readFileSync2(path, "utf8"));
@@ -2561,8 +2564,8 @@ function resolveSelectedConnection(projectRoot, options = {}) {
 
 // packages/cli/src/commands/_server-client.ts
 init_runner();
-import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
-import { resolve as resolve8 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync3 } from "fs";
+import { resolve as resolve9 } from "path";
 import { ensureLocalRigServerConnection } from "@rig/runtime/local-server";
 var scopedGitHubBearerTokens = new Map;
 function cleanToken(value) {
@@ -2570,12 +2573,12 @@ function cleanToken(value) {
   return trimmed ? trimmed : null;
 }
 function setGitHubBearerTokenForCurrentProcess(token, projectRoot) {
-  const scopedKey = resolve8(projectRoot ?? process.cwd());
+  const scopedKey = resolve9(projectRoot ?? process.cwd());
   scopedGitHubBearerTokens.set(scopedKey, cleanToken(token ?? undefined));
 }
 function readPrivateRemoteSessionToken(projectRoot) {
-  const path = resolve8(projectRoot, ".rig", "state", "github-auth.json");
-  if (!existsSync4(path))
+  const path = resolve9(projectRoot, ".rig", "state", "github-auth.json");
+  if (!existsSync5(path))
     return null;
   try {
     const parsed = JSON.parse(readFileSync3(path, "utf8"));
@@ -2585,7 +2588,7 @@ function readPrivateRemoteSessionToken(projectRoot) {
   }
 }
 function readGitHubBearerTokenForRemote(projectRoot) {
-  const scopedKey = resolve8(projectRoot);
+  const scopedKey = resolve9(projectRoot);
   if (scopedGitHubBearerTokens.has(scopedKey))
     return scopedGitHubBearerTokens.get(scopedKey) ?? null;
   const privateSession = readPrivateRemoteSessionToken(projectRoot);
@@ -2727,7 +2730,7 @@ async function registerProjectViaServer(context, input) {
   return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
 }
 function sleep(ms) {
-  return new Promise((resolve9) => setTimeout(resolve9, ms));
+  return new Promise((resolve10) => setTimeout(resolve10, ms));
 }
 function isRetryableProjectRootSwitchError(error) {
   if (!(error instanceof Error))
@@ -3210,7 +3213,7 @@ async function executeQueue(context, args) {
 
 // packages/cli/src/commands/agent.ts
 init_runner();
-import { resolve as resolve10 } from "path";
+import { resolve as resolve11 } from "path";
 import {
   agentId,
   cleanupAgentRuntime,
@@ -3220,8 +3223,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,
@@ -3243,8 +3246,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;
@@ -3312,7 +3315,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;
 }
 
@@ -3434,10 +3437,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({
@@ -3457,10 +3460,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})`
           });
@@ -3477,10 +3480,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 {
@@ -3556,7 +3559,7 @@ init__parsers();
 import {
   chmodSync,
   copyFileSync as copyFileSync2,
-  existsSync as existsSync6,
+  existsSync as existsSync7,
   mkdirSync as mkdirSync5,
   readdirSync,
   readlinkSync,
@@ -3566,7 +3569,7 @@ import {
   unlinkSync
 } from "fs";
 import { homedir as homedir3 } 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,
@@ -3585,13 +3588,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;
@@ -3600,7 +3603,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
       });
     }
@@ -3609,16 +3612,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;
     }
   }
@@ -3630,7 +3633,7 @@ async function isRunnableRigBinary(binaryPath, projectRoot) {
 async function runDistDoctor(projectRoot) {
   const bunPath = Bun.which("bun");
   const rigPath = Bun.which("rig");
-  const userBinDir = resolve11(homedir3(), ".local/bin");
+  const userBinDir = resolve12(homedir3(), ".local/bin");
   const userBinInPath = (process.env.PATH || "").split(":").filter(Boolean).includes(userBinDir);
   let rigRunnable = false;
   if (rigPath) {
@@ -3678,15 +3681,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);
@@ -3728,22 +3731,22 @@ async function executeDist(context, args) {
       requireNoExtraArgs(rest, "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) {
-          rmSync3(resolve11(imagesDir, entry.name), { recursive: true, force: true });
+          rmSync3(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",
@@ -3757,25 +3760,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 }));
@@ -3786,17 +3789,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 {}
@@ -3804,10 +3807,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;
@@ -3815,9 +3818,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 {}
@@ -3826,18 +3829,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()) {
@@ -3872,7 +3875,7 @@ async function executeDist(context, args) {
 // packages/cli/src/commands/inbox.ts
 init_runner();
 import { writeFileSync as writeFileSync4 } from "fs";
-import { resolve as resolve12 } from "path";
+import { resolve as resolve13 } from "path";
 import {
   listAuthorityRuns,
   readJsonlFile as readJsonlFile3,
@@ -4274,7 +4277,7 @@ async function listRemoteInboxRecords(context, kind, filters) {
 function listLocalInboxRecords(context, kind, filters) {
   const fileName = kind === "approvals" ? "approvals.jsonl" : "user-input.jsonl";
   const runs = listAuthorityRuns(context.projectRoot).filter((entry) => (!filters.run || entry.runId === filters.run) && (!filters.task || entry.taskId === filters.task));
-  return runs.flatMap((entry) => readJsonlFile3(resolve12(resolveAuthorityRunDir2(context.projectRoot, entry.runId), fileName)).map((record) => ({
+  return runs.flatMap((entry) => readJsonlFile3(resolve13(resolveAuthorityRunDir2(context.projectRoot, entry.runId), fileName)).map((record) => ({
     runId: entry.runId,
     taskId: entry.taskId ?? undefined,
     record
@@ -4322,7 +4325,7 @@ async function executeInbox(context, args) {
       if (isRemoteConnectionSelected(context.projectRoot)) {
         throw new CliError2("Remote approval resolution is not available from this CLI yet; use the server UI/API or switch to local state for direct JSONL edits.", 2);
       }
-      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: note4.value ?? null, resolvedAt } : entry);
@@ -4378,7 +4381,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);
@@ -4394,16 +4397,16 @@ async function executeInbox(context, args) {
 
 // packages/cli/src/commands/init.ts
 init_runner();
-import { appendFileSync as appendFileSync2, existsSync as existsSync9, mkdirSync as mkdirSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
+import { appendFileSync as appendFileSync2, existsSync as existsSync10, mkdirSync as mkdirSync6, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
 import { spawnSync } from "child_process";
-import { resolve as resolve16 } from "path";
+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/_pi-install.ts
-import { existsSync as existsSync7, readFileSync as readFileSync4, rmSync as rmSync4 } from "fs";
+import { existsSync as existsSync8, readFileSync as readFileSync4, rmSync as rmSync4 } from "fs";
 import { homedir as homedir4 } from "os";
-import { resolve as resolve13 } from "path";
+import { resolve as resolve14 } from "path";
 var PI_RIG_PACKAGE_NAME = "@h-rig/pi-rig";
 var LEGACY_PI_RIG_PACKAGE_NAME = "@rig/pi-rig";
 var LEGACY_PI_RIG_MARKER = `// Managed by Rig. Source package: @rig/pi-rig.
@@ -4419,11 +4422,11 @@ async function defaultCommandRunner(command, options = {}) {
   return { exitCode, stdout, stderr };
 }
 function resolvePiRigExtensionPath(homeDir) {
-  return resolve13(homeDir, ".pi", "agent", "extensions", "pi-rig");
+  return resolve14(homeDir, ".pi", "agent", "extensions", "pi-rig");
 }
-function resolvePiRigPackageSource(projectRoot, exists = existsSync7) {
-  const localPackage = resolve13(projectRoot, "packages", "pi-rig");
-  if (exists(resolve13(localPackage, "package.json")))
+function resolvePiRigPackageSource(projectRoot, exists = existsSync8) {
+  const localPackage = resolve14(projectRoot, "packages", "pi-rig");
+  if (exists(resolve14(localPackage, "package.json")))
     return localPackage;
   return `npm:${PI_RIG_PACKAGE_NAME}`;
 }
@@ -4474,9 +4477,9 @@ async function ensurePiBinaryAvailable(input) {
     ...next.exitCode === 0 ? {} : { error: (next.stderr || next.stdout).trim() || "pi --version failed after install" }
   };
 }
-function removeManagedLegacyPiRigBridge(homeDir, exists = existsSync7) {
+function removeManagedLegacyPiRigBridge(homeDir, exists = existsSync8) {
   const extensionPath = resolvePiRigExtensionPath(homeDir);
-  const indexPath = resolve13(extensionPath, "index.ts");
+  const indexPath = resolve14(extensionPath, "index.ts");
   if (!exists(indexPath))
     return;
   try {
@@ -4496,13 +4499,13 @@ async function checkPiRigInstall(input = {}) {
       piRig: { ok: true, label: "pi-rig global extension", detail: extensionPath }
     };
   }
-  const exists = input.exists ?? existsSync7;
+  const exists = input.exists ?? existsSync8;
   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(resolve13(extensionPath, "index.ts"));
+  const legacyBridge = exists(resolve14(extensionPath, "index.ts"));
   const hasPiRig = listedPiRig;
   return {
     extensionPath,
@@ -4579,7 +4582,7 @@ async function buildPiSetupChecks(input = {}) {
 
 // packages/cli/src/commands/_snapshot-upload.ts
 import { mkdir, readdir, readFile, writeFile } from "fs/promises";
-import { dirname as dirname2, resolve as resolve14, relative, sep } from "path";
+import { dirname as dirname2, resolve as resolve15, 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([
@@ -4601,15 +4604,15 @@ function assertManifestPath(root, relativePath) {
   if (!relativePath || relativePath.startsWith("/") || relativePath.includes("\x00")) {
     throw new Error(`Invalid snapshot path: ${relativePath}`);
   }
-  const resolved = resolve14(root, relativePath);
+  const resolved = resolve15(root, relativePath);
   const relativeToRoot = relative(root, resolved);
-  if (relativeToRoot.startsWith("..") || relativeToRoot === ".." || resolve14(relativeToRoot) === resolved) {
+  if (relativeToRoot.startsWith("..") || relativeToRoot === ".." || resolve15(relativeToRoot) === resolved) {
     throw new Error(`Snapshot path escapes project root: ${relativePath}`);
   }
   return resolved;
 }
 async function buildSnapshotUploadManifest(projectRoot, options = {}) {
-  const root = resolve14(projectRoot);
+  const root = resolve15(projectRoot);
   const excludedDirectories = [...new Set([
     ...DEFAULT_EXCLUDED_DIRECTORIES,
     ...options.excludedDirectories ?? []
@@ -4621,7 +4624,7 @@ async function buildSnapshotUploadManifest(projectRoot, options = {}) {
     for (const entry of entries) {
       if (entry.isDirectory() && excludedSet.has(entry.name))
         continue;
-      const fullPath = resolve14(dir, entry.name);
+      const fullPath = resolve15(dir, entry.name);
       if (entry.isDirectory()) {
         await visit(fullPath);
         continue;
@@ -4670,8 +4673,8 @@ async function uploadSnapshotArchiveViaServer(context, input) {
 
 // packages/cli/src/commands/_doctor-checks.ts
 init_runner();
-import { existsSync as existsSync8, readFileSync as readFileSync5 } from "fs";
-import { resolve as resolve15 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync5 } from "fs";
+import { resolve as resolve16 } from "path";
 import { isSupportedBunVersion, MIN_SUPPORTED_BUN_VERSION } from "@rig/runtime/control-plane/setup-version";
 init__parsers();
 function check(id, label, status, detail, remediation) {
@@ -4712,8 +4715,8 @@ function repoSlugFromConfig(config) {
 function loadFallbackConfig(projectRoot) {
   const candidates = ["rig.config.ts", "rig.config.mts", "rig.config.json"];
   for (const name of candidates) {
-    const path = resolve15(projectRoot, name);
-    if (!existsSync8(path))
+    const path = resolve16(projectRoot, name);
+    if (!existsSync9(path))
       continue;
     try {
       const source = readFileSync5(path, "utf8");
@@ -4795,7 +4798,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) => existsSync8(resolve15(projectRoot, name)));
+  const hasConfigFile = ["rig.config.ts", "rig.config.mts", "rig.config.json"].some((name) => existsSync9(resolve16(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."));
@@ -4914,20 +4917,20 @@ function parseRepoSlug(value) {
   return { owner: match[1], repo: match[2], slug: `${match[1]}/${match[2]}` };
 }
 function ensureRigPrivateDirs(projectRoot) {
-  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))
+  const rigDir = resolve17(projectRoot, ".rig");
+  mkdirSync6(resolve17(rigDir, "state"), { recursive: true });
+  mkdirSync6(resolve17(rigDir, "logs"), { recursive: true });
+  mkdirSync6(resolve17(rigDir, "runs"), { recursive: true });
+  mkdirSync6(resolve17(rigDir, "tmp"), { recursive: true });
+  mkdirSync6(resolve17(projectRoot, "artifacts"), { recursive: true });
+  const taskConfigPath = resolve17(rigDir, "task-config.json");
+  if (!existsSync10(taskConfigPath))
     writeFileSync5(taskConfigPath, `{}
 `, "utf-8");
 }
 function ensureGitignoreEntries(projectRoot) {
-  const path = resolve16(projectRoot, ".gitignore");
-  const existing = existsSync9(path) ? readFileSync6(path, "utf8") : "";
+  const path = resolve17(projectRoot, ".gitignore");
+  const existing = existsSync10(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)
@@ -4940,14 +4943,14 @@ function ensureGitignoreEntries(projectRoot) {
 `, "utf8");
 }
 function ensureRigConfigPackageDependencies(projectRoot) {
-  const path = resolve16(projectRoot, "package.json");
-  const existing = existsSync9(path) ? JSON.parse(readFileSync6(path, "utf8")) : {};
+  const path = resolve17(projectRoot, "package.json");
+  const existing = existsSync10(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 = {
-    ...existsSync9(path) ? existing : { name: "rig-project", private: true },
+    ...existsSync10(path) ? existing : { name: "rig-project", private: true },
     devDependencies
   };
   writeFileSync5(path, `${JSON.stringify(next, null, 2)}
@@ -5199,7 +5202,7 @@ async function promptGitHubProjectConfig(context, prompts, repoSlug, githubToken
   };
 }
 function sleep2(ms) {
-  return new Promise((resolve17) => setTimeout(resolve17, ms));
+  return new Promise((resolve18) => setTimeout(resolve18, ms));
 }
 function positiveIntFromEnv(name, fallback) {
   const value = Number.parseInt(process.env[name] ?? "", 10);
@@ -5228,7 +5231,7 @@ function remoteGitHubAuthMetadata(payload) {
   };
 }
 function writeRemoteGitHubAuthState(projectRoot, input) {
-  writeFileSync5(resolve16(projectRoot, ".rig", "state", "github-auth.json"), `${JSON.stringify({
+  writeFileSync5(resolve17(projectRoot, ".rig", "state", "github-auth.json"), `${JSON.stringify({
     authenticated: true,
     source: input.source,
     storedOnServer: true,
@@ -5285,9 +5288,9 @@ async function runControlPlaneInit(context, options) {
   });
   ensureRigPrivateDirs(projectRoot);
   ensureGitignoreEntries(projectRoot);
-  const configTsPath = resolve16(projectRoot, "rig.config.ts");
-  const configJsonPath = resolve16(projectRoot, "rig.config.json");
-  const configExists = existsSync9(configTsPath) || existsSync9(configJsonPath);
+  const configTsPath = resolve17(projectRoot, "rig.config.ts");
+  const configJsonPath = resolve17(projectRoot, "rig.config.json");
+  const configExists = existsSync10(configTsPath) || existsSync10(configJsonPath);
   if (!options.privateStateOnly) {
     if (configExists && !options.repair) {
       if (context.outputMode !== "json")
@@ -5303,7 +5306,7 @@ async function runControlPlaneInit(context, options) {
     }
     ensureRigConfigPackageDependencies(projectRoot);
   }
-  writeFileSync5(resolve16(projectRoot, ".rig", "state", "project-link.json"), `${JSON.stringify({ repoSlug: repo.slug, connection: connectionAlias, linkedAt: new Date().toISOString() }, null, 2)}
+  writeFileSync5(resolve17(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;
@@ -5499,7 +5502,7 @@ function parseInitOptions(args) {
 async function runInteractiveControlPlaneInit(context, prompts) {
   prompts.intro?.("Initialize a Rig control-plane project");
   const projectRoot = context.projectRoot;
-  const existingConfig = existsSync9(resolve16(projectRoot, "rig.config.ts")) || existsSync9(resolve16(projectRoot, "rig.config.json"));
+  const existingConfig = existsSync10(resolve17(projectRoot, "rig.config.ts")) || existsSync10(resolve17(projectRoot, "rig.config.json"));
   let repair = false;
   let privateStateOnly = false;
   if (existingConfig) {
@@ -5803,7 +5806,7 @@ async function executeDoctor(context, args) {
 // packages/cli/src/commands/_run-driver-helpers.ts
 init_runner();
 import { readFileSync as readFileSync7 } from "fs";
-import { resolve as resolve17 } from "path";
+import { resolve as resolve18 } from "path";
 import {
   appendJsonlRecord as appendJsonlRecord2,
   readAuthorityRun as readAuthorityRun2,
@@ -5823,7 +5826,7 @@ function patchAuthorityRun(projectRoot, runId, patch) {
     ...patch,
     updatedAt: new Date().toISOString()
   };
-  writeJsonFile4(resolve17(resolveAuthorityRunDir3(projectRoot, runId), "run.json"), next);
+  writeJsonFile4(resolve18(resolveAuthorityRunDir3(projectRoot, runId), "run.json"), next);
   return next;
 }
 function touchAuthorityRun(projectRoot, runId) {
@@ -5831,21 +5834,21 @@ function touchAuthorityRun(projectRoot, runId) {
   if (!current) {
     return;
   }
-  writeJsonFile4(resolve17(resolveAuthorityRunDir3(projectRoot, runId), "run.json"), {
+  writeJsonFile4(resolve18(resolveAuthorityRunDir3(projectRoot, runId), "run.json"), {
     ...current,
     updatedAt: new Date().toISOString()
   });
 }
 function appendRunTimeline(projectRoot, runId, value) {
-  appendJsonlRecord2(resolve17(resolveAuthorityRunDir3(projectRoot, runId), "timeline.jsonl"), value);
+  appendJsonlRecord2(resolve18(resolveAuthorityRunDir3(projectRoot, runId), "timeline.jsonl"), value);
   touchAuthorityRun(projectRoot, runId);
 }
 function appendRunLog(projectRoot, runId, value) {
-  appendJsonlRecord2(resolve17(resolveAuthorityRunDir3(projectRoot, runId), "logs.jsonl"), value);
+  appendJsonlRecord2(resolve18(resolveAuthorityRunDir3(projectRoot, runId), "logs.jsonl"), value);
   touchAuthorityRun(projectRoot, runId);
 }
 function appendRunAction(projectRoot, runId, value) {
-  appendJsonlRecord2(resolve17(resolveAuthorityRunDir3(projectRoot, runId), "timeline.jsonl"), {
+  appendJsonlRecord2(resolve18(resolveAuthorityRunDir3(projectRoot, runId), "timeline.jsonl"), {
     id: value.id,
     type: "action",
     actionType: value.actionType,
@@ -6030,8 +6033,8 @@ function renderSourceScopeValidation(task, validation) {
 
 // packages/cli/src/commands/inspect.ts
 init_runner();
-import { existsSync as existsSync10, readFileSync as readFileSync8 } from "fs";
-import { resolve as resolve18 } from "path";
+import { existsSync as existsSync11, readFileSync as readFileSync8 } from "fs";
+import { resolve as resolve19 } from "path";
 import {
   listAuthorityRuns as listAuthorityRuns2,
   readAuthorityRun as readAuthorityRun3,
@@ -6052,8 +6055,8 @@ async function executeInspect(context, args) {
       if (!latestRun) {
         throw new CliError2(`No runs found for ${requiredTask}.`);
       }
-      const logsPath = resolve18(resolveAuthorityRunDir4(context.projectRoot, latestRun.runId), "logs.jsonl");
-      if (!existsSync10(logsPath)) {
+      const logsPath = resolve19(resolveAuthorityRunDir4(context.projectRoot, latestRun.runId), "logs.jsonl");
+      if (!existsSync11(logsPath)) {
         throw new CliError2(`No logs found for run ${latestRun.runId}.`);
       }
       await context.runCommand(["cat", logsPath]);
@@ -6063,7 +6066,7 @@ async function executeInspect(context, args) {
       const { value: task, rest: remaining } = takeOption(rest, "--task");
       requireNoExtraArgs(remaining, "rig inspect artifacts --task <task-id>");
       const requiredTask = requireTask(task, "rig inspect artifacts --task <task-id>");
-      const artifactRoot = resolveTaskArtifactDirs(context.projectRoot, requiredTask).find((path) => existsSync10(path));
+      const artifactRoot = resolveTaskArtifactDirs(context.projectRoot, requiredTask).find((path) => existsSync11(path));
       if (!artifactRoot) {
         throw new CliError2(`No artifacts found for ${requiredTask}.`);
       }
@@ -6120,7 +6123,7 @@ async function executeInspect(context, args) {
     case "failures": {
       requireNoExtraArgs(rest, "rig inspect failures");
       const failed = resolveHarnessPaths2(context.projectRoot).failedApproachesPath;
-      if (!existsSync10(failed)) {
+      if (!existsSync11(failed)) {
         console.log("No failures recorded.");
       } else {
         process.stdout.write(readFileSync8(failed, "utf-8"));
@@ -6140,8 +6143,8 @@ async function executeInspect(context, args) {
       return { ok: true, group: "inspect", command };
     case "audit": {
       requireNoExtraArgs(rest, "rig inspect audit");
-      const auditPath = resolve18(resolveHarnessPaths2(context.projectRoot).logsDir, "audit.jsonl");
-      if (!existsSync10(auditPath)) {
+      const auditPath = resolve19(resolveHarnessPaths2(context.projectRoot).logsDir, "audit.jsonl");
+      if (!existsSync11(auditPath)) {
         console.log("No audit log found.");
       } else {
         const lines = readFileSync8(auditPath, "utf-8").split(/\r?\n/).filter(Boolean).slice(-20);
@@ -7293,7 +7296,7 @@ async function connectWorkerStream(options, ctx, state) {
   const buffered = [];
   const wsUrl = await buildRunPiEventsWebSocketUrl(options.context, options.runId);
   const socket = new WebSocket(wsUrl);
-  const closePromise = new Promise((resolve19) => {
+  const closePromise = new Promise((resolve20) => {
     socket.onopen = () => {
       state.wsConnected = true;
       state.status = "live worker Pi WebSocket connected";
@@ -7318,7 +7321,7 @@ async function connectWorkerStream(options, ctx, state) {
       state.wsConnected = false;
       state.status = "worker Pi WebSocket disconnected";
       updatePiUi(ctx, state);
-      resolve19();
+      resolve20();
     };
   });
   try {
@@ -7354,11 +7357,11 @@ async function connectWorkerStream(options, ctx, state) {
 function createRemoteBashOperations(options, state, excludeFromContext) {
   return {
     exec(command, _cwd, execOptions) {
-      return new Promise((resolve19, reject) => {
+      return new Promise((resolve20, reject) => {
         const pending = {
           command,
           onData: execOptions.onData,
-          resolve: resolve19,
+          resolve: resolve20,
           reject,
           sawChunk: false
         };
@@ -8169,7 +8172,7 @@ async function executeServer(context, args, options) {
 init_runner();
 import { readFileSync as readFileSync9 } from "fs";
 import { spawnSync as spawnSync3 } from "child_process";
-import { resolve as resolve19 } from "path";
+import { resolve as resolve20 } from "path";
 import { cancel as cancel4, confirm as confirm2, isCancel as isCancel4 } from "@clack/prompts";
 import {
   taskArtifactDir,
@@ -8878,7 +8881,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 = readFileSync9(resolve20(context.projectRoot, fileFlag.value), "utf-8");
       } else {
         content = await readStdin();
       }
@@ -9112,8 +9115,8 @@ async function executeTask(context, args, options) {
 
 // packages/cli/src/commands/task-run-driver.ts
 init_runner();
-import { copyFileSync as copyFileSync3, existsSync as existsSync11, mkdirSync as mkdirSync7, readFileSync as readFileSync10, statSync as statSync2, writeFileSync as writeFileSync6 } from "fs";
-import { resolve as resolve20 } from "path";
+import { copyFileSync as copyFileSync3, existsSync as existsSync12, mkdirSync as mkdirSync7, 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";
@@ -9196,12 +9199,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 {}
@@ -9240,7 +9243,7 @@ function buildDirtyBaselineHandshakeEnv(input) {
     return { RIG_BASELINE_MODE: input.baselineMode ?? "head" };
   return {
     RIG_BASELINE_MODE: "dirty-snapshot",
-    RIG_DIRTY_BASELINE_READY_FILE: resolve20(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) {
@@ -9351,9 +9354,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")
@@ -9427,7 +9430,7 @@ async function runTaskRunPostValidationLifecycle(input) {
     config,
     sourceTask: input.sourceTask,
     uploadedSnapshot: input.uploadedSnapshot,
-    artifactRoot: resolve20(input.projectRoot, "artifacts", taskId3),
+    artifactRoot: resolve21(input.projectRoot, "artifacts", taskId3),
     command: ghCommand,
     gitCommand,
     steerPi,
@@ -9557,7 +9560,7 @@ function summarizeValidationFailure(projectRoot, taskId3) {
     return null;
   }
   for (const artifactDir of resolveTaskArtifactDirs2(projectRoot, taskId3)) {
-    const summary = readJsonFile3(resolve20(artifactDir, "validation-summary.json"), null);
+    const summary = readJsonFile3(resolve21(artifactDir, "validation-summary.json"), null);
     if (!summary || summary.status !== "fail") {
       continue;
     }
@@ -9638,9 +9641,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 };
@@ -9677,12 +9680,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);
@@ -9868,7 +9871,7 @@ function appendToolTimelineFromLog(input) {
   });
 }
 function readTaskRunReviewStatus(reviewStatusPath) {
-  if (!existsSync11(reviewStatusPath)) {
+  if (!existsSync12(reviewStatusPath)) {
     return null;
   }
   try {
@@ -10086,15 +10089,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 = resolve20("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()
   };
-  mkdirSync7(resolve20(context.projectRoot, ".rig", "runs", input.runId), { recursive: true });
-  writeFileSync6(resolve20(context.projectRoot, ".rig", "runs", input.runId, "planning-classification.json"), `${JSON.stringify(persistedPlanning, null, 2)}
+  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}
@@ -10144,7 +10147,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" ? resolve20(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;
@@ -10230,10 +10233,10 @@ ${planningClassification.planningRequired ? `Before implementing, write a concis
       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) {
@@ -10241,7 +10244,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) {
-          mkdirSync7(resolve20(readyFile, ".."), { recursive: true });
+          mkdirSync7(resolve21(readyFile, ".."), { recursive: true });
           writeFileSync6(readyFile, `${JSON.stringify({ ...dirty, workspaceDir: latestRuntimeWorkspace, appliedAt: new Date().toISOString() }, null, 2)}
 `, "utf8");
         }
@@ -10626,7 +10629,7 @@ ${planningClassification.planningRequired ? `Before implementing, write a concis
     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)
@@ -10634,7 +10637,7 @@ ${planningClassification.planningRequired ? `Before implementing, write a concis
         settled = true;
         if (acceptedArtifactPollTimer)
           clearInterval(acceptedArtifactPollTimer);
-        resolve21(result);
+        resolve22(result);
       };
       const pollAcceptedArtifacts = () => {
         const artifactState = readTaskRunAcceptedArtifactState({
@@ -10836,8 +10839,8 @@ Failed to update task source for ${input.taskId ?? runtimeTaskId} to failed: ${e
   }
   if (planningClassification.planningRequired) {
     const planWorkspace = latestRuntimeWorkspace ?? context.projectRoot;
-    const expectedPlanPath = resolve20(planWorkspace, planningArtifactPath);
-    if (!existsSync11(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, {
@@ -11007,9 +11010,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));
     });
     for (const pendingLog of flushPendingClaudeToolUseLogs({
       runId: input.runId,
@@ -11151,8 +11154,8 @@ async function executeTest(context, args) {
 
 // packages/cli/src/commands/setup.ts
 init_runner();
-import { existsSync as existsSync12, mkdirSync as mkdirSync8, readdirSync as readdirSync2, writeFileSync as writeFileSync7 } 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,
@@ -11210,8 +11213,8 @@ 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)) {
+  const failuresPath = resolve22(stateDir, "failed_approaches.md");
+  if (!existsSync13(failuresPath)) {
     writeFileSync7(failuresPath, `# Failed Approaches
 
 `, "utf-8");
@@ -11229,18 +11232,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}`);
@@ -11385,7 +11388,7 @@ var PROJECT_REQUIRED_GROUPS = new Set([
 ]);
 var RIG_CONFIG_FILENAMES = ["rig.config.ts", "rig.config.mts", "rig.config.json"];
 function hasInitializedRigProject(projectRoot) {
-  return RIG_CONFIG_FILENAMES.some((name) => existsSync13(resolve22(projectRoot, name))) || existsSync13(resolve22(projectRoot, ".rig"));
+  return RIG_CONFIG_FILENAMES.some((name) => existsSync14(resolve23(projectRoot, name))) || existsSync14(resolve23(projectRoot, ".rig"));
 }
 function requireInitializedRigProject(context, group) {
   if (hasInitializedRigProject(context.projectRoot)) {