@h-rig/cli 0.0.6-alpha.9 → 0.0.6-alpha.90

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-driver-helpers.js

@@ -5,21 +5,33 @@ 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 { CliError as RuntimeCliError } 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";
+
+class CliError extends RuntimeCliError {
+  hint;
+  constructor(message, exitCode = 1, options = {}) {
+    super(message, exitCode);
+    if (options.hint?.trim()) {
+      this.hint = options.hint.trim();
+    }
+  }
+}
 
 // packages/cli/src/commands/_run-driver-helpers.ts
 import {
-  appendJsonlRecord,
+  appendRunJournalEvent,
+  appendRunLogEntry,
+  appendRunTimelineEntry,
+  patchAuthorityRunRecord,
   readAuthorityRun as readAuthorityRun2,
-  resolveAuthorityRunDir as resolveAuthorityRunDir2,
-  writeJsonFile as writeJsonFile2
+  resolveAuthorityRunDir,
+  setAuthorityRunStatus,
+  writeJsonFile
 } from "@rig/runtime/control-plane/authority-files";
 import { taskLookup } from "@rig/runtime/control-plane/native/task-ops";
+import { readPriorPrProgressPromptSection } from "@rig/runtime/control-plane/prompt-context";
 import { buildProviderTaskRunInstructionLines } from "@rig/runtime/control-plane/provider/runtime-instructions";
 import { loadRigTaskRunSkillBody } from "@rig/runtime/control-plane/provider/rig-task-run-skill";
 
@@ -29,8 +41,7 @@ import { resolve as resolve2 } from "path";
 import {
   readAuthorityRun,
   readJsonlFile,
-  resolveAuthorityRunDir,
-  writeJsonFile
+  writeAuthorityRunRecord
 } from "@rig/runtime/control-plane/authority-files";
 
 // packages/cli/src/commands/_paths.ts
@@ -64,16 +75,20 @@ function readLatestBeadRecord(projectRoot, taskId) {
 
 // packages/cli/src/commands/_run-driver-helpers.ts
 function patchAuthorityRun(projectRoot, runId, patch) {
-  const current = readAuthorityRun2(projectRoot, runId);
-  if (!current) {
-    throw new CliError2(`Run not found: ${runId}`, 2);
+  const next = patchAuthorityRunRecord(projectRoot, runId, patch);
+  if (!next) {
+    throw new CliError(`Run not found: ${runId}`, 2, { hint: "Run `rig run list` to see recorded runs." });
+  }
+  return next;
+}
+function setRunStatusOrFail(projectRoot, runId, to, options = {}) {
+  const next = setAuthorityRunStatus(projectRoot, runId, to, {
+    ...options,
+    actor: { kind: "agent" }
+  });
+  if (!next) {
+    throw new CliError(`Run not found: ${runId}`, 2, { hint: "Run `rig run list` to see recorded runs." });
   }
-  const next = {
-    ...current,
-    ...patch,
-    updatedAt: new Date().toISOString()
-  };
-  writeJsonFile2(resolve3(resolveAuthorityRunDir2(projectRoot, runId), "run.json"), next);
   return next;
 }
 function touchAuthorityRun(projectRoot, runId) {
@@ -81,21 +96,21 @@ function touchAuthorityRun(projectRoot, runId) {
   if (!current) {
     return;
   }
-  writeJsonFile2(resolve3(resolveAuthorityRunDir2(projectRoot, runId), "run.json"), {
+  writeJsonFile(resolve3(resolveAuthorityRunDir(projectRoot, runId), "run.json"), {
     ...current,
     updatedAt: new Date().toISOString()
   });
 }
 function appendRunTimeline(projectRoot, runId, value) {
-  appendJsonlRecord(resolve3(resolveAuthorityRunDir2(projectRoot, runId), "timeline.jsonl"), value);
+  appendRunTimelineEntry(projectRoot, runId, value);
   touchAuthorityRun(projectRoot, runId);
 }
 function appendRunLog(projectRoot, runId, value) {
-  appendJsonlRecord(resolve3(resolveAuthorityRunDir2(projectRoot, runId), "logs.jsonl"), value);
+  appendRunLogEntry(projectRoot, runId, value);
   touchAuthorityRun(projectRoot, runId);
 }
 function appendRunAction(projectRoot, runId, value) {
-  appendJsonlRecord(resolve3(resolveAuthorityRunDir2(projectRoot, runId), "timeline.jsonl"), {
+  appendRunTimelineEntry(projectRoot, runId, {
     id: value.id,
     type: "action",
     actionType: value.actionType,
@@ -149,8 +164,43 @@ function startRunAction(projectRoot, runId, input) {
     }
   };
 }
+var runEventSinkProjectRoot = null;
+function configureRunEventSink(projectRoot) {
+  runEventSinkProjectRoot = projectRoot;
+}
+var lastDoorbellRangAt = 0;
+function ringServerRunDoorbell(runId) {
+  const serverUrl = process.env.RIG_SERVER_URL?.trim();
+  if (!serverUrl)
+    return;
+  const now = Date.now();
+  if (now - lastDoorbellRangAt < 250)
+    return;
+  lastDoorbellRangAt = now;
+  const token = process.env.RIG_AUTH_TOKEN || process.env.RIG_GITHUB_TOKEN || "";
+  fetch(`${serverUrl.replace(/\/+$/, "")}/api/runs/doorbell`, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${token}`
+    },
+    body: JSON.stringify({ runId }),
+    signal: AbortSignal.timeout(1000)
+  }).catch(() => {});
+}
 function emitServerRunEvent(event) {
   console.log(`__RIG_RUN_EVENT__${JSON.stringify({ ...event, at: new Date().toISOString() })}`);
+  if (runEventSinkProjectRoot) {
+    try {
+      if (event.type === "status" || event.type === "completed" || event.type === "failed") {
+        appendRunJournalEvent(runEventSinkProjectRoot, event.runId, {
+          type: "timeline-entry",
+          payload: { kind: "driver-event", ...event }
+        });
+      }
+    } catch {}
+    ringServerRunDoorbell(event.runId);
+  }
 }
 function buildRunPrompt(input) {
   const initialPrompt = input.initialPrompt?.trim() || null;
@@ -207,6 +257,7 @@ ${acceptance}` : null,
 ${sourceContractLines.join(`
 `)}` : null,
     scopeText || renderSourceScopeValidation(sourceTask, sourceValidation) || null,
+    readPriorPrProgressPromptSection(input.projectRoot, input.taskId),
     initialPrompt ? `Additional operator guidance:
 ${initialPrompt}` : null,
     providerLines.length > 0 ? `Provider-specific runtime tooling:
@@ -280,8 +331,10 @@ function renderSourceScopeValidation(task, validation) {
 export {
   touchAuthorityRun,
   startRunAction,
+  setRunStatusOrFail,
   patchAuthorityRun,
   emitServerRunEvent,
+  configureRunEventSink,
   buildRunPrompt,
   appendRunTimeline,
   appendRunLog,

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/_run-replay.js

@@ -0,0 +1,142 @@
+// @bun
+// packages/cli/src/commands/_run-replay.ts
+import { existsSync, readdirSync } from "fs";
+import { join, resolve } from "path";
+import {
+  readAuthorityRun,
+  readJsonlFile,
+  runJournalPath
+} from "@rig/runtime/control-plane/authority-files";
+function asRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function text(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function snippet(value, max = 120) {
+  const raw = text(value);
+  if (!raw)
+    return null;
+  const flat = raw.replace(/\s+/g, " ");
+  return flat.length > max ? `${flat.slice(0, max - 1)}\u2026` : flat;
+}
+function summarizeLifecycleEntry(entry) {
+  const type = text(entry.type) ?? "event";
+  switch (type) {
+    case "status": {
+      const anchor = text(entry.sessionId);
+      return [
+        `status \u2192 ${text(entry.status) ?? "(unknown)"}`,
+        snippet(entry.detail) ? `\u2014 ${snippet(entry.detail)}` : null,
+        anchor ? `[session ${anchor}]` : null
+      ].filter(Boolean).join(" ");
+    }
+    case "timeline-entry": {
+      const payload = asRecord(entry.payload) ?? {};
+      const kind = text(payload.type) ?? "entry";
+      const body = snippet(payload.title) ?? snippet(payload.text) ?? snippet(payload.detail);
+      const state = text(payload.state);
+      return [`timeline ${kind}`, body ? `\u2014 ${body}` : null, state ? `(${state})` : null].filter(Boolean).join(" ");
+    }
+    case "log-entry": {
+      const payload = asRecord(entry.payload) ?? {};
+      const title = snippet(payload.title) ?? "log";
+      const detail = snippet(payload.detail);
+      return [`log ${title}`, detail ? `\u2014 ${detail}` : null].filter(Boolean).join(" ");
+    }
+    case "record-patch": {
+      const patch = asRecord(entry.patch) ?? {};
+      const keys = Object.keys(patch);
+      const shown = keys.slice(0, 8).join(", ");
+      return `record-patch {${shown}${keys.length > 8 ? `, +${keys.length - 8} more` : ""}}`;
+    }
+    case "timeline":
+      return "timeline updated (signal)";
+    case "log":
+      return `log signal${snippet(entry.title) ? ` \u2014 ${snippet(entry.title)}` : ""}`;
+    case "completed":
+      return "run completed";
+    case "failed":
+      return `run failed${snippet(entry.error) ? ` \u2014 ${snippet(entry.error)}` : ""}`;
+    default:
+      return type;
+  }
+}
+function summarizeSessionEntry(entry) {
+  const type = text(entry.type) ?? "entry";
+  const message = asRecord(entry.message);
+  const role = text(message?.role);
+  const content = message?.content;
+  let body = null;
+  if (typeof content === "string") {
+    body = snippet(content);
+  } else if (Array.isArray(content)) {
+    body = snippet(content.map((part) => text(asRecord(part)?.text) ?? "").filter(Boolean).join(" "));
+  }
+  return [
+    `pi ${type}`,
+    role ? `(${role})` : null,
+    body ? `\u2014 ${body}` : null
+  ].filter(Boolean).join(" ");
+}
+function sessionEntryTimestamp(entry) {
+  return text(entry.timestamp) ?? text(entry.at) ?? text(entry.createdAt) ?? null;
+}
+function resolveRunSessionFile(record) {
+  const piSession = record?.piSession ?? null;
+  if (!piSession)
+    return null;
+  const recorded = text(piSession.sessionFile);
+  if (recorded && existsSync(recorded)) {
+    return recorded;
+  }
+  const cwd = text(piSession.cwd);
+  const sessionId = text(piSession.sessionId);
+  if (!cwd || !sessionId)
+    return null;
+  const sessionDir = resolve(cwd, ".rig", "session");
+  try {
+    const match = readdirSync(sessionDir).find((name) => name.endsWith(`_${sessionId}.jsonl`));
+    return match ? join(sessionDir, match) : null;
+  } catch {
+    return null;
+  }
+}
+function buildRunReplay(projectRoot, runId, options = {}) {
+  const logPath = runJournalPath(projectRoot, runId);
+  const record = readAuthorityRun(projectRoot, runId);
+  const lifecycleEntries = readJsonlFile(logPath).map((entry) => asRecord(entry)).filter((entry) => entry !== null);
+  const merged = lifecycleEntries.map((entry) => ({
+    at: text(entry.at),
+    source: "run",
+    summary: summarizeLifecycleEntry(entry)
+  }));
+  let sessionFile = null;
+  let sessionEntryCount = 0;
+  if (options.withSession) {
+    sessionFile = resolveRunSessionFile(record);
+    if (sessionFile) {
+      let lastSeenAt = null;
+      const sessionLines = readJsonlFile(sessionFile).map((entry) => asRecord(entry)).filter((entry) => entry !== null).map((entry) => {
+        lastSeenAt = sessionEntryTimestamp(entry) ?? lastSeenAt;
+        return { at: lastSeenAt, source: "session", summary: summarizeSessionEntry(entry) };
+      });
+      sessionEntryCount = sessionLines.length;
+      merged.push(...sessionLines);
+      merged.sort((left, right) => (left.at ?? "").localeCompare(right.at ?? ""));
+    }
+  }
+  const lines = merged.map((line) => `${line.at ?? "(no timestamp)      "}  ${line.source === "run" ? "run    " : "session"}  ${line.summary}`);
+  return {
+    runId,
+    logPath,
+    sessionFile,
+    entryCount: lifecycleEntries.length,
+    sessionEntryCount,
+    lines
+  };
+}
+export {
+  resolveRunSessionFile,
+  buildRunReplay
+};

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