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

package/dist/src/commands/_pi-frontend.js

@@ -1,7 +1,7 @@
 // @bun
 // 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";
@@ -318,7 +318,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 });
@@ -405,8 +407,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;
@@ -440,8 +513,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;
@@ -482,6 +555,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,
@@ -491,6 +565,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`);
@@ -504,7 +582,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;
@@ -516,6 +594,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/_pi-install.d.ts

@@ -0,0 +1,42 @@
+export type PiInstallCheck = {
+    readonly ok: boolean;
+    readonly label: string;
+    readonly detail?: string;
+    readonly hint?: string;
+};
+export type CommandRunner = (command: string[], options?: {
+    cwd?: string;
+}) => Promise<{
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}>;
+export type PiRigInstallStatus = {
+    readonly pi: PiInstallCheck;
+    readonly piRig: PiInstallCheck;
+    readonly extensionPath: string;
+};
+export declare function resolvePiRigExtensionPath(homeDir: string): string;
+export declare function resolvePiRigPackageSource(projectRoot: string, exists?: (path: string) => boolean): string;
+export declare function checkPiRigInstall(input?: {
+    readonly homeDir?: string;
+    readonly commandRunner?: CommandRunner;
+    readonly exists?: (path: string) => boolean;
+}): Promise<PiRigInstallStatus>;
+export declare function ensurePiRigInstalled(input: {
+    readonly projectRoot: string;
+    readonly homeDir?: string;
+    readonly commandRunner?: CommandRunner;
+}): Promise<PiRigInstallStatus & {
+    installedPath: string;
+}>;
+export declare function ensureRemotePiRigInstalled(input: {
+    readonly requestJson: (pathname: string, init?: RequestInit) => Promise<unknown>;
+}): Promise<PiRigInstallStatus & {
+    readonly remote: true;
+}>;
+export declare function buildPiSetupChecks(input?: {
+    readonly homeDir?: string;
+    readonly commandRunner?: CommandRunner;
+    readonly exists?: (path: string) => boolean;
+}): Promise<PiInstallCheck[]>;

package/dist/src/commands/_pi-install.js

@@ -56,7 +56,7 @@ async function ensurePiBinaryAvailable(input) {
     }
     return { ok: true, detail: (current.stdout || current.stderr).trim() || undefined };
   }
-  const installCommand = process.env.RIG_PI_INSTALL_COMMAND?.trim() || "bunx @earendil-works/pi@latest install";
+  const installCommand = process.env.RIG_PI_INSTALL_COMMAND?.trim() || "bunx @earendil-works/pi-coding-agent@latest install";
   const parts = splitInstallCommand(installCommand);
   if (parts.length === 0) {
     return { ok: false, error: (current.stderr || current.stdout).trim() || "pi --version failed" };

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

@@ -0,0 +1,8 @@
+import { type RunnerContext } from "../runner";
+import type { PolicyMode } from "@rig/runtime/control-plane/runtime/guard-types";
+export declare function resolveEffectivePolicyMode(context: RunnerContext): PolicyMode;
+export declare function appendControlledBashAudit(context: RunnerContext, mode: PolicyMode, command: string, args: string[], matchedRuleIds: string[], action?: "warn" | "blocked"): void;
+export declare function enforceNativeCommandPolicy(context: RunnerContext, args: string[], options: {
+    commandPrefix: string;
+    writeAuditLog: boolean;
+}): Promise<void>;

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

@@ -0,0 +1,22 @@
+import { type RunnerContext } from "../runner";
+export type TaskRunPreflightStatus = "pass" | "warn" | "fail";
+export type TaskRunPreflightCheck = {
+    readonly id: string;
+    readonly label: string;
+    readonly status: TaskRunPreflightStatus;
+    readonly detail?: string;
+    readonly remediation?: string;
+};
+export type TaskRunPreflightResult = {
+    readonly ok: boolean;
+    readonly checks: readonly TaskRunPreflightCheck[];
+};
+export type TaskRunPreflightOptions = {
+    readonly taskId?: string | null;
+    readonly runtimeAdapter?: "claude-code" | "codex" | "pi";
+    readonly requestJson?: (pathname: string, init?: RequestInit) => Promise<unknown>;
+};
+export declare function runFastTaskRunPreflight(context: RunnerContext, options?: TaskRunPreflightOptions): Promise<TaskRunPreflightResult>;
+export declare function runProjectMainSyncPreflight(context: RunnerContext, options: {
+    disabled: boolean;
+}): Promise<void>;

package/dist/src/commands/_preflight.js

@@ -305,7 +305,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/_probes.d.ts

@@ -0,0 +1 @@
+export declare function runQuietBinaryProbe(binaryPath: string, args: string[], cwd: string): Promise<boolean>;

package/dist/src/commands/_run-driver-helpers.d.ts

@@ -0,0 +1,99 @@
+import { type AuthorityRunPatch, type AuthorityRunRecord } from "@rig/runtime/control-plane/authority-files";
+import type { RunStatus } from "@rig/contracts";
+export type SourceTaskContract = {
+    id: string;
+    title?: string | null;
+    description?: string | null;
+    body?: string | null;
+    acceptanceCriteria?: string | null;
+    acceptance_criteria?: string | null;
+    sourceIssueId?: string | null;
+    status?: string | null;
+    issueType?: string | null;
+    role?: string | null;
+    externalRef?: string | null;
+    scope?: readonly string[];
+    validation?: readonly string[];
+    validators?: readonly string[];
+    labels?: readonly string[];
+};
+export declare function patchAuthorityRun(projectRoot: string, runId: string, patch: AuthorityRunPatch): AuthorityRunRecord;
+/**
+ * THE status mutation on the CLI driver side: transition-checked and
+ * journaled as a status-changed event (see @rig/contracts run-journal).
+ */
+export declare function setRunStatusOrFail(projectRoot: string, runId: string, to: RunStatus, options?: {
+    reason?: string | null;
+    errorText?: string | null;
+}): AuthorityRunRecord;
+export declare function touchAuthorityRun(projectRoot: string, runId: string): void;
+export declare function appendRunTimeline(projectRoot: string, runId: string, value: Record<string, unknown>): void;
+export declare function appendRunLog(projectRoot: string, runId: string, value: Record<string, unknown>): void;
+type RunActionInput = {
+    id: string;
+    actionType: string;
+    title: string;
+    detail?: string | null;
+    state: "running" | "completed" | "failed";
+    startedAt: string;
+    completedAt?: string | null;
+    payload?: Record<string, unknown>;
+};
+export declare function appendRunAction(projectRoot: string, runId: string, value: RunActionInput): void;
+export type RunActionHandle = {
+    startedAt: string;
+    complete: (detail?: string | null, payload?: Record<string, unknown>) => void;
+    fail: (detail: string, payload?: Record<string, unknown>) => void;
+};
+export declare function startRunAction(projectRoot: string, runId: string, input: {
+    actionId: string;
+    actionType: string;
+    title: string;
+    detail?: string | null;
+    payload?: Record<string, unknown>;
+}): RunActionHandle;
+export type RunEvent = {
+    type: "status";
+    runId: string;
+    status: string;
+    detail?: string | null;
+    sessionId?: string | null;
+} | {
+    type: "timeline";
+    runId: string;
+} | {
+    type: "log";
+    runId: string;
+    title?: string;
+} | {
+    type: "completed";
+    runId: string;
+} | {
+    type: "failed";
+    runId: string;
+    error: string;
+};
+/**
+ * Route emitServerRunEvent through the run.jsonl lifecycle log + doorbell in
+ * addition to stdout. Called once at the start of executeRigOwnedTaskRun.
+ */
+export declare function configureRunEventSink(projectRoot: string): void;
+/**
+ * Print a parseable status line to stdout that the server's spawn-and-watch
+ * path reads to update its own state. Format: `__RIG_RUN_EVENT__<json>`.
+ *
+ * When `configureRunEventSink` has run, the same event is also appended to
+ * the run's `run.jsonl` lifecycle log and the server doorbell is rung.
+ */
+export declare function emitServerRunEvent(event: RunEvent): void;
+export declare function buildRunPrompt(input: {
+    projectRoot: string;
+    taskId?: string;
+    fallbackTitle?: string | null;
+    fallbackDescription?: string | null;
+    fallbackAcceptanceCriteria?: string | null;
+    sourceTask?: SourceTaskContract | null;
+    initialPrompt?: string;
+    runtimeAdapter: "claude-code" | "codex" | "pi";
+}): string;
+export {};

package/dist/src/commands/_run-replay.d.ts

@@ -0,0 +1,24 @@
+import { type AuthorityRunRecord } from "@rig/runtime/control-plane/authority-files";
+export type RunReplayLine = {
+    at: string | null;
+    source: "run" | "session";
+    summary: string;
+};
+export type RunReplayResult = {
+    runId: string;
+    logPath: string;
+    sessionFile: string | null;
+    entryCount: number;
+    sessionEntryCount: number;
+    lines: string[];
+};
+/**
+ * Locate the worker Pi session.jsonl for a run, without ever reading the file
+ * during the run lifecycle — replay-time only. Prefers the exact
+ * piSession.sessionFile recorded on the run record; falls back to scanning
+ * `<piSession.cwd>/.rig/session/` for `*_<sessionId>.jsonl`.
+ */
+export declare function resolveRunSessionFile(record: AuthorityRunRecord | null): string | null;
+export declare function buildRunReplay(projectRoot: string, runId: string, options?: {
+    withSession?: boolean;
+}): RunReplayResult;

package/dist/src/commands/_server-client.d.ts

@@ -0,0 +1,186 @@
+type ServerPhaseListener = (label: string) => void;
+/** Returns the previously registered listener so scopes can restore it. */
+export declare function setServerPhaseListener(listener: ServerPhaseListener | null): ServerPhaseListener | null;
+export declare function setGitHubBearerTokenForCurrentProcess(token: string | null, projectRoot?: string): void;
+export declare function ensureServerForCli(projectRoot: string): Promise<{
+    baseUrl: string;
+    authToken: string | null;
+    connectionKind: "local" | "remote";
+    serverProjectRoot: string | null;
+}>;
+export interface WorkspaceTaskFilters {
+    readonly assignee?: string;
+    readonly state?: string;
+    readonly status?: string;
+    readonly limit?: number;
+}
+export type WorkspaceTaskRecord = Record<string, unknown> & {
+    readonly id?: unknown;
+    readonly title?: unknown;
+    readonly status?: unknown;
+};
+export type SubmitTaskRunInput = {
+    runId: string;
+    taskId?: string;
+    title?: string;
+    runtimeAdapter: "claude-code" | "codex" | "pi";
+    model?: string;
+    runtimeMode: string;
+    interactionMode: string;
+    initialPrompt?: string;
+    baselineMode?: "head" | "dirty-snapshot";
+    prMode?: "auto" | "ask" | "off";
+};
+export declare function requestServerJson(context: {
+    projectRoot: string;
+}, pathname: string, init?: RequestInit): Promise<unknown>;
+export declare function listWorkspaceTasksViaServer(context: {
+    projectRoot: string;
+}, filters?: WorkspaceTaskFilters): Promise<WorkspaceTaskRecord[]>;
+export declare function getWorkspaceTaskViaServer(context: {
+    projectRoot: string;
+}, taskId: string): Promise<WorkspaceTaskRecord | null>;
+export declare function selectNextWorkspaceTaskViaServer(context: {
+    projectRoot: string;
+}, filters?: WorkspaceTaskFilters): Promise<{
+    task: WorkspaceTaskRecord | null;
+    count: number;
+}>;
+/**
+ * Submit a run (task or ad-hoc) to the local rig server. Routes to
+ * /api/runs/task vs /api/runs/adhoc based on whether a taskId is provided.
+ *
+ * Caller is responsible for any pre-flight (e.g. project sync). This helper
+ * only performs the POST and surfaces server errors as CliError.
+ */
+export declare function getGitHubAuthStatusViaServer(context: {
+    projectRoot: string;
+}): Promise<Record<string, unknown>>;
+export declare function postGitHubTokenViaServer(context: {
+    projectRoot: string;
+}, token: string, options?: {
+    readonly selectedRepo?: string;
+    readonly projectRoot?: string;
+}): Promise<Record<string, unknown>>;
+export declare function prepareRemoteCheckoutViaServer(context: {
+    projectRoot: string;
+}, input: {
+    repoSlug: string;
+    checkout: Record<string, unknown>;
+    repoUrl?: string;
+    baseDir?: string;
+}): Promise<Record<string, unknown>>;
+export declare function registerProjectViaServer(context: {
+    projectRoot: string;
+}, input: {
+    repoSlug: string;
+    checkout?: Record<string, unknown>;
+}): Promise<Record<string, unknown>>;
+export declare function switchServerProjectRootViaServer(context: {
+    projectRoot: string;
+}, projectRoot: string, options?: {
+    timeoutMs?: number;
+    pollMs?: number;
+}): Promise<Record<string, unknown>>;
+export declare function listRunsViaServer(context: {
+    projectRoot: string;
+}, options?: {
+    limit?: number;
+}): Promise<Record<string, unknown>[]>;
+export declare function getRunDetailsViaServer(context: {
+    projectRoot: string;
+}, runId: string): Promise<Record<string, unknown>>;
+export declare function getRunLogsViaServer(context: {
+    projectRoot: string;
+}, runId: string, options?: {
+    limit?: number;
+    cursor?: string;
+}): Promise<Record<string, unknown>>;
+export declare function getRunTimelineViaServer(context: {
+    projectRoot: string;
+}, runId: string, options?: {
+    limit?: number;
+    cursor?: string;
+}): Promise<Record<string, unknown>>;
+export declare function ensureTaskLabelsViaServer(context: {
+    projectRoot: string;
+}): Promise<Record<string, unknown>>;
+export declare function listGitHubProjectsViaServer(context: {
+    projectRoot: string;
+}, owner: string): Promise<Record<string, unknown>>;
+export declare function getGitHubProjectStatusFieldViaServer(context: {
+    projectRoot: string;
+}, projectId: string): Promise<Record<string, unknown>>;
+export declare function updateWorkspaceTaskViaServer(context: {
+    projectRoot: string;
+}, input: {
+    id: string;
+    status?: string;
+    comment?: string;
+    title?: string;
+    body?: string;
+    issueNodeId?: string | null;
+}): Promise<Record<string, unknown>>;
+/**
+ * Resume (or restart) a run through the selected server — works against the
+ * auto-started local daemon AND a remote connection, unlike the old
+ * runtime-side path that could only spawn a local engine-checkout server.
+ * Without an explicit run id, targets the most recently updated resumable
+ * run known to the server.
+ */
+export declare function resumeRunViaServer(context: {
+    projectRoot: string;
+}, runId: string | null, options: {
+    restart: boolean;
+}): Promise<Record<string, unknown>>;
+/** Short human label for the selected server — board/header decoration. */
+export declare function resolveServerConnectionLabel(projectRoot: string): Promise<string>;
+export declare function stopRunViaServer(context: {
+    projectRoot: string;
+}, runId: string): Promise<Record<string, unknown>>;
+export declare function steerRunViaServer(context: {
+    projectRoot: string;
+}, runId: string, message: string): Promise<Record<string, unknown>>;
+export declare function getRunPiSessionViaServer(context: {
+    projectRoot: string;
+}, runId: string): Promise<Record<string, unknown>>;
+export declare function getRunPiMessagesViaServer(context: {
+    projectRoot: string;
+}, runId: string): Promise<Record<string, unknown>>;
+export declare function getRunPiStatusViaServer(context: {
+    projectRoot: string;
+}, runId: string): Promise<Record<string, unknown>>;
+export declare function getRunPiCommandsViaServer(context: {
+    projectRoot: string;
+}, runId: string): Promise<Record<string, unknown>>;
+export declare function getRunPiCapabilitiesViaServer(context: {
+    projectRoot: string;
+}, runId: string): Promise<Record<string, unknown>>;
+export declare function sendRunPiPromptViaServer(context: {
+    projectRoot: string;
+}, runId: string, text: string, streamingBehavior?: "steer" | "followUp"): Promise<Record<string, unknown>>;
+export declare function sendRunPiShellViaServer(context: {
+    projectRoot: string;
+}, runId: string, text: string): Promise<Record<string, unknown>>;
+export declare function runRunPiCommandViaServer(context: {
+    projectRoot: string;
+}, runId: string, text: string): Promise<Record<string, unknown>>;
+export declare function respondRunPiExtensionUiViaServer(context: {
+    projectRoot: string;
+}, runId: string, requestId: string, valueOrCancel: {
+    value?: unknown;
+    confirmed?: boolean;
+    cancelled?: boolean;
+}): Promise<Record<string, unknown>>;
+export declare function abortRunPiViaServer(context: {
+    projectRoot: string;
+}, runId: string): Promise<Record<string, unknown>>;
+export declare function buildRunPiEventsWebSocketUrl(context: {
+    projectRoot: string;
+}, runId: string): Promise<string>;
+export declare function submitTaskRunViaServer(context: {
+    projectRoot: string;
+}, input: SubmitTaskRunInput): Promise<{
+    runId: string;
+}>;
+export {};

package/dist/src/commands/_server-client.js

@@ -325,7 +325,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 });