@h-rig/core 0.0.6-alpha.18 → 0.0.6-alpha.181

package/dist/src/remote-config.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Deprecated compatibility subpath. Remote transport configuration, registry /
+ * relay defaults, managed endpoints, dispatch placement, and owner namespace
+ * resolution are owned by @rig/transport-plugin. Core must not implement this
+ * product behavior.
+ */
+export declare const DEFAULT_REMOTE_PORT = 7890;
+export declare const REMOTES_CONFIG_PATH = "";
+export declare class RemoteCliError extends Error {
+    readonly code: string;
+    readonly exitCode: number;
+    readonly details: Record<string, unknown> | undefined;
+    constructor(code: string, message: string, exitCode?: number, details?: Record<string, unknown>);
+}
+export type RemoteConfigEntry = {
+    host?: string;
+    port?: number;
+    token?: string;
+    addedAt?: string;
+    lastConnected?: string;
+};
+export type RemotesToml = {
+    version?: number;
+    remotes?: Record<string, RemoteConfigEntry>;
+};
+export type AuthorityRemoteEndpointRecord = {
+    id: string;
+    alias: string;
+    host: string;
+    port: number;
+    transport: string;
+    auto_connect: boolean;
+    labels: string[];
+    capabilities: string[];
+    secret_ref: string;
+    created_at: string;
+    updated_at: string;
+    last_connected_at?: string | null;
+};
+export type AuthorityRemoteEndpointsToml = {
+    version?: number;
+    endpoints?: Record<string, AuthorityRemoteEndpointRecord>;
+};
+export type AuthorityRemoteSecretsToml = {
+    version?: number;
+    secrets?: Record<string, string>;
+};
+export type AuthorityMaterializedRemoteEndpoint = {
+    id: string;
+    alias: string;
+    host: string;
+    port: number;
+    token: string;
+    autoConnect: boolean;
+    addedAt: string;
+    updatedAt: string;
+    lastConnectedAt: string | null;
+    labels: string[];
+    capabilities: string[];
+    transport: string;
+    secretRef: string;
+};
+export type ManagedRemoteEndpoint = {
+    id: string;
+    alias: string;
+    host: string;
+    port: number;
+    token: string;
+    addedAt: string | null;
+    lastConnected: string | null;
+};
+export type SelectedRemote = {
+    alias: string;
+    host: string;
+    port: number;
+    sshTarget: string;
+    checkout: string | null;
+    registryBaseUrl: string | null;
+    secretRef: string | null;
+};
+export type DispatchTransportPlacement = {
+    readonly kind: "local";
+    readonly alias: "local";
+    readonly sshTarget: null;
+    readonly selected: null;
+} | {
+    readonly kind: "remote";
+    readonly alias: string;
+    readonly sshTarget: string;
+    readonly selected: SelectedRemote | null;
+};
+export declare function registerBackboneDefaults(_defaults: {
+    relayUrl?: string;
+    registryBaseUrl?: string;
+    sshTarget?: string;
+}): void;
+export declare function resolveRelayUrl(_env?: NodeJS.ProcessEnv): string;
+export declare function resolveSshTarget(_env?: NodeJS.ProcessEnv): string;
+export declare function loadRemotesConfig(_configPath?: string): RemotesToml;
+export declare function listManagedRemoteEndpoints(_configPath?: string, _projectRoot?: string): ManagedRemoteEndpoint[];
+export declare function resolveManagedRemoteEndpoint(_alias: string, _configPath?: string, _projectRoot?: string): SelectedRemote | null;
+export declare function upsertManagedRemoteEndpoint(_input: {
+    alias: string;
+    host: string;
+    port: number;
+    token?: string;
+}, _configPath?: string, _projectRoot?: string): ManagedRemoteEndpoint;
+export declare function updateAuthorityRemoteEndpoint(_projectRoot: string, _input: {
+    endpointId?: string;
+    alias?: string;
+    host?: string;
+    port?: number;
+    token?: string;
+    autoConnect?: boolean;
+    transport?: string;
+    labels?: string[];
+    capabilities?: string[];
+}): AuthorityMaterializedRemoteEndpoint | null;
+export declare function removeManagedRemoteEndpoint(_alias: string, _configPath?: string, _projectRoot?: string): boolean;
+export declare function resolveSelectedRemote(_projectRoot: string, _env?: NodeJS.ProcessEnv): SelectedRemote | null;
+export declare function resolveDispatchTransportPlacement(_projectRoot: string, _env?: NodeJS.ProcessEnv): DispatchTransportPlacement;
+export declare function resolveRegistryBaseUrl(_projectRoot: string, _env?: NodeJS.ProcessEnv): string;
+export declare function resolveOwnerNamespaceKey(_projectRoot: string, _env?: NodeJS.ProcessEnv): string | undefined;
+export declare function resolveRigOmpConfigOverlayPath(_projectRoot?: string): string;
+export declare function materializeRigOmpConfigOverlay(_projectRoot: string, _env?: NodeJS.ProcessEnv): string;

package/dist/src/remote-config.js

@@ -0,0 +1,85 @@
+// @bun
+// packages/core/src/remote-config.ts
+var DEFAULT_REMOTE_PORT = 7890;
+var REMOTES_CONFIG_PATH = "";
+
+class RemoteCliError extends Error {
+  code;
+  exitCode;
+  details;
+  constructor(code, message, exitCode = 1, details) {
+    super(message);
+    this.name = "RemoteCliError";
+    this.code = code;
+    this.exitCode = exitCode;
+    this.details = details;
+  }
+}
+function remoteConfigOwnerRequired() {
+  throw new Error("This remote config compatibility API is deprecated. Resolve transport-owned remote config through the TRANSPORT_CONFIG capability.");
+}
+function registerBackboneDefaults(_defaults) {
+  remoteConfigOwnerRequired();
+}
+function resolveRelayUrl(_env = process.env) {
+  return remoteConfigOwnerRequired();
+}
+function resolveSshTarget(_env = process.env) {
+  return remoteConfigOwnerRequired();
+}
+function loadRemotesConfig(_configPath) {
+  return remoteConfigOwnerRequired();
+}
+function listManagedRemoteEndpoints(_configPath, _projectRoot) {
+  return remoteConfigOwnerRequired();
+}
+function resolveManagedRemoteEndpoint(_alias, _configPath, _projectRoot) {
+  return remoteConfigOwnerRequired();
+}
+function upsertManagedRemoteEndpoint(_input, _configPath, _projectRoot) {
+  return remoteConfigOwnerRequired();
+}
+function updateAuthorityRemoteEndpoint(_projectRoot, _input) {
+  return remoteConfigOwnerRequired();
+}
+function removeManagedRemoteEndpoint(_alias, _configPath, _projectRoot) {
+  return remoteConfigOwnerRequired();
+}
+function resolveSelectedRemote(_projectRoot, _env = process.env) {
+  return remoteConfigOwnerRequired();
+}
+function resolveDispatchTransportPlacement(_projectRoot, _env = process.env) {
+  return remoteConfigOwnerRequired();
+}
+function resolveRegistryBaseUrl(_projectRoot, _env = process.env) {
+  return remoteConfigOwnerRequired();
+}
+function resolveOwnerNamespaceKey(_projectRoot, _env = process.env) {
+  return remoteConfigOwnerRequired();
+}
+function resolveRigOmpConfigOverlayPath(_projectRoot = process.cwd()) {
+  return remoteConfigOwnerRequired();
+}
+function materializeRigOmpConfigOverlay(_projectRoot, _env = process.env) {
+  return remoteConfigOwnerRequired();
+}
+export {
+  upsertManagedRemoteEndpoint,
+  updateAuthorityRemoteEndpoint,
+  resolveSshTarget,
+  resolveSelectedRemote,
+  resolveRigOmpConfigOverlayPath,
+  resolveRelayUrl,
+  resolveRegistryBaseUrl,
+  resolveOwnerNamespaceKey,
+  resolveManagedRemoteEndpoint,
+  resolveDispatchTransportPlacement,
+  removeManagedRemoteEndpoint,
+  registerBackboneDefaults,
+  materializeRigOmpConfigOverlay,
+  loadRemotesConfig,
+  listManagedRemoteEndpoints,
+  RemoteCliError,
+  REMOTES_CONFIG_PATH,
+  DEFAULT_REMOTE_PORT
+};

package/dist/src/root-resolver.d.ts

@@ -0,0 +1,5 @@
+export declare function resolveProjectRoot(options?: {
+    cwd?: string;
+    projectRootEnv?: string;
+    fallbackFromDir?: string;
+}): string;

package/dist/src/root-resolver.js

@@ -0,0 +1,68 @@
+// @bun
+// packages/core/src/root-resolver.ts
+import { existsSync, readFileSync } from "fs";
+import { dirname, parse, resolve } from "path";
+
+// packages/core/src/layout.ts
+import {
+  RIG_DEFINITION_DIRNAME,
+  RIG_STATE_DIRNAME
+} from "@rig/contracts";
+
+// packages/core/src/root-resolver.ts
+function hasProjectMarker(candidate) {
+  return existsSync(resolve(candidate, RIG_DEFINITION_DIRNAME)) || existsSync(resolve(candidate, RIG_STATE_DIRNAME));
+}
+function resolveProjectRoot(options) {
+  const cwd = options?.cwd || process.cwd();
+  const envRoot = options?.projectRootEnv || process.env.PROJECT_RIG_ROOT || "";
+  const fallbackFromDir = options?.fallbackFromDir || cwd;
+  if (envRoot && hasProjectMarker(envRoot)) {
+    return envRoot;
+  }
+  const walked = walkUpForRoot(cwd);
+  if (walked) {
+    return walked;
+  }
+  const configRoot = readConfiguredRoot();
+  if (configRoot && hasProjectMarker(configRoot)) {
+    return configRoot;
+  }
+  let fileDir = resolve(fallbackFromDir);
+  for (let i = 0;i < 5; i += 1) {
+    if (hasProjectMarker(fileDir)) {
+      return fileDir;
+    }
+    fileDir = dirname(fileDir);
+  }
+  return cwd;
+}
+function walkUpForRoot(start) {
+  let searchDir = resolve(start);
+  const root = parse(searchDir).root || "/";
+  while (searchDir !== root) {
+    if (hasProjectMarker(searchDir)) {
+      return searchDir;
+    }
+    searchDir = dirname(searchDir);
+  }
+  if (hasProjectMarker(root)) {
+    return root;
+  }
+  return "";
+}
+function readConfiguredRoot() {
+  const configPath = resolve(process.env.HOME || "~", ".config", "project-rig", "root");
+  if (!existsSync(configPath)) {
+    return "";
+  }
+  try {
+    const value = readFileSync(configPath, "utf-8").split(/\r?\n/)[0]?.trim() || "";
+    return value;
+  } catch {
+    return "";
+  }
+}
+export {
+  resolveProjectRoot
+};

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

@@ -0,0 +1,37 @@
+/**
+ * Deprecated compatibility subpath. Run launch/provisioning behavior is owned
+ * outside @rig/core (transport/run-host). Resolve the typed owner services or
+ * import the owner plugin's run-provisioning helper instead.
+ */
+import type { EnsureAgentRuntimeOptions } from "@rig/contracts";
+export type RunWorkspaceProvisioningOptions = Pick<EnsureAgentRuntimeOptions, "projectRoot" | "id" | "taskId" | "mode" | "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 declare function buildRunWorkspaceProvisioningOptions(_input: {
+    readonly projectRoot: string;
+    readonly runId: string;
+    readonly taskId: string;
+    readonly mode: EnsureAgentRuntimeOptions["mode"];
+    readonly provider?: EnsureAgentRuntimeOptions["provider"];
+}): RunWorkspaceProvisioningOptions;
+export declare function buildRigRunLaunchArgs(_input: RigRunLaunchOptions, _runId: string, _projectRoot: string): string[];
+export declare function isCompiledBunBinary(_importMetaUrl: string): boolean;
+export declare function resolveCompiledSiblingPath(_execPath: string, _siblingBinaryName: string, _platform?: NodeJS.Platform): string;
+export declare function ensureSiblingBinaryCurrent(_sourceBin: string, _siblingBin: string): void;
+export declare function resolveLocalDispatchRigRunBin(_input: {
+    readonly importMetaUrl: string;
+    readonly sourceRigRunPath: string;
+    readonly compiledSiblingName: 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,35 @@
+// @bun
+// packages/core/src/run-provisioning.ts
+function runProvisioningOwnerRequired() {
+  throw new Error("This run provisioning compatibility API is deprecated. Resolve run provisioning through the owning transport/run-host boundary instead.");
+}
+function buildRunWorkspaceProvisioningOptions(_input) {
+  return runProvisioningOwnerRequired();
+}
+function buildRigRunLaunchArgs(_input, _runId, _projectRoot) {
+  return runProvisioningOwnerRequired();
+}
+function isCompiledBunBinary(_importMetaUrl) {
+  return runProvisioningOwnerRequired();
+}
+function resolveCompiledSiblingPath(_execPath, _siblingBinaryName, _platform = process.platform) {
+  return runProvisioningOwnerRequired();
+}
+function ensureSiblingBinaryCurrent(_sourceBin, _siblingBin) {
+  runProvisioningOwnerRequired();
+}
+function resolveLocalDispatchRigRunBin(_input) {
+  return runProvisioningOwnerRequired();
+}
+function resolveInProcessRigRunBin(_input) {
+  return runProvisioningOwnerRequired();
+}
+export {
+  resolveLocalDispatchRigRunBin,
+  resolveInProcessRigRunBin,
+  resolveCompiledSiblingPath,
+  isCompiledBunBinary,
+  ensureSiblingBinaryCurrent,
+  buildRunWorkspaceProvisioningOptions,
+  buildRigRunLaunchArgs
+};

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