@h-rig/rig-host 0.0.6-alpha.91

package/dist/src/index.js

@@ -0,0 +1,684 @@
+// @bun
+// packages/rig-host/src/host-session.ts
+import { resolve as resolve3 } from "path";
+
+// packages/rig-host/src/domain/run.ts
+import { basename, resolve as resolve2 } from "path";
+
+// packages/rig-host/src/domain/task.ts
+import { resolve } from "path";
+import { createPluginHost } from "@rig/core";
+import { loadConfig } from "@rig/core/load-config";
+function stringList(value) {
+  if (!Array.isArray(value))
+    return [];
+  return value.filter((entry) => typeof entry === "string").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+}
+function stringOrNull(value) {
+  if (typeof value !== "string")
+    return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function titleFor(record) {
+  return stringOrNull(record.title) ?? stringOrNull(record.name) ?? record.id;
+}
+function descriptionFor(record) {
+  return stringOrNull(record.description) ?? stringOrNull(record.body) ?? "";
+}
+function scopeFor(record) {
+  const direct = stringList(record.scope);
+  if (direct.length > 0)
+    return direct;
+  return stringList(record.labels).filter((label) => label.startsWith("scope:")).map((label) => label.slice("scope:".length).trim()).filter((label) => label.length > 0);
+}
+function validationKeysFor(record) {
+  const direct = stringList(record.validationKeys);
+  if (direct.length > 0)
+    return direct;
+  const validation = stringList(record.validation);
+  if (validation.length > 0)
+    return validation;
+  return stringList(record.labels).filter((label) => label.startsWith("validator:")).map((label) => label.slice("validator:".length).trim()).filter((label) => label.length > 0);
+}
+function createdAtFor(record, fallback) {
+  return stringOrNull(record.createdAt) ?? fallback;
+}
+function updatedAtFor(record, fallback) {
+  return stringOrNull(record.updatedAt) ?? createdAtFor(record, fallback) ?? fallback;
+}
+function mapTaskRecordToSummary(record, workspaceId, fallbackTimestamp) {
+  const metadata = record;
+  const createdAt = createdAtFor(record, fallbackTimestamp);
+  const updatedAt = updatedAtFor(record, fallbackTimestamp);
+  return {
+    id: record.id,
+    workspaceId,
+    graphId: null,
+    externalId: stringOrNull(metadata.externalId) ?? stringOrNull(metadata.externalRef),
+    title: titleFor(record),
+    description: descriptionFor(record),
+    status: record.status,
+    priority: typeof metadata.priority === "number" && Number.isInteger(metadata.priority) && metadata.priority > 0 ? metadata.priority : null,
+    role: stringOrNull(metadata.role),
+    scope: scopeFor(record),
+    validationKeys: validationKeysFor(record),
+    sourceIssueId: stringOrNull(metadata.sourceIssueId),
+    dependencies: [...record.deps],
+    parentChildDeps: [],
+    metadata,
+    createdAt,
+    updatedAt
+  };
+}
+async function loadRigIdeaTasks(workspaceRoot) {
+  const normalizedRoot = resolve(workspaceRoot);
+  const config = await loadConfig(normalizedRoot);
+  const pluginHost = createPluginHost(config.plugins);
+  const taskSourceFactory = pluginHost.resolveTaskSourceFactoryByKind(config.taskSource.kind);
+  if (!taskSourceFactory) {
+    const kinds = pluginHost.listExecutableTaskSources().map((entry) => entry.kind).join(", ") || "none";
+    throw new Error(`No task source factory registered for kind "${config.taskSource.kind}". Registered kinds: ${kinds}.`);
+  }
+  const source = taskSourceFactory.factory(config.taskSource, { projectRoot: normalizedRoot });
+  const fallbackTimestamp = new Date().toISOString();
+  const workspaceId = normalizedRoot;
+  const tasks = await source.list();
+  return tasks.map((task) => mapTaskRecordToSummary(task, workspaceId, fallbackTimestamp));
+}
+
+// packages/rig-host/src/domain/run.ts
+var LEGACY_AUTHORITY_RUN_CREATION_RETIRED_MESSAGE = "Legacy rig-host run-record creation is retired for the product path. Use the default Rig OMP extension/collab session flow instead.";
+var LEGACY_AUTHORITY_RUN_CONTROL_RETIRED_MESSAGE = "Legacy rig-host run-record control, inspection, and active-run state are retired for the product path. Use the default Rig OMP extension/collab session flow instead.";
+function legacyAuthorityRunUnsupportedMessage() {
+  return LEGACY_AUTHORITY_RUN_CREATION_RETIRED_MESSAGE;
+}
+function legacyAuthorityRunControlUnsupportedMessage() {
+  return LEGACY_AUTHORITY_RUN_CONTROL_RETIRED_MESSAGE;
+}
+function legacyAuthorityRunControlUnsupportedError() {
+  return new Error(legacyAuthorityRunControlUnsupportedMessage());
+}
+function projectRetiredLegacyRigIdeaWorkspace(workspaceRoot, tasks) {
+  const normalizedRoot = resolve2(workspaceRoot);
+  const updatedAt = new Date().toISOString();
+  const title = basename(normalizedRoot) || normalizedRoot;
+  return {
+    workspaceRoot: normalizedRoot,
+    activeRunId: null,
+    sequence: 0,
+    workspaces: [{
+      id: normalizedRoot,
+      title,
+      rootPath: normalizedRoot,
+      sourceKind: "native",
+      defaultModel: null,
+      createdAt: updatedAt,
+      updatedAt
+    }],
+    graphs: [],
+    tasks: [...tasks],
+    runs: [],
+    runtimes: [],
+    conversations: [],
+    messages: [],
+    actions: [],
+    logs: [],
+    approvals: [],
+    userInputs: [],
+    validations: [],
+    reviews: [],
+    artifacts: [],
+    policyDecisions: [],
+    queue: [],
+    worktrees: [],
+    remoteEndpoints: [],
+    remoteConnections: [],
+    remoteOrchestrations: [],
+    updatedAt
+  };
+}
+async function createRigIdeaHarness(workspaceRoot) {
+  const normalizedRoot = resolve2(workspaceRoot);
+  const tasks = await loadRigIdeaTasks(normalizedRoot).catch(() => []);
+  return {
+    snapshot() {
+      return projectRetiredLegacyRigIdeaWorkspace(normalizedRoot, tasks);
+    },
+    async stopRun(_runId) {
+      throw legacyAuthorityRunControlUnsupportedError();
+    },
+    async resolveApproval(_runId, _requestId, _decision) {
+      throw legacyAuthorityRunControlUnsupportedError();
+    },
+    async resolveUserInput(_runId, _requestId, _answers) {
+      throw legacyAuthorityRunControlUnsupportedError();
+    }
+  };
+}
+
+// packages/rig-host/src/replication/broadcast.ts
+function createRigHostBroadcaster(listener, collab) {
+  const backlog = [];
+  const welcomedPeers = new Set;
+  const hasWelcomedRelayPeer = () => {
+    for (const peer of welcomedPeers) {
+      if (peer !== 0)
+        return true;
+    }
+    return false;
+  };
+  const emit = (frame, targetPeer = 0) => {
+    listener?.(frame);
+    collab?.send(frame, targetPeer);
+  };
+  const flush = (targetPeer) => {
+    let write = 0;
+    for (let read = 0;read < backlog.length; read += 1) {
+      const next = backlog[read];
+      if (next.targetPeer === targetPeer) {
+        emit(next.frame, next.targetPeer);
+      } else {
+        backlog[write] = next;
+        write += 1;
+      }
+    }
+    backlog.length = write;
+  };
+  return {
+    publish(frame, targetPeer = 0) {
+      if (frame.t === "welcome") {
+        welcomedPeers.add(targetPeer);
+        emit(frame, targetPeer);
+        flush(targetPeer);
+        return;
+      }
+      if (!welcomedPeers.has(targetPeer) && frame.t !== "bye" && frame.t !== "error") {
+        if (targetPeer === 0) {
+          if (hasWelcomedRelayPeer())
+            emit(frame, targetPeer);
+          return;
+        }
+        backlog.push({ frame, targetPeer });
+        return;
+      }
+      emit(frame, targetPeer);
+    },
+    publishWelcome(snapshot, readOnly, targetPeer) {
+      this.publish({ t: "welcome", snapshot, readOnly }, targetPeer);
+    },
+    rejectReadOnly(action, targetPeer) {
+      this.publish({
+        t: "error",
+        code: "READ_ONLY",
+        message: `${action} is disabled on a read-only link`
+      }, targetPeer);
+    }
+  };
+}
+
+// packages/rig-host/src/host-session.ts
+var LOCAL_PEER_ID = 0;
+var RIG_GENERIC_OMP_JOIN_LIMITATION = "Legacy rig-host remote join and attachment are retired for the product path. Use the default Rig OMP extension/collab session flow instead.";
+var RIG_RUN_SCOPE_LIMITATION = "Legacy rig-host selected-run remote join is retired for the product path. Selected-run discovery now belongs to OMP collab; use the default Rig OMP extension/collab session flow instead.";
+async function createRigOmpWritableJoinLink(_options) {
+  throw new Error(RIG_GENERIC_OMP_JOIN_LIMITATION);
+}
+async function createRigOmpJoinRoute(options) {
+  const runId = options.runId?.trim() ? options.runId : null;
+  throw new Error(runId ? RIG_RUN_SCOPE_LIMITATION : RIG_GENERIC_OMP_JOIN_LIMITATION);
+}
+async function joinRigOmpRelayLink(_options) {
+  throw new Error(RIG_GENERIC_OMP_JOIN_LIMITATION);
+}
+async function runRigJoinSelectedRun(_options) {
+  throw new Error(RIG_RUN_SCOPE_LIMITATION);
+}
+function rigGenericOmpJoinLimitation() {
+  return RIG_GENERIC_OMP_JOIN_LIMITATION;
+}
+async function startRigHostSession(options) {
+  if (options.relayUrl) {
+    throw new Error(RIG_GENERIC_OMP_JOIN_LIMITATION);
+  }
+  const workspaceRoot = resolve3(options.workspaceRoot);
+  let stopped = false;
+  let harness = await createRigIdeaHarness(workspaceRoot);
+  let snapshot = harness.snapshot();
+  let hostSequence = snapshot.sequence;
+  const guests = new Map;
+  const broadcast = createRigHostBroadcaster(options.onFrame);
+  function publishState(nextSnapshot) {
+    hostSequence = Math.max(hostSequence, nextSnapshot.sequence) + 1;
+    snapshot = { ...nextSnapshot, sequence: hostSequence };
+    broadcast.publish({ t: "state", snapshot });
+    return snapshot;
+  }
+  async function refreshWorkspaceState() {
+    harness = await createRigIdeaHarness(workspaceRoot);
+    publishState(harness.snapshot());
+  }
+  function publishLegacyRunError(message, fromPeer) {
+    broadcast.publish({
+      t: "error",
+      code: "LEGACY_AUTHORITY_RUN_UNSUPPORTED",
+      message
+    }, fromPeer);
+  }
+  async function handleCommand(frame, fromPeer) {
+    switch (frame.command.kind) {
+      case "workspace.refresh":
+        await refreshWorkspaceState();
+        return;
+      case "run.createAdhoc":
+      case "task.run":
+        publishLegacyRunError(legacyAuthorityRunUnsupportedMessage(), fromPeer);
+        return;
+      case "run.stop":
+      case "run.resume":
+      case "run.interrupt":
+      case "run.submitMessage":
+      case "approval.resolve":
+      case "input.resolve":
+        publishLegacyRunError(legacyAuthorityRunControlUnsupportedMessage(), fromPeer);
+        return;
+    }
+  }
+  async function handleGuestFrame(frame, fromPeer = LOCAL_PEER_ID) {
+    if (stopped)
+      return;
+    switch (frame.t) {
+      case "hello": {
+        const guest = {
+          sessionName: frame.sessionName.trim().slice(0, 64) || `guest-${fromPeer}`,
+          readOnly: frame.readOnly === true
+        };
+        guests.set(fromPeer, guest);
+        broadcast.publishWelcome(snapshot, guest.readOnly, fromPeer);
+        return;
+      }
+      case "command": {
+        if (guests.get(fromPeer)?.readOnly !== false) {
+          broadcast.rejectReadOnly("command", fromPeer);
+          return;
+        }
+        try {
+          await handleCommand(frame, fromPeer);
+        } catch (error) {
+          broadcast.publish({
+            t: "error",
+            code: "COMMAND_FAILED",
+            message: error instanceof Error ? error.message : String(error)
+          }, fromPeer);
+        }
+        return;
+      }
+      case "abort": {
+        if (guests.get(fromPeer)?.readOnly !== false) {
+          broadcast.rejectReadOnly("abort", fromPeer);
+          return;
+        }
+        publishLegacyRunError(legacyAuthorityRunControlUnsupportedMessage(), fromPeer);
+        return;
+      }
+      case "fetch-transcript": {
+        publishLegacyRunError(legacyAuthorityRunControlUnsupportedMessage(), fromPeer);
+        return;
+      }
+    }
+  }
+  return {
+    snapshot() {
+      return snapshot;
+    },
+    async createShareLink(_readOnly = false) {
+      throw new Error(RIG_GENERIC_OMP_JOIN_LIMITATION);
+    },
+    handleGuestFrame(frame) {
+      return handleGuestFrame(frame);
+    },
+    async stop(reason) {
+      if (stopped)
+        return;
+      stopped = true;
+      broadcast.publish({ t: "bye", reason });
+    }
+  };
+}
+// packages/rig-host/src/protocol.ts
+var RigHostFrameKinds = ["welcome", "entry", "event", "state", "bus", "backfill", "bye", "error"];
+var RigGuestFrameKinds = ["hello", "command", "abort", "fetch-transcript"];
+// packages/rig-host/src/cli-entry.ts
+import { existsSync, readFileSync } from "fs";
+import { dirname, resolve as resolve4 } from "path";
+function packageVersionFrom(startDir) {
+  let current = resolve4(startDir);
+  while (true) {
+    const pkgPath = resolve4(current, "package.json");
+    if (existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+        if ((pkg.name === "rig" || pkg.name === "@rig/cli" || pkg.name === "@h-rig/cli") && pkg.version)
+          return pkg.version;
+      } catch {}
+    }
+    const parent = dirname(current);
+    if (parent === current)
+      return null;
+    current = parent;
+  }
+}
+function usageText() {
+  return [
+    "Usage: rig [host|share] [--workspace <path>] [--json]",
+    "",
+    "Commands:",
+    "  host   Boot the host-authoritative runtime and print the current workspace summary.",
+    "  share  Boot the host-authoritative runtime and print a read-only share link.",
+    "",
+    "Flags:",
+    "  --workspace <path>  Override the workspace root (defaults to the current working directory).",
+    "  --json              Emit JSON instead of the text summary.",
+    "  --write             For share, emit a writable collaboration link instead of read-only.",
+    "  --help, -h          Show this help text.",
+    "  --version, -V       Show the rig CLI version."
+  ].join(`
+`);
+}
+function parseRigHostCli(args) {
+  let command = "host";
+  let help = false;
+  let json = false;
+  let readOnly = true;
+  let version = false;
+  let workspaceRoot = process.cwd();
+  for (let index = 0;index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === undefined)
+      continue;
+    if (arg === "--help" || arg === "-h" || arg === "help") {
+      help = true;
+      continue;
+    }
+    if (arg === "--version" || arg === "-V" || arg === "version") {
+      version = true;
+      continue;
+    }
+    if (arg === "--json") {
+      json = true;
+      continue;
+    }
+    if (arg === "--write") {
+      readOnly = false;
+      continue;
+    }
+    if (arg === "--workspace") {
+      const next = args[index + 1];
+      if (!next)
+        throw new Error("Missing value for --workspace");
+      workspaceRoot = next;
+      index += 1;
+      continue;
+    }
+    if (arg === "host" || arg === "share") {
+      command = arg;
+      continue;
+    }
+    return null;
+  }
+  return {
+    command,
+    help,
+    json,
+    readOnly,
+    version,
+    workspaceRoot: resolve4(workspaceRoot)
+  };
+}
+function writeLine(text) {
+  process.stdout.write(`${text}
+`);
+}
+function renderHostSummary(workspaceRoot, snapshot) {
+  const pendingApprovals = snapshot.approvals.filter((item) => item.status === "pending").length;
+  const pendingInputs = (snapshot.userInputs ?? []).filter((item) => item.status === "pending").length;
+  return [
+    `Workspace: ${workspaceRoot}`,
+    `Tasks: ${snapshot.tasks.length}`,
+    `Runs: ${snapshot.runs.length}`,
+    `Approvals: ${pendingApprovals}`,
+    `Inputs: ${pendingInputs}`
+  ];
+}
+async function runRigHostCli(args) {
+  const options = parseRigHostCli(args);
+  if (!options) {
+    throw new Error("__RIG_HOST_CLI_FALLBACK__");
+  }
+  if (options.version) {
+    writeLine(`rig ${process.env.RIG_CLI_VERSION?.trim() || packageVersionFrom(import.meta.dir) || "0.0.0-dev"}`);
+    return;
+  }
+  if (options.help) {
+    writeLine(usageText());
+    return;
+  }
+  const host = await startRigHostSession({ workspaceRoot: options.workspaceRoot });
+  try {
+    if (options.command === "share") {
+      const link = await host.createShareLink(options.readOnly);
+      if (options.json) {
+        writeLine(JSON.stringify({ link, readOnly: options.readOnly, workspaceRoot: options.workspaceRoot }, null, 2));
+        return;
+      }
+      writeLine(`Share link (${options.readOnly ? "read-only" : "write"}): ${link}`);
+      return;
+    }
+    const snapshot = host.snapshot();
+    if (options.json) {
+      writeLine(JSON.stringify({
+        connection: "connected",
+        snapshot
+      }, null, 2));
+      return;
+    }
+    for (const line of renderHostSummary(options.workspaceRoot, snapshot))
+      writeLine(line);
+  } finally {
+    await host.stop("rig host cli complete");
+  }
+}
+// packages/rig-host/src/local-omp-runner.ts
+import { randomUUID } from "crypto";
+import { resolve as resolve5 } from "path";
+import { createAgentSession, SessionManager } from "@oh-my-pi/pi-coding-agent";
+import { parseArgs } from "@oh-my-pi/pi-coding-agent/cli/args";
+import { runRootCommand } from "@oh-my-pi/pi-coding-agent/main";
+import {
+  ensureAgentRuntime,
+  listAgentRuntimes,
+  resolveRuntimeTaskRecord,
+  runtimeEnv as hydrateRuntimeEnv
+} from "@rig/runtime/control-plane/runtime/isolation";
+import rigExtension from "@rig/rig-extension";
+
+// packages/rig-host/src/pty-spawn.ts
+import { spawn as nodeSpawn } from "child_process";
+import { closeSync as fsCloseSync, mkdirSync, openSync as fsOpenSync } from "fs";
+import { dirname as dirname2 } from "path";
+function buildPtyRunArgv(input) {
+  return ["-L", `rig-${input.runId}`, "new-session", "-d", "-s", `rig-run-${input.runId}`, input.rigRunBin, "--inside-pty", ...input.args];
+}
+async function spawnDetachedPtyRun(input, deps = {}) {
+  const tmux = await (deps.which ?? Bun.which)("tmux");
+  if (!tmux) {
+    throw new Error("tmux is required to launch a detached Rig PTY run. Install tmux or provide a Phase-0-approved PTY fallback.");
+  }
+  mkdirSync(dirname2(input.logPath), { recursive: true });
+  const openSync = deps.openSync ?? fsOpenSync;
+  const closeSync = deps.closeSync ?? fsCloseSync;
+  const spawn = deps.spawn ?? nodeSpawn;
+  const logFd = openSync(input.logPath, "a");
+  const child = spawn(tmux, buildPtyRunArgv(input), {
+    cwd: input.cwd,
+    env: input.env,
+    detached: true,
+    stdio: ["ignore", logFd, logFd]
+  });
+  closeSync(logFd);
+  child.unref();
+  if (typeof child.pid !== "number")
+    throw new Error("tmux did not report a child process pid for the detached Rig run.");
+  return { pid: child.pid };
+}
+
+// packages/rig-host/src/local-omp-runner.ts
+async function provisionRunWorkspace(input) {
+  return (input.ensureRuntime ?? ensureAgentRuntime)({
+    projectRoot: input.projectRoot,
+    id: input.runId,
+    taskId: input.taskId,
+    mode: "worktree",
+    provider: "pi"
+  });
+}
+async function loadRunWorkspace(projectRoot, runId) {
+  const runtimes = await listAgentRuntimes(projectRoot);
+  const runtime = runtimes.find((candidate) => candidate.id === runId);
+  if (!runtime)
+    throw new Error(`Rig run workspace is not provisioned for run ${runId}.`);
+  return runtime;
+}
+async function applyRunEnv(input) {
+  const env = await (input.runtimeEnv ?? hydrateRuntimeEnv)(input.projectRoot, input.runtime);
+  for (const [key, value] of Object.entries(env))
+    process.env[key] = value;
+  return env;
+}
+async function launchInteractiveRun(input) {
+  await applyRunEnv({ projectRoot: input.projectRoot, runtime: input.runtime });
+  process.env.RIG_RUN_PROCESS = "1";
+  process.env.RIG_RUN_ID = input.runId;
+  process.env.RIG_TASK_ID = input.taskId;
+  process.env.PROJECT_RIG_ROOT = input.projectRoot;
+  process.env.RIG_HOST_PROJECT_ROOT = input.projectRoot;
+  if (input.title?.trim())
+    process.env.RIG_RUN_TITLE = input.title.trim();
+  if (input.forceSteerOnce)
+    process.env.RIG_RUN_FORCE_STEER_ONCE = "1";
+  const sessionManager = SessionManager.create(input.runtime.workspaceDir, input.runtime.sessionDir);
+  await sessionManager.ensureOnDisk();
+  const initialPrompt = input.prompt?.trim() || await (input.resolveInitialPrompt ?? buildRunInitialPrompt)(input.projectRoot, input.taskId);
+  const args = withRigDefaultConfig([
+    ...input.model?.trim() ? ["--model", input.model.trim()] : [],
+    initialPrompt
+  ]);
+  const createRigAgentSession = async (options = {}) => createAgentSession({
+    ...options,
+    cwd: input.runtime.workspaceDir,
+    agentDir: resolve5(input.runtime.homeDir, ".pi", "agent"),
+    sessionManager,
+    extensions: [(api) => rigExtension(api), ...options.extensions ?? []]
+  });
+  await runRootCommand(parseArgs(args), args, { createAgentSession: createRigAgentSession });
+}
+async function runRunProcess(input) {
+  const projectRoot = resolve5(input.projectRoot ?? process.cwd());
+  const runId = input.runId?.trim() || `run-${randomUUID()}`;
+  const runtime = await provisionRunWorkspace({
+    projectRoot,
+    taskId: input.taskId,
+    runId,
+    ...input.ensureRuntime ? { ensureRuntime: input.ensureRuntime } : {}
+  });
+  const rigRunBin = input.rigRunBin ?? resolve5(import.meta.dir, "../bin/rig-run.ts");
+  const initialPrompt = input.prompt?.trim() || await (input.resolveInitialPrompt ?? buildRunInitialPrompt)(projectRoot, input.taskId);
+  const env = {
+    ...process.env,
+    RIG_RUN_PROCESS: "1",
+    RIG_RUN_ID: runId,
+    RIG_TASK_ID: input.taskId,
+    ...input.title?.trim() ? { RIG_RUN_TITLE: input.title.trim() } : {}
+  };
+  const args = [
+    "--task",
+    input.taskId,
+    "--run-id",
+    runId,
+    "--project",
+    projectRoot,
+    ...input.title?.trim() ? ["--title", input.title.trim()] : [],
+    ...input.model?.trim() ? ["--model", input.model.trim()] : [],
+    ...input.forceSteerOnce || process.env.RIG_RUN_FORCE_STEER_ONCE === "1" ? ["--force-steer-once"] : [],
+    "--prompt",
+    initialPrompt
+  ];
+  const spawnRun = input.spawnPtyRun ?? spawnDetachedPtyRun;
+  const { pid } = await spawnRun({
+    runId,
+    rigRunBin,
+    args,
+    cwd: runtime.workspaceDir,
+    env,
+    logPath: resolve5(runtime.logsDir, "run-process.log")
+  });
+  const sessionName = `rig-run-${runId}`;
+  input.writeStdout?.(`${runId}
+${sessionName}
+`);
+  return { runId, pid, sessionName, runtime };
+}
+async function buildRunInitialPrompt(projectRoot, taskId) {
+  const { task } = await resolveRuntimeTaskRecord({ projectRoot, taskId });
+  const record = task;
+  const title = readPromptString(record.title) ?? taskId;
+  const body = readPromptString(record.body) ?? readPromptString(record.description);
+  const acceptance = readPromptString(record.acceptanceCriteria) ?? readPromptString(record.acceptance_criteria);
+  const scope = readPromptList(record.scope);
+  const validation = readPromptList(record.validation).length > 0 ? readPromptList(record.validation) : readPromptList(record.validators);
+  const sections = [
+    `You are working on task ${taskId}: ${title}.`,
+    body ? `Task:
+${body}` : null,
+    acceptance ? `Acceptance criteria:
+${acceptance}` : null,
+    scope.length > 0 ? `Scope:
+- ${scope.join(`
+- `)}` : null,
+    validation.length > 0 ? `Validation:
+- ${validation.join(`
+- `)}` : null,
+    "Work directly in the assigned runtime workspace and leave the result in a reviewable state."
+  ];
+  return sections.filter((value) => Boolean(value)).join(`
+
+`);
+}
+function readPromptString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function readPromptList(value) {
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string" && entry.trim().length > 0).map((entry) => entry.trim()) : [];
+}
+function withRigDefaultConfig(argv) {
+  return ["--config", resolve5(import.meta.dir, "../../cli/config/rig-default-config.yml"), ...argv];
+}
+export {
+  startRigHostSession,
+  spawnDetachedPtyRun,
+  runRunProcess,
+  runRigJoinSelectedRun,
+  runRigHostCli,
+  rigGenericOmpJoinLimitation,
+  provisionRunWorkspace,
+  loadRunWorkspace,
+  launchInteractiveRun,
+  joinRigOmpRelayLink,
+  createRigOmpWritableJoinLink,
+  createRigOmpJoinRoute,
+  buildRunInitialPrompt,
+  buildPtyRunArgv,
+  applyRunEnv,
+  RigHostFrameKinds,
+  RigGuestFrameKinds
+};