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

package/dist/src/index.js

@@ -355,6 +355,8 @@ __export(exports_plugin, {
   resolvePluginCliCommand: () => resolvePluginCliCommand,
   executePlugin: () => executePlugin
 });
+import { existsSync as existsSync4 } from "fs";
+import { resolve as resolve8 } from "path";
 import { buildPluginHostContext } from "@rig/runtime/control-plane/plugin-host-context";
 async function executePlugin(context, args) {
   const [command = "list", ...rest] = args;
@@ -382,7 +384,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) => existsSync4(resolve8(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) {
@@ -524,9 +527,9 @@ var init_plugin = __esm(() => {
 // packages/cli/src/commands.ts
 init_runner();
 import {
-  existsSync as existsSync14
+  existsSync as existsSync15
 } from "fs";
-import { resolve as resolve23 } from "path";
+import { resolve as resolve24 } from "path";
 import { readBuildConfig } from "@rig/runtime/build-time-config";
 
 // packages/cli/src/commands/browser.ts
@@ -2648,23 +2651,23 @@ import { ensureProjectMainFreshBeforeRun } from "@rig/runtime/control-plane/proj
 
 // packages/cli/src/commands/_connection-state.ts
 init_runner();
-import { existsSync as existsSync4, mkdirSync as mkdirSync5, readFileSync as readFileSync2, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync2, writeFileSync as writeFileSync3 } from "fs";
 import { homedir as homedir2 } from "os";
-import { dirname, resolve as resolve8 } from "path";
+import { dirname, resolve as resolve9 } from "path";
 function resolveGlobalConnectionsPath(env = process.env) {
   const explicit = env.RIG_CONNECTIONS_FILE?.trim();
   if (explicit)
-    return resolve8(explicit);
+    return resolve9(explicit);
   const stateDir = env.RIG_GLOBAL_STATE_DIR?.trim();
   if (stateDir)
-    return resolve8(stateDir, "connections.json");
-  return resolve8(homedir2(), ".rig", "connections.json");
+    return resolve9(stateDir, "connections.json");
+  return resolve9(homedir2(), ".rig", "connections.json");
 }
 function resolveRepoConnectionPath(projectRoot) {
-  return resolve8(projectRoot, ".rig", "state", "connection.json");
+  return resolve9(projectRoot, ".rig", "state", "connection.json");
 }
 function readJsonFile2(path) {
-  if (!existsSync4(path))
+  if (!existsSync5(path))
     return null;
   try {
     return JSON.parse(readFileSync2(path, "utf8"));
@@ -2751,8 +2754,8 @@ function resolveSelectedConnection(projectRoot, options = {}) {
 
 // packages/cli/src/commands/_server-client.ts
 init_runner();
-import { existsSync as existsSync5, readFileSync as readFileSync3 } from "fs";
-import { resolve as resolve9 } from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync3 } from "fs";
+import { resolve as resolve10 } from "path";
 import { ensureLocalRigServerConnection } from "@rig/runtime/local-server";
 var scopedGitHubBearerTokens = new Map;
 function cleanToken(value) {
@@ -2760,12 +2763,12 @@ function cleanToken(value) {
   return trimmed ? trimmed : null;
 }
 function setGitHubBearerTokenForCurrentProcess(token, projectRoot) {
-  const scopedKey = resolve9(projectRoot ?? process.cwd());
+  const scopedKey = resolve10(projectRoot ?? process.cwd());
   scopedGitHubBearerTokens.set(scopedKey, cleanToken(token ?? undefined));
 }
 function readPrivateRemoteSessionToken(projectRoot) {
-  const path = resolve9(projectRoot, ".rig", "state", "github-auth.json");
-  if (!existsSync5(path))
+  const path = resolve10(projectRoot, ".rig", "state", "github-auth.json");
+  if (!existsSync6(path))
     return null;
   try {
     const parsed = JSON.parse(readFileSync3(path, "utf8"));
@@ -2775,7 +2778,7 @@ function readPrivateRemoteSessionToken(projectRoot) {
   }
 }
 function readGitHubBearerTokenForRemote(projectRoot) {
-  const scopedKey = resolve9(projectRoot);
+  const scopedKey = resolve10(projectRoot);
   if (scopedGitHubBearerTokens.has(scopedKey))
     return scopedGitHubBearerTokens.get(scopedKey) ?? null;
   const privateSession = readPrivateRemoteSessionToken(projectRoot);
@@ -2917,7 +2920,7 @@ async function registerProjectViaServer(context, input) {
   return payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
 }
 function sleep(ms) {
-  return new Promise((resolve10) => setTimeout(resolve10, ms));
+  return new Promise((resolve11) => setTimeout(resolve11, ms));
 }
 function isRetryableProjectRootSwitchError(error) {
   if (!(error instanceof Error))
@@ -3400,7 +3403,7 @@ async function executeQueue(context, args) {
 
 // packages/cli/src/commands/agent.ts
 init_runner();
-import { resolve as resolve11 } from "path";
+import { resolve as resolve12 } from "path";
 import {
   agentId,
   cleanupAgentRuntime,
@@ -3410,8 +3413,8 @@ import {
 } from "@rig/runtime/control-plane/runtime/isolation";
 
 // packages/cli/src/commands/_authority-runs.ts
-import { existsSync as existsSync6 } from "fs";
-import { resolve as resolve10 } from "path";
+import { existsSync as existsSync7 } from "fs";
+import { resolve as resolve11 } from "path";
 import {
   readAuthorityRun,
   readJsonlFile as readJsonlFile2,
@@ -3433,8 +3436,8 @@ function normalizeRuntimeAdapter(value) {
   return "claude-code";
 }
 function readLatestBeadRecord(projectRoot, taskId) {
-  const issuesPath = resolve10(resolveControlPlaneMonorepoRoot(projectRoot), ".beads", "issues.jsonl");
-  if (!existsSync6(issuesPath)) {
+  const issuesPath = resolve11(resolveControlPlaneMonorepoRoot(projectRoot), ".beads", "issues.jsonl");
+  if (!existsSync7(issuesPath)) {
     return null;
   }
   let latest = null;
@@ -3502,7 +3505,7 @@ function upsertAgentAuthorityRun(projectRoot, input) {
   } else if ("errorText" in next) {
     delete next.errorText;
   }
-  writeJsonFile3(resolve10(resolveAuthorityRunDir(projectRoot, input.runId), "run.json"), next);
+  writeJsonFile3(resolve11(resolveAuthorityRunDir(projectRoot, input.runId), "run.json"), next);
   return next;
 }
 
@@ -3624,10 +3627,10 @@ async function executeAgent(context, args) {
           status: "running",
           startedAt: createdAt,
           worktreePath: runtime.workspaceDir,
-          artifactRoot: resolve11(runtime.workspaceDir, "artifacts", taskId),
+          artifactRoot: resolve12(runtime.workspaceDir, "artifacts", taskId),
           logRoot: runtime.logsDir,
-          sessionPath: resolve11(runtime.sessionDir, "session.json"),
-          sessionLogPath: resolve11(runtime.logsDir, "agent-stdout.log"),
+          sessionPath: resolve12(runtime.sessionDir, "session.json"),
+          sessionLogPath: resolve12(runtime.logsDir, "agent-stdout.log"),
           pid: process.pid
         });
         const result = await runInAgentRuntime({
@@ -3647,10 +3650,10 @@ async function executeAgent(context, args) {
             startedAt: createdAt,
             completedAt: failedAt,
             worktreePath: runtime.workspaceDir,
-            artifactRoot: resolve11(runtime.workspaceDir, "artifacts", taskId),
+            artifactRoot: resolve12(runtime.workspaceDir, "artifacts", taskId),
             logRoot: runtime.logsDir,
-            sessionPath: resolve11(runtime.sessionDir, "session.json"),
-            sessionLogPath: resolve11(runtime.logsDir, "agent-stdout.log"),
+            sessionPath: resolve12(runtime.sessionDir, "session.json"),
+            sessionLogPath: resolve12(runtime.logsDir, "agent-stdout.log"),
             pid: process.pid,
             errorText: result.stderr ? result.stderr.trim() : `Agent runtime command failed (${result.exitCode})`
           });
@@ -3667,10 +3670,10 @@ ${result.stderr.trim()}` : ""}`, result.exitCode);
           startedAt: createdAt,
           completedAt,
           worktreePath: runtime.workspaceDir,
-          artifactRoot: resolve11(runtime.workspaceDir, "artifacts", taskId),
+          artifactRoot: resolve12(runtime.workspaceDir, "artifacts", taskId),
           logRoot: runtime.logsDir,
-          sessionPath: resolve11(runtime.sessionDir, "session.json"),
-          sessionLogPath: resolve11(runtime.logsDir, "agent-stdout.log"),
+          sessionPath: resolve12(runtime.sessionDir, "session.json"),
+          sessionLogPath: resolve12(runtime.logsDir, "agent-stdout.log"),
           pid: process.pid
         });
         return {
@@ -3746,7 +3749,7 @@ init__parsers();
 import {
   chmodSync,
   copyFileSync as copyFileSync2,
-  existsSync as existsSync7,
+  existsSync as existsSync8,
   mkdirSync as mkdirSync6,
   readdirSync,
   readlinkSync,
@@ -3756,7 +3759,7 @@ import {
   unlinkSync
 } from "fs";
 import { homedir as homedir3 } from "os";
-import { resolve as resolve12 } from "path";
+import { resolve as resolve13 } from "path";
 import { buildBinary as buildBinary2 } from "@rig/runtime/control-plane/runtime/isolation";
 import {
   computeRuntimeImageFingerprint,
@@ -3775,13 +3778,13 @@ async function runQuietBinaryProbe(binaryPath, args, cwd) {
 
 // packages/cli/src/commands/dist.ts
 function collectRigValidatorBuildTargets(input) {
-  const validatorsRoot = resolve12(input.hostProjectRoot, "packages/runtime/src/control-plane/validators");
-  if (!existsSync7(validatorsRoot))
+  const validatorsRoot = resolve13(input.hostProjectRoot, "packages/runtime/src/control-plane/validators");
+  if (!existsSync8(validatorsRoot))
     return [];
   const targets = [];
   const categories = readdirSync(validatorsRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory());
   for (const category of categories) {
-    const categoryDir = resolve12(validatorsRoot, category.name);
+    const categoryDir = resolve13(validatorsRoot, category.name);
     for (const entry of readdirSync(categoryDir, { withFileTypes: true })) {
       if (!entry.isFile() || !entry.name.endsWith(".ts"))
         continue;
@@ -3790,7 +3793,7 @@ function collectRigValidatorBuildTargets(input) {
         continue;
       targets.push({
         source: `packages/runtime/src/control-plane/validators/${category.name}/${entry.name}`,
-        dest: resolve12(input.imageDir, `bin/validators/${category.name}-${check}`),
+        dest: resolve13(input.imageDir, `bin/validators/${category.name}-${check}`),
         cwd: input.hostProjectRoot
       });
     }
@@ -3799,16 +3802,16 @@ function collectRigValidatorBuildTargets(input) {
 }
 async function findLatestDistBinary(projectRoot) {
   const distRoot = resolveControlPlaneHostDistDir(projectRoot);
-  if (!existsSync7(distRoot)) {
+  if (!existsSync8(distRoot)) {
     return null;
   }
   const entries = readdirSync(distRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name.startsWith("rig-")).map((entry) => ({
     name: entry.name,
-    mtimeMs: statSync(resolve12(distRoot, entry.name)).mtimeMs
+    mtimeMs: statSync(resolve13(distRoot, entry.name)).mtimeMs
   })).sort((a, b) => b.mtimeMs - a.mtimeMs || b.name.localeCompare(a.name));
   for (const { name } of entries) {
-    const candidate = resolve12(distRoot, name, "bin", "rig");
-    if (existsSync7(candidate) && await isRunnableRigBinary(candidate, projectRoot)) {
+    const candidate = resolve13(distRoot, name, "bin", "rig");
+    if (existsSync8(candidate) && await isRunnableRigBinary(candidate, projectRoot)) {
       return candidate;
     }
   }
@@ -3820,7 +3823,7 @@ async function isRunnableRigBinary(binaryPath, projectRoot) {
 async function runDistDoctor(projectRoot) {
   const bunPath = Bun.which("bun");
   const rigPath = Bun.which("rig");
-  const userBinDir = resolve12(homedir3(), ".local/bin");
+  const userBinDir = resolve13(homedir3(), ".local/bin");
   const userBinInPath = (process.env.PATH || "").split(":").filter(Boolean).includes(userBinDir);
   let rigRunnable = false;
   if (rigPath) {
@@ -3868,15 +3871,15 @@ async function executeDist(context, args) {
       let source = await findLatestDistBinary(context.projectRoot);
       let buildDir = null;
       if (!source) {
-        buildDir = resolve12(resolveControlPlaneHostDistDir(context.projectRoot), `rig-install-${Date.now()}`);
+        buildDir = resolve13(resolveControlPlaneHostDistDir(context.projectRoot), `rig-install-${Date.now()}`);
         await context.runCommand(["bun", "run", "packages/cli/bin/build-rig-binaries.ts", "--output-dir", buildDir]);
-        source = resolve12(buildDir, "bin", "rig");
+        source = resolve13(buildDir, "bin", "rig");
       }
-      if (!existsSync7(source)) {
+      if (!existsSync8(source)) {
         throw new CliError2(`Unable to locate rig binary at ${source}.`, 2);
       }
-      const installedPath = resolve12(installDir, "rig");
-      if (existsSync7(installedPath)) {
+      const installedPath = resolve13(installDir, "rig");
+      if (existsSync8(installedPath)) {
         unlinkSync(installedPath);
       }
       copyFileSync2(source, installedPath);
@@ -3918,22 +3921,22 @@ async function executeDist(context, args) {
       requireNoExtraArgs(rest, "rig dist rebuild-agent");
       const fp = await computeRuntimeImageFingerprint(context.projectRoot);
       const currentId = computeRuntimeImageId(fp);
-      const imagesDir = resolve12(resolveControlPlaneMonorepoRuntimeDir(context.projectRoot), "images");
+      const imagesDir = resolve13(resolveControlPlaneMonorepoRuntimeDir(context.projectRoot), "images");
       mkdirSync6(imagesDir, { recursive: true });
       let pruned = 0;
       for (const entry of readdirSync(imagesDir, { withFileTypes: true })) {
         if (entry.isDirectory() && entry.name !== currentId) {
-          rmSync3(resolve12(imagesDir, entry.name), { recursive: true, force: true });
+          rmSync3(resolve13(imagesDir, entry.name), { recursive: true, force: true });
           pruned++;
         }
       }
       if (pruned > 0 && context.outputMode === "text") {
         console.log(`Pruned ${pruned} stale image(s).`);
       }
-      const imageDir = resolve12(imagesDir, currentId);
-      mkdirSync6(resolve12(imageDir, "bin/hooks"), { recursive: true });
-      mkdirSync6(resolve12(imageDir, "bin/plugins"), { recursive: true });
-      mkdirSync6(resolve12(imageDir, "bin/validators"), { recursive: true });
+      const imageDir = resolve13(imagesDir, currentId);
+      mkdirSync6(resolve13(imageDir, "bin/hooks"), { recursive: true });
+      mkdirSync6(resolve13(imageDir, "bin/plugins"), { recursive: true });
+      mkdirSync6(resolve13(imageDir, "bin/validators"), { recursive: true });
       const hookNames = [
         "scope-guard",
         "import-guard",
@@ -3947,25 +3950,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: 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 });
+      targets.push({ source: "packages/runtime/bin/rig-agent.ts", dest: resolve13(imageDir, "bin/rig-agent"), cwd: hostProjectRoot });
+      targets.push({ source: "packages/runtime/bin/rig-agent-dispatch.ts", dest: resolve13(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: resolve12(imageDir, `bin/hooks/${hookName}`), cwd: hostProjectRoot });
-        targets.push({ source: src, dest: resolve12(resolveControlPlaneHostBinDir(context.projectRoot), `hooks/${hookName}`), cwd: hostProjectRoot });
+        targets.push({ source: src, dest: resolve13(imageDir, `bin/hooks/${hookName}`), cwd: hostProjectRoot });
+        targets.push({ source: src, dest: resolve13(resolveControlPlaneHostBinDir(context.projectRoot), `hooks/${hookName}`), cwd: hostProjectRoot });
       }
-      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");
+      const pluginsDir = resolve13(context.projectRoot, "rig/plugins");
+      const binPluginsDir = resolve13(resolveControlPlaneHostBinDir(context.projectRoot), "plugins");
+      const validatorsRoot = resolve13(hostProjectRoot, "packages/runtime/src/control-plane/validators");
+      const binValidatorsDir = resolve13(resolveControlPlaneHostBinDir(context.projectRoot), "validators");
       mkdirSync6(binPluginsDir, { recursive: true });
       mkdirSync6(binValidatorsDir, { recursive: true });
-      if (existsSync7(pluginsDir)) {
+      if (existsSync8(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: resolve12(imageDir, `bin/plugins/${m[1]}`), cwd: context.projectRoot });
+          targets.push({ source: `rig/plugins/${entry.name}`, dest: resolve13(imageDir, `bin/plugins/${m[1]}`), cwd: context.projectRoot });
         }
       }
       targets.push(...collectRigValidatorBuildTargets({ contextProjectRoot: context.projectRoot, hostProjectRoot, imageDir }));
@@ -3976,17 +3979,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 (existsSync7(pluginsDir)) {
+      if (existsSync8(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 = resolve12(imageDir, `bin/plugins/${pluginName}`);
+          const imageBin = resolve13(imageDir, `bin/plugins/${pluginName}`);
           if (!pluginName)
             continue;
-          const symlinkPath = resolve12(binPluginsDir, pluginName);
-          if (existsSync7(imageBin)) {
+          const symlinkPath = resolve13(binPluginsDir, pluginName);
+          if (existsSync8(imageBin)) {
             try {
               unlinkSync(symlinkPath);
             } catch {}
@@ -3994,10 +3997,10 @@ async function executeDist(context, args) {
           }
         }
       }
-      if (existsSync7(validatorsRoot)) {
+      if (existsSync8(validatorsRoot)) {
         const categories = readdirSync(validatorsRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory());
         for (const category of categories) {
-          const categoryDir = resolve12(validatorsRoot, category.name);
+          const categoryDir = resolve13(validatorsRoot, category.name);
           for (const entry of readdirSync(categoryDir, { withFileTypes: true })) {
             if (!entry.isFile() || !entry.name.endsWith(".ts"))
               continue;
@@ -4005,9 +4008,9 @@ async function executeDist(context, args) {
             if (!check || check === "index" || check === "shared")
               continue;
             const validatorName = `${category.name}-${check}`;
-            const imageBin = resolve12(imageDir, `bin/validators/${validatorName}`);
-            const symlinkPath = resolve12(binValidatorsDir, validatorName);
-            if (existsSync7(imageBin)) {
+            const imageBin = resolve13(imageDir, `bin/validators/${validatorName}`);
+            const symlinkPath = resolve13(binValidatorsDir, validatorName);
+            if (existsSync8(imageBin)) {
               try {
                 unlinkSync(symlinkPath);
               } catch {}
@@ -4016,18 +4019,18 @@ async function executeDist(context, args) {
           }
         }
       }
-      const agentsDir = resolve12(resolveControlPlaneMonorepoRuntimeDir(context.projectRoot), "agents");
-      if (existsSync7(agentsDir)) {
+      const agentsDir = resolve13(resolveControlPlaneMonorepoRuntimeDir(context.projectRoot), "agents");
+      if (existsSync8(agentsDir)) {
         let relinkCount = 0;
         for (const agentEntry of readdirSync(agentsDir, { withFileTypes: true })) {
           if (!agentEntry.isDirectory())
             continue;
-          const agentBinDir = resolve12(agentsDir, agentEntry.name, "worktree", ".rig", "bin");
-          if (!existsSync7(agentBinDir))
+          const agentBinDir = resolve13(agentsDir, agentEntry.name, "worktree", ".rig", "bin");
+          if (!existsSync8(agentBinDir))
             continue;
           const walkDir = (dir) => {
             for (const entry of readdirSync(dir, { withFileTypes: true })) {
-              const fullPath = resolve12(dir, entry.name);
+              const fullPath = resolve13(dir, entry.name);
               if (entry.isDirectory()) {
                 walkDir(fullPath);
               } else if (entry.isSymbolicLink()) {
@@ -4062,7 +4065,7 @@ async function executeDist(context, args) {
 // packages/cli/src/commands/inbox.ts
 init_runner();
 import { writeFileSync as writeFileSync4 } from "fs";
-import { resolve as resolve13 } from "path";
+import { resolve as resolve14 } from "path";
 import {
   listAuthorityRuns,
   readJsonlFile as readJsonlFile3,
@@ -4464,7 +4467,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(resolve13(resolveAuthorityRunDir2(context.projectRoot, entry.runId), fileName)).map((record) => ({
+  return runs.flatMap((entry) => readJsonlFile3(resolve14(resolveAuthorityRunDir2(context.projectRoot, entry.runId), fileName)).map((record) => ({
     runId: entry.runId,
     taskId: entry.taskId ?? undefined,
     record
@@ -4512,7 +4515,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 = resolve13(resolveAuthorityRunDir2(context.projectRoot, run.value), "approvals.jsonl");
+      const approvalsPath = resolve14(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);
@@ -4568,7 +4571,7 @@ async function executeInbox(context, args) {
         const [key, ...restValue] = entry.split("=");
         return [key, restValue.join("=")];
       }));
-      const requestsPath = resolve13(resolveAuthorityRunDir2(context.projectRoot, run.value), "user-input.jsonl");
+      const requestsPath = resolve14(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);
@@ -4584,16 +4587,16 @@ async function executeInbox(context, args) {
 
 // packages/cli/src/commands/init.ts
 init_runner();
-import { appendFileSync as appendFileSync2, existsSync as existsSync10, mkdirSync as mkdirSync7, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
+import { appendFileSync as appendFileSync2, existsSync as existsSync11, mkdirSync as mkdirSync7, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
 import { spawnSync } from "child_process";
-import { resolve as resolve17 } from "path";
+import { resolve as resolve18 } 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 existsSync8, readFileSync as readFileSync4, rmSync as rmSync4 } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync4, rmSync as rmSync4 } from "fs";
 import { homedir as homedir4 } from "os";
-import { resolve as resolve14 } from "path";
+import { resolve as resolve15 } 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.
@@ -4609,11 +4612,11 @@ async function defaultCommandRunner(command, options = {}) {
   return { exitCode, stdout, stderr };
 }
 function resolvePiRigExtensionPath(homeDir) {
-  return resolve14(homeDir, ".pi", "agent", "extensions", "pi-rig");
+  return resolve15(homeDir, ".pi", "agent", "extensions", "pi-rig");
 }
-function resolvePiRigPackageSource(projectRoot, exists = existsSync8) {
-  const localPackage = resolve14(projectRoot, "packages", "pi-rig");
-  if (exists(resolve14(localPackage, "package.json")))
+function resolvePiRigPackageSource(projectRoot, exists = existsSync9) {
+  const localPackage = resolve15(projectRoot, "packages", "pi-rig");
+  if (exists(resolve15(localPackage, "package.json")))
     return localPackage;
   return `npm:${PI_RIG_PACKAGE_NAME}`;
 }
@@ -4664,9 +4667,9 @@ async function ensurePiBinaryAvailable(input) {
     ...next.exitCode === 0 ? {} : { error: (next.stderr || next.stdout).trim() || "pi --version failed after install" }
   };
 }
-function removeManagedLegacyPiRigBridge(homeDir, exists = existsSync8) {
+function removeManagedLegacyPiRigBridge(homeDir, exists = existsSync9) {
   const extensionPath = resolvePiRigExtensionPath(homeDir);
-  const indexPath = resolve14(extensionPath, "index.ts");
+  const indexPath = resolve15(extensionPath, "index.ts");
   if (!exists(indexPath))
     return;
   try {
@@ -4686,13 +4689,13 @@ async function checkPiRigInstall(input = {}) {
       piRig: { ok: true, label: "pi-rig global extension", detail: extensionPath }
     };
   }
-  const exists = input.exists ?? existsSync8;
+  const exists = input.exists ?? existsSync9;
   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(resolve14(extensionPath, "index.ts"));
+  const legacyBridge = exists(resolve15(extensionPath, "index.ts"));
   const hasPiRig = listedPiRig;
   return {
     extensionPath,
@@ -4769,7 +4772,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 resolve15, relative, sep } from "path";
+import { dirname as dirname2, resolve as resolve16, 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([
@@ -4791,15 +4794,15 @@ function assertManifestPath(root, relativePath) {
   if (!relativePath || relativePath.startsWith("/") || relativePath.includes("\x00")) {
     throw new Error(`Invalid snapshot path: ${relativePath}`);
   }
-  const resolved = resolve15(root, relativePath);
+  const resolved = resolve16(root, relativePath);
   const relativeToRoot = relative(root, resolved);
-  if (relativeToRoot.startsWith("..") || relativeToRoot === ".." || resolve15(relativeToRoot) === resolved) {
+  if (relativeToRoot.startsWith("..") || relativeToRoot === ".." || resolve16(relativeToRoot) === resolved) {
     throw new Error(`Snapshot path escapes project root: ${relativePath}`);
   }
   return resolved;
 }
 async function buildSnapshotUploadManifest(projectRoot, options = {}) {
-  const root = resolve15(projectRoot);
+  const root = resolve16(projectRoot);
   const excludedDirectories = [...new Set([
     ...DEFAULT_EXCLUDED_DIRECTORIES,
     ...options.excludedDirectories ?? []
@@ -4811,7 +4814,7 @@ async function buildSnapshotUploadManifest(projectRoot, options = {}) {
     for (const entry of entries) {
       if (entry.isDirectory() && excludedSet.has(entry.name))
         continue;
-      const fullPath = resolve15(dir, entry.name);
+      const fullPath = resolve16(dir, entry.name);
       if (entry.isDirectory()) {
         await visit(fullPath);
         continue;
@@ -4860,8 +4863,8 @@ async function uploadSnapshotArchiveViaServer(context, input) {
 
 // packages/cli/src/commands/_doctor-checks.ts
 init_runner();
-import { existsSync as existsSync9, readFileSync as readFileSync5 } from "fs";
-import { resolve as resolve16 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync5 } from "fs";
+import { resolve as resolve17 } from "path";
 import { isSupportedBunVersion, MIN_SUPPORTED_BUN_VERSION } from "@rig/runtime/control-plane/setup-version";
 init__parsers();
 function check(id, label, status, detail, remediation) {
@@ -4902,8 +4905,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 = resolve16(projectRoot, name);
-    if (!existsSync9(path))
+    const path = resolve17(projectRoot, name);
+    if (!existsSync10(path))
       continue;
     try {
       const source = readFileSync5(path, "utf8");
@@ -4985,7 +4988,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) => existsSync9(resolve16(projectRoot, name)));
+  const hasConfigFile = ["rig.config.ts", "rig.config.mts", "rig.config.json"].some((name) => existsSync10(resolve17(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."));
@@ -5104,20 +5107,20 @@ function parseRepoSlug(value) {
   return { owner: match[1], repo: match[2], slug: `${match[1]}/${match[2]}` };
 }
 function ensureRigPrivateDirs(projectRoot) {
-  const rigDir = resolve17(projectRoot, ".rig");
-  mkdirSync7(resolve17(rigDir, "state"), { recursive: true });
-  mkdirSync7(resolve17(rigDir, "logs"), { recursive: true });
-  mkdirSync7(resolve17(rigDir, "runs"), { recursive: true });
-  mkdirSync7(resolve17(rigDir, "tmp"), { recursive: true });
-  mkdirSync7(resolve17(projectRoot, "artifacts"), { recursive: true });
-  const taskConfigPath = resolve17(rigDir, "task-config.json");
-  if (!existsSync10(taskConfigPath))
+  const rigDir = resolve18(projectRoot, ".rig");
+  mkdirSync7(resolve18(rigDir, "state"), { recursive: true });
+  mkdirSync7(resolve18(rigDir, "logs"), { recursive: true });
+  mkdirSync7(resolve18(rigDir, "runs"), { recursive: true });
+  mkdirSync7(resolve18(rigDir, "tmp"), { recursive: true });
+  mkdirSync7(resolve18(projectRoot, "artifacts"), { recursive: true });
+  const taskConfigPath = resolve18(rigDir, "task-config.json");
+  if (!existsSync11(taskConfigPath))
     writeFileSync5(taskConfigPath, `{}
 `, "utf-8");
 }
 function ensureGitignoreEntries(projectRoot) {
-  const path = resolve17(projectRoot, ".gitignore");
-  const existing = existsSync10(path) ? readFileSync6(path, "utf8") : "";
+  const path = resolve18(projectRoot, ".gitignore");
+  const existing = existsSync11(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)
@@ -5130,14 +5133,14 @@ function ensureGitignoreEntries(projectRoot) {
 `, "utf8");
 }
 function ensureRigConfigPackageDependencies(projectRoot) {
-  const path = resolve17(projectRoot, "package.json");
-  const existing = existsSync10(path) ? JSON.parse(readFileSync6(path, "utf8")) : {};
+  const path = resolve18(projectRoot, "package.json");
+  const existing = existsSync11(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 = {
-    ...existsSync10(path) ? existing : { name: "rig-project", private: true },
+    ...existsSync11(path) ? existing : { name: "rig-project", private: true },
     devDependencies
   };
   writeFileSync5(path, `${JSON.stringify(next, null, 2)}
@@ -5389,7 +5392,7 @@ async function promptGitHubProjectConfig(context, prompts, repoSlug, githubToken
   };
 }
 function sleep2(ms) {
-  return new Promise((resolve18) => setTimeout(resolve18, ms));
+  return new Promise((resolve19) => setTimeout(resolve19, ms));
 }
 function positiveIntFromEnv(name, fallback) {
   const value = Number.parseInt(process.env[name] ?? "", 10);
@@ -5418,7 +5421,7 @@ function remoteGitHubAuthMetadata(payload) {
   };
 }
 function writeRemoteGitHubAuthState(projectRoot, input) {
-  writeFileSync5(resolve17(projectRoot, ".rig", "state", "github-auth.json"), `${JSON.stringify({
+  writeFileSync5(resolve18(projectRoot, ".rig", "state", "github-auth.json"), `${JSON.stringify({
     authenticated: true,
     source: input.source,
     storedOnServer: true,
@@ -5475,9 +5478,9 @@ async function runControlPlaneInit(context, options) {
   });
   ensureRigPrivateDirs(projectRoot);
   ensureGitignoreEntries(projectRoot);
-  const configTsPath = resolve17(projectRoot, "rig.config.ts");
-  const configJsonPath = resolve17(projectRoot, "rig.config.json");
-  const configExists = existsSync10(configTsPath) || existsSync10(configJsonPath);
+  const configTsPath = resolve18(projectRoot, "rig.config.ts");
+  const configJsonPath = resolve18(projectRoot, "rig.config.json");
+  const configExists = existsSync11(configTsPath) || existsSync11(configJsonPath);
   if (!options.privateStateOnly) {
     if (configExists && !options.repair) {
       if (context.outputMode !== "json")
@@ -5493,7 +5496,7 @@ async function runControlPlaneInit(context, options) {
     }
     ensureRigConfigPackageDependencies(projectRoot);
   }
-  writeFileSync5(resolve17(projectRoot, ".rig", "state", "project-link.json"), `${JSON.stringify({ repoSlug: repo.slug, connection: connectionAlias, linkedAt: new Date().toISOString() }, null, 2)}
+  writeFileSync5(resolve18(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;
@@ -5689,7 +5692,7 @@ function parseInitOptions(args) {
 async function runInteractiveControlPlaneInit(context, prompts) {
   prompts.intro?.("Initialize a Rig control-plane project");
   const projectRoot = context.projectRoot;
-  const existingConfig = existsSync10(resolve17(projectRoot, "rig.config.ts")) || existsSync10(resolve17(projectRoot, "rig.config.json"));
+  const existingConfig = existsSync11(resolve18(projectRoot, "rig.config.ts")) || existsSync11(resolve18(projectRoot, "rig.config.json"));
   let repair = false;
   let privateStateOnly = false;
   if (existingConfig) {
@@ -5993,7 +5996,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 resolve18 } from "path";
+import { resolve as resolve19 } from "path";
 import {
   appendJsonlRecord as appendJsonlRecord2,
   readAuthorityRun as readAuthorityRun2,
@@ -6013,7 +6016,7 @@ function patchAuthorityRun(projectRoot, runId, patch) {
     ...patch,
     updatedAt: new Date().toISOString()
   };
-  writeJsonFile4(resolve18(resolveAuthorityRunDir3(projectRoot, runId), "run.json"), next);
+  writeJsonFile4(resolve19(resolveAuthorityRunDir3(projectRoot, runId), "run.json"), next);
   return next;
 }
 function touchAuthorityRun(projectRoot, runId) {
@@ -6021,21 +6024,21 @@ function touchAuthorityRun(projectRoot, runId) {
   if (!current) {
     return;
   }
-  writeJsonFile4(resolve18(resolveAuthorityRunDir3(projectRoot, runId), "run.json"), {
+  writeJsonFile4(resolve19(resolveAuthorityRunDir3(projectRoot, runId), "run.json"), {
     ...current,
     updatedAt: new Date().toISOString()
   });
 }
 function appendRunTimeline(projectRoot, runId, value) {
-  appendJsonlRecord2(resolve18(resolveAuthorityRunDir3(projectRoot, runId), "timeline.jsonl"), value);
+  appendJsonlRecord2(resolve19(resolveAuthorityRunDir3(projectRoot, runId), "timeline.jsonl"), value);
   touchAuthorityRun(projectRoot, runId);
 }
 function appendRunLog(projectRoot, runId, value) {
-  appendJsonlRecord2(resolve18(resolveAuthorityRunDir3(projectRoot, runId), "logs.jsonl"), value);
+  appendJsonlRecord2(resolve19(resolveAuthorityRunDir3(projectRoot, runId), "logs.jsonl"), value);
   touchAuthorityRun(projectRoot, runId);
 }
 function appendRunAction(projectRoot, runId, value) {
-  appendJsonlRecord2(resolve18(resolveAuthorityRunDir3(projectRoot, runId), "timeline.jsonl"), {
+  appendJsonlRecord2(resolve19(resolveAuthorityRunDir3(projectRoot, runId), "timeline.jsonl"), {
     id: value.id,
     type: "action",
     actionType: value.actionType,
@@ -6220,8 +6223,8 @@ function renderSourceScopeValidation(task, validation) {
 
 // packages/cli/src/commands/inspect.ts
 init_runner();
-import { existsSync as existsSync11, readFileSync as readFileSync8 } from "fs";
-import { resolve as resolve19 } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync8 } from "fs";
+import { resolve as resolve20 } from "path";
 import {
   listAuthorityRuns as listAuthorityRuns2,
   readAuthorityRun as readAuthorityRun3,
@@ -6242,8 +6245,8 @@ async function executeInspect(context, args) {
       if (!latestRun) {
         throw new CliError2(`No runs found for ${requiredTask}.`);
       }
-      const logsPath = resolve19(resolveAuthorityRunDir4(context.projectRoot, latestRun.runId), "logs.jsonl");
-      if (!existsSync11(logsPath)) {
+      const logsPath = resolve20(resolveAuthorityRunDir4(context.projectRoot, latestRun.runId), "logs.jsonl");
+      if (!existsSync12(logsPath)) {
         throw new CliError2(`No logs found for run ${latestRun.runId}.`);
       }
       await context.runCommand(["cat", logsPath]);
@@ -6253,7 +6256,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) => existsSync11(path));
+      const artifactRoot = resolveTaskArtifactDirs(context.projectRoot, requiredTask).find((path) => existsSync12(path));
       if (!artifactRoot) {
         throw new CliError2(`No artifacts found for ${requiredTask}.`);
       }
@@ -6310,7 +6313,7 @@ async function executeInspect(context, args) {
     case "failures": {
       requireNoExtraArgs(rest, "rig inspect failures");
       const failed = resolveHarnessPaths2(context.projectRoot).failedApproachesPath;
-      if (!existsSync11(failed)) {
+      if (!existsSync12(failed)) {
         console.log("No failures recorded.");
       } else {
         process.stdout.write(readFileSync8(failed, "utf-8"));
@@ -6330,8 +6333,8 @@ async function executeInspect(context, args) {
       return { ok: true, group: "inspect", command };
     case "audit": {
       requireNoExtraArgs(rest, "rig inspect audit");
-      const auditPath = resolve19(resolveHarnessPaths2(context.projectRoot).logsDir, "audit.jsonl");
-      if (!existsSync11(auditPath)) {
+      const auditPath = resolve20(resolveHarnessPaths2(context.projectRoot).logsDir, "audit.jsonl");
+      if (!existsSync12(auditPath)) {
         console.log("No audit log found.");
       } else {
         const lines = readFileSync8(auditPath, "utf-8").split(/\r?\n/).filter(Boolean).slice(-20);
@@ -7483,7 +7486,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((resolve20) => {
+  const closePromise = new Promise((resolve21) => {
     socket.onopen = () => {
       state.wsConnected = true;
       state.status = "live worker Pi WebSocket connected";
@@ -7508,7 +7511,7 @@ async function connectWorkerStream(options, ctx, state) {
       state.wsConnected = false;
       state.status = "worker Pi WebSocket disconnected";
       updatePiUi(ctx, state);
-      resolve20();
+      resolve21();
     };
   });
   try {
@@ -7544,11 +7547,11 @@ async function connectWorkerStream(options, ctx, state) {
 function createRemoteBashOperations(options, state, excludeFromContext) {
   return {
     exec(command, _cwd, execOptions) {
-      return new Promise((resolve20, reject) => {
+      return new Promise((resolve21, reject) => {
         const pending = {
           command,
           onData: execOptions.onData,
-          resolve: resolve20,
+          resolve: resolve21,
           reject,
           sawChunk: false
         };
@@ -8359,7 +8362,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 resolve20 } from "path";
+import { resolve as resolve21 } from "path";
 import { cancel as cancel4, confirm as confirm2, isCancel as isCancel4 } from "@clack/prompts";
 import {
   taskArtifactDir,
@@ -9068,7 +9071,7 @@ async function executeTask(context, args, options) {
       const fileFlag = takeOption(rest.slice(1), "--file");
       let content;
       if (fileFlag.value) {
-        content = readFileSync9(resolve20(context.projectRoot, fileFlag.value), "utf-8");
+        content = readFileSync9(resolve21(context.projectRoot, fileFlag.value), "utf-8");
       } else {
         content = await readStdin();
       }
@@ -9302,8 +9305,8 @@ async function executeTask(context, args, options) {
 
 // packages/cli/src/commands/task-run-driver.ts
 init_runner();
-import { copyFileSync as copyFileSync3, existsSync as existsSync12, mkdirSync as mkdirSync8, readFileSync as readFileSync10, statSync as statSync2, writeFileSync as writeFileSync6 } from "fs";
-import { resolve as resolve21 } from "path";
+import { copyFileSync as copyFileSync3, existsSync as existsSync13, mkdirSync as mkdirSync8, readFileSync as readFileSync10, statSync as statSync2, writeFileSync as writeFileSync6 } from "fs";
+import { resolve as resolve22 } 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";
@@ -9386,12 +9389,12 @@ function copyUntrackedDirtyFiles(sourceRoot, targetRoot) {
     return 0;
   let copied = 0;
   for (const relativePath of listed.stdout.split("\x00").filter(Boolean)) {
-    const sourcePath = resolve21(sourceRoot, relativePath);
-    const targetPath = resolve21(targetRoot, relativePath);
+    const sourcePath = resolve22(sourceRoot, relativePath);
+    const targetPath = resolve22(targetRoot, relativePath);
     try {
       if (!statSync2(sourcePath).isFile())
         continue;
-      mkdirSync8(resolve21(targetPath, ".."), { recursive: true });
+      mkdirSync8(resolve22(targetPath, ".."), { recursive: true });
       copyFileSync3(sourcePath, targetPath);
       copied += 1;
     } catch {}
@@ -9430,7 +9433,7 @@ function buildDirtyBaselineHandshakeEnv(input) {
     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")
+    RIG_DIRTY_BASELINE_READY_FILE: resolve22(input.projectRoot, ".rig", "runs", input.runId, "dirty-baseline.ready.json")
   };
 }
 function positiveInt(value, fallback) {
@@ -9541,9 +9544,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((resolve22) => {
-      child.once("error", (error) => resolve22({ exitCode: 1, stderr: error.message }));
-      child.once("close", (code) => resolve22({
+    return await new Promise((resolve23) => {
+      child.once("error", (error) => resolve23({ exitCode: 1, stderr: error.message }));
+      child.once("close", (code) => resolve23({
         exitCode: code ?? 1,
         stdout: Buffer.concat(stdoutChunks).toString("utf8"),
         stderr: Buffer.concat(stderrChunks).toString("utf8")
@@ -9617,7 +9620,7 @@ async function runTaskRunPostValidationLifecycle(input) {
     config,
     sourceTask: input.sourceTask,
     uploadedSnapshot: input.uploadedSnapshot,
-    artifactRoot: resolve21(input.projectRoot, "artifacts", taskId3),
+    artifactRoot: resolve22(input.projectRoot, "artifacts", taskId3),
     command: ghCommand,
     gitCommand,
     steerPi,
@@ -9747,7 +9750,7 @@ function summarizeValidationFailure(projectRoot, taskId3) {
     return null;
   }
   for (const artifactDir of resolveTaskArtifactDirs2(projectRoot, taskId3)) {
-    const summary = readJsonFile3(resolve21(artifactDir, "validation-summary.json"), null);
+    const summary = readJsonFile3(resolve22(artifactDir, "validation-summary.json"), null);
     if (!summary || summary.status !== "fail") {
       continue;
     }
@@ -9828,9 +9831,9 @@ function readTaskRunAcceptedArtifactState(input) {
   if (!input.taskId || !input.workspaceDir) {
     return { accepted: false, reason: null };
   }
-  const artifactDir = resolve21(input.workspaceDir, "artifacts", input.taskId);
-  const reviewStatusPath = resolve21(artifactDir, "review-status.txt");
-  const taskResultPath = resolve21(artifactDir, "task-result.json");
+  const artifactDir = resolve22(input.workspaceDir, "artifacts", input.taskId);
+  const reviewStatusPath = resolve22(artifactDir, "review-status.txt");
+  const taskResultPath = resolve22(artifactDir, "task-result.json");
   const reviewStatus = readTaskRunReviewStatus(reviewStatusPath);
   if (reviewStatus !== "APPROVED") {
     return { accepted: false, reason: null };
@@ -9867,12 +9870,12 @@ function resolveTaskRunRetryContext(input) {
   if (!input.taskId || !input.workspaceDir) {
     return { shouldRetry: false, failureDetail: null, nextPrompt: null };
   }
-  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 artifactDir = resolve22(input.workspaceDir, "artifacts", input.taskId);
+  const reviewStatePath = resolve22(artifactDir, "review-state.json");
+  const reviewFeedbackPath = resolve22(artifactDir, "review-feedback.md");
+  const reviewStatusPath = resolve22(artifactDir, "review-status.txt");
+  const failedApproachesPath = resolve22(input.workspaceDir, ".rig", "state", "failed_approaches.md");
+  const validationSummaryPath = resolve22(artifactDir, "validation-summary.json");
   const reviewState = readJsonFile3(reviewStatePath, null);
   const reviewStatus = readTaskRunReviewStatus(reviewStatusPath);
   const reviewRejected = isTaskRunReviewRejected(reviewState);
@@ -10058,7 +10061,7 @@ function appendToolTimelineFromLog(input) {
   });
 }
 function readTaskRunReviewStatus(reviewStatusPath) {
-  if (!existsSync12(reviewStatusPath)) {
+  if (!existsSync13(reviewStatusPath)) {
     return null;
   }
   try {
@@ -10276,15 +10279,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 = resolve21("artifacts", runtimeTaskId, "implementation-plan.md");
+  const planningArtifactPath = resolve22("artifacts", runtimeTaskId, "implementation-plan.md");
   const persistedPlanning = {
     ...planningClassification,
     classifier: input.runtimeAdapter === "pi" ? "pi-rig-structured-policy" : "rig-structured-policy",
     artifactPath: planningClassification.planningRequired ? planningArtifactPath : null,
     classifiedAt: new Date().toISOString()
   };
-  mkdirSync8(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)}
+  mkdirSync8(resolve22(context.projectRoot, ".rig", "runs", input.runId), { recursive: true });
+  writeFileSync6(resolve22(context.projectRoot, ".rig", "runs", input.runId, "planning-classification.json"), `${JSON.stringify(persistedPlanning, null, 2)}
 `, "utf8");
   patchAuthorityRun(context.projectRoot, input.runId, { planning: persistedPlanning });
   prompt = `${prompt}
@@ -10334,7 +10337,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" ? resolve21(existingRunRecord.sessionPath, "..") : null;
+  let latestSessionDir = resumeMode && typeof existingRunRecord?.sessionPath === "string" ? resolve22(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;
@@ -10420,10 +10423,10 @@ ${planningClassification.planningRequired ? `Before implementing, write a concis
       patchAuthorityRun(context.projectRoot, input.runId, {
         status: "running",
         worktreePath: latestRuntimeWorkspace,
-        artifactRoot: latestRuntimeWorkspace && input.taskId ? resolve21(latestRuntimeWorkspace, "artifacts", input.taskId) : null,
+        artifactRoot: latestRuntimeWorkspace && input.taskId ? resolve22(latestRuntimeWorkspace, "artifacts", input.taskId) : null,
         logRoot: latestLogsDir,
-        sessionPath: latestSessionDir ? resolve21(latestSessionDir, "session.json") : null,
-        sessionLogPath: latestLogsDir ? resolve21(latestLogsDir, "agent-stdout.log") : null,
+        sessionPath: latestSessionDir ? resolve22(latestSessionDir, "session.json") : null,
+        sessionLogPath: latestLogsDir ? resolve22(latestLogsDir, "agent-stdout.log") : null,
         branch: runtimeId
       });
       if (!dirtyBaselineApplied && input.baselineMode === "dirty-snapshot" && latestRuntimeWorkspace) {
@@ -10431,7 +10434,7 @@ ${planningClassification.planningRequired ? `Before implementing, write a concis
         const dirty = applyDirtyBaselineSnapshot({ sourceRoot: context.projectRoot, targetRoot: latestRuntimeWorkspace });
         const readyFile = childEnv.RIG_DIRTY_BASELINE_READY_FILE;
         if (readyFile) {
-          mkdirSync8(resolve21(readyFile, ".."), { recursive: true });
+          mkdirSync8(resolve22(readyFile, ".."), { recursive: true });
           writeFileSync6(readyFile, `${JSON.stringify({ ...dirty, workspaceDir: latestRuntimeWorkspace, appliedAt: new Date().toISOString() }, null, 2)}
 `, "utf8");
         }
@@ -10816,7 +10819,7 @@ ${planningClassification.planningRequired ? `Before implementing, write a concis
     let acceptedArtifactObservedAt = null;
     let acceptedArtifactPollTimer = null;
     let acceptedArtifactKillTimer = null;
-    const attemptExit = await new Promise((resolve22) => {
+    const attemptExit = await new Promise((resolve23) => {
       let settled = false;
       const settle = (result) => {
         if (settled)
@@ -10824,7 +10827,7 @@ ${planningClassification.planningRequired ? `Before implementing, write a concis
         settled = true;
         if (acceptedArtifactPollTimer)
           clearInterval(acceptedArtifactPollTimer);
-        resolve22(result);
+        resolve23(result);
       };
       const pollAcceptedArtifacts = () => {
         const artifactState = readTaskRunAcceptedArtifactState({
@@ -11026,8 +11029,8 @@ Failed to update task source for ${input.taskId ?? runtimeTaskId} to failed: ${e
   }
   if (planningClassification.planningRequired) {
     const planWorkspace = latestRuntimeWorkspace ?? context.projectRoot;
-    const expectedPlanPath = resolve21(planWorkspace, planningArtifactPath);
-    if (!existsSync12(expectedPlanPath)) {
+    const expectedPlanPath = resolve22(planWorkspace, planningArtifactPath);
+    if (!existsSync13(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, {
@@ -11197,9 +11200,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((resolve22) => {
-      child.once("error", () => resolve22(1));
-      child.once("close", (code) => resolve22(code ?? 1));
+    const exitCode = await new Promise((resolve23) => {
+      child.once("error", () => resolve23(1));
+      child.once("close", (code) => resolve23(code ?? 1));
     });
     for (const pendingLog of flushPendingClaudeToolUseLogs({
       runId: input.runId,
@@ -11341,8 +11344,8 @@ async function executeTest(context, args) {
 
 // packages/cli/src/commands/setup.ts
 init_runner();
-import { existsSync as existsSync13, mkdirSync as mkdirSync9, readdirSync as readdirSync2, writeFileSync as writeFileSync7 } from "fs";
-import { resolve as resolve22 } from "path";
+import { existsSync as existsSync14, mkdirSync as mkdirSync9, readdirSync as readdirSync2, writeFileSync as writeFileSync7 } from "fs";
+import { resolve as resolve23 } from "path";
 import { createPluginHost } from "@rig/core";
 import {
   isSupportedBunVersion as isSupportedBunVersion2,
@@ -11400,8 +11403,8 @@ function runSetupInit(projectRoot) {
   mkdirSync9(stateDir, { recursive: true });
   mkdirSync9(logsDir, { recursive: true });
   mkdirSync9(artifactsDir, { recursive: true });
-  const failuresPath = resolve22(stateDir, "failed_approaches.md");
-  if (!existsSync13(failuresPath)) {
+  const failuresPath = resolve23(stateDir, "failed_approaches.md");
+  if (!existsSync14(failuresPath)) {
     writeFileSync7(failuresPath, `# Failed Approaches
 
 `, "utf-8");
@@ -11419,18 +11422,18 @@ async function runSetupCheck(projectRoot) {
 }
 async function runSetupPreflight(projectRoot) {
   await runSetupCheck(projectRoot);
-  const validationRoot = resolve22(resolveControlPlaneDefinitionRoot(projectRoot), "validation");
-  if (existsSync13(validationRoot)) {
+  const validationRoot = resolve23(resolveControlPlaneDefinitionRoot(projectRoot), "validation");
+  if (existsSync14(validationRoot)) {
     const validators = readdirSync2(validationRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory());
     for (const validator of validators) {
-      const script = resolve22(validationRoot, validator.name, "validate.sh");
-      if (existsSync13(script)) {
+      const script = resolve23(validationRoot, validator.name, "validate.sh");
+      if (existsSync14(script)) {
         console.log(`OK: validator script ${script}`);
       }
     }
   }
-  const hooksRoot = resolve22(resolveControlPlaneDefinitionRoot(projectRoot), "hooks");
-  if (existsSync13(hooksRoot)) {
+  const hooksRoot = resolve23(resolveControlPlaneDefinitionRoot(projectRoot), "hooks");
+  if (existsSync14(hooksRoot)) {
     const hooks = readdirSync2(hooksRoot).filter((name) => name.endsWith(".sh"));
     for (const hook of hooks) {
       console.log(`OK: hook ${hook}`);
@@ -11575,7 +11578,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) => existsSync14(resolve23(projectRoot, name))) || existsSync14(resolve23(projectRoot, ".rig"));
+  return RIG_CONFIG_FILENAMES.some((name) => existsSync15(resolve24(projectRoot, name))) || existsSync15(resolve24(projectRoot, ".rig"));
 }
 function requireInitializedRigProject(context, group) {
   if (hasInitializedRigProject(context.projectRoot)) {
@@ -11790,8 +11793,8 @@ var __testOnly = {
   validateRequiredBugPromptValue
 };
 // packages/cli/src/launcher.ts
-import { existsSync as existsSync15 } from "fs";
-import { basename as basename2, resolve as resolve24 } from "path";
+import { existsSync as existsSync16 } from "fs";
+import { basename as basename2, resolve as resolve25 } from "path";
 import { loadDotEnvSecrets } from "@rig/runtime/baked-secrets";
 import { RIG_DEFINITION_DIRNAME, RIG_STATE_DIRNAME, resolveNearestRigProjectRoot } from "@rig/runtime/layout";
 function parsePolicyMode(value) {
@@ -11804,7 +11807,7 @@ function parsePolicyMode(value) {
   throw new Error(`Invalid --policy-mode value: ${value}. Use off|observe|enforce.`);
 }
 function hasRigProjectMarker(candidate) {
-  return existsSync15(resolve24(candidate, RIG_DEFINITION_DIRNAME)) || existsSync15(resolve24(candidate, RIG_STATE_DIRNAME)) || existsSync15(resolve24(candidate, "rig.config.ts")) || existsSync15(resolve24(candidate, "rig.config.json")) || existsSync15(resolve24(candidate, ".git"));
+  return existsSync16(resolve25(candidate, RIG_DEFINITION_DIRNAME)) || existsSync16(resolve25(candidate, RIG_STATE_DIRNAME)) || existsSync16(resolve25(candidate, "rig.config.ts")) || existsSync16(resolve25(candidate, "rig.config.json")) || existsSync16(resolve25(candidate, ".git"));
 }
 function resolveProjectRoot({
   envProjectRoot,
@@ -11813,19 +11816,19 @@ function resolveProjectRoot({
   cwd = process.cwd()
 }) {
   if (envProjectRoot) {
-    return resolve24(cwd, envProjectRoot);
+    return resolve25(cwd, envProjectRoot);
   }
   const fallbackImportDir = importDir ?? cwd;
   const execName = basename2(execPath).toLowerCase();
-  const execCandidates = execName === "rig" || execName === "rig.exe" ? [resolve24(execPath, "..", "..")] : [];
-  const candidates = [cwd, ...execCandidates, resolve24(fallbackImportDir, "..")];
+  const execCandidates = execName === "rig" || execName === "rig.exe" ? [resolve25(execPath, "..", "..")] : [];
+  const candidates = [cwd, ...execCandidates, resolve25(fallbackImportDir, "..")];
   for (const candidate of candidates) {
     const nearest = resolveNearestRigProjectRoot(candidate);
     if (hasRigProjectMarker(nearest)) {
       return nearest;
     }
   }
-  return resolve24(cwd);
+  return resolve25(cwd);
 }
 function normalizeCliErrorCode(message2, isCliError) {
   if (message2.startsWith("Invalid --policy-mode value:")) {
@@ -11892,7 +11895,7 @@ async function runRigCli(module, options = {}) {
         runId: context.runId,
         outcome,
         eventsFile: context.eventBus.getEventsFile(),
-        policyFile: resolve24(projectRoot, "rig", "policy", "policy.json"),
+        policyFile: resolve25(projectRoot, "rig", "policy", "policy.json"),
         policyMode: context.policyMode ?? policyMode ?? module.loadPolicy(projectRoot).mode
       }, null, 2));
     }