@h-rig/cli 0.0.6-alpha.27 → 0.0.6-alpha.280

package/dist/src/commands/connect.js

@@ -1,288 +0,0 @@
-// @bun
-// packages/cli/src/commands/connect.ts
-import { cancel, isCancel, select } from "@clack/prompts";
-
-// packages/cli/src/runner.ts
-import { EventBus } from "@rig/runtime/control-plane/runtime/events";
-import { CliError } from "@rig/runtime/control-plane/errors";
-import { evaluate, loadPolicy, resolveAction } from "@rig/runtime/control-plane/runtime/guard";
-import { PluginManager } from "@rig/runtime/control-plane/runtime/plugins";
-import { loadRuntimeContextFromEnv } from "@rig/runtime/control-plane/runtime/context";
-import { buildBinary } from "@rig/runtime/control-plane/runtime/isolation";
-import { CliError as CliError2 } from "@rig/runtime/control-plane/errors";
-function requireNoExtraArgs(args, usage) {
-  if (args.length > 0) {
-    throw new CliError(`Unexpected arguments: ${args.join(" ")}
-Usage: ${usage}`);
-  }
-}
-
-// packages/cli/src/commands/_connection-state.ts
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { homedir } from "os";
-import { dirname, resolve } from "path";
-function resolveGlobalConnectionsPath(env = process.env) {
-  const explicit = env.RIG_CONNECTIONS_FILE?.trim();
-  if (explicit)
-    return resolve(explicit);
-  const stateDir = env.RIG_GLOBAL_STATE_DIR?.trim();
-  if (stateDir)
-    return resolve(stateDir, "connections.json");
-  return resolve(homedir(), ".rig", "connections.json");
-}
-function resolveRepoConnectionPath(projectRoot) {
-  return resolve(projectRoot, ".rig", "state", "connection.json");
-}
-function readJsonFile(path) {
-  if (!existsSync(path))
-    return null;
-  try {
-    return JSON.parse(readFileSync(path, "utf8"));
-  } catch (error) {
-    throw new CliError2(`Invalid Rig connection state at ${path}: ${error instanceof Error ? error.message : String(error)}`, 1);
-  }
-}
-function writeJsonFile(path, value) {
-  mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, `${JSON.stringify(value, null, 2)}
-`, "utf8");
-}
-function normalizeConnection(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value))
-    return null;
-  const record = value;
-  if (record.kind === "local")
-    return { kind: "local", mode: "auto" };
-  if (record.kind === "remote" && typeof record.baseUrl === "string" && record.baseUrl.trim()) {
-    const baseUrl = record.baseUrl.trim().replace(/\/+$/, "");
-    return { kind: "remote", baseUrl };
-  }
-  return null;
-}
-function readGlobalConnections(options = {}) {
-  const path = resolveGlobalConnectionsPath(options.env ?? process.env);
-  const payload = readJsonFile(path);
-  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
-    return { connections: {} };
-  }
-  const rawConnections = payload.connections;
-  const connections = {};
-  if (rawConnections && typeof rawConnections === "object" && !Array.isArray(rawConnections)) {
-    for (const [alias, raw] of Object.entries(rawConnections)) {
-      const connection = normalizeConnection(raw);
-      if (connection)
-        connections[alias] = connection;
-    }
-  }
-  return { connections };
-}
-function writeGlobalConnections(state, options = {}) {
-  writeJsonFile(resolveGlobalConnectionsPath(options.env ?? process.env), state);
-}
-function upsertGlobalConnection(alias, connection, options = {}) {
-  const cleanAlias = alias.trim();
-  if (!cleanAlias)
-    throw new CliError2("Connection alias is required.", 1);
-  const state = readGlobalConnections(options);
-  state.connections[cleanAlias] = connection;
-  writeGlobalConnections(state, options);
-  return state;
-}
-function readRepoConnection(projectRoot) {
-  const payload = readJsonFile(resolveRepoConnectionPath(projectRoot));
-  if (!payload || typeof payload !== "object" || Array.isArray(payload))
-    return null;
-  const record = payload;
-  const selected = typeof record.selected === "string" ? record.selected.trim() : "";
-  if (!selected)
-    return null;
-  return {
-    selected,
-    project: typeof record.project === "string" ? record.project : undefined,
-    linkedAt: typeof record.linkedAt === "string" ? record.linkedAt : undefined
-  };
-}
-function writeRepoConnection(projectRoot, state) {
-  writeJsonFile(resolveRepoConnectionPath(projectRoot), state);
-}
-
-// packages/cli/src/commands/_cli-format.ts
-import pc from "picocolors";
-function truncate(value, width) {
-  if (value.length <= width)
-    return value;
-  if (width <= 1)
-    return "\u2026";
-  return `${value.slice(0, width - 1)}\u2026`;
-}
-function pad(value, width) {
-  return value.length >= width ? value : `${value}${" ".repeat(width - value.length)}`;
-}
-function statusColor(status) {
-  const normalized = status.toLowerCase();
-  if (["completed", "merged", "closed", "done", "accepted", "pass", "selected"].includes(normalized))
-    return pc.green;
-  if (["failed", "needs_attention", "needs-attention", "blocked", "error"].includes(normalized))
-    return pc.red;
-  if (["running", "reviewing", "validating", "in_progress", "in-progress", "remote"].includes(normalized))
-    return pc.cyan;
-  if (["ready", "open", "queued", "created", "preparing", "local"].includes(normalized))
-    return pc.yellow;
-  return pc.dim;
-}
-function formatStatusPill(status) {
-  const label = status || "unknown";
-  return statusColor(label)(`\u25CF ${label}`);
-}
-function formatSection(title, subtitle) {
-  return `${pc.bold(pc.cyan("\u25C6"))} ${pc.bold(title)}${subtitle ? pc.dim(` \u2014 ${subtitle}`) : ""}`;
-}
-function formatSuccessCard(title, rows = []) {
-  const body = rows.filter(([, value]) => value !== undefined && value !== null && String(value).length > 0).map(([key, value]) => `${pc.dim("\u2502")} ${pc.dim(key.padEnd(9))} ${value}`);
-  return [formatSection(title), ...body].join(`
-`);
-}
-function formatNextSteps(steps) {
-  if (steps.length === 0)
-    return [];
-  return [pc.bold("Next"), ...steps.map((step) => `${pc.dim("\u203A")} ${step}`)];
-}
-function formatConnectionList(connections) {
-  const rows = [["local", { kind: "local", mode: "auto" }], ...Object.entries(connections)];
-  const aliasWidth = Math.min(24, Math.max(5, ...rows.map(([alias]) => alias.length)));
-  const lines = rows.map(([alias, connection]) => [
-    pc.bold(pad(truncate(alias, aliasWidth), aliasWidth)),
-    formatStatusPill(connection.kind),
-    connection.kind === "remote" ? connection.baseUrl ?? "" : connection.mode ?? "local"
-  ].join("  "));
-  return [formatSection("Rig servers", `${rows.length} available`), `${pc.bold(pad("ALIAS", aliasWidth))}  ${pc.bold("KIND")}  ${pc.bold("TARGET")}`, ...lines, "", ...formatNextSteps(["Select one: `rig server use <alias|local>`"])].join(`
-`);
-}
-function formatConnectionStatus(selected, connections) {
-  const connection = selected === "local" ? { kind: "local", mode: "auto" } : connections[selected];
-  const target = !connection ? "not configured" : connection.kind === "remote" ? connection.baseUrl : "local";
-  return [
-    formatSection("Rig server", "selected for this repo"),
-    `${pc.dim("\u2502")} ${pc.dim("selected ")} ${pc.bold(selected)}`,
-    `${pc.dim("\u2502")} ${pc.dim("kind     ")} ${formatStatusPill(connection?.kind ?? "unknown")}`,
-    `${pc.dim("\u2502")} ${pc.dim("target   ")} ${target ?? "not configured"}`,
-    "",
-    ...formatNextSteps(["Change: `rig server use <alias|local>`", "List saved servers: `rig server list`"])
-  ].join(`
-`);
-}
-
-// packages/cli/src/commands/connect.ts
-function usageName(options) {
-  return `rig ${options.group}`;
-}
-function parseConnection(alias, value, options) {
-  if (alias === "local" && !value)
-    return { kind: "local", mode: "auto" };
-  if (!value)
-    throw new CliError2(`Missing remote server URL. Usage: ${usageName(options)} add <alias> <url>`, 1);
-  let parsed;
-  try {
-    parsed = new URL(value);
-  } catch {
-    throw new CliError2(`Invalid Rig server URL: ${value}`, 1);
-  }
-  if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
-    throw new CliError2("Rig remote server URL must be http(s).", 1);
-  }
-  return { kind: "remote", baseUrl: parsed.toString().replace(/\/+$/, "") };
-}
-function printJsonOrText(context, payload, text) {
-  if (context.outputMode === "json") {
-    console.log(JSON.stringify(payload, null, 2));
-  } else {
-    console.log(text);
-  }
-}
-async function promptForConnectionAlias(context) {
-  const state = readGlobalConnections();
-  const repo = readRepoConnection(context.projectRoot);
-  const options = [
-    { value: "local", label: "local", hint: "Use/start a local Rig server" },
-    ...Object.entries(state.connections).map(([alias, connection]) => ({
-      value: alias,
-      label: alias,
-      hint: connection.kind === "remote" ? connection.baseUrl : "local"
-    }))
-  ].filter((option, index, all) => all.findIndex((candidate) => candidate.value === option.value) === index);
-  const answer = await select({
-    message: "Select Rig server for this repo",
-    initialValue: repo?.selected ?? "local",
-    options
-  });
-  if (isCancel(answer)) {
-    cancel("No server selected.");
-    throw new CliError2("No server selected.", 3);
-  }
-  return String(answer);
-}
-async function executeConnectionCommand(context, args, options) {
-  const [command, ...rest] = args;
-  switch (command ?? "status") {
-    case "list": {
-      requireNoExtraArgs(rest, `${usageName(options)} list`);
-      const state = readGlobalConnections();
-      printJsonOrText(context, state, formatConnectionList(state.connections));
-      return { ok: true, group: options.group, command: "list", details: state };
-    }
-    case "add": {
-      const [alias, url, ...extra] = rest;
-      if (!alias)
-        throw new CliError2(`Missing alias. Usage: ${usageName(options)} add <alias> <url>`, 1);
-      requireNoExtraArgs(extra, `${usageName(options)} add <alias> <url>`);
-      const connection = parseConnection(alias, url, options);
-      const state = upsertGlobalConnection(alias, connection);
-      printJsonOrText(context, { alias, connection }, formatSuccessCard("Rig server saved", [
-        ["alias", alias],
-        ["target", connection.kind === "remote" ? connection.baseUrl : "local"],
-        ["next", `${usageName(options)} use ${alias}`]
-      ]));
-      return { ok: true, group: options.group, command: "add", details: { alias, connection, count: Object.keys(state.connections).length } };
-    }
-    case "use": {
-      let [alias, ...extra] = rest;
-      requireNoExtraArgs(extra, `${usageName(options)} use <alias|local>`);
-      if (!alias && options.interactiveUse && context.outputMode === "text" && process.stdin.isTTY) {
-        alias = await promptForConnectionAlias(context);
-      }
-      if (!alias)
-        throw new CliError2(`Missing alias. Usage: ${usageName(options)} use <alias|local>`, 1);
-      if (alias !== "local") {
-        const state = readGlobalConnections();
-        if (!state.connections[alias])
-          throw new CliError2(`Unknown Rig server: ${alias}`, 1);
-      }
-      const repoState = { selected: alias, linkedAt: new Date().toISOString() };
-      writeRepoConnection(context.projectRoot, repoState);
-      printJsonOrText(context, repoState, formatSuccessCard("Rig server selected", [
-        ["selected", alias],
-        ["scope", "this repo"],
-        ["next", "rig task list"]
-      ]));
-      return { ok: true, group: options.group, command: "use", details: repoState };
-    }
-    case "status": {
-      requireNoExtraArgs(rest, `${usageName(options)} status`);
-      const repo = readRepoConnection(context.projectRoot);
-      const global = readGlobalConnections();
-      const details = { selected: repo?.selected ?? "local", repo, connections: global.connections };
-      printJsonOrText(context, details, formatConnectionStatus(details.selected, global.connections));
-      return { ok: true, group: options.group, command: "status", details };
-    }
-    default:
-      throw new CliError2(`Unknown ${options.group} command: ${String(command)}
-Usage: ${usageName(options)} <list|add|use|status>`, 1);
-  }
-}
-async function executeConnect(context, args) {
-  return executeConnectionCommand(context, args, { group: "connect" });
-}
-export {
-  executeConnectionCommand,
-  executeConnect
-};

package/dist/src/commands/dist.js

@@ -1,402 +0,0 @@
-// @bun
-// packages/cli/src/commands/dist.ts
-import {
-  chmodSync,
-  copyFileSync,
-  existsSync,
-  mkdirSync,
-  readdirSync,
-  readlinkSync,
-  rmSync,
-  statSync,
-  symlinkSync,
-  unlinkSync
-} from "fs";
-import { homedir as homedir2 } from "os";
-import { resolve as resolve3 } from "path";
-
-// packages/cli/src/runner.ts
-import { EventBus } from "@rig/runtime/control-plane/runtime/events";
-import { CliError } from "@rig/runtime/control-plane/errors";
-import { evaluate, loadPolicy, resolveAction } from "@rig/runtime/control-plane/runtime/guard";
-import { PluginManager } from "@rig/runtime/control-plane/runtime/plugins";
-import { loadRuntimeContextFromEnv } from "@rig/runtime/control-plane/runtime/context";
-import { buildBinary } from "@rig/runtime/control-plane/runtime/isolation";
-import { CliError as CliError2 } from "@rig/runtime/control-plane/errors";
-function takeOption(args, option) {
-  const rest = [];
-  let value;
-  for (let index = 0;index < args.length; index += 1) {
-    const current = args[index];
-    if (current === option) {
-      const next = args[index + 1];
-      if (!next || next.startsWith("-")) {
-        throw new CliError(`Missing value for ${option}`);
-      }
-      value = next;
-      index += 1;
-      continue;
-    }
-    if (current !== undefined) {
-      rest.push(current);
-    }
-  }
-  return { value, rest };
-}
-function requireNoExtraArgs(args, usage) {
-  if (args.length > 0) {
-    throw new CliError(`Unexpected arguments: ${args.join(" ")}
-Usage: ${usage}`);
-  }
-}
-
-// packages/cli/src/commands/dist.ts
-import { buildBinary as buildBinary2 } from "@rig/runtime/control-plane/runtime/isolation";
-import {
-  computeRuntimeImageFingerprint,
-  computeRuntimeImageId
-} from "@rig/runtime/control-plane/runtime/image/index";
-
-// packages/cli/src/commands/_parsers.ts
-import { homedir } from "os";
-import { resolve } from "path";
-function parseInstallScope(value) {
-  if (!value || value === "user") {
-    return "user";
-  }
-  if (value === "system") {
-    return "system";
-  }
-  throw new CliError2(`Invalid --scope value: ${value}. Use user|system.`);
-}
-function resolveInstallDir(scope, explicitPath) {
-  if (explicitPath) {
-    return resolve(explicitPath);
-  }
-  if (scope === "system") {
-    return "/usr/local/bin";
-  }
-  return resolve(homedir(), ".local/bin");
-}
-
-// packages/cli/src/commands/_paths.ts
-import { resolve as resolve2 } from "path";
-import { resolveMonorepoRoot } from "@rig/runtime/control-plane/native/utils";
-function resolveControlPlaneMonorepoRoot(projectRoot) {
-  return resolveMonorepoRoot(projectRoot);
-}
-function resolveControlPlaneHostStateRoot(projectRoot) {
-  return resolve2(projectRoot, ".rig");
-}
-function resolveControlPlaneHostBinDir(projectRoot) {
-  return resolve2(resolveControlPlaneHostStateRoot(projectRoot), "bin");
-}
-function resolveControlPlaneHostDistDir(projectRoot) {
-  return resolve2(resolveControlPlaneHostStateRoot(projectRoot), "dist");
-}
-function resolveControlPlaneMonorepoStateRoot(projectRoot) {
-  return resolve2(resolveControlPlaneMonorepoRoot(projectRoot), ".rig");
-}
-function resolveControlPlaneMonorepoRuntimeDir(projectRoot) {
-  return resolve2(resolveControlPlaneMonorepoStateRoot(projectRoot), "runtime");
-}
-
-// packages/cli/src/commands/_probes.ts
-async function runQuietBinaryProbe(binaryPath, args, cwd) {
-  try {
-    const run = await Bun.$`${binaryPath} ${args}`.cwd(cwd).quiet().nothrow();
-    return run.exitCode === 0;
-  } catch {
-    return false;
-  }
-}
-
-// packages/cli/src/commands/dist.ts
-function collectRigValidatorBuildTargets(input) {
-  const validatorsRoot = resolve3(input.hostProjectRoot, "packages/runtime/src/control-plane/validators");
-  if (!existsSync(validatorsRoot))
-    return [];
-  const targets = [];
-  const categories = readdirSync(validatorsRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory());
-  for (const category of categories) {
-    const categoryDir = resolve3(validatorsRoot, category.name);
-    for (const entry of readdirSync(categoryDir, { withFileTypes: true })) {
-      if (!entry.isFile() || !entry.name.endsWith(".ts"))
-        continue;
-      const check = entry.name.replace(/\.ts$/, "");
-      if (!check || check === "index" || check === "shared")
-        continue;
-      targets.push({
-        source: `packages/runtime/src/control-plane/validators/${category.name}/${entry.name}`,
-        dest: resolve3(input.imageDir, `bin/validators/${category.name}-${check}`),
-        cwd: input.hostProjectRoot
-      });
-    }
-  }
-  return targets;
-}
-async function findLatestDistBinary(projectRoot) {
-  const distRoot = resolveControlPlaneHostDistDir(projectRoot);
-  if (!existsSync(distRoot)) {
-    return null;
-  }
-  const entries = readdirSync(distRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name.startsWith("rig-")).map((entry) => ({
-    name: entry.name,
-    mtimeMs: statSync(resolve3(distRoot, entry.name)).mtimeMs
-  })).sort((a, b) => b.mtimeMs - a.mtimeMs || b.name.localeCompare(a.name));
-  for (const { name } of entries) {
-    const candidate = resolve3(distRoot, name, "bin", "rig");
-    if (existsSync(candidate) && await isRunnableRigBinary(candidate, projectRoot)) {
-      return candidate;
-    }
-  }
-  return null;
-}
-async function isRunnableRigBinary(binaryPath, projectRoot) {
-  return runQuietBinaryProbe(binaryPath, ["help"], projectRoot);
-}
-async function runDistDoctor(projectRoot) {
-  const bunPath = Bun.which("bun");
-  const rigPath = Bun.which("rig");
-  const userBinDir = resolve3(homedir2(), ".local/bin");
-  const userBinInPath = (process.env.PATH || "").split(":").filter(Boolean).includes(userBinDir);
-  let rigRunnable = false;
-  if (rigPath) {
-    rigRunnable = await runQuietBinaryProbe(rigPath, ["help"], projectRoot);
-  }
-  return {
-    bun: {
-      available: Boolean(bunPath),
-      path: bunPath || null,
-      version: Bun.version
-    },
-    rig: {
-      onPath: Boolean(rigPath),
-      path: rigPath || null,
-      runnable: rigRunnable
-    },
-    userBinDir,
-    userBinInPath,
-    latestDistBinary: await findLatestDistBinary(projectRoot)
-  };
-}
-async function executeDist(context, args) {
-  const [command = "build", ...rest] = args;
-  switch (command) {
-    case "build": {
-      const { value: outputDir, rest: pending } = takeOption(rest, "--output-dir");
-      requireNoExtraArgs(pending, "bun run rig dist build [--output-dir <dir>]");
-      const commandParts = ["bun", "run", "packages/cli/bin/build-rig-binaries.ts"];
-      if (outputDir) {
-        commandParts.push("--output-dir", outputDir);
-      }
-      await context.runCommand(commandParts);
-      return { ok: true, group: "dist", command, details: { outputDir: outputDir || null } };
-    }
-    case "install": {
-      let pending = rest;
-      const scopeResult = takeOption(pending, "--scope");
-      pending = scopeResult.rest;
-      const pathResult = takeOption(pending, "--path");
-      pending = pathResult.rest;
-      requireNoExtraArgs(pending, "bun run rig dist install [--scope user|system] [--path <dir>]");
-      const scope = parseInstallScope(scopeResult.value);
-      const installDir = resolveInstallDir(scope, pathResult.value);
-      mkdirSync(installDir, { recursive: true });
-      let source = await findLatestDistBinary(context.projectRoot);
-      let buildDir = null;
-      if (!source) {
-        buildDir = resolve3(resolveControlPlaneHostDistDir(context.projectRoot), `rig-install-${Date.now()}`);
-        await context.runCommand(["bun", "run", "packages/cli/bin/build-rig-binaries.ts", "--output-dir", buildDir]);
-        source = resolve3(buildDir, "bin", "rig");
-      }
-      if (!existsSync(source)) {
-        throw new CliError2(`Unable to locate rig binary at ${source}.`, 2);
-      }
-      const installedPath = resolve3(installDir, "rig");
-      if (existsSync(installedPath)) {
-        unlinkSync(installedPath);
-      }
-      copyFileSync(source, installedPath);
-      chmodSync(installedPath, 493);
-      const pathEntries = (process.env.PATH || "").split(":").filter(Boolean);
-      const inPath = pathEntries.includes(installDir);
-      if (context.outputMode === "text") {
-        console.log(`Installed: ${installedPath}`);
-        if (!inPath) {
-          console.log(`PATH note: add ${installDir} to PATH to run 'rig' directly.`);
-        }
-      }
-      return {
-        ok: true,
-        group: "dist",
-        command,
-        details: {
-          scope,
-          installDir,
-          installedPath,
-          sourcePath: source,
-          builtNow: Boolean(buildDir),
-          inPath
-        }
-      };
-    }
-    case "doctor": {
-      requireNoExtraArgs(rest, "bun run rig dist doctor");
-      const details = await runDistDoctor(context.projectRoot);
-      if (context.outputMode === "text") {
-        console.log(`bun: ${details.bun.available ? `ok (${details.bun.version})` : "missing"}`);
-        console.log(`rig on PATH: ${details.rig.onPath ? details.rig.path : "missing"}`);
-        console.log(`user bin dir: ${details.userBinDir} (${details.userBinInPath ? "in PATH" : "not in PATH"})`);
-        console.log(`latest dist binary: ${details.latestDistBinary || "none"}`);
-      }
-      return { ok: true, group: "dist", command, details };
-    }
-    case "rebuild-agent": {
-      requireNoExtraArgs(rest, "bun run rig dist rebuild-agent");
-      const fp = await computeRuntimeImageFingerprint(context.projectRoot);
-      const currentId = computeRuntimeImageId(fp);
-      const imagesDir = resolve3(resolveControlPlaneMonorepoRuntimeDir(context.projectRoot), "images");
-      mkdirSync(imagesDir, { recursive: true });
-      let pruned = 0;
-      for (const entry of readdirSync(imagesDir, { withFileTypes: true })) {
-        if (entry.isDirectory() && entry.name !== currentId) {
-          rmSync(resolve3(imagesDir, entry.name), { recursive: true, force: true });
-          pruned++;
-        }
-      }
-      if (pruned > 0 && context.outputMode === "text") {
-        console.log(`Pruned ${pruned} stale image(s).`);
-      }
-      const imageDir = resolve3(imagesDir, currentId);
-      mkdirSync(resolve3(imageDir, "bin/hooks"), { recursive: true });
-      mkdirSync(resolve3(imageDir, "bin/plugins"), { recursive: true });
-      mkdirSync(resolve3(imageDir, "bin/validators"), { recursive: true });
-      const hookNames = [
-        "scope-guard",
-        "import-guard",
-        "safety-guard",
-        "test-integrity-guard",
-        "audit-trail",
-        "post-edit-lint",
-        "completion-verification",
-        "inject-context",
-        "task-runtime-start"
-      ];
-      const targets = [];
-      const hostProjectRoot = process.env.RIG_HOST_PROJECT_ROOT?.trim() || context.projectRoot;
-      targets.push({ source: "packages/runtime/bin/rig-agent.ts", dest: resolve3(imageDir, "bin/rig-agent"), cwd: hostProjectRoot });
-      targets.push({ source: "packages/runtime/bin/rig-agent-dispatch.ts", dest: resolve3(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: resolve3(imageDir, `bin/hooks/${hookName}`), cwd: hostProjectRoot });
-        targets.push({ source: src, dest: resolve3(resolveControlPlaneHostBinDir(context.projectRoot), `hooks/${hookName}`), cwd: hostProjectRoot });
-      }
-      const pluginsDir = resolve3(context.projectRoot, "rig/plugins");
-      const binPluginsDir = resolve3(resolveControlPlaneHostBinDir(context.projectRoot), "plugins");
-      const validatorsRoot = resolve3(hostProjectRoot, "packages/runtime/src/control-plane/validators");
-      const binValidatorsDir = resolve3(resolveControlPlaneHostBinDir(context.projectRoot), "validators");
-      mkdirSync(binPluginsDir, { recursive: true });
-      mkdirSync(binValidatorsDir, { recursive: true });
-      if (existsSync(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: resolve3(imageDir, `bin/plugins/${m[1]}`), cwd: context.projectRoot });
-        }
-      }
-      targets.push(...collectRigValidatorBuildTargets({ contextProjectRoot: context.projectRoot, hostProjectRoot, imageDir }));
-      for (const { source, dest, cwd } of targets) {
-        if (context.outputMode === "text") {
-          console.log(`Building: ${dest}`);
-        }
-        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 (existsSync(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 = resolve3(imageDir, `bin/plugins/${pluginName}`);
-          if (!pluginName)
-            continue;
-          const symlinkPath = resolve3(binPluginsDir, pluginName);
-          if (existsSync(imageBin)) {
-            try {
-              unlinkSync(symlinkPath);
-            } catch {}
-            symlinkSync(imageBin, symlinkPath);
-          }
-        }
-      }
-      if (existsSync(validatorsRoot)) {
-        const categories = readdirSync(validatorsRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory());
-        for (const category of categories) {
-          const categoryDir = resolve3(validatorsRoot, category.name);
-          for (const entry of readdirSync(categoryDir, { withFileTypes: true })) {
-            if (!entry.isFile() || !entry.name.endsWith(".ts"))
-              continue;
-            const check = entry.name.replace(/\.ts$/, "");
-            if (!check || check === "index" || check === "shared")
-              continue;
-            const validatorName = `${category.name}-${check}`;
-            const imageBin = resolve3(imageDir, `bin/validators/${validatorName}`);
-            const symlinkPath = resolve3(binValidatorsDir, validatorName);
-            if (existsSync(imageBin)) {
-              try {
-                unlinkSync(symlinkPath);
-              } catch {}
-              symlinkSync(imageBin, symlinkPath);
-            }
-          }
-        }
-      }
-      const agentsDir = resolve3(resolveControlPlaneMonorepoRuntimeDir(context.projectRoot), "agents");
-      if (existsSync(agentsDir)) {
-        let relinkCount = 0;
-        for (const agentEntry of readdirSync(agentsDir, { withFileTypes: true })) {
-          if (!agentEntry.isDirectory())
-            continue;
-          const agentBinDir = resolve3(agentsDir, agentEntry.name, "worktree", ".rig", "bin");
-          if (!existsSync(agentBinDir))
-            continue;
-          const walkDir = (dir) => {
-            for (const entry of readdirSync(dir, { withFileTypes: true })) {
-              const fullPath = resolve3(dir, entry.name);
-              if (entry.isDirectory()) {
-                walkDir(fullPath);
-              } else if (entry.isSymbolicLink()) {
-                const target = readlinkSync(fullPath);
-                if (target.includes("/.rig/runtime/images/") && !target.includes(`/${currentId}/`)) {
-                  const newTarget = target.replace(/\/\.rig\/runtime\/images\/[^/]+\//, `/.rig/runtime/images/${currentId}/`);
-                  try {
-                    unlinkSync(fullPath);
-                    symlinkSync(newTarget, fullPath);
-                    relinkCount++;
-                  } catch {}
-                }
-              }
-            }
-          };
-          walkDir(agentBinDir);
-        }
-        if (relinkCount > 0 && context.outputMode === "text") {
-          console.log(`Re-linked ${relinkCount} worktree symlink(s) to image ${currentId}.`);
-        }
-      }
-      if (context.outputMode === "text") {
-        console.log(`Rebuilt ${targets.length} binaries into image ${currentId}.`);
-      }
-      return { ok: true, group: "dist", command, details: { imageId: currentId, count: targets.length } };
-    }
-    default:
-      throw new CliError2(`Unknown dist command: ${command}`);
-  }
-}
-export {
-  executeDist,
-  collectRigValidatorBuildTargets
-};