@h-rig/core 0.0.6-alpha.17 → 0.0.6-alpha.170

package/dist/src/run-provisioning.d.ts

@@ -0,0 +1,58 @@
+export declare const RUN_WORKSPACE_ISOLATION_MODE: "worktree";
+export declare const RUN_WORKSPACE_PROVIDER: "pi";
+export declare const REMOTE_RIG_RUN_COMMAND: "rig-run";
+export declare const REMOTE_RESOLVED_RIG_RUN_COMMAND: "\"$__RIG_RUN_BIN\"";
+export type RunWorkspaceProvisioningOptions = {
+    readonly projectRoot: string;
+    readonly id: string;
+    readonly taskId: string;
+    readonly mode: typeof RUN_WORKSPACE_ISOLATION_MODE;
+    readonly provider: typeof RUN_WORKSPACE_PROVIDER;
+};
+export type RigRunLaunchOptions = {
+    readonly taskId: string;
+    readonly title?: string | null | undefined;
+    readonly model?: string | null | undefined;
+    readonly prompt?: string | null | undefined;
+    readonly forceSteerOnce?: boolean | undefined;
+};
+export type RemoteCheckoutPlan = {
+    readonly mode: "configured" | "managed";
+    readonly repoName: string;
+    readonly checkoutPath: string;
+    readonly checkoutPathKind: "literal" | "home-relative";
+    readonly originUrl: string | null;
+};
+export type RunGithubAuthMaterialization = {
+    readonly operatorAuthPath: string;
+    readonly operatorStateDir: string;
+    readonly remoteAuthPath: string;
+    readonly remoteStateDir: string;
+};
+export declare function buildRunWorkspaceProvisioningOptions(input: {
+    readonly projectRoot: string;
+    readonly runId: string;
+    readonly taskId: string;
+}): RunWorkspaceProvisioningOptions;
+export declare function buildRigRunLaunchArgs(input: RigRunLaunchOptions, runId: string, projectRoot: string): string[];
+export declare function resolveRemoteCheckoutPlan(input: {
+    readonly selectedCheckout?: string | null;
+    readonly projectSlug?: string | null;
+}): RemoteCheckoutPlan;
+export declare function resolveRunGithubAuthMaterialization(projectRoot: string, checkoutExpression?: string): RunGithubAuthMaterialization;
+export declare function readGithubAuthStateBase64(operatorAuthPath: string): string;
+export declare function buildRemoteRigRunResolutionShell(installUrl: string, command?: "rig-run"): string[];
+export declare function isCompiledBunBinary(importMetaUrl: string): boolean;
+export declare function resolveCompiledRigRunSiblingPath(execPath: string, platform?: NodeJS.Platform): string;
+export declare function ensureRigRunSiblingCurrent(rigBin: string, rigRun: string): void;
+export declare function resolveLocalDispatchRigRunBin(input: {
+    readonly importMetaUrl: string;
+    readonly sourceRigRunPath: string;
+    readonly execPath?: string;
+    readonly platform?: NodeJS.Platform;
+}): string;
+export declare function resolveInProcessRigRunBin(input: {
+    readonly importMetaUrl: string;
+    readonly sourceRigRunPath: string;
+    readonly execPath?: string;
+}): string;

package/dist/src/run-provisioning.js

@@ -0,0 +1,128 @@
+// @bun
+// packages/core/src/run-provisioning.ts
+import { chmodSync, copyFileSync, existsSync, linkSync, readFileSync, renameSync, rmSync, statSync } from "fs";
+import { dirname, resolve } from "path";
+var RUN_WORKSPACE_ISOLATION_MODE = "worktree";
+var RUN_WORKSPACE_PROVIDER = "pi";
+var REMOTE_RIG_RUN_COMMAND = "rig-run";
+var REMOTE_RESOLVED_RIG_RUN_COMMAND = '"$__RIG_RUN_BIN"';
+function buildRunWorkspaceProvisioningOptions(input) {
+  return {
+    projectRoot: input.projectRoot,
+    id: input.runId,
+    taskId: input.taskId,
+    mode: RUN_WORKSPACE_ISOLATION_MODE,
+    provider: RUN_WORKSPACE_PROVIDER
+  };
+}
+function buildRigRunLaunchArgs(input, runId, projectRoot) {
+  const args = ["--task", input.taskId, "--run-id", runId, "--project", projectRoot];
+  const title = optionalString(input.title);
+  const model = optionalString(input.model);
+  const prompt = optionalString(input.prompt);
+  if (title)
+    args.push("--title", title);
+  if (model)
+    args.push("--model", model);
+  if (input.forceSteerOnce)
+    args.push("--force-steer-once");
+  if (prompt)
+    args.push("--prompt", prompt);
+  return args;
+}
+function resolveRemoteCheckoutPlan(input) {
+  const repoName = sanitizeRepoName(input.projectSlug?.split("/").pop() ?? "project");
+  const selectedCheckout = optionalString(input.selectedCheckout);
+  return {
+    mode: selectedCheckout ? "configured" : "managed",
+    repoName,
+    checkoutPath: selectedCheckout ?? `.rig/checkouts/${repoName}`,
+    checkoutPathKind: selectedCheckout ? "literal" : "home-relative",
+    originUrl: resolveProjectOriginUrl(input.projectSlug)
+  };
+}
+function resolveRunGithubAuthMaterialization(projectRoot, checkoutExpression = "$CHECKOUT") {
+  const operatorStateDir = resolve(projectRoot, ".rig", "state");
+  return {
+    operatorAuthPath: resolve(operatorStateDir, "github-auth.json"),
+    operatorStateDir,
+    remoteAuthPath: `${checkoutExpression}/.rig/state/github-auth.json`,
+    remoteStateDir: `${checkoutExpression}/.rig/state`
+  };
+}
+function readGithubAuthStateBase64(operatorAuthPath) {
+  return existsSync(operatorAuthPath) ? readFileSync(operatorAuthPath).toString("base64") : "";
+}
+function buildRemoteRigRunResolutionShell(installUrl, command = REMOTE_RIG_RUN_COMMAND) {
+  return [
+    `export PATH="$HOME/.local/bin:$HOME/.bun/bin:$PATH"`,
+    `__RIG_RUN_BIN="$(command -v ${command} || true)"`,
+    `if [ -z "$__RIG_RUN_BIN" ]; then for __RIG_RUN_CANDIDATE in "$HOME"/.bun/install/global/node_modules/@h-rig/cli-*/rig-run; do if [ -x "$__RIG_RUN_CANDIDATE" ]; then __RIG_RUN_BIN="$__RIG_RUN_CANDIDATE"; break; fi; done; fi`,
+    `[ -x "$__RIG_RUN_BIN" ] || { echo "rig: remote rig-run not found; install @h-rig/cli on the remote host (curl -fsSL ${installUrl} | bash) and ensure rig-run is installed" >&2; exit 1; }`
+  ];
+}
+function isCompiledBunBinary(importMetaUrl) {
+  return importMetaUrl.includes("$bunfs");
+}
+function resolveCompiledRigRunSiblingPath(execPath, platform = process.platform) {
+  const suffix = platform === "win32" || execPath.toLowerCase().endsWith(".exe") ? ".exe" : "";
+  return resolve(dirname(execPath), `${REMOTE_RIG_RUN_COMMAND}${suffix}`);
+}
+function ensureRigRunSiblingCurrent(rigBin, rigRun) {
+  const tempRigRun = `${rigRun}.tmp-${process.pid}`;
+  try {
+    if (existsSync(rigRun) && statSync(rigRun).mtimeMs >= statSync(rigBin).mtimeMs)
+      return;
+    rmSync(tempRigRun, { force: true });
+    try {
+      linkSync(rigBin, tempRigRun);
+    } catch {
+      copyFileSync(rigBin, tempRigRun);
+    }
+    chmodSync(tempRigRun, 493);
+    renameSync(tempRigRun, rigRun);
+  } catch {
+    try {
+      rmSync(tempRigRun, { force: true });
+    } catch {}
+  }
+}
+function resolveLocalDispatchRigRunBin(input) {
+  if (!isCompiledBunBinary(input.importMetaUrl))
+    return input.sourceRigRunPath;
+  const rigBin = input.execPath ?? process.execPath;
+  const rigRun = resolveCompiledRigRunSiblingPath(rigBin, input.platform);
+  ensureRigRunSiblingCurrent(rigBin, rigRun);
+  return rigRun;
+}
+function resolveInProcessRigRunBin(input) {
+  return isCompiledBunBinary(input.importMetaUrl) ? input.execPath ?? process.execPath : input.sourceRigRunPath;
+}
+function optionalString(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : undefined;
+}
+function sanitizeRepoName(value) {
+  return (optionalString(value) ?? "project").replace(/[^A-Za-z0-9._-]/g, "-");
+}
+function resolveProjectOriginUrl(projectSlug) {
+  const slug = optionalString(projectSlug);
+  return slug && /^[^/]+\/[^/]+$/.test(slug) ? `https://github.com/${slug}.git` : null;
+}
+export {
+  resolveRunGithubAuthMaterialization,
+  resolveRemoteCheckoutPlan,
+  resolveLocalDispatchRigRunBin,
+  resolveInProcessRigRunBin,
+  resolveCompiledRigRunSiblingPath,
+  readGithubAuthStateBase64,
+  isCompiledBunBinary,
+  ensureRigRunSiblingCurrent,
+  buildRunWorkspaceProvisioningOptions,
+  buildRigRunLaunchArgs,
+  buildRemoteRigRunResolutionShell,
+  RUN_WORKSPACE_PROVIDER,
+  RUN_WORKSPACE_ISOLATION_MODE,
+  REMOTE_RIG_RUN_COMMAND,
+  REMOTE_RESOLVED_RIG_RUN_COMMAND
+};

package/dist/src/runtime-context.d.ts

@@ -0,0 +1,20 @@
+import type { RuntimeBrowserContext, RuntimeMemoryRetrievalConfig, RuntimeTaskContext } from "@rig/contracts";
+export type { RuntimeBrowserContext, RuntimeMemoryRetrievalConfig, RuntimeMemoryContext, RuntimeSourceTaskContract, RuntimeTaskContext, } from "@rig/contracts";
+export declare const RUNTIME_CONTEXT_ENV = "RIG_RUNTIME_CONTEXT_FILE";
+export declare const DEFAULT_RUNTIME_MEMORY_RETRIEVAL: RuntimeMemoryRetrievalConfig;
+export declare const runtimeContextStringFields: readonly (keyof RuntimeTaskContext)[];
+export declare const runtimeContextArrayFields: readonly (keyof RuntimeTaskContext)[];
+export declare const runtimeContextOptionalStringFields: readonly (keyof RuntimeTaskContext)[];
+export declare function writeRuntimeContext(path: string, ctx: RuntimeTaskContext): void;
+export declare function loadRuntimeContext(path: string): RuntimeTaskContext;
+export declare function runtimeMemoryEnvFromContext(ctx: RuntimeTaskContext | null | undefined): Record<string, string>;
+/**
+ * Serialize an already-resolved browser context into the RIG_BROWSER_* env wire
+ * contract read by rig-agent and rig-browser-tool. This is dumb substrate
+ * plumbing (a flat projection of the resolved context's own fields) — the
+ * browser DOMAIN resolution that produced this context lives in
+ * @rig/browser-plugin, resolved via browser-contract-port.ts. Mirrors
+ * runtimeMemoryEnvFromContext above.
+ */
+export declare function browserEnvFromContext(browser: RuntimeBrowserContext | undefined): Record<string, string>;
+export declare function loadRuntimeContextFromEnv(env?: NodeJS.ProcessEnv): RuntimeTaskContext | null;

package/dist/src/runtime-context.js

@@ -0,0 +1,257 @@
+// @bun
+// packages/core/src/runtime-context.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, resolve } from "path";
+var RUNTIME_CONTEXT_ENV = "RIG_RUNTIME_CONTEXT_FILE";
+var DEFAULT_RUNTIME_MEMORY_RETRIEVAL = {
+  topK: 5,
+  lexicalWeight: 0.35,
+  vectorWeight: 0.45,
+  recencyWeight: 0.1,
+  confidenceWeight: 0.1
+};
+var runtimeContextStringFields = [
+  "runtimeId",
+  "taskId",
+  "role",
+  "workspaceDir",
+  "stateDir",
+  "logsDir",
+  "sessionDir",
+  "sessionFile",
+  "policyFile",
+  "binDir",
+  "createdAt"
+];
+var runtimeContextArrayFields = ["scopes", "validation"];
+var runtimeContextOptionalStringFields = [
+  "artifactRoot",
+  "hostProjectRoot",
+  "monorepoMainRoot",
+  "monorepoBaseRef",
+  "monorepoBaseCommit"
+];
+function writeRuntimeContext(path, ctx) {
+  const absPath = resolve(path);
+  const dir = dirname(absPath);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(absPath, JSON.stringify(ctx, null, 2), "utf8");
+}
+function loadRuntimeContext(path) {
+  const absPath = resolve(path);
+  if (!existsSync(absPath)) {
+    throw new Error(`RuntimeTaskContext file not found: ${absPath}`);
+  }
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync(absPath, "utf8"));
+  } catch (err) {
+    throw new Error(`Failed to parse RuntimeTaskContext at ${absPath}: ${String(err)}`);
+  }
+  if (typeof raw !== "object" || raw === null) {
+    throw new Error(`RuntimeTaskContext at ${absPath} is not an object`);
+  }
+  const obj = raw;
+  for (const field of runtimeContextStringFields) {
+    if (typeof obj[field] !== "string" || obj[field].length === 0) {
+      throw new Error(`RuntimeTaskContext field "${field}" must be a non-empty string (at ${absPath})`);
+    }
+  }
+  for (const field of runtimeContextArrayFields) {
+    if (!Array.isArray(obj[field])) {
+      throw new Error(`RuntimeTaskContext field "${field}" must be an array (at ${absPath})`);
+    }
+    if (!obj[field].every((entry) => typeof entry === "string")) {
+      throw new Error(`RuntimeTaskContext field "${field}" must be a string[] (at ${absPath})`);
+    }
+  }
+  for (const field of runtimeContextOptionalStringFields) {
+    if (field in obj && obj[field] !== undefined && typeof obj[field] !== "string") {
+      throw new Error(`RuntimeTaskContext field "${field}" must be a string when present (at ${absPath})`);
+    }
+  }
+  if (obj.browser !== undefined) {
+    if (typeof obj.browser !== "object" || obj.browser === null || Array.isArray(obj.browser)) {
+      throw new Error(`RuntimeTaskContext field "browser" must be an object when present (at ${absPath})`);
+    }
+    const browser = obj.browser;
+    for (const field of [
+      "preset",
+      "mode",
+      "stateDir",
+      "defaultProfile",
+      "effectiveProfile",
+      "defaultAttachUrl",
+      "effectiveAttachUrl",
+      "launchHelper",
+      "checkHelper",
+      "attachInfoHelper",
+      "e2eHelper",
+      "resetProfileHelper"
+    ]) {
+      if (typeof browser[field] !== "string" || browser[field].length === 0) {
+        throw new Error(`RuntimeTaskContext field "browser.${field}" must be a non-empty string (at ${absPath})`);
+      }
+    }
+    for (const field of ["devCommand", "launchCommand", "checkCommand", "e2eCommand"]) {
+      if (browser[field] !== undefined && typeof browser[field] !== "string") {
+        throw new Error(`RuntimeTaskContext field "browser.${field}" must be a string when present (at ${absPath})`);
+      }
+    }
+    if (typeof browser.required !== "boolean") {
+      throw new Error(`RuntimeTaskContext field "browser.required" must be a boolean (at ${absPath})`);
+    }
+  }
+  if (obj.memory !== undefined) {
+    if (typeof obj.memory !== "object" || obj.memory === null || Array.isArray(obj.memory)) {
+      throw new Error(`RuntimeTaskContext field "memory" must be an object when present (at ${absPath})`);
+    }
+    const memory = obj.memory;
+    for (const field of ["canonicalPath", "canonicalRef", "hydratedPath"]) {
+      if (typeof memory[field] !== "string" || memory[field].length === 0) {
+        throw new Error(`RuntimeTaskContext field "memory.${field}" must be a non-empty string (at ${absPath})`);
+      }
+    }
+    if (typeof memory.createdFresh !== "boolean") {
+      throw new Error(`RuntimeTaskContext field "memory.createdFresh" must be a boolean (at ${absPath})`);
+    }
+    const hasCanonicalBaseOid = typeof memory.canonicalBaseOid === "string" && memory.canonicalBaseOid.length > 0;
+    if (memory.canonicalBaseOid !== undefined && !hasCanonicalBaseOid) {
+      throw new Error(`RuntimeTaskContext field "memory.canonicalBaseOid" must be a non-empty string when present (at ${absPath})`);
+    }
+    if (!memory.createdFresh && !hasCanonicalBaseOid) {
+      throw new Error(`RuntimeTaskContext field "memory.canonicalBaseOid" must be a non-empty string when memory.createdFresh is false (at ${absPath})`);
+    }
+    if (typeof memory.retrieval !== "object" || memory.retrieval === null || Array.isArray(memory.retrieval)) {
+      throw new Error(`RuntimeTaskContext field "memory.retrieval" must be an object (at ${absPath})`);
+    }
+    const retrieval = memory.retrieval;
+    for (const field of ["topK", "lexicalWeight", "vectorWeight", "recencyWeight", "confidenceWeight"]) {
+      if (typeof retrieval[field] !== "number" || Number.isNaN(retrieval[field])) {
+        throw new Error(`RuntimeTaskContext field "memory.retrieval.${field}" must be a number (at ${absPath})`);
+      }
+    }
+  }
+  if (obj.initialDirtyFiles !== undefined) {
+    if (typeof obj.initialDirtyFiles !== "object" || obj.initialDirtyFiles === null || Array.isArray(obj.initialDirtyFiles)) {
+      throw new Error(`RuntimeTaskContext field "initialDirtyFiles" must be an object when present (at ${absPath})`);
+    }
+    const dirtyFiles = obj.initialDirtyFiles;
+    for (const key of ["project", "monorepo"]) {
+      if (dirtyFiles[key] === undefined) {
+        continue;
+      }
+      if (!Array.isArray(dirtyFiles[key]) || !dirtyFiles[key].every((entry) => typeof entry === "string")) {
+        throw new Error(`RuntimeTaskContext field "initialDirtyFiles.${key}" must be a string[] when present (at ${absPath})`);
+      }
+    }
+  }
+  if (obj.initialHeadCommits !== undefined) {
+    if (typeof obj.initialHeadCommits !== "object" || obj.initialHeadCommits === null || Array.isArray(obj.initialHeadCommits)) {
+      throw new Error(`RuntimeTaskContext field "initialHeadCommits" must be an object when present (at ${absPath})`);
+    }
+    const headCommits = obj.initialHeadCommits;
+    for (const key of ["project", "monorepo"]) {
+      if (headCommits[key] === undefined) {
+        continue;
+      }
+      if (typeof headCommits[key] !== "string") {
+        throw new Error(`RuntimeTaskContext field "initialHeadCommits.${key}" must be a string when present (at ${absPath})`);
+      }
+    }
+  }
+  return obj;
+}
+function runtimeMemoryEnvFromContext(ctx) {
+  if (!ctx?.memory) {
+    return {};
+  }
+  return {
+    RIG_MEMORY_DB_PATH: ctx.memory.hydratedPath,
+    RIG_MEMORY_CANONICAL_PATH: ctx.memory.canonicalPath,
+    RIG_MEMORY_CANONICAL_REF: ctx.memory.canonicalRef,
+    ...ctx.memory.canonicalBaseOid ? { RIG_MEMORY_CANONICAL_BASE_OID: ctx.memory.canonicalBaseOid } : {},
+    RIG_MEMORY_CREATED_FRESH: ctx.memory.createdFresh ? "1" : "0",
+    RIG_MEMORY_RETRIEVAL_TOP_K: String(ctx.memory.retrieval.topK),
+    RIG_MEMORY_RETRIEVAL_LEXICAL_WEIGHT: String(ctx.memory.retrieval.lexicalWeight),
+    RIG_MEMORY_RETRIEVAL_VECTOR_WEIGHT: String(ctx.memory.retrieval.vectorWeight),
+    RIG_MEMORY_RETRIEVAL_RECENCY_WEIGHT: String(ctx.memory.retrieval.recencyWeight),
+    RIG_MEMORY_RETRIEVAL_CONFIDENCE_WEIGHT: String(ctx.memory.retrieval.confidenceWeight)
+  };
+}
+function browserEnvFromContext(browser) {
+  if (!browser?.required) {
+    return {};
+  }
+  const env = {
+    RIG_BROWSER_REQUIRED: "1",
+    RIG_BROWSER_PRESET: browser.preset,
+    RIG_BROWSER_MODE: browser.mode,
+    RIG_BROWSER_STATE_DIR: browser.stateDir,
+    RIG_BROWSER_PROFILE: browser.effectiveProfile,
+    RIG_BROWSER_BASE_PROFILE: browser.defaultProfile,
+    RIG_BROWSER_ATTACH_URL: browser.effectiveAttachUrl,
+    RIG_BROWSER_DEFAULT_ATTACH_URL: browser.defaultAttachUrl,
+    RIG_BROWSER_LAUNCH_HELPER: browser.launchHelper,
+    RIG_BROWSER_CHECK_HELPER: browser.checkHelper,
+    RIG_BROWSER_ATTACH_INFO_HELPER: browser.attachInfoHelper,
+    RIG_BROWSER_E2E_HELPER: browser.e2eHelper,
+    RIG_BROWSER_RESET_HELPER: browser.resetProfileHelper
+  };
+  if (browser.devCommand) {
+    env.RIG_BROWSER_DEV_COMMAND = browser.devCommand;
+  }
+  if (browser.launchCommand) {
+    env.RIG_BROWSER_LAUNCH_COMMAND = browser.launchCommand;
+  }
+  if (browser.checkCommand) {
+    env.RIG_BROWSER_CHECK_COMMAND = browser.checkCommand;
+  }
+  if (browser.e2eCommand) {
+    env.RIG_BROWSER_E2E_COMMAND = browser.e2eCommand;
+  }
+  return env;
+}
+function loadRuntimeContextFromEnv(env = process.env) {
+  const contextFile = env[RUNTIME_CONTEXT_ENV];
+  if (contextFile) {
+    return loadRuntimeContext(contextFile);
+  }
+  const inferred = findRuntimeContextFile(process.cwd());
+  if (!inferred) {
+    return null;
+  }
+  return loadRuntimeContext(inferred);
+}
+function findRuntimeContextFile(startPath) {
+  let current = resolve(startPath);
+  while (true) {
+    const candidate = resolve(current, "runtime-context.json");
+    if (existsSync(candidate) && isAgentRuntimeContextPath(candidate)) {
+      return candidate;
+    }
+    const parent = dirname(current);
+    if (parent === current) {
+      return "";
+    }
+    current = parent;
+  }
+}
+function isAgentRuntimeContextPath(path) {
+  const normalized = path.replace(/\\/g, "/");
+  return /\/\.rig\/runtime-context\.json$/.test(normalized);
+}
+export {
+  writeRuntimeContext,
+  runtimeMemoryEnvFromContext,
+  runtimeContextStringFields,
+  runtimeContextOptionalStringFields,
+  runtimeContextArrayFields,
+  loadRuntimeContextFromEnv,
+  loadRuntimeContext,
+  browserEnvFromContext,
+  RUNTIME_CONTEXT_ENV,
+  DEFAULT_RUNTIME_MEMORY_RETRIEVAL
+};

package/dist/src/runtime-events.d.ts

@@ -0,0 +1,44 @@
+import type { HarnessEvent, HarnessEventType } from "@rig/contracts";
+export type EventBusLike = {
+    getRunId(): string;
+    getEventsFile(): string;
+    getMemoryEvents(): HarnessEvent[];
+    emit<TPayload extends Record<string, unknown>>(type: HarnessEventType, payload: TPayload): Promise<HarnessEvent<TPayload>>;
+    attachRuntimeBus(runtimeBus: RuntimeEventBus): Promise<void>;
+    attachRuntimeWorkspace(projectRoot: string): Promise<RuntimeEventBus>;
+};
+export declare class RuntimeEventBus implements EventBusLike {
+    private readonly runId;
+    private readonly eventsFile;
+    private readonly memoryEvents;
+    constructor(options: {
+        projectRoot: string;
+        runId?: string;
+        eventsFile?: string;
+    });
+    getRunId(): string;
+    getEventsFile(): string;
+    getMemoryEvents(): HarnessEvent[];
+    attachRuntimeBus(runtimeBus: RuntimeEventBus): Promise<void>;
+    attachRuntimeWorkspace(projectRoot: string): Promise<RuntimeEventBus>;
+    ingest(event: HarnessEvent): Promise<void>;
+    emit<TPayload extends Record<string, unknown>>(type: HarnessEventType, payload: TPayload): Promise<HarnessEvent<TPayload>>;
+}
+export declare class GeneralCliEventBus implements EventBusLike {
+    private readonly runId;
+    private readonly eventsFile;
+    private readonly memoryEvents;
+    private readonly runtimeBuses;
+    constructor(options: {
+        projectRoot: string;
+        runId?: string;
+        eventsFile?: string;
+    });
+    getRunId(): string;
+    getEventsFile(): string;
+    getMemoryEvents(): HarnessEvent[];
+    attachRuntimeBus(runtimeBus: RuntimeEventBus): Promise<void>;
+    attachRuntimeWorkspace(projectRoot: string): Promise<RuntimeEventBus>;
+    emit<TPayload extends Record<string, unknown>>(type: HarnessEventType, payload: TPayload): Promise<HarnessEvent<TPayload>>;
+}
+export { GeneralCliEventBus as EventBus };