@h-rig/cli 0.0.6-alpha.77 → 0.0.6-alpha.79

package/dist/src/commands/_connection-state.d.ts

@@ -0,0 +1,44 @@
+export type RigConnection = {
+    kind: "local";
+    mode: "auto";
+} | {
+    kind: "remote";
+    baseUrl: string;
+};
+export type GlobalConnectionState = {
+    connections: Record<string, RigConnection>;
+};
+export type RepoConnectionState = {
+    selected: string;
+    project?: string;
+    linkedAt?: string;
+    /**
+     * The server-host project root this repo scopes to (multi-root serving).
+     * Sent as the x-rig-project-root header on every remote request.
+     */
+    serverProjectRoot?: string;
+};
+export declare function resolveGlobalConnectionsPath(env?: NodeJS.ProcessEnv): string;
+export declare function resolveRepoConnectionPath(projectRoot: string): string;
+export declare function readGlobalConnections(options?: {
+    env?: NodeJS.ProcessEnv;
+}): GlobalConnectionState;
+export declare function writeGlobalConnections(state: GlobalConnectionState, options?: {
+    env?: NodeJS.ProcessEnv;
+}): void;
+export declare function upsertGlobalConnection(alias: string, connection: RigConnection, options?: {
+    env?: NodeJS.ProcessEnv;
+}): GlobalConnectionState;
+export declare function readRepoConnection(projectRoot: string): RepoConnectionState | null;
+export declare function writeRepoConnection(projectRoot: string, state: RepoConnectionState): void;
+export declare function resolveSelectedConnection(projectRoot: string, options?: {
+    env?: NodeJS.ProcessEnv;
+}): {
+    alias: string;
+    connection: RigConnection;
+    serverProjectRoot?: string;
+} | null;
+/** Persist the server-host project root this repo scopes to (multi-root serving). */
+export declare function writeRepoServerProjectRoot(projectRoot: string, serverProjectRoot: string): void;
+/** Whether this repo's selected connection targets a remote Rig server. */
+export declare function isRemoteConnectionSelected(projectRoot: string): boolean;

package/dist/src/commands/_doctor-checks.d.ts

@@ -0,0 +1,52 @@
+type DoctorConfig = {
+    readonly project?: Record<string, unknown>;
+    readonly taskSource?: {
+        readonly kind?: string;
+        readonly owner?: string;
+        readonly repo?: string;
+    };
+    readonly github?: {
+        readonly projects?: {
+            readonly enabled?: boolean;
+            readonly projectId?: string;
+            readonly statusFieldId?: string;
+        };
+    };
+    readonly pr?: {
+        readonly mode?: string;
+    };
+    readonly merge?: {
+        readonly mode?: string;
+        readonly method?: string;
+    };
+};
+import { type PiInstallCheck } from "./_pi-install";
+export type DoctorStatus = "pass" | "warn" | "fail";
+export type RigDoctorCheck = {
+    readonly id: string;
+    readonly label: string;
+    readonly status: DoctorStatus;
+    readonly detail?: string;
+    readonly remediation?: string;
+};
+export type RigDoctorServer = {
+    readonly baseUrl: string;
+    readonly authToken: string | null;
+    readonly connectionKind: "local" | "remote";
+};
+export type RunRigDoctorChecksOptions = {
+    readonly projectRoot: string;
+    readonly resolveServer?: (projectRoot: string) => Promise<RigDoctorServer>;
+    readonly requestJson?: (pathname: string, init?: RequestInit) => Promise<unknown>;
+    readonly piChecks?: () => Promise<readonly PiInstallCheck[]>;
+    readonly which?: (binary: string) => string | null;
+    readonly bunVersion?: string;
+    readonly loadConfig?: (projectRoot: string) => Promise<DoctorConfig | null>;
+    /** Per-check status narration ("Checking GitHub auth…") for wait spinners. */
+    readonly onProgress?: (label: string) => void;
+};
+export declare function runRigDoctorChecks(options: RunRigDoctorChecksOptions): Promise<RigDoctorCheck[]>;
+export declare function formatDoctorChecks(checks: readonly RigDoctorCheck[]): string;
+export declare function countDoctorFailures(checks: readonly RigDoctorCheck[]): number;
+export declare function throwIfDoctorFailed(checks: readonly RigDoctorCheck[]): void;
+export {};

package/dist/src/commands/_doctor-checks.js

@@ -311,7 +311,9 @@ ${failure.contextLine}`, 1, { hint: failure.hint });
   })() : null;
   if (!response.ok) {
     const diagnostics = diagnosticMessage(payload);
-    const detail = diagnostics ?? (text || response.statusText);
+    const rawDetail = diagnostics ?? (text || response.statusText);
+    const detail = diagnostics ? rawDetail : rawDetail.split(`
+`).map((line) => line.trim()).find((line) => line.length > 0)?.slice(0, 200) ?? response.statusText;
     const failure = await buildServerFailureContext(context.projectRoot, server);
     throw new CliError(`Rig server request failed (${response.status}): ${detail}
 ${failure.contextLine}`, 1, { hint: failure.hint });

package/dist/src/commands/_help-catalog.d.ts

@@ -0,0 +1,51 @@
+export type HelpCommand = {
+    command: string;
+    description: string;
+    primary?: boolean;
+};
+export type HelpGroup = {
+    name: string;
+    summary: string;
+    usage: string[];
+    commands: HelpCommand[];
+    examples?: string[];
+    next?: string[];
+    advanced?: string[];
+};
+export type TopLevelSection = {
+    title: string;
+    subtitle: string;
+    commands: HelpCommand[];
+};
+/** Catalog DATA for the app's help view — the view builds its own layout
+ * from these; the render* functions below remain for plain/script output. */
+export declare function helpCatalog(): {
+    sections: readonly TopLevelSection[];
+    groups: readonly HelpGroup[];
+};
+/**
+ * Night City boot screen. Rendered only on interactive TTY launches — plain
+ * mode and --json never see it.
+ */
+export declare function renderRigBanner(version?: string): string;
+export declare function renderTopLevelHelp(): string;
+export declare function renderAdvancedHelp(): string;
+export declare function renderGroupHelp(groupName: string): string | null;
+export declare function listHelpGroups(): string[];
+/**
+ * Fuzzy-match a bare word against known group subcommand names so the
+ * unknown-command error can suggest the canonical `rig <group> <cmd>`
+ * spelling. Primary groups win ties (ALL_GROUPS is primary-first).
+ */
+export declare function suggestGroupCommandForWord(word: string): string | null;
+export type TopLevelLaunchState = {
+    /** True when the cwd resolves to an initialized Rig project. */
+    projectInitialized?: boolean;
+    /** Short description of the selected server connection, if known. */
+    selectedServer?: string | null;
+    /** CLI version for the banner footer. */
+    version?: string;
+};
+export declare function printTopLevelHelp(state?: TopLevelLaunchState): void;
+export declare function printAdvancedHelp(): void;
+export declare function printGroupHelpDocument(groupName: string): void;

package/dist/src/commands/_help-catalog.js

@@ -1,7 +1,9 @@
 // @bun
 // packages/cli/src/commands/_help-catalog.ts
-import { intro, log, note, outro } from "@clack/prompts";
 import pc from "picocolors";
+function helpCatalog() {
+  return { sections: TOP_LEVEL_SECTIONS, groups: ALL_GROUPS };
+}
 var TOP_LEVEL_SECTIONS = [
   {
     title: "Pi console",
@@ -92,6 +94,7 @@ var PRIMARY_GROUPS = [
       { command: "next [filters]", description: "Render the next matching task as a selected-task card.", primary: true },
       { command: "show <id>|--task <id> [--raw]", description: "Show a human task summary; --raw prints the full payload.", primary: true },
       { command: "run [#<issue>|<task-id>|--next|--task <id>]", description: "Submit a task run; interactive follows with bundled Pi.", primary: true },
+      { command: "ready", description: "List task IDs that are runnable now." },
       { command: "validate|verify [--task <id>]", description: "Run configured task checks/review gates." },
       { command: "details --task <id>", description: "Show full task info from the configured source." },
       { command: "reopen [--task <id> | --all] [--reason <text>]", description: "Reopen closed task(s) in the configured source." },
@@ -416,79 +419,14 @@ function suggestGroupCommandForWord(word) {
   }
   return null;
 }
-function shouldUseClackOutput() {
-  return Boolean(process.stdout.isTTY) && process.env.RIG_CLI_PLAIN_HELP !== "1";
-}
 function printTopLevelHelp(state = {}) {
-  if (!shouldUseClackOutput()) {
-    console.log(renderTopLevelHelp());
-    return;
-  }
-  console.log(renderRigBanner(state.version));
-  console.log("");
-  if (state.projectInitialized === false) {
-    intro("no rig project in this directory");
-    note([
-      commandLine("rig init", "Set this repo up: config, GitHub auth, task source, server, Pi."),
-      commandLine("rig init --yes", "Same, non-interactive, sensible defaults."),
-      commandLine("rig doctor", "Already initialized somewhere else? Check the wiring.")
-    ].join(`
-`), "Get started");
-    outro("After init: rig task run --next puts an agent on your next task.");
-    return;
-  }
-  intro(state.selectedServer ? `server: ${state.selectedServer}` : "rig");
-  for (const section of TOP_LEVEL_SECTIONS) {
-    note(renderCommandBlock(section.commands), `${section.title} \u2014 ${section.subtitle}`);
-  }
-  log.info("More: rig help --advanced \xB7 rig <group> --help \xB7 rig --version");
-  note([
-    commandLine("--project <path>", "Use a project root instead of auto-discovery."),
-    commandLine("--json", "Emit structured output for scripts/agents."),
-    commandLine("--dry-run", "Print the command plan without mutating state.")
-  ].join(`
-`), "Global options");
-  outro("init \u2192 task run \u2192 attach (Pi console: watch + steer live) \u2192 inbox \u2192 merged.");
+  console.log(renderTopLevelHelp());
 }
 function printAdvancedHelp() {
-  if (!shouldUseClackOutput()) {
-    console.log(renderAdvancedHelp());
-    return;
-  }
-  intro("rig advanced");
-  note(ADVANCED_COMMANDS.map((entry) => commandLine(entry.command, entry.description)).join(`
-`), "Advanced commands");
-  note(ADVANCED_GROUPS.map((group) => commandLine(group.name, group.summary)).join(`
-`), "Advanced groups");
-  outro("Primary daily flow: rig server \xB7 rig task \xB7 rig run \xB7 rig inbox.");
+  console.log(renderAdvancedHelp());
 }
 function printGroupHelpDocument(groupName) {
-  const rendered = renderGroupHelp(groupName) ?? renderTopLevelHelp();
-  if (!shouldUseClackOutput()) {
-    console.log(rendered);
-    return;
-  }
-  const group = ALL_GROUPS.find((candidate) => candidate.name === groupName);
-  if (!group) {
-    printTopLevelHelp();
-    return;
-  }
-  intro(`rig ${group.name}`);
-  note(group.summary, "Purpose");
-  note(group.usage.join(`
-`), "Usage");
-  note(group.commands.map((entry) => commandLine(entry.command, entry.description)).join(`
-`), "Commands");
-  if (group.examples?.length)
-    note(group.examples.map((line) => `$ ${line}`).join(`
-`), "Examples");
-  if (group.next?.length)
-    note(group.next.map((line) => `\u203A ${line}`).join(`
-`), "Next steps");
-  if (group.advanced?.length)
-    log.info(group.advanced.join(`
-`));
-  outro("Run with --json when scripts need structured output.");
+  console.log(renderGroupHelp(groupName) ?? renderTopLevelHelp());
 }
 export {
   suggestGroupCommandForWord,
@@ -499,5 +437,6 @@ export {
   printTopLevelHelp,
   printGroupHelpDocument,
   printAdvancedHelp,
-  listHelpGroups
+  listHelpGroups,
+  helpCatalog
 };

package/dist/src/commands/_json-output.d.ts

@@ -0,0 +1,11 @@
+import { type RigCliOutputEnvelope } from "@rig/contracts";
+/**
+ * Build the versioned `{ v: 1, command, data }` envelope for a command
+ * outcome, or null when the command has no output schema (legacy payload)
+ * or the details fail validation (warned on stderr, legacy payload).
+ */
+export declare function buildCliJsonEnvelope(outcome: unknown, options?: {
+    warn?: (message: string) => void;
+}): RigCliOutputEnvelope | null;
+/** Commands with a versioned --json envelope (for help/docs/tests). */
+export declare function listSchematizedCliCommands(): string[];

package/dist/src/commands/_operator-surface.d.ts

@@ -0,0 +1,34 @@
+import type { WorkspaceTaskRecord } from "./_server-client";
+export type OperatorSnapshot = {
+    readonly run: Record<string, unknown>;
+    readonly logs?: readonly Record<string, unknown>[];
+    readonly timeline?: readonly Record<string, unknown>[];
+};
+export declare function renderOperatorSnapshot(snapshot: OperatorSnapshot): string;
+export type PiRunStreamRenderer = {
+    renderSnapshot(snapshot: OperatorSnapshot): void;
+    renderTimeline(entries: readonly Record<string, unknown>[]): void;
+    renderLogs(entries: readonly Record<string, unknown>[]): void;
+};
+export declare function createPiRunStreamRenderer(output?: Pick<NodeJS.WriteStream, "write">): PiRunStreamRenderer;
+export type OperatorSurface = PiRunStreamRenderer & {
+    readonly mode: "text" | "pi-compatible-text";
+    info(message: string): void;
+    error(message: string): void;
+    attachCommandInput(handler: (line: string) => void | Promise<void>): {
+        close(): void;
+    } | null;
+};
+export declare function createOperatorSurface(options?: {
+    readonly input?: NodeJS.ReadStream;
+    readonly output?: Pick<NodeJS.WriteStream, "write"> & {
+        readonly isTTY?: boolean;
+    };
+    readonly errorOutput?: Pick<NodeJS.WriteStream, "write">;
+    readonly interactive?: boolean;
+}): OperatorSurface;
+export type TaskPickerRenderer = {
+    readonly writeLine: (line: string) => void;
+};
+export declare function renderTaskPickerRows(tasks: readonly WorkspaceTaskRecord[]): string[];
+export declare function promptForTaskSelection(question: string): Promise<string>;

package/dist/src/commands/_operator-view.d.ts

@@ -0,0 +1,30 @@
+import { steerRunViaServer, stopRunViaServer } from "./_server-client";
+import { createPiRunStreamRenderer, renderOperatorSnapshot } from "./_operator-surface";
+import type { RunnerContext } from "../runner";
+export { createPiRunStreamRenderer, renderOperatorSnapshot };
+export declare function applyOperatorCommand(context: Pick<RunnerContext, "projectRoot">, input: {
+    readonly runId: string;
+    readonly line: string;
+}, deps?: {
+    readonly steer?: typeof steerRunViaServer;
+    readonly stop?: typeof stopRunViaServer;
+}): Promise<{
+    action: "continue" | "detach" | "stopped" | "ignored";
+    message?: string;
+}>;
+export declare function attachRunOperatorView(context: Pick<RunnerContext, "projectRoot" | "outputMode">, input: {
+    readonly runId: string;
+    readonly message?: string | null;
+    readonly once?: boolean;
+    readonly follow?: boolean;
+    readonly pollMs?: number;
+    readonly interactive?: boolean;
+}): Promise<{
+    run: Record<string, unknown>;
+    logs: Record<string, unknown>[];
+    timeline: Record<string, unknown>[];
+    timelineCursor: string | null;
+    steered: boolean;
+    rendered: string;
+    detached?: boolean;
+}>;

package/dist/src/commands/_operator-view.js

@@ -311,7 +311,9 @@ ${failure.contextLine}`, 1, { hint: failure.hint });
   })() : null;
   if (!response.ok) {
     const diagnostics = diagnosticMessage(payload);
-    const detail = diagnostics ?? (text || response.statusText);
+    const rawDetail = diagnostics ?? (text || response.statusText);
+    const detail = diagnostics ? rawDetail : rawDetail.split(`
+`).map((line) => line.trim()).find((line) => line.length > 0)?.slice(0, 200) ?? response.statusText;
     const failure = await buildServerFailureContext(context.projectRoot, server);
     throw new CliError(`Rig server request failed (${response.status}): ${detail}
 ${failure.contextLine}`, 1, { hint: failure.hint });
@@ -569,8 +571,8 @@ function createOperatorSurface(options = {}) {
 }
 
 // packages/cli/src/commands/_pi-frontend.ts
-import { mkdtempSync, rmSync, writeFileSync as writeFileSync2 } from "fs";
-import { tmpdir } from "os";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, mkdtempSync, readFileSync as readFileSync3, rmSync, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir2, tmpdir } from "os";
 import { join } from "path";
 import { main as runPiMain } from "@earendil-works/pi-coding-agent";
 import createPiRigExtension from "@rig/pi-rig";
@@ -639,8 +641,79 @@ function createTtySpinner(input) {
   };
 }
 
+// packages/cli/src/app/theme.ts
+var RIG_PALETTE = {
+  ink: "#f2f3f6",
+  ink2: "#aeb0ba",
+  ink3: "#6c6e79",
+  ink4: "#44464f",
+  accent: "#ccff4d",
+  accentDim: "#a9d63f",
+  cyan: "#56d8ff",
+  red: "#ff5d5d",
+  yellow: "#ffd24d"
+};
+function hexToRgb(hex) {
+  const value = hex.replace("#", "");
+  return [
+    Number.parseInt(value.slice(0, 2), 16),
+    Number.parseInt(value.slice(2, 4), 16),
+    Number.parseInt(value.slice(4, 6), 16)
+  ];
+}
+function fg(hex) {
+  const [r, g, b] = hexToRgb(hex);
+  return (text) => `\x1B[38;2;${r};${g};${b}m${text}\x1B[39m`;
+}
+var ink = fg(RIG_PALETTE.ink);
+var ink2 = fg(RIG_PALETTE.ink2);
+var ink3 = fg(RIG_PALETTE.ink3);
+var ink4 = fg(RIG_PALETTE.ink4);
+var accent = fg(RIG_PALETTE.accent);
+var accentDim = fg(RIG_PALETTE.accentDim);
+var cyan = fg(RIG_PALETTE.cyan);
+var red = fg(RIG_PALETTE.red);
+var yellow = fg(RIG_PALETTE.yellow);
+function bold(text) {
+  return `\x1B[1m${text}\x1B[22m`;
+}
+var DRONE_ART = [
+  "  .-=-.                   .-=-.   ",
+  " ( !!! )                 ( !!! )  ",
+  "  '-=-'._               _.'-=-'   ",
+  "        '._           _.'         ",
+  "           '=$$$$$$$=.'           ",
+  "          =$$$$$$$$$$$=           ",
+  "         $$$@@@@@@@@@@$$$         ",
+  "        $$$@@        @@$$$        ",
+  "        $$@    ?     @$$$         ",
+  "        $$$@   '-'   @$$$         ",
+  "        $$$@@        @@$$$        ",
+  "         $$$@@@@@@@@@@$$$         ",
+  "          =$$$$$$$$$$$=           ",
+  "           '=$$$$$$$=.'           ",
+  "        _.'           '._         ",
+  "  .-=-.'                 '.-=-.   ",
+  " ( !!! )                 ( !!! )  ",
+  "  '-=-'                   '-=-'   "
+];
+var EYE_FRAMES = ["@", "o", "."];
+var DRONE_WIDTH = DRONE_ART[0].length;
+var DRONE_HEIGHT = DRONE_ART.length;
+var MICRO_BLADES = ["---", "\\\\\\", "|||", "///"];
+function microDroneFrame(tick) {
+  const blade = MICRO_BLADES[tick % MICRO_BLADES.length];
+  const eye = EYE_FRAMES[Math.floor(tick / 2) % EYE_FRAMES.length];
+  return `(${blade})${eye}(${blade})`;
+}
+var MICRO_DRONE_FRAMES = Array.from({ length: 12 }, (_, index) => microDroneFrame(index));
+function renderMicroDroneFrame(tick) {
+  const blade = MICRO_BLADES[tick % MICRO_BLADES.length];
+  const eye = EYE_FRAMES[Math.floor(tick / 2) % EYE_FRAMES.length];
+  return `${ink4("(")}${cyan(blade)}${ink4(")")}${bold(accent(eye))}${ink4("(")}${cyan(blade)}${ink4(")")}`;
+}
+
 // packages/cli/src/commands/_async-ui.ts
-var CLACK_SPINNER_FRAMES = ["\u25D2", "\u25D0", "\u25D3", "\u25D1"];
 var DONE_SYMBOL = pc.green("\u25C7");
 var FAIL_SYMBOL = pc.red("\u25A0");
 var activeUpdate = null;
@@ -674,8 +747,8 @@ async function withSpinner(label, work, options = {}) {
   const spinner = createTtySpinner({
     label,
     output,
-    frames: CLACK_SPINNER_FRAMES,
-    styleFrame: (frame) => pc.magenta(frame)
+    frames: MICRO_DRONE_FRAMES,
+    styleFrame: (frame) => renderMicroDroneFrame(Math.max(0, MICRO_DRONE_FRAMES.indexOf(frame)))
   });
   const update = (next) => {
     lastLabel = next;
@@ -716,6 +789,7 @@ function buildOperatorPiEnv(input) {
   return {
     PI_CODING_AGENT_SESSION_DIR: input.sessionDir,
     PI_SKIP_VERSION_CHECK: "1",
+    PI_HIDDEN_COMMANDS: "import,fork,clone,tree,new,resume,trust",
     RIG_PI_OPERATOR_SESSION: "1",
     RIG_RUN_ID: input.runId,
     RIG_SERVER_URL: input.serverUrl,
@@ -725,6 +799,10 @@ function buildOperatorPiEnv(input) {
 }
 async function prepareOperatorConsole(context, runId, tempSessionDir) {
   const server = await ensureServerForCli(context.projectRoot);
+  const localCwd = join(homedir2(), ".rig", "drones", runId.slice(0, 8));
+  mkdirSync2(localCwd, { recursive: true });
+  trustDroneCwd(localCwd);
+  installRigPiTheme();
   let sessionFileArg = [];
   try {
     const payload = await requestServerJson(context, `/api/runs/${encodeURIComponent(runId)}/session-file`);
@@ -738,7 +816,7 @@ async function prepareOperatorConsole(context, runId, tempSessionDir) {
         try {
           const header = JSON.parse(line);
           if (header.type === "session" && typeof header.cwd === "string") {
-            return JSON.stringify({ ...header, cwd: process.cwd() });
+            return JSON.stringify({ ...header, cwd: localCwd });
           }
         } catch {}
         return line;
@@ -750,6 +828,105 @@ async function prepareOperatorConsole(context, runId, tempSessionDir) {
   } catch {}
   return { server, sessionFileArg };
 }
+var RIG_PI_THEME = {
+  $schema: "https://raw.githubusercontent.com/earendil-works/pi/main/packages/coding-agent/src/modes/interactive/theme/theme-schema.json",
+  name: "rig",
+  vars: {
+    acid: "#ccff4d",
+    acidDim: "#a9d63f",
+    cyan: "#56d8ff",
+    red: "#ff5d5d",
+    yellow: "#ffd24d",
+    ink: "#f2f3f6",
+    ink2: "#aeb0ba",
+    ink3: "#6c6e79",
+    ink4: "#44464f",
+    panel: "#101115",
+    panelUser: "#14161b",
+    toolPending: "#0e1013",
+    toolSuccess: "#10150c",
+    toolError: "#1a0f0f",
+    customMsg: "#0f1410"
+  },
+  colors: {
+    accent: "acid",
+    border: "ink4",
+    borderAccent: "acid",
+    borderMuted: "ink4",
+    success: "acid",
+    error: "red",
+    warning: "yellow",
+    muted: "ink3",
+    dim: "ink4",
+    text: "ink",
+    thinkingText: "ink3",
+    selectedBg: "panel",
+    userMessageBg: "panelUser",
+    userMessageText: "ink",
+    customMessageBg: "customMsg",
+    customMessageText: "ink2",
+    customMessageLabel: "acidDim",
+    toolPendingBg: "toolPending",
+    toolSuccessBg: "toolSuccess",
+    toolErrorBg: "toolError",
+    toolTitle: "ink",
+    toolOutput: "ink3",
+    mdHeading: "acid",
+    mdLink: "cyan",
+    mdLinkUrl: "ink4",
+    mdCode: "acidDim",
+    mdCodeBlock: "ink2",
+    mdCodeBlockBorder: "ink4",
+    mdQuote: "ink3",
+    mdQuoteBorder: "ink4",
+    mdHr: "ink4",
+    mdListBullet: "acid",
+    toolDiffAdded: "acid",
+    toolDiffRemoved: "red",
+    toolDiffContext: "ink3",
+    syntaxComment: "ink3",
+    syntaxKeyword: "cyan",
+    syntaxFunction: "acid",
+    syntaxVariable: "ink",
+    syntaxString: "acidDim",
+    syntaxNumber: "yellow",
+    syntaxType: "cyan",
+    syntaxOperator: "ink2",
+    syntaxPunctuation: "ink3",
+    thinkingOff: "ink4",
+    thinkingMinimal: "ink3",
+    thinkingLow: "ink2",
+    thinkingMedium: "cyan",
+    thinkingHigh: "acidDim",
+    thinkingXhigh: "acid",
+    bashMode: "cyan"
+  }
+};
+function trustDroneCwd(localCwd) {
+  try {
+    const agentDir = join(homedir2(), ".pi", "agent");
+    mkdirSync2(agentDir, { recursive: true });
+    const trustPath = join(agentDir, "trust.json");
+    const store = existsSync3(trustPath) ? JSON.parse(readFileSync3(trustPath, "utf8")) : {};
+    if (store[localCwd] !== true) {
+      store[localCwd] = true;
+      writeFileSync2(trustPath, `${JSON.stringify(store, null, "\t")}
+`);
+    }
+  } catch {}
+}
+function installRigPiTheme() {
+  try {
+    const themesDir = join(homedir2(), ".pi", "agent", "themes");
+    mkdirSync2(themesDir, { recursive: true });
+    const themePath = join(themesDir, "rig.json");
+    const next = `${JSON.stringify(RIG_PI_THEME, null, "\t")}
+`;
+    if (!existsSync3(themePath) || readFileSync3(themePath, "utf8") !== next) {
+      writeFileSync2(themePath, next);
+    }
+  } catch {}
+}
 async function attachRunBundledPiFrontend(context, input) {
   const tempSessionDir = mkdtempSync(join(tmpdir(), "rig-pi-frontend-sessions-"));
   const { server, sessionFileArg } = await withSpinner(`Opening Pi console for run ${input.runId}\u2026`, () => prepareOperatorConsole(context, input.runId, tempSessionDir), { outputMode: context.outputMode });

package/dist/src/commands/_parsers.d.ts

@@ -0,0 +1,15 @@
+import type { TaskSourceConfig } from "@rig/contracts";
+import type { RigPluginWithRuntime } from "@rig/core";
+export declare function parsePositiveInt(value: string | undefined, option: string, fallback: number): number;
+export declare function parseOptionalPositiveInt(value: string | undefined, option: string): number | undefined;
+export declare function parseRequiredPositiveInt(value: string | undefined, option: string): number;
+export declare function parseAction(value: string | undefined): "validate" | "verify" | "pipeline";
+export declare function parseIsolationMode(value: string | undefined, allowOff: true): "off" | "worktree";
+export declare function parseIsolationMode(value: string | undefined, allowOff: false): "worktree";
+export declare function parseInstallScope(value: string | undefined): "user" | "system";
+export declare function resolveInstallDir(scope: "user" | "system", explicitPath: string | undefined): string;
+export type CliRigConfig = {
+    plugins?: readonly RigPluginWithRuntime[];
+    taskSource?: TaskSourceConfig;
+};
+export declare function loadRigConfigOrNull(projectRoot: string): Promise<CliRigConfig | null>;

package/dist/src/commands/_paths.d.ts

@@ -0,0 +1,11 @@
+export declare function resolveControlPlaneMonorepoRoot(projectRoot: string): string;
+export declare function resolveControlPlaneTaskConfigPath(projectRoot: string): string;
+export declare function resolveControlPlaneHostStateRoot(projectRoot: string): string;
+export declare function resolveControlPlaneHostStateDir(projectRoot: string): string;
+export declare function resolveControlPlaneHostLogsDir(projectRoot: string): string;
+export declare function resolveControlPlaneHostBinDir(projectRoot: string): string;
+export declare function resolveControlPlaneHostDistDir(projectRoot: string): string;
+export declare function resolveControlPlaneMonorepoStateRoot(projectRoot: string): string;
+export declare function resolveControlPlaneMonorepoRuntimeDir(projectRoot: string): string;
+export declare function resolveControlPlaneArtifactsDir(projectRoot: string): string;
+export declare function resolveControlPlaneDefinitionRoot(projectRoot: string): string;

package/dist/src/commands/_pi-frontend.d.ts

@@ -0,0 +1,27 @@
+import type { RunnerContext } from "../runner";
+type AttachResult = {
+    run: Record<string, unknown>;
+    logs: Record<string, unknown>[];
+    timeline: Record<string, unknown>[];
+    timelineCursor: string | null;
+    steered: boolean;
+    rendered: string;
+    detached?: boolean;
+};
+/**
+ * Compose the operator-session environment for the attached Pi console.
+ * Exported for tests: this is the contract between `rig run attach` and the
+ * pi-rig extension's context discovery (see packages/pi-rig/src/client.ts).
+ */
+export declare function buildOperatorPiEnv(input: {
+    readonly runId: string;
+    readonly serverUrl: string;
+    readonly authToken?: string | null;
+    readonly serverProjectRoot?: string | null;
+    readonly sessionDir: string;
+}): Record<string, string>;
+export declare function attachRunBundledPiFrontend(context: Pick<RunnerContext, "projectRoot" | "outputMode">, input: {
+    readonly runId: string;
+    readonly steered?: boolean;
+}): Promise<AttachResult>;
+export {};