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

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/_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 {};

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/_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/_snapshot-upload.d.ts

@@ -0,0 +1,39 @@
+export declare const UPLOADED_SNAPSHOT_PR_MARKER = "<!-- rig:uploaded-snapshot -->";
+export declare const SNAPSHOT_ARCHIVE_VERSION = 1;
+export declare const SNAPSHOT_ARCHIVE_CONTENT_TYPE = "application/vnd.rig.snapshot+json";
+export type SnapshotUploadManifest = {
+    readonly root: string;
+    readonly files: readonly string[];
+    readonly excludedDirectories: readonly string[];
+};
+export type SnapshotUploadArchiveFile = {
+    readonly path: string;
+    readonly contentBase64: string;
+};
+export type SnapshotUploadArchive = {
+    readonly version: typeof SNAPSHOT_ARCHIVE_VERSION;
+    readonly root: string;
+    readonly files: readonly SnapshotUploadArchiveFile[];
+    readonly excludedDirectories: readonly string[];
+    readonly createdAt: string;
+};
+export declare function buildSnapshotUploadManifest(projectRoot: string, options?: {
+    readonly excludedDirectories?: readonly string[];
+}): Promise<SnapshotUploadManifest>;
+export declare function createSnapshotUploadArchive(projectRoot: string, options?: {
+    readonly excludedDirectories?: readonly string[];
+    readonly now?: () => Date;
+}): Promise<SnapshotUploadArchive>;
+export declare function encodeSnapshotUploadArchive(archive: SnapshotUploadArchive): string;
+export declare function writeSnapshotUploadArchive(projectRoot: string, outputPath: string, options?: {
+    readonly excludedDirectories?: readonly string[];
+    readonly now?: () => Date;
+}): Promise<SnapshotUploadArchive>;
+export declare function uploadSnapshotArchiveViaServer(context: {
+    readonly projectRoot: string;
+}, input: {
+    readonly repoSlug: string;
+    readonly archive: SnapshotUploadArchive;
+    readonly baseDir?: string;
+}): Promise<Record<string, unknown>>;
+export declare function appendUploadedSnapshotPrNotice(body: string): string;

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

@@ -0,0 +1,25 @@
+export declare const SPINNER_FRAMES: readonly ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+export type TtySpinner = {
+    setLabel(label: string): void;
+    /** Erase the spinner line so other output can print cleanly. */
+    pause(): void;
+    /** Resume rendering after pause(). */
+    resume(): void;
+    /** Stop for good; optionally leave a final line. */
+    stop(finalLine?: string): void;
+};
+/**
+ * A line-rewriting spinner for async CLI waits. On non-TTY outputs it prints
+ * the label once (and label changes) so logs stay readable without ANSI.
+ */
+export declare function createTtySpinner(input: {
+    label: string;
+    output?: Pick<NodeJS.WriteStream, "write"> & {
+        readonly isTTY?: boolean;
+    };
+    intervalMs?: number;
+    /** Frame glyph cycle; defaults to SPINNER_FRAMES. */
+    frames?: readonly string[];
+    /** Optional glyph decorator (e.g. color), applied on TTY renders only. */
+    styleFrame?: (frame: string) => string;
+}): TtySpinner;

package/dist/src/commands/_task-picker.d.ts

@@ -0,0 +1,9 @@
+import type { WorkspaceTaskRecord } from "./_server-client";
+import { renderTaskPickerRows, type TaskPickerRenderer } from "./_operator-surface";
+export { renderTaskPickerRows, type TaskPickerRenderer };
+export type TaskPickerIO = {
+    readonly isTty?: boolean;
+    readonly prompt?: (question: string) => Promise<string>;
+    readonly renderer?: TaskPickerRenderer;
+};
+export declare function selectTaskWithTextPicker(tasks: readonly WorkspaceTaskRecord[], io?: TaskPickerIO): Promise<WorkspaceTaskRecord | null>;

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

@@ -0,0 +1,3 @@
+import { type RunnerContext } from "../runner";
+import type { CommandOutcome } from "@rig/runtime/control-plane/runtime/types";
+export declare function executeAgent(context: RunnerContext, args: string[]): Promise<CommandOutcome>;

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

@@ -0,0 +1,65 @@
+import { type RunnerContext } from "../runner";
+import type { CommandOutcome } from "@rig/runtime/control-plane/runtime/types";
+export type BrowserHelpOptions = {
+    color?: boolean;
+};
+export declare function browserHelpText(options?: BrowserHelpOptions): string;
+type BrowserDemoRuntimeOptions = {
+    port?: number;
+    profile?: string;
+    stateDir?: string;
+    targetUrl?: string;
+};
+type BrowserDemoRuntime = {
+    attachUrl: string;
+    browserDir: string;
+    env: Record<string, string>;
+    helperCommands: string[];
+    port: number;
+    profile: string;
+    stateDir: string;
+    targetUrl: string;
+};
+type BrowserDemoAgentCommand = {
+    accepted: string[];
+    primary: string;
+};
+type BrowserDemoAgentCommands = {
+    attach: BrowserDemoAgentCommand;
+    attachInfo: BrowserDemoAgentCommand;
+    check: BrowserDemoAgentCommand;
+    launch: BrowserDemoAgentCommand;
+};
+export declare function buildBrowserDemoRuntime(projectRoot: string, options?: BrowserDemoRuntimeOptions): BrowserDemoRuntime;
+export declare function buildBrowserDemoAgentCommands(runtime: Pick<BrowserDemoRuntime, "attachUrl">): BrowserDemoAgentCommands;
+export declare function normalizeBrowserDemoCommand(value: string): string;
+export declare function browserDemoCommandMatches(value: string, command: BrowserDemoAgentCommand): boolean;
+export declare function browserDemoCommandCompletions(line: string, command: BrowserDemoAgentCommand): [string[], string];
+export declare function formatBrowserDemoCommandOutput(command: string, output: string): string;
+export declare function executeBrowser(context: RunnerContext, args: string[]): Promise<CommandOutcome>;
+export declare function executeBrowserDemo(context: RunnerContext, args: string[]): Promise<CommandOutcome>;
+type BrowserDemoVersionInfo = {
+    Browser?: string;
+    webSocketDebuggerUrl?: string;
+};
+type BrowserDemoTarget = {
+    id?: string;
+    title?: string;
+    type?: string;
+    url?: string;
+    webSocketDebuggerUrl?: string;
+};
+type BrowserDemoCdpResult = {
+    afterDomState: unknown;
+    beforeDomState: unknown;
+    consoleEvents: unknown[];
+    layoutMetrics: unknown;
+    mutationEvaluation: unknown;
+    title: string | undefined;
+};
+export declare function formatBrowserDemoCheckOutput(runtime: BrowserDemoRuntime, version: BrowserDemoVersionInfo, pageTarget: BrowserDemoTarget, targets: BrowserDemoTarget[]): string;
+export declare function formatBrowserDemoCdpResult(result: BrowserDemoCdpResult): string;
+export declare function findBrowserDemoPageTarget(runtime: Pick<BrowserDemoRuntime, "targetUrl">, targets: BrowserDemoTarget[]): (BrowserDemoTarget & {
+    webSocketDebuggerUrl: string;
+}) | null;
+export {};

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

@@ -0,0 +1,7 @@
+import { type RunnerContext } from "../runner";
+import type { CommandOutcome } from "@rig/runtime/control-plane/runtime/types";
+export type ConnectionCommandOptions = {
+    group: "server";
+    interactiveUse?: boolean;
+};
+export declare function executeConnectionCommand(context: RunnerContext, args: string[], options: ConnectionCommandOptions): Promise<CommandOutcome>;