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

package/dist/src/local-omp-runner.d.ts

@@ -0,0 +1,52 @@
+import { ensureAgentRuntime, runtimeEnv as hydrateRuntimeEnv, type AgentRuntime } from "@rig/runtime/control-plane/runtime/isolation";
+import { spawnDetachedPtyRun } from "./pty-spawn";
+type EnsureRuntime = typeof ensureAgentRuntime;
+type RuntimeEnv = typeof hydrateRuntimeEnv;
+export type ProvisionRunWorkspaceInput = {
+    readonly projectRoot: string;
+    readonly taskId: string;
+    readonly runId: string;
+    readonly ensureRuntime?: EnsureRuntime;
+};
+export type ApplyRunEnvInput = {
+    readonly projectRoot: string;
+    readonly runtime: AgentRuntime;
+    readonly runtimeEnv?: RuntimeEnv;
+};
+export type LaunchInteractiveRunInput = {
+    readonly projectRoot: string;
+    readonly runtime: AgentRuntime;
+    readonly runId: string;
+    readonly taskId: string;
+    readonly title?: string | null;
+    readonly model?: string | null;
+    readonly prompt?: string | null;
+    readonly resolveInitialPrompt?: (projectRoot: string, taskId: string) => Promise<string>;
+    readonly forceSteerOnce?: boolean;
+};
+export type RunRunProcessInput = {
+    readonly projectRoot?: string;
+    readonly taskId: string;
+    readonly runId?: string;
+    readonly title?: string | null;
+    readonly model?: string | null;
+    readonly prompt?: string | null;
+    readonly rigRunBin?: string;
+    readonly writeStdout?: (text: string) => void;
+    readonly ensureRuntime?: EnsureRuntime;
+    readonly spawnPtyRun?: typeof spawnDetachedPtyRun;
+    readonly resolveInitialPrompt?: (projectRoot: string, taskId: string) => Promise<string>;
+    readonly forceSteerOnce?: boolean;
+};
+export declare function provisionRunWorkspace(input: ProvisionRunWorkspaceInput): Promise<AgentRuntime>;
+export declare function loadRunWorkspace(projectRoot: string, runId: string): Promise<AgentRuntime>;
+export declare function applyRunEnv(input: ApplyRunEnvInput): Promise<Record<string, string>>;
+export declare function launchInteractiveRun(input: LaunchInteractiveRunInput): Promise<void>;
+export declare function runRunProcess(input: RunRunProcessInput): Promise<{
+    runId: string;
+    pid: number;
+    sessionName: string;
+    runtime: AgentRuntime;
+}>;
+export declare function buildRunInitialPrompt(projectRoot: string, taskId: string): Promise<string>;
+export {};

package/dist/src/local-omp-runner.js

@@ -0,0 +1,184 @@
+// @bun
+// packages/rig-host/src/local-omp-runner.ts
+import { randomUUID } from "crypto";
+import { resolve } 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 } 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(dirname(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: resolve(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 = resolve(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 ?? resolve(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: resolve(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", resolve(import.meta.dir, "../../cli/config/rig-default-config.yml"), ...argv];
+}
+export {
+  runRunProcess,
+  provisionRunWorkspace,
+  loadRunWorkspace,
+  launchInteractiveRun,
+  buildRunInitialPrompt,
+  applyRunEnv
+};

package/dist/src/operator-entry.d.ts

@@ -0,0 +1,7 @@
+type OperatorCliRunOptions = {
+    readonly argv?: readonly string[];
+    readonly cwd?: string;
+    readonly envProjectRoot?: string;
+};
+export declare function runRigHostOperatorCli(input?: readonly string[] | OperatorCliRunOptions): Promise<void>;
+export {};

package/dist/src/operator-entry.js

@@ -0,0 +1,79 @@
+// @bun
+// packages/rig-host/src/domain/task.ts
+import { createPluginHost } from "@rig/core";
+import { loadConfig } from "@rig/core/load-config";
+
+// 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;
+}
+
+// packages/rig-host/src/operator-entry.ts
+var LEGACY_HOST_OPERATOR_ENTRY_RETIRED_MESSAGE = "Legacy rig-host operator entrypoint is retired for the product path. Use the default Rig OMP extension/collab session flow instead.";
+var OPERATOR_GROUPS = {
+  init: true,
+  task: true,
+  run: true,
+  inspect: true,
+  stats: true,
+  inbox: true,
+  doctor: true,
+  setup: true
+};
+function isOperatorCliRunOptions(input) {
+  return typeof input === "object" && input !== null && !Array.isArray(input);
+}
+function normalizeInput(input) {
+  if (isOperatorCliRunOptions(input)) {
+    return {
+      argv: input.argv ?? process.argv.slice(2),
+      cwd: input.cwd ?? process.cwd(),
+      envProjectRoot: input.envProjectRoot ?? process.env.RIG_PROJECT_ROOT ?? process.env.PROJECT_RIG_ROOT
+    };
+  }
+  return { argv: input ?? process.argv.slice(2), cwd: process.cwd(), envProjectRoot: process.env.RIG_PROJECT_ROOT ?? process.env.PROJECT_RIG_ROOT };
+}
+function parseOperatorCli(options) {
+  let group = null;
+  const args = [];
+  for (let index = 0;index < options.argv.length; index += 1) {
+    const token = options.argv[index];
+    if (!token)
+      continue;
+    if (token === "--cwd" || token === "--project" || token === "--project-root") {
+      index += 1;
+      continue;
+    }
+    if (token.startsWith("--"))
+      continue;
+    if (!group && OPERATOR_GROUPS[token]) {
+      group = token;
+      continue;
+    }
+    args.push(token);
+  }
+  return { group, args };
+}
+function retiredOperatorEntrypointError(parsed) {
+  const group = parsed.group ?? "task";
+  const command = parsed.args[0] ?? "";
+  if (group === "run" && (command === "start" || command === "task") || group === "task" && command === "run") {
+    return new Error(legacyAuthorityRunUnsupportedMessage());
+  }
+  if (group === "run" || group === "inspect" || group === "stats" || group === "inbox") {
+    return new Error(legacyAuthorityRunControlUnsupportedMessage());
+  }
+  return new Error(LEGACY_HOST_OPERATOR_ENTRY_RETIRED_MESSAGE);
+}
+async function runRigHostOperatorCli(input) {
+  const parsed = parseOperatorCli(normalizeInput(input));
+  throw retiredOperatorEntrypointError(parsed);
+}
+export {
+  runRigHostOperatorCli
+};

package/dist/src/protocol.d.ts

@@ -0,0 +1,123 @@
+import type { ApprovalSummary, EngineRunLog, RigCreateAdhocRunInput, RigCreateTaskRunInput, RigInterruptRunInput, RigResolveApprovalInput, RigResolveUserInputInput, RigResumeRunInput, RigSnapshot, RigStopRunInput, RigSubmitRunMessageInput, RunId, RunJournalEvent, TaskId, UserInputRequestSummary, WorkspaceId } from "@rig/contracts";
+export declare const RigHostFrameKinds: readonly ["welcome", "entry", "event", "state", "bus", "backfill", "bye", "error"];
+export type RigHostFrameKind = (typeof RigHostFrameKinds)[number];
+export declare const RigGuestFrameKinds: readonly ["hello", "command", "abort", "fetch-transcript"];
+export type RigGuestFrameKind = (typeof RigGuestFrameKinds)[number];
+type UnsupportedLegacyHostRunLaunchOptions = Partial<Pick<RigCreateAdhocRunInput, "runtimeAdapter" | "model" | "runtimeMode" | "interactionMode" | "initialPrompt" | "baselineMode" | "prMode">>;
+export type RigIdeaSnapshot = Omit<RigSnapshot, "snapshotSequence"> & {
+    readonly workspaceRoot: string;
+    readonly activeRunId: RunId | null;
+    readonly sequence: RigSnapshot["snapshotSequence"];
+};
+export type RigCreateAdhocRunCommand = {
+    readonly kind: "run.createAdhoc";
+    readonly workspaceId: WorkspaceId;
+    readonly title: RigCreateAdhocRunInput["title"];
+} & UnsupportedLegacyHostRunLaunchOptions;
+export type RigRunTaskCommand = {
+    readonly kind: "task.run";
+    readonly workspaceId: WorkspaceId;
+    readonly taskId: TaskId;
+} & Partial<Pick<RigCreateTaskRunInput, "runtimeAdapter" | "model" | "runtimeMode" | "interactionMode" | "initialPrompt" | "baselineMode" | "prMode">>;
+export type RigResumeRunCommand = {
+    readonly kind: "run.resume";
+} & Omit<RigResumeRunInput, "commandId" | "createdAt">;
+export type RigStopRunCommand = {
+    readonly kind: "run.stop";
+} & Omit<RigStopRunInput, "commandId" | "createdAt">;
+export type RigInterruptRunCommand = {
+    readonly kind: "run.interrupt";
+} & Omit<RigInterruptRunInput, "commandId" | "createdAt">;
+export type RigSubmitRunMessageCommand = {
+    readonly kind: "run.submitMessage";
+} & Omit<RigSubmitRunMessageInput, "commandId" | "messageId" | "createdAt">;
+export type RigResolveApprovalCommand = {
+    readonly kind: "approval.resolve";
+} & Omit<RigResolveApprovalInput, "commandId" | "createdAt">;
+export type RigResolveUserInputCommand = {
+    readonly kind: "input.resolve";
+} & Omit<RigResolveUserInputInput, "commandId" | "createdAt">;
+export type RigGuestCommand = {
+    readonly kind: "workspace.refresh";
+    readonly workspaceId?: WorkspaceId;
+} | RigCreateAdhocRunCommand | RigRunTaskCommand | RigResumeRunCommand | RigStopRunCommand | RigInterruptRunCommand | RigSubmitRunMessageCommand | RigResolveApprovalCommand | RigResolveUserInputCommand;
+export type RigGuestFrame = {
+    readonly t: "hello";
+    readonly sessionName: string;
+    readonly readOnly?: boolean;
+    readonly lastSeenSequence?: RigIdeaSnapshot["sequence"];
+} | {
+    readonly t: "command";
+    readonly command: RigGuestCommand;
+} | {
+    readonly t: "abort";
+    readonly runId?: RunId;
+} | {
+    readonly t: "fetch-transcript";
+    readonly reqId: number;
+    readonly runId: RunId;
+    readonly fromByte: number;
+};
+export type RigShareNotice = {
+    readonly kind: "guest-joined";
+    readonly sessionName: string;
+    readonly readOnly: boolean;
+} | {
+    readonly kind: "guest-left";
+    readonly sessionName: string;
+    readonly reason?: string;
+};
+export type RigHostBusFrame = {
+    readonly t: "bus";
+    readonly channel: "run-log";
+    readonly data: EngineRunLog;
+} | {
+    readonly t: "bus";
+    readonly channel: "approval";
+    readonly data: ApprovalSummary;
+} | {
+    readonly t: "bus";
+    readonly channel: "input";
+    readonly data: UserInputRequestSummary;
+} | {
+    readonly t: "bus";
+    readonly channel: "share";
+    readonly data: RigShareNotice;
+};
+export type RigHostFrame = {
+    readonly t: "welcome";
+    readonly snapshot: RigIdeaSnapshot;
+    readonly readOnly: boolean;
+} | {
+    readonly t: "entry";
+    readonly entry: RunJournalEvent;
+} | {
+    readonly t: "event";
+    readonly event: RunJournalEvent;
+    readonly sequence: RigIdeaSnapshot["sequence"];
+} | {
+    readonly t: "state";
+    readonly snapshot: RigIdeaSnapshot;
+} | RigHostBusFrame | {
+    readonly t: "backfill";
+    readonly reqId: number;
+    readonly runId: RunId;
+    readonly text: string;
+    readonly newSize: number;
+} | {
+    readonly t: "bye";
+    readonly reason: string;
+} | {
+    readonly t: "error";
+    readonly message: string;
+    readonly code?: string;
+};
+export type RigReplicaState = {
+    readonly snapshot?: RigIdeaSnapshot;
+    readonly readOnly: boolean;
+    readonly selectionPath: readonly string[];
+    readonly draftCommand: string;
+    readonly connection: "connecting" | "connected" | "reconnecting" | "closed";
+    readonly error?: string;
+};
+export {};

package/dist/src/protocol.js

@@ -0,0 +1,8 @@
+// @bun
+// packages/rig-host/src/protocol.ts
+var RigHostFrameKinds = ["welcome", "entry", "event", "state", "bus", "backfill", "bye", "error"];
+var RigGuestFrameKinds = ["hello", "command", "abort", "fetch-transcript"];
+export {
+  RigHostFrameKinds,
+  RigGuestFrameKinds
+};

package/dist/src/pty-spawn.d.ts

@@ -0,0 +1,25 @@
+import { type ChildProcess } from "node:child_process";
+import { closeSync as fsCloseSync, openSync as fsOpenSync } from "node:fs";
+export type SpawnDetachedPtyRunInput = {
+    readonly runId: string;
+    readonly rigRunBin: string;
+    readonly args: readonly string[];
+    readonly cwd: string;
+    readonly env: NodeJS.ProcessEnv | Record<string, string | undefined>;
+    readonly logPath: string;
+};
+export declare function buildPtyRunArgv(input: Pick<SpawnDetachedPtyRunInput, "runId" | "rigRunBin" | "args">): string[];
+export type PtySpawnDeps = {
+    readonly which?: (command: string) => string | null | Promise<string | null>;
+    readonly spawn?: (command: string, args: readonly string[], options: {
+        readonly cwd: string;
+        readonly env: NodeJS.ProcessEnv | Record<string, string | undefined>;
+        readonly detached: true;
+        readonly stdio: ["ignore", number, number];
+    }) => Pick<ChildProcess, "pid" | "unref">;
+    readonly openSync?: typeof fsOpenSync;
+    readonly closeSync?: typeof fsCloseSync;
+};
+export declare function spawnDetachedPtyRun(input: SpawnDetachedPtyRunInput, deps?: PtySpawnDeps): Promise<{
+    pid: number;
+}>;

package/dist/src/pty-spawn.js

@@ -0,0 +1,34 @@
+// @bun
+// 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 } 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(dirname(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 };
+}
+export {
+  spawnDetachedPtyRun,
+  buildPtyRunArgv
+};

package/dist/src/replication/broadcast.d.ts

@@ -0,0 +1,13 @@
+import type { CollabSocket } from "@oh-my-pi/pi-coding-agent/collab/relay-client";
+import type { RigHostFrame, RigIdeaSnapshot } from "../protocol";
+export type RigHostFrameListener = (frame: RigHostFrame) => void;
+export type RigHostCollabTransport = {
+    readonly socket?: CollabSocket;
+    send(frame: RigHostFrame, targetPeer?: number): void | Promise<void>;
+};
+export type RigHostBroadcaster = {
+    publish(frame: RigHostFrame, targetPeer?: number): void;
+    publishWelcome(snapshot: RigIdeaSnapshot, readOnly: boolean, targetPeer?: number): void;
+    rejectReadOnly(action: string, targetPeer?: number): void;
+};
+export declare function createRigHostBroadcaster(listener?: RigHostFrameListener, collab?: RigHostCollabTransport): RigHostBroadcaster;

package/dist/src/replication/broadcast.js

@@ -0,0 +1,63 @@
+// @bun
+// 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);
+    }
+  };
+}
+export {
+  createRigHostBroadcaster
+};

package/dist/src/replication/replay.d.ts

@@ -0,0 +1,12 @@
+import type { RunId } from "@rig/contracts";
+import type { RigHostFrame, RigIdeaSnapshot } from "../protocol";
+export type RigHostReplayState = {
+    readonly runs: RigIdeaSnapshot["runs"];
+    readonly approvals: RigIdeaSnapshot["approvals"];
+    readonly userInputs: NonNullable<RigIdeaSnapshot["userInputs"]>;
+    readonly sequence: RigIdeaSnapshot["sequence"];
+    readonly updatedAt: RigIdeaSnapshot["updatedAt"];
+    readonly activeRunId: RigIdeaSnapshot["activeRunId"];
+};
+export declare function loadRigHostReplayState(_workspaceRoot: string): RigHostReplayState;
+export declare function readRigTranscriptBackfill(_workspaceRoot: string, runId: RunId, _reqId: number, _fromByte: number): Promise<RigHostFrame>;

package/dist/src/replication/replay.js

@@ -0,0 +1,25 @@
+// @bun
+// packages/rig-host/src/replication/replay.ts
+var LEGACY_REPLAY_RETIRED_MESSAGE = "Legacy host run replay from authority files is retired. Use the OMP collab run detail/session projection flow for live run state.";
+function loadRigHostReplayState(_workspaceRoot) {
+  const updatedAt = new Date().toISOString();
+  return {
+    runs: [],
+    approvals: [],
+    userInputs: [],
+    sequence: 0,
+    updatedAt,
+    activeRunId: null
+  };
+}
+async function readRigTranscriptBackfill(_workspaceRoot, runId, _reqId, _fromByte) {
+  return {
+    t: "error",
+    code: "LEGACY_REPLAY_RETIRED",
+    message: `${LEGACY_REPLAY_RETIRED_MESSAGE} No transcript backfill is available for run ${runId}.`
+  };
+}
+export {
+  readRigTranscriptBackfill,
+  loadRigHostReplayState
+};

package/dist/src/replication/welcome.d.ts

@@ -0,0 +1,3 @@
+import type { RigIdeaSnapshot } from "../protocol";
+import type { RigHostReplayState } from "./replay";
+export declare function buildRigWelcomeSnapshot(workspaceRoot: string, replay: RigHostReplayState): RigIdeaSnapshot;