@h-rig/core 0.0.6-alpha.157 → 0.0.6-alpha.159

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

@@ -0,0 +1,11 @@
+import { type HookEvent, type HookImplementation } from "@rig/contracts";
+export interface TypedHookOptions {
+    readonly event: HookEvent;
+    readonly projectRoot?: string;
+    readonly taskId?: string;
+}
+export declare function resolveBunCliInvocation(): {
+    command: string;
+    env: Record<string, string>;
+};
+export declare function runTypedHook(fn: HookImplementation, opts: TypedHookOptions): Promise<never>;

package/dist/src/hook-runtime.js

@@ -0,0 +1,307 @@
+// @bun
+// packages/core/src/hook-runtime.ts
+import { existsSync, readFileSync, realpathSync, writeSync } from "fs";
+import { resolve } from "path";
+import { RIG_DEFINITION_DIRNAME, RIG_STATE_DIRNAME } from "@rig/contracts";
+function normalizeBuildConfig(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return {};
+  }
+  return Object.fromEntries(Object.entries(value).filter((entry) => typeof entry[1] === "string"));
+}
+function readBuildConfigForCoreHooks() {
+  if (typeof __RIG_BUILD_CONFIG__ !== "undefined") {
+    return normalizeBuildConfig(__RIG_BUILD_CONFIG__);
+  }
+  const raw = process.env.RIG_BUILD_CONFIG_JSON?.trim();
+  if (!raw) {
+    return {};
+  }
+  try {
+    return normalizeBuildConfig(JSON.parse(raw));
+  } catch {
+    return {};
+  }
+}
+var BUILD_CONFIG = readBuildConfigForCoreHooks();
+var BAKED_PROJECT_ROOT = BUILD_CONFIG.AGENT_PROJECT_ROOT ?? "";
+var BAKED_TASK_ID = BUILD_CONFIG.AGENT_TASK_ID ?? "";
+var BAKED_BUN_PATH = BUILD_CONFIG.AGENT_BUN_PATH ?? "";
+var RUNTIME_CONTEXT_ENV = "RIG_RUNTIME_CONTEXT_FILE";
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStringArray(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function loadHookContextFromEnv() {
+  const contextFile = process.env[RUNTIME_CONTEXT_ENV]?.trim();
+  let filePath = contextFile || "";
+  if (!filePath) {
+    let current = resolve(process.cwd());
+    while (true) {
+      const candidate = resolve(current, "runtime-context.json");
+      if (existsSync(candidate)) {
+        filePath = candidate;
+        break;
+      }
+      const parent = resolve(current, "..");
+      if (parent === current) {
+        break;
+      }
+      current = parent;
+    }
+  }
+  if (!filePath || !existsSync(filePath)) {
+    return null;
+  }
+  try {
+    const raw = JSON.parse(readFileSync(filePath, "utf-8"));
+    if (!isPlainObject(raw)) {
+      return null;
+    }
+    const taskId = typeof raw.taskId === "string" ? raw.taskId : "";
+    const role = typeof raw.role === "string" ? raw.role : "";
+    const scopes = isStringArray(raw.scopes) ? raw.scopes : [];
+    const validation = isStringArray(raw.validation) ? raw.validation : [];
+    const hostProjectRoot = typeof raw.hostProjectRoot === "string" ? raw.hostProjectRoot : undefined;
+    const monorepoMainRoot = typeof raw.monorepoMainRoot === "string" ? raw.monorepoMainRoot : undefined;
+    const stateDir = typeof raw.stateDir === "string" ? raw.stateDir : "";
+    const policyFile = typeof raw.policyFile === "string" ? raw.policyFile : "";
+    if (!taskId || !stateDir) {
+      return null;
+    }
+    return {
+      taskId,
+      role,
+      scopes,
+      validation,
+      hostProjectRoot,
+      monorepoMainRoot,
+      stateDir,
+      policyFile
+    };
+  } catch {
+    return null;
+  }
+}
+var cachedContext;
+function getContext() {
+  if (cachedContext !== undefined) {
+    return cachedContext;
+  }
+  cachedContext = loadHookContextFromEnv();
+  return cachedContext;
+}
+function resolveProjectRoot() {
+  const ctx = getContext();
+  if (ctx?.hostProjectRoot)
+    return ctx.hostProjectRoot;
+  if (BAKED_PROJECT_ROOT) {
+    return BAKED_PROJECT_ROOT;
+  }
+  if (process.env.PROJECT_RIG_ROOT) {
+    return process.env.PROJECT_RIG_ROOT;
+  }
+  const candidates = [process.cwd(), resolve(import.meta.dirname, "../..")];
+  for (const candidate of candidates) {
+    if (existsSync(resolve(candidate, RIG_DEFINITION_DIRNAME)) || existsSync(resolve(candidate, RIG_STATE_DIRNAME))) {
+      return candidate;
+    }
+  }
+  return resolve(import.meta.dirname, "../..");
+}
+function resolveTaskIdForHook(_projectRoot) {
+  const ctx = getContext();
+  if (ctx)
+    return ctx.taskId;
+  if (BAKED_TASK_ID) {
+    return BAKED_TASK_ID;
+  }
+  const fromEnv = (process.env.RIG_TASK_ID || "").trim();
+  if (fromEnv) {
+    return fromEnv;
+  }
+  const runtimeId = (process.env.RIG_TASK_RUNTIME_ID || "").trim();
+  if (runtimeId.startsWith("task-") && runtimeId.length > "task-".length) {
+    return runtimeId.slice("task-".length);
+  }
+  return "";
+}
+async function readHookInput() {
+  let text = "";
+  const inputFile = process.env.RIG_HOOK_INPUT_FILE?.trim();
+  if (inputFile) {
+    text = readFileSync(inputFile, "utf-8");
+  } else {
+    try {
+      text = readFileSync("/dev/stdin", "utf-8");
+    } catch {
+      text = readFileSync(0, "utf-8");
+    }
+  }
+  if (!text.trim()) {
+    return { input: {}, valid: true, hadPayload: false };
+  }
+  try {
+    return {
+      input: JSON.parse(text),
+      valid: true,
+      hadPayload: true
+    };
+  } catch {
+    return { input: {}, valid: false, hadPayload: true };
+  }
+}
+function extractToolFilePaths(toolName, input) {
+  const paths = [];
+  const add = (value) => {
+    if (typeof value === "string" && value.trim()) {
+      paths.push(value.trim());
+    }
+  };
+  if (toolName === "Read" || toolName === "Write" || toolName === "Edit" || toolName === "MultiEdit") {
+    add(input.file_path);
+    add(input.path);
+  } else if (toolName === "Glob") {
+    add(input.path);
+  } else if (toolName === "Grep") {
+    add(input.path);
+  } else {
+    add(input.file_path);
+    add(input.path);
+  }
+  return paths;
+}
+function buildPluginHookContext(parsed, opts) {
+  const toolName = parsed.input.tool_name;
+  const toolInput = parsed.input.tool_input ?? {};
+  return {
+    event: opts.event,
+    toolName,
+    toolInput,
+    filePaths: toolName ? extractToolFilePaths(toolName, toolInput) : [],
+    projectRoot: opts.projectRoot,
+    taskId: opts.taskId
+  };
+}
+function hookResultToProtocol(result) {
+  if (result.decision === "block") {
+    const lines = [`BLOCKED: ${result.reason ?? "blocked by plugin hook"}`];
+    if (result.systemMessage) {
+      lines.push(result.systemMessage);
+    }
+    return { exitCode: 1, stdout: `${lines.join(`
+`)}
+` };
+  }
+  return {
+    exitCode: 0,
+    stdout: result.systemMessage ? `${result.systemMessage}
+` : ""
+  };
+}
+function normalizeExecutablePath(candidate) {
+  if (!candidate) {
+    return "";
+  }
+  const normalized = resolve(candidate);
+  if (!existsSync(normalized)) {
+    return "";
+  }
+  try {
+    return realpathSync(normalized);
+  } catch {
+    return normalized;
+  }
+}
+function looksLikeRuntimeGateway(candidate) {
+  const normalized = resolve(candidate).replace(/\\/g, "/");
+  return normalized.includes("/.rig/bin/") || normalized.endsWith("/rig-shell") || normalized.endsWith("/rig-agent");
+}
+function resolveBunBinaryPath() {
+  const explicit = normalizeExecutablePath(process.env.RIG_BUN_PATH?.trim());
+  if (explicit) {
+    return explicit;
+  }
+  const bunGlobal = globalThis.Bun;
+  const bunWhich = bunGlobal?.which?.("bun");
+  const pathBun = normalizeExecutablePath(bunWhich?.trim());
+  if (pathBun && !looksLikeRuntimeGateway(pathBun)) {
+    return pathBun;
+  }
+  const home = process.env.HOME?.trim();
+  const fallbackCandidates = [
+    home ? resolve(home, ".bun/bin/bun") : "",
+    "/opt/homebrew/bin/bun",
+    "/usr/local/bin/bun",
+    "/usr/bin/bun"
+  ];
+  for (const candidate of fallbackCandidates) {
+    const normalized = normalizeExecutablePath(candidate);
+    if (normalized) {
+      return normalized;
+    }
+  }
+  const execPath = normalizeExecutablePath(process.execPath?.trim());
+  if (execPath && !looksLikeRuntimeGateway(execPath)) {
+    return execPath;
+  }
+  throw new Error("bun not found in PATH");
+}
+function resolveBunCliInvocation() {
+  if (BAKED_BUN_PATH) {
+    return {
+      command: BAKED_BUN_PATH,
+      env: {}
+    };
+  }
+  if (process.env.RIG_BUN_PATH?.trim()) {
+    return {
+      command: process.env.RIG_BUN_PATH.trim(),
+      env: {}
+    };
+  }
+  try {
+    const systemBun = resolveBunBinaryPath();
+    return {
+      command: systemBun,
+      env: {}
+    };
+  } catch {}
+  if (process.execPath?.trim()) {
+    return {
+      command: process.execPath,
+      env: { BUN_BE_BUN: "1" }
+    };
+  }
+  return { command: "bun", env: {} };
+}
+async function runTypedHook(fn, opts) {
+  const parsed = await readHookInput();
+  const projectRoot = opts.projectRoot ?? resolveProjectRoot();
+  const taskId = opts.taskId ?? resolveTaskIdForHook(projectRoot);
+  const ctx = buildPluginHookContext(parsed, {
+    event: opts.event,
+    projectRoot,
+    taskId
+  });
+  let result;
+  try {
+    result = await fn(ctx);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    writeSync(2, `[rig hook] typed hook threw: ${message}
+`);
+    process.exit(0);
+  }
+  const { exitCode, stdout } = hookResultToProtocol(result);
+  if (stdout) {
+    writeSync(1, stdout);
+  }
+  process.exit(exitCode);
+}
+export {
+  runTypedHook,
+  resolveBunCliInvocation
+};

package/dist/src/index.d.ts

@@ -3,4 +3,6 @@ export { definePlugin } from "./define-plugin";
 export { defineConfig } from "./define-config";
 export { createPluginHost } from "./plugin-host";
 export type { PluginHost } from "./plugin-host";
-export type { RigPlugin, PluginContributes, Validator, TaskSource, FeatureCapability, Panel, BlockerClassifierEntry, CliCommand, Hook, StageEntry, SessionExtensionEntry, SessionExtensionInstall, TaskSourceFactoryContext, RuntimeCliContext, ValidatorContext, ValidatorResult, } from "./plugin-runtime";
+export { defineCapability, defineServiceCapability, CapabilityProviderMissingError } from "./capability";
+export type { Capability, CapabilityImpl, CapabilityProvideOptions, ServiceCapability, ServiceCapabilityImpl, } from "./capability";
+export type { RigPlugin, PluginContributes, Validator, TaskSource, FeatureCapability, Panel, BlockerClassifierEntry, CliCommand, Hook, StageEntry, SessionExtensionEntry, SessionExtensionInstall, SeedEntrypoint, SeedEntrypointContext, SeedEntrypointRunResult, TaskSourceFactoryContext, RuntimeCliContext, ValidatorContext, ValidatorResult, } from "./plugin-runtime";

package/dist/src/index.js

@@ -10,10 +10,13 @@ function definePlugin(plugin) {
 import { Schema as Schema2 } from "effect";
 import { RigConfig } from "@rig/contracts";
 function normalizeWorkspaceConfig(raw) {
-  const workspace = raw && typeof raw === "object" && !Array.isArray(raw) ? { ...raw } : { mainRepo: "." };
-  workspace.checkout = workspace.checkout ?? workspace.isolation ?? "worktree";
-  workspace.isolation = workspace.isolation ?? workspace.checkout;
-  workspace.sandbox = workspace.sandbox ?? "enforce";
+  const workspace = raw && typeof raw === "object" && !Array.isArray(raw) ? { ...raw } : {};
+  if (workspace.mainRepo === undefined)
+    workspace.mainRepo = ".";
+  if (workspace.checkout === undefined && workspace.isolation !== undefined)
+    workspace.checkout = workspace.isolation;
+  if (workspace.isolation === undefined && workspace.checkout !== undefined)
+    workspace.isolation = workspace.checkout;
   return workspace;
 }
 function applyConfigDefaults(raw) {
@@ -71,6 +74,7 @@ function createPluginHost(plugins) {
   const panels = [];
   const blockerClassifiers = [];
   const sessionExtensions = [];
+  const seedEntrypoints = [];
   const stages = [];
   const stageMutations = [];
   const stageExecutors = {};
@@ -103,6 +107,8 @@ function createPluginHost(plugins) {
       blockerClassifiers.push(...c.blockerClassifiers.map((item) => ({ item, pluginName })));
     if (c.sessionExtensions)
       sessionExtensions.push(...c.sessionExtensions.map((item) => ({ item, pluginName })));
+    if (c.seedEntrypoints)
+      seedEntrypoints.push(...c.seedEntrypoints.map((item) => ({ item, pluginName })));
     if (c.stageMutations)
       stageMutations.push(...c.stageMutations.map((item) => ({ item, pluginName })));
     if (c.stages) {
@@ -125,6 +131,7 @@ function createPluginHost(plugins) {
   const panelMap = indexById(panels, "panel");
   const blockerClassifierMap = indexById(blockerClassifiers, "blockerClassifier");
   indexById(sessionExtensions, "sessionExtension");
+  indexById(seedEntrypoints, "seedEntrypoint");
   const taskSourceFactoryByKind = new Map;
   const taskSourceKindRegistrant = new Map;
   for (const { item, pluginName } of taskSources) {
@@ -134,6 +141,38 @@ function createPluginHost(plugins) {
     taskSourceFactoryByKind.set(item.kind, item);
     taskSourceKindRegistrant.set(item.kind, pluginName);
   }
+  const seedEntrypointByBasename = new Map;
+  const seedEntrypointByWorkerArg = new Map;
+  let insidePtySeedEntrypoint;
+  const registerSeedEntrypointSelector = (map, selectorKind, selector, contribution) => {
+    const existing = map.get(selector);
+    if (existing) {
+      throw new Error(`duplicate seed entrypoint ${selectorKind} "${selector}": registered by entrypoint "${existing.item.id}" from plugin "${existing.pluginName}" and entrypoint "${contribution.item.id}" from plugin "${contribution.pluginName}"`);
+    }
+    map.set(selector, contribution);
+  };
+  for (const contribution of seedEntrypoints) {
+    const entrypoint = contribution.item;
+    let selectorCount = 0;
+    if (entrypoint.basename) {
+      selectorCount += 1;
+      registerSeedEntrypointSelector(seedEntrypointByBasename, "basename", entrypoint.basename, contribution);
+    }
+    if (entrypoint.workerArg) {
+      selectorCount += 1;
+      registerSeedEntrypointSelector(seedEntrypointByWorkerArg, "workerArg", entrypoint.workerArg, contribution);
+    }
+    if (entrypoint.insidePty) {
+      selectorCount += 1;
+      if (insidePtySeedEntrypoint) {
+        throw new Error(`duplicate seed entrypoint inside-pty selector: registered by entrypoint "${insidePtySeedEntrypoint.item.id}" from plugin "${insidePtySeedEntrypoint.pluginName}" and entrypoint "${entrypoint.id}" from plugin "${contribution.pluginName}"`);
+      }
+      insidePtySeedEntrypoint = contribution;
+    }
+    if (selectorCount === 0) {
+      throw new Error(`seed entrypoint "${entrypoint.id}" from plugin "${contribution.pluginName}" must declare at least one selector (basename, workerArg, or insidePty)`);
+    }
+  }
   const allValidators = validators.map((c) => c.item);
   const allHooks = hooks.map((c) => c.item);
   const allSkills = skills.map((c) => c.item);
@@ -148,6 +187,7 @@ function createPluginHost(plugins) {
   const allPanels = panels.map((c) => c.item);
   const allBlockerClassifiers = blockerClassifiers.map((c) => c.item);
   const allSessionExtensions = sessionExtensions.map((c) => c.item);
+  const allSeedEntrypoints = seedEntrypoints.map((c) => c.item);
   const executableCliCommandByName = new Map;
   const registerExecutableCliCommandSelector = (selector, contribution) => {
     const existing = executableCliCommandByName.get(selector);
@@ -165,6 +205,15 @@ function createPluginHost(plugins) {
       registerExecutableCliCommandSelector(alias, contribution);
     }
   }
+  let defaultRootCliCommand;
+  for (const contribution of cliCommands) {
+    if (!contribution.item.rootDefault)
+      continue;
+    if (defaultRootCliCommand) {
+      throw new Error(`duplicate default root CLI command registered by command "${defaultRootCliCommand.item.id}" from plugin "${defaultRootCliCommand.pluginName}" and command "${contribution.item.id}" from plugin "${contribution.pluginName}"`);
+    }
+    defaultRootCliCommand = contribution;
+  }
   return {
     getValidator: (id) => validatorMap.get(id),
     getHook: (id) => hookMap.get(id),
@@ -198,16 +247,81 @@ function createPluginHost(plugins) {
     listExecutableBlockerClassifiers: () => allBlockerClassifiers,
     listExecutableCliCommands: () => allCliCommands,
     listSessionExtensions: () => allSessionExtensions,
+    listSeedEntrypoints: () => allSeedEntrypoints,
+    resolveSeedEntrypointByBasename: (value) => seedEntrypointByBasename.get(value)?.item,
+    resolveSeedEntrypointByWorkerArg: (value) => seedEntrypointByWorkerArg.get(value)?.item,
+    resolveInsidePtySeedEntrypoint: () => insidePtySeedEntrypoint?.item,
     resolveExecutableCliCommand: (requested) => executableCliCommandByName.get(requested)?.item,
+    resolveDefaultRootCliCommand: () => defaultRootCliCommand?.item,
     resolveTaskSourceFactoryByKind: (kind) => taskSourceFactoryByKind.get(kind)
   };
 }
+// packages/core/src/capability.ts
+import { resolveCapability } from "@rig/kernel-seed";
+
+class CapabilityProviderMissingError extends Error {
+  capabilityId;
+  name = "CapabilityProviderMissingError";
+  constructor(capabilityId) {
+    super(`No provider resolved for capability "${capabilityId}"`);
+    this.capabilityId = capabilityId;
+  }
+}
+function isFactory(impl) {
+  return typeof impl === "function";
+}
+function defineCapability(id) {
+  const idString = String(id);
+  const tag = idString;
+  async function resolve(host) {
+    const providers = host.listExecutableCapabilities().filter((c) => c.id === idString && typeof c.run === "function").map((c) => ({
+      name: c.id,
+      provides: [c.id],
+      capabilityProviders: { [c.id]: c.run }
+    }));
+    const resolution = resolveCapability(providers, tag);
+    const run = resolution?.value;
+    if (!run)
+      return null;
+    return await run(undefined);
+  }
+  return {
+    id,
+    provide(impl, opts) {
+      return {
+        id: idString,
+        title: opts?.title ?? idString,
+        ...opts?.description !== undefined ? { description: opts.description } : {},
+        run: isFactory(impl) ? () => impl() : () => impl
+      };
+    },
+    resolve,
+    async require(host) {
+      const value = await resolve(host);
+      if (value === null)
+        throw new CapabilityProviderMissingError(idString);
+      return value;
+    }
+  };
+}
+function defineServiceCapability(id) {
+  const capability = defineCapability(id);
+  return {
+    ...capability,
+    provideService: capability.provide,
+    resolveService: capability.resolve,
+    requireService: capability.require
+  };
+}
 
 // packages/core/src/index.ts
 var RIG_CORE_PACKAGE = "@rig/core";
 export {
+  defineServiceCapability,
   definePlugin,
   defineConfig,
+  defineCapability,
   createPluginHost,
-  RIG_CORE_PACKAGE
+  RIG_CORE_PACKAGE,
+  CapabilityProviderMissingError
 };

package/dist/src/json-files.d.ts

@@ -0,0 +1,9 @@
+export declare function appendJsonlRecord(path: string, value: unknown): void;
+export declare function writeJsonFile(path: string, value: unknown): void;
+export declare function readJsonFile<T>(path: string, fallback: T): T;
+export declare function readAuthorityStateJson<T>(projectRoot: string, relativePath: string, fallback: T): T;
+export declare function writeAuthorityStateJson(projectRoot: string, relativePath: string, value: unknown): string;
+export declare function readAuthorityProjectStateJson<T>(projectRoot: string, relativePath: string, fallback: T): T;
+export declare function writeAuthorityProjectStateJson(projectRoot: string, relativePath: string, value: unknown): string;
+export declare function readJsonlFile(path: string): unknown[];
+export declare function stripAuthorityRunLiveCollabFields<T extends Record<string, unknown>>(record: T): T;

package/dist/src/json-files.js

@@ -0,0 +1,125 @@
+// @bun
+// packages/core/src/json-files.ts
+import { appendFileSync, existsSync as existsSync2, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname as dirname2, resolve as resolve2 } from "path";
+
+// packages/core/src/layout.ts
+import {
+  RIG_ARTIFACTS_DIRNAME,
+  RIG_DEFINITION_DIRNAME,
+  RIG_STATE_DIRNAME
+} from "@rig/contracts";
+
+// packages/core/src/authority-paths.ts
+import { existsSync } from "fs";
+import { dirname, resolve } from "path";
+function normalizeOptionalString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function resolveAuthorityStateRoot(projectRoot) {
+  const normalizedRoot = resolve(projectRoot);
+  const taskWorkspace = normalizeOptionalString(process.env.RIG_TASK_WORKSPACE);
+  if (taskWorkspace) {
+    return resolve(taskWorkspace, ".rig");
+  }
+  const stateDir = normalizeOptionalString(process.env.RIG_STATE_DIR);
+  if (stateDir) {
+    return dirname(resolve(stateDir));
+  }
+  const logsDir = normalizeOptionalString(process.env.RIG_LOGS_DIR);
+  if (logsDir) {
+    return dirname(resolve(logsDir));
+  }
+  const sessionFile = normalizeOptionalString(process.env.RIG_SESSION_FILE);
+  if (sessionFile) {
+    return dirname(dirname(resolve(sessionFile)));
+  }
+  const projectStateRoot = resolve(normalizedRoot, ".rig");
+  if (existsSync(projectStateRoot)) {
+    return projectStateRoot;
+  }
+  return resolve(normalizedRoot, ".rig");
+}
+function resolveAuthorityStateDir(projectRoot) {
+  const explicit = normalizeOptionalString(process.env.RIG_STATE_DIR);
+  if (explicit) {
+    return resolve(explicit);
+  }
+  return resolve(resolveAuthorityStateRoot(projectRoot), "state");
+}
+function resolveAuthorityProjectStateDir(projectRoot) {
+  const explicit = normalizeOptionalString(process.env.RIG_STATE_DIR);
+  if (explicit) {
+    return resolve(explicit);
+  }
+  return resolve(resolve(projectRoot), ".rig", "state");
+}
+// packages/core/src/json-files.ts
+function appendJsonlRecord(path, value) {
+  mkdirSync(dirname2(path), { recursive: true });
+  appendFileSync(path, `${JSON.stringify(value)}
+`, "utf8");
+}
+function writeJsonFile(path, value) {
+  mkdirSync(dirname2(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+}
+function readJsonFile(path, fallback) {
+  if (!existsSync2(path))
+    return fallback;
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return fallback;
+  }
+}
+function readAuthorityStateJson(projectRoot, relativePath, fallback) {
+  return readJsonFile(resolve2(resolveAuthorityStateDir(projectRoot), relativePath), fallback);
+}
+function writeAuthorityStateJson(projectRoot, relativePath, value) {
+  const path = resolve2(resolveAuthorityStateDir(projectRoot), relativePath);
+  writeJsonFile(path, value);
+  return path;
+}
+function readAuthorityProjectStateJson(projectRoot, relativePath, fallback) {
+  return readJsonFile(resolve2(resolveAuthorityProjectStateDir(projectRoot), relativePath), fallback);
+}
+function writeAuthorityProjectStateJson(projectRoot, relativePath, value) {
+  const path = resolve2(resolveAuthorityProjectStateDir(projectRoot), relativePath);
+  writeJsonFile(path, value);
+  return path;
+}
+function readJsonlFile(path) {
+  if (!existsSync2(path))
+    return [];
+  return readFileSync(path, "utf8").split(/\r?\n/).map((line) => line.trim()).filter(Boolean).flatMap((line) => {
+    try {
+      return [JSON.parse(line)];
+    } catch {
+      return [];
+    }
+  });
+}
+function stripAuthorityRunLiveCollabFields(record) {
+  const {
+    collabLink: _collabLink,
+    collabWebLink: _collabWebLink,
+    collabRoomId: _collabRoomId,
+    collabRelayUrl: _collabRelayUrl,
+    collabToken: _collabToken,
+    ...rest
+  } = record;
+  return rest;
+}
+export {
+  writeJsonFile,
+  writeAuthorityStateJson,
+  writeAuthorityProjectStateJson,
+  stripAuthorityRunLiveCollabFields,
+  readJsonlFile,
+  readJsonFile,
+  readAuthorityStateJson,
+  readAuthorityProjectStateJson,
+  appendJsonlRecord
+};

package/dist/src/kernel-entrypoint.d.ts

@@ -0,0 +1,22 @@
+import type { JournalCapability, TransportCapability } from "@rig/contracts";
+import { type DefaultKernelBootRecord } from "@rig/kernel-seed/boot-default";
+import type { CapabilityProviderPlugin } from "@rig/kernel-seed/plugin-abi";
+export type HydrationResult = {
+    readonly projectRoot: string;
+    readonly dotenvLoaded: boolean;
+    readonly configLoaded: boolean;
+    readonly errors: readonly string[];
+};
+export type HydrateProjectProcessEnvOptions = {
+    readonly env?: NodeJS.ProcessEnv;
+    readonly dotenvPath?: string;
+};
+export type AdoptKernelOptions = HydrateProjectProcessEnvOptions & {
+    readonly entrypoint?: string;
+    readonly journal?: JournalCapability;
+    readonly transport?: TransportCapability;
+    readonly hydrateEnv?: boolean;
+};
+export declare function createPlacementKernelTransportPlugin(transport: TransportCapability): CapabilityProviderPlugin;
+export declare function hydrateProjectProcessEnv(projectRoot: string, options?: HydrateProjectProcessEnvOptions): Promise<HydrationResult>;
+export declare function adopt(root?: string, options?: AdoptKernelOptions): Promise<DefaultKernelBootRecord>;