@h-rig/core 0.0.6-alpha.9 → 0.0.6-alpha.91

package/dist/src/load-config.js

@@ -1,17 +1,269 @@
 // @bun
 // packages/core/src/load-config.ts
-import { existsSync, readFileSync } from "fs";
-import { join } from "path";
-import { pathToFileURL } from "url";
+import { existsSync, mkdtempSync, readFileSync, readdirSync, rmSync } from "fs";
+import { tmpdir } from "os";
+import { dirname, join } from "path";
+import { fileURLToPath, pathToFileURL } from "url";
+import { Schema as Schema2 } from "effect";
+import { RigConfig as RigConfig2 } from "@rig/contracts";
+
+// packages/core/src/define-config.ts
 import { Schema } 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";
+  return workspace;
+}
+function applyConfigDefaults(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw))
+    return raw;
+  const record = raw;
+  return {
+    ...record,
+    plugins: Array.isArray(record.plugins) ? record.plugins : [],
+    workspace: normalizeWorkspaceConfig(record.workspace)
+  };
+}
+
+// packages/core/src/load-config.ts
 var TS_NAMES = ["rig.config.ts", "rig.config.mts"];
 var JSON_NAMES = ["rig.config.json"];
+function isModuleResolutionError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.includes("Cannot find module") || message.includes("Could not resolve");
+}
+function runningFromCompiledBinary() {
+  return import.meta.url.includes("$bunfs");
+}
+function packageNameAndSubpath(specifier) {
+  if (specifier.startsWith(".") || specifier.startsWith("/") || /^[a-zA-Z]+:/.test(specifier))
+    return null;
+  const parts = specifier.split("/");
+  const packageName = specifier.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
+  if (!packageName)
+    return null;
+  const rest = parts.slice(specifier.startsWith("@") ? 2 : 1).join("/");
+  return { packageName, subpath: rest ? `./${rest}` : "." };
+}
+function exportTargetFromEntry(entry) {
+  if (typeof entry === "string")
+    return entry;
+  if (entry && typeof entry === "object" && !Array.isArray(entry)) {
+    const conditions = entry;
+    for (const key of ["bun", "import", "default", "require"]) {
+      if (typeof conditions[key] === "string")
+        return conditions[key];
+    }
+  }
+  return null;
+}
+function patternExportTarget(record, subpath) {
+  for (const [pattern, entry] of Object.entries(record)) {
+    if (!pattern.includes("*"))
+      continue;
+    const [prefix = "", suffix = ""] = pattern.split("*");
+    if (!subpath.startsWith(prefix) || !subpath.endsWith(suffix))
+      continue;
+    const replacement = subpath.slice(prefix.length, subpath.length - suffix.length);
+    const target = exportTargetFromEntry(entry);
+    if (target)
+      return target.replace("*", replacement);
+  }
+  return null;
+}
+function exportTargetFromPackageJson(pkg, subpath) {
+  const exportsField = pkg.exports;
+  const target = (() => {
+    if (typeof exportsField === "string" && subpath === ".")
+      return exportsField;
+    if (!exportsField || typeof exportsField !== "object" || Array.isArray(exportsField))
+      return null;
+    const record = exportsField;
+    return exportTargetFromEntry(record[subpath] ?? (subpath === "." ? record["."] : undefined)) ?? patternExportTarget(record, subpath);
+  })();
+  if (target)
+    return target;
+  return subpath === "." && typeof pkg.module === "string" ? pkg.module : subpath === "." && typeof pkg.main === "string" ? pkg.main : null;
+}
+function resolvePackageDirFromBunStore(packageName, nodeModulesDir) {
+  const storeDir = join(nodeModulesDir, ".bun");
+  if (!existsSync(storeDir))
+    return null;
+  const encoded = packageName.replace("/", "+");
+  try {
+    for (const entry of readdirSync(storeDir).sort()) {
+      if (!entry.startsWith(`${encoded}@`))
+        continue;
+      const candidate = join(storeDir, entry, "node_modules", packageName);
+      if (existsSync(join(candidate, "package.json")))
+        return candidate;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function resolvePackageExportFromDir(packageDir, subpath) {
+  const packageJsonPath = join(packageDir, "package.json");
+  if (!existsSync(packageJsonPath))
+    return null;
+  try {
+    const pkg = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+    const target = exportTargetFromPackageJson(pkg, subpath);
+    if (target) {
+      const resolved = join(packageDir, target);
+      if (existsSync(resolved))
+        return resolved;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function resolveBarePackageExport(specifier, parentDir) {
+  const parsed = packageNameAndSubpath(specifier);
+  if (!parsed)
+    return null;
+  const packageNames = parsed.packageName.startsWith("@rig/") ? [parsed.packageName, parsed.packageName.replace(/^@rig\//, "@h-rig/")] : [parsed.packageName];
+  let current = parentDir;
+  while (true) {
+    const nodeModulesDir = join(current, "node_modules");
+    for (const packageName of packageNames) {
+      const directPackageDir = join(nodeModulesDir, packageName);
+      const resolvedDirect = resolvePackageExportFromDir(directPackageDir, parsed.subpath);
+      if (resolvedDirect)
+        return resolvedDirect;
+      const bunStorePackageDir = resolvePackageDirFromBunStore(packageName, nodeModulesDir);
+      if (bunStorePackageDir) {
+        const resolvedFromStore = resolvePackageExportFromDir(bunStorePackageDir, parsed.subpath);
+        if (resolvedFromStore)
+          return resolvedFromStore;
+      }
+    }
+    const next = dirname(current);
+    if (next === current)
+      break;
+    current = next;
+  }
+  return null;
+}
+var runtimeBundleQueue = Promise.resolve();
+function enqueueRuntimeBundle(operation) {
+  const next = runtimeBundleQueue.then(operation, operation);
+  runtimeBundleQueue = next.then(() => {
+    return;
+  }, () => {
+    return;
+  });
+  return next;
+}
+async function importConfigViaRuntimeBundleUnserialized(configPath) {
+  const bun = globalThis.Bun;
+  if (!bun?.build) {
+    throw new Error(`Failed to import ${configPath}: bare imports could not be resolved and no Bun.build runtime bundler is available.`);
+  }
+  const hostDir = (() => {
+    try {
+      return dirname(fileURLToPath(import.meta.url));
+    } catch {
+      return process.cwd();
+    }
+  })();
+  const configDir = dirname(configPath);
+  const UNRESOLVED_NAMESPACE = "rig-config-unresolved";
+  const hostResolverPlugin = {
+    name: "rig-host-package-resolver",
+    setup(build) {
+      build.onResolve({ filter: /^@rig\// }, (args) => {
+        const candidates = [
+          [args.path, hostDir],
+          [args.path.replace(/^@rig\//, "@h-rig/"), hostDir],
+          [args.path, configDir]
+        ];
+        for (const [specifier, parent] of candidates) {
+          try {
+            const resolved = bun.resolveSync?.(specifier, parent) ?? resolveBarePackageExport(specifier, parent);
+            if (resolved)
+              return { path: resolved };
+          } catch {
+            const resolved = resolveBarePackageExport(specifier, parent);
+            if (resolved)
+              return { path: resolved };
+          }
+        }
+        return;
+      });
+      build.onResolve({ filter: /.*/ }, (args) => {
+        if (/^(?:node|bun):/.test(args.path))
+          return;
+        const parent = args.importer ? dirname(args.importer) : configDir;
+        try {
+          const resolved = bun.resolveSync?.(args.path, parent) ?? resolveBarePackageExport(args.path, parent);
+          if (resolved)
+            return { path: resolved };
+        } catch {
+          const resolved = resolveBarePackageExport(args.path, parent);
+          if (resolved)
+            return { path: resolved };
+          return { path: args.path, namespace: UNRESOLVED_NAMESPACE };
+        }
+        return;
+      });
+      build.onLoad({ filter: /.*/, namespace: UNRESOLVED_NAMESPACE }, (args) => ({
+        loader: "js",
+        contents: `module.exports = {};
+throw new Error(${JSON.stringify(`Failed to bundle ${configPath}: Could not resolve: "${args.path}". Maybe you need to "bun install"?`)});
+`
+      }));
+    }
+  };
+  const result = await bun.build({
+    entrypoints: [configPath],
+    target: "bun",
+    format: "esm",
+    throw: false,
+    plugins: [hostResolverPlugin]
+  });
+  if (!result.success || !result.outputs[0]) {
+    const detail = result.logs.map((log) => String(log)).join(`
+`);
+    throw new Error(`Failed to bundle ${configPath}: ${detail || "unknown bundler error"}`);
+  }
+  const dir = mkdtempSync(join(tmpdir(), "rig-config-bundle-"));
+  try {
+    const bundledPath = join(dir, "rig.config.bundled.js");
+    await bun.write(bundledPath, await result.outputs[0].text());
+    return await import(pathToFileURL(bundledPath).href);
+  } finally {
+    try {
+      rmSync(dir, { recursive: true, force: true });
+    } catch {}
+  }
+}
 async function loadConfig(cwd) {
   for (const name of TS_NAMES) {
     const p = join(cwd, name);
     if (existsSync(p)) {
-      const mod = await import(pathToFileURL(p).href);
+      const mod = await enqueueRuntimeBundle(async () => {
+        if (runningFromCompiledBinary()) {
+          return importConfigViaRuntimeBundleUnserialized(p);
+        }
+        const source = readFileSync(p, "utf8");
+        const importsRigHostPackages = /(?:import\s+[^;]*?from\s*|import\s*\()\s*["']@rig\//.test(source);
+        if (importsRigHostPackages) {
+          return importConfigViaRuntimeBundleUnserialized(p);
+        }
+        try {
+          return await import(pathToFileURL(p).href);
+        } catch (error) {
+          if (!isModuleResolutionError(error))
+            throw error;
+          return importConfigViaRuntimeBundleUnserialized(p);
+        }
+      });
       const raw = mod.default ?? mod.config;
       return decodePreservingRuntime(raw);
     }
@@ -35,7 +287,7 @@ function decodePreservingRuntime(raw) {
       }
     }
   }
-  const decoded = Schema.decodeUnknownSync(RigConfig)(raw);
+  const decoded = Schema2.decodeUnknownSync(RigConfig2)(applyConfigDefaults(raw));
   const plugins = decoded.plugins.map((p) => {
     const runtime = runtimeByName.get(p.name);
     if (!runtime)

package/dist/src/plugin-host.d.ts

@@ -0,0 +1,40 @@
+import type { ValidatorRegistration, HookRegistration, SkillRegistration, RepoSourceRegistration, AgentRoleRegistration, TaskFieldExtension, TaskSourceRegistration, CliCommandRegistration } from "@rig/contracts";
+import type { RegisteredValidator, RigPluginWithRuntime, TaskSourceFactoryEntry } from "./plugin-runtime";
+export interface PluginHost {
+    getValidator(id: string): ValidatorRegistration | undefined;
+    getHook(id: string): HookRegistration | undefined;
+    getSkill(id: string): SkillRegistration | undefined;
+    getRepoSource(id: string): RepoSourceRegistration | undefined;
+    getAgentRole(id: string): AgentRoleRegistration | undefined;
+    getTaskFieldExtension(id: string): TaskFieldExtension | undefined;
+    getTaskSource(id: string): TaskSourceRegistration | undefined;
+    getCliCommand(id: string): CliCommandRegistration | undefined;
+    listValidators(): readonly ValidatorRegistration[];
+    listHooks(): readonly HookRegistration[];
+    listSkills(): readonly SkillRegistration[];
+    listRepoSources(): readonly RepoSourceRegistration[];
+    listAgentRoles(): readonly AgentRoleRegistration[];
+    listTaskFieldExtensions(): readonly TaskFieldExtension[];
+    listTaskSources(): readonly TaskSourceRegistration[];
+    listCliCommands(): readonly CliCommandRegistration[];
+    /**
+     * Executable validators contributed by plugins. Only validators whose
+     * metadata appears in `listValidators()` and whose plugin shipped a runtime
+     * implementation via `definePlugin(meta, { validators: [...] })` appear here.
+     * Validators registered metadata-only (no run() implementation) are absent.
+     */
+    listExecutableValidators(): readonly RegisteredValidator[];
+    /**
+     * Executable task source factories contributed by plugins. Used by the
+     * runtime's `buildTaskSourceRegistry` to instantiate non-standard task
+     * source kinds (Linear, Jira, custom) declared by plugins.
+     */
+    listExecutableTaskSources(): readonly TaskSourceFactoryEntry[];
+    /**
+     * Look up an executable task source factory by its `kind` (the value in
+     * `config.taskSource.kind`). Returns undefined when no plugin provides
+     * a factory for that kind.
+     */
+    resolveTaskSourceFactoryByKind(kind: string): TaskSourceFactoryEntry | undefined;
+}
+export declare function createPluginHost(plugins: readonly RigPluginWithRuntime[]): PluginHost;

package/dist/src/plugin-host.js

@@ -58,6 +58,24 @@ function assertRuntimeMatchesMetadata(plugin) {
       }
     }
   }
+  const declaredHooks = new Map((plugin.contributes?.hooks ?? []).map((hook) => [hook.id, hook]));
+  const runtimeHooks = plugin.__runtime?.hooks;
+  for (const hookId of Object.keys(runtimeHooks ?? {})) {
+    const metadata = declaredHooks.get(hookId);
+    if (!metadata) {
+      throw new Error(`plugin "${plugin.name}" typed hook "${hookId}" has no matching metadata entry in contributes.hooks`);
+    }
+    if (metadata.command) {
+      throw new Error(`plugin "${plugin.name}" hook "${hookId}" has both a typed implementation and a command string \u2014 pick one`);
+    }
+  }
+  if (runtimeHooks) {
+    for (const hook of declaredHooks.values()) {
+      if (!runtimeHooks[hook.id] && !hook.command) {
+        throw new Error(`plugin "${plugin.name}" hook metadata "${hook.id}" has no implementation (typed function or command)`);
+      }
+    }
+  }
 }
 function createPluginHost(plugins) {
   assertUniquePluginNames(plugins);

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

@@ -0,0 +1,64 @@
+import type { HookImplementation, RegisteredTaskSource, RigConfig, RigPlugin, TaskSourceConfig, TaskSourceRegistration, ValidatorRegistration } from "@rig/contracts";
+export interface ValidatorResult {
+    id: string;
+    passed: boolean;
+    summary: string;
+    details?: string;
+}
+export interface ValidatorContext {
+    taskId: string;
+    workspaceRoot: string;
+    scope: readonly string[];
+    monorepoRoot?: string;
+    artifactsDir?: string;
+    taskConfig?: unknown;
+}
+export interface RegisteredValidator extends ValidatorRegistration {
+    run(ctx: ValidatorContext): Promise<ValidatorResult>;
+}
+/**
+ * Project context handed to task-source factories at instantiation. The
+ * server process's cwd is NOT necessarily the project root (workspace-spawned
+ * servers run from the engine checkout), so factories that touch the
+ * filesystem must resolve relative config paths against `projectRoot`,
+ * never cwd.
+ */
+export interface TaskSourceFactoryContext {
+    projectRoot: string;
+    /**
+     * Full project config for adapters that need source-adjacent top-level
+     * settings (for example github.projects). Factories should still treat
+     * TaskSourceConfig as the primary adapter config.
+     */
+    rigConfig?: RigConfig;
+}
+/**
+ * Executable task-source factory contributed by a plugin. A plugin
+ * registers a TaskSourceRegistration metadata entry (with `id` and `kind`)
+ * AND a factory here that turns a TaskSourceConfig into a RegisteredTaskSource.
+ *
+ * `kind` is matched against `config.taskSource.kind` at boot. The first
+ * matching plugin factory wins; if multiple plugins claim the same kind,
+ * `createPluginHost` throws a duplicate-kind error.
+ */
+export interface TaskSourceFactoryEntry extends TaskSourceRegistration {
+    factory(config: TaskSourceConfig, context?: TaskSourceFactoryContext): RegisteredTaskSource;
+}
+export interface RigPluginRuntime {
+    validators?: readonly RegisteredValidator[];
+    taskSources?: readonly TaskSourceFactoryEntry[];
+    /**
+     * Typed hook implementations keyed by hook id. Each key must match a
+     * declared `contributes.hooks` entry on the same plugin. A typed hook and
+     * a metadata `command` string are mutually exclusive per hook — and when
+     * this channel is present, every declared hook must be implemented one way
+     * or the other (same all-or-none rule as validators). The runtime's
+     * hook-materializer generates the shim command that routes Claude Code's
+     * hook invocation to the typed function (see
+     * `@rig/runtime/control-plane/hook-runner`).
+     */
+    hooks?: Record<string, HookImplementation>;
+}
+export type RigPluginWithRuntime = RigPlugin & {
+    __runtime?: RigPluginRuntime;
+};

package/dist/src/rig-init-builder.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Pure builder that turns a small input shape into the source text of a
+ * `rig.config.ts` file. Shared between the CLI `rig init` wizard and the
+ * desktop app's in-app setup wizard so both surfaces produce identical
+ * output.
+ *
+ * Pure — no fs, no node, no imports outside this file. Safe to bundle into
+ * a renderer (Vite, esbuild, webpack).
+ */
+export type RigInitConfigInput = {
+    projectName: string;
+    projectRepo?: string;
+    taskSource: {
+        kind: "github-issues";
+        owner: string;
+        repo: string;
+        assignee?: string;
+    } | {
+        kind: "files";
+        path: string;
+    };
+    useStandardPlugin: boolean;
+};
+export declare function buildRigInitConfigSource(input: RigInitConfigInput): string;

package/dist/src/rig-init-builder.js

@@ -43,7 +43,7 @@ function buildRigInitConfigSource(input) {
   lines.push(`    issueUpdates: "lifecycle",`);
   lines.push(`    projects: { enabled: false },`);
   lines.push(`  },`);
-  lines.push(`  automation: { maxValidationAttempts: 30, maxPrFixIterations: 30 },`);
+  lines.push(`  automation: { maxValidationAttempts: 30, maxPrFixIterations: 100500 },`);
   lines.push(`  pr: { mode: "auto", watchChecks: true, autoFixChecks: true, autoFixReview: true },`);
   lines.push(`  merge: { mode: "auto", method: "repo-default", deleteBranch: "repo-default", bypass: false },`);
   lines.push(`  issueAnalysis: { enabled: true, harness: "pi", mode: "continuous" },`);

package/dist/src/rigSelectors.d.ts

@@ -0,0 +1,220 @@
+import type { ArtifactSummary, ApprovalSummary, EngineReadModel, GraphSummary, QueueEntry, RemoteConnectionSummary, RemoteEndpoint, RunId, RunJournalProjection, RunStatus, RunSummary, TaskId, TaskStatus, TaskSummary, UserInputRequestSummary, WorkspaceId, WorkspaceSummary } from "@rig/contracts";
+import type { TaskDependencyProjection } from "./taskGraph";
+export declare function selectWorkspaces(snapshot: EngineReadModel | null): readonly WorkspaceSummary[];
+export declare function selectPrimaryWorkspace(snapshot: EngineReadModel | null): WorkspaceSummary | null;
+export declare function pickDefaultWorkspaceId(snapshot: EngineReadModel | null): WorkspaceId | null;
+export declare function selectWorkspace(snapshot: EngineReadModel | null, workspaceId: WorkspaceId | null): WorkspaceSummary | null;
+export declare function selectTask(snapshot: EngineReadModel | null, taskId: TaskId | null): TaskSummary | null;
+export declare function selectTasksByWorkspace(snapshot: EngineReadModel | null, workspaceId: WorkspaceId | null): TaskSummary[];
+export declare const selectTasksForWorkspace: typeof selectTasksByWorkspace;
+export declare function selectTasksByStatus(snapshot: EngineReadModel | null, status: TaskStatus): TaskSummary[];
+export type RigTaskSessionProjection = Pick<RunJournalProjection, "record" | "status" | "lastEventAt"> & {
+    readonly taskId?: string | null;
+};
+export interface RigTaskStatusGroupingInput<T extends TaskDependencyProjection = TaskDependencyProjection> {
+    readonly tasks: readonly T[];
+    readonly sessions?: readonly RigTaskSessionProjection[];
+    readonly workspaceId?: string | null;
+}
+export interface RigTaskStatusGroup<T extends TaskDependencyProjection = TaskDependencyProjection> {
+    readonly status: string;
+    readonly tasks: readonly T[];
+}
+export declare function projectTaskStatusForGrouping(status: string | null | undefined): string;
+export declare function projectRunStatusForTaskGrouping(status: RunStatus | null | undefined): string | null;
+export declare function projectTaskStatusWithSessions(task: TaskDependencyProjection, sessionsByTask?: ReadonlyMap<string, RigTaskSessionProjection>): string;
+export declare function selectTasksGroupedByStatus(snapshot: EngineReadModel | null, workspaceId: WorkspaceId | null): Array<{
+    status: string;
+    tasks: readonly TaskSummary[];
+}>;
+export declare function selectTasksGroupedByStatus<T extends TaskDependencyProjection>(input: RigTaskStatusGroupingInput<T>): Array<RigTaskStatusGroup<T>>;
+export declare function normalizeTaskAssigneeFilter(assignee: string | null | undefined, currentUserLogin?: string | null): string | null;
+export declare function readTaskAssigneeLogins(task: TaskDependencyProjection): readonly string[];
+export declare function taskMatchesAssigneeFilter(task: TaskDependencyProjection, assignee: string | null | undefined, options?: {
+    readonly currentUserLogin?: string | null;
+}): boolean;
+export declare function selectTasksAssignedTo<T extends TaskDependencyProjection>(tasks: readonly T[], assignee: string | null | undefined, options?: {
+    readonly currentUserLogin?: string | null;
+}): T[];
+export declare function selectTasksAssignedToMe<T extends TaskDependencyProjection>(tasks: readonly T[], currentUserLogin: string | null | undefined): T[];
+export declare function selectRun(snapshot: EngineReadModel | null, runId: RunId | null): RunSummary | null;
+export declare function selectRunsByTask(snapshot: EngineReadModel | null, taskId: TaskId | null): RunSummary[];
+export declare const selectRunsForTask: typeof selectRunsByTask;
+export declare function selectRunsForWorkspace(snapshot: EngineReadModel | null, workspaceId: WorkspaceId | null): RunSummary[];
+export declare function selectAdhocRuns(snapshot: EngineReadModel | null): RunSummary[];
+export declare function selectAdhocRunsForWorkspace(snapshot: EngineReadModel | null, workspaceId: WorkspaceId | null): RunSummary[];
+export declare function selectGraphsForWorkspace(snapshot: EngineReadModel | null, workspaceId: WorkspaceId | null): GraphSummary[];
+export declare function selectQueueForWorkspace(snapshot: EngineReadModel | null, workspaceId: WorkspaceId | null): QueueEntry[];
+export declare function selectPendingApprovals(snapshot: EngineReadModel | null): ApprovalSummary[];
+export declare function selectApprovalsForRun(snapshot: EngineReadModel | null, runId: RunId | null): ApprovalSummary[];
+export declare function selectPendingApprovalsForRun(snapshot: EngineReadModel | null, runId: RunId | null): ApprovalSummary[];
+export declare function selectApprovalsForWorkspace(snapshot: EngineReadModel | null, workspaceId: WorkspaceId | null): ApprovalSummary[];
+export declare function selectUserInputsForRun(snapshot: EngineReadModel | null, runId: RunId | null): UserInputRequestSummary[];
+export declare function selectPendingUserInputs(snapshot: EngineReadModel | null): UserInputRequestSummary[];
+export declare function selectPendingUserInputsForRun(snapshot: EngineReadModel | null, runId: RunId | null): UserInputRequestSummary[];
+export declare function selectUserInputsForWorkspace(snapshot: EngineReadModel | null, workspaceId: WorkspaceId | null): UserInputRequestSummary[];
+export declare function selectRuntimeForRun(snapshot: EngineReadModel | null, runId: RunId | null): {
+    readonly id: string & import("effect/Brand").Brand<"EngineRuntimeId">;
+    readonly updatedAt: string;
+    readonly status: "starting" | "running" | "interrupted" | "failed" | "prepared" | "exited" | "destroyed";
+    readonly startedAt: string | null;
+    readonly pid: number | null;
+    readonly stateDir: string | null;
+    readonly workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">;
+    readonly workspaceDir: string | null;
+    readonly homeDir: string | null;
+    readonly tmpDir: string | null;
+    readonly cacheDir: string | null;
+    readonly logsDir: string | null;
+    readonly sessionDir: string | null;
+    readonly sessionLogPath: string | null;
+    readonly exitedAt: string | null;
+    readonly runId: string & import("effect/Brand").Brand<"RunId">;
+    readonly adapterKind: string;
+    readonly sandboxMode: "read-only" | "workspace-write" | "danger-full-access";
+    readonly isolationMode: "none" | "env" | "worktree";
+    readonly executionTarget?: "remote" | "local" | undefined;
+    readonly remoteHostId?: string | null | undefined;
+} | null;
+export declare function selectLatestRuntimeForTask(snapshot: EngineReadModel | null, taskId: TaskId | null): {
+    readonly id: string & import("effect/Brand").Brand<"EngineRuntimeId">;
+    readonly updatedAt: string;
+    readonly status: "starting" | "running" | "interrupted" | "failed" | "prepared" | "exited" | "destroyed";
+    readonly startedAt: string | null;
+    readonly pid: number | null;
+    readonly stateDir: string | null;
+    readonly workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">;
+    readonly workspaceDir: string | null;
+    readonly homeDir: string | null;
+    readonly tmpDir: string | null;
+    readonly cacheDir: string | null;
+    readonly logsDir: string | null;
+    readonly sessionDir: string | null;
+    readonly sessionLogPath: string | null;
+    readonly exitedAt: string | null;
+    readonly runId: string & import("effect/Brand").Brand<"RunId">;
+    readonly adapterKind: string;
+    readonly sandboxMode: "read-only" | "workspace-write" | "danger-full-access";
+    readonly isolationMode: "none" | "env" | "worktree";
+    readonly executionTarget?: "remote" | "local" | undefined;
+    readonly remoteHostId?: string | null | undefined;
+} | null;
+export declare function selectActionsForTask(snapshot: EngineReadModel | null, taskId: TaskId | null): {
+    readonly id: string & import("effect/Brand").Brand<"ActionId">;
+    readonly title: string;
+    readonly completedAt: string | null;
+    readonly payload: unknown;
+    readonly startedAt: string;
+    readonly state: string;
+    readonly messageId: (string & import("effect/Brand").Brand<"MessageId">) | null;
+    readonly runId: string & import("effect/Brand").Brand<"RunId">;
+    readonly detail: string | null;
+    readonly actionType: string;
+}[];
+export declare function selectApprovalsForTask(snapshot: EngineReadModel | null, taskId: TaskId | null): {
+    readonly id: string;
+    readonly createdAt: string;
+    readonly status: "pending" | "resolved";
+    readonly payload: unknown;
+    readonly runId: string & import("effect/Brand").Brand<"RunId">;
+    readonly actionId: string | null;
+    readonly resolvedAt: string | null;
+    readonly requestKind: string;
+}[];
+export declare function selectUserInputsForTask(snapshot: EngineReadModel | null, taskId: TaskId | null): {
+    readonly id: string;
+    readonly createdAt: string;
+    readonly status: "pending" | "resolved";
+    readonly payload: unknown;
+    readonly runId: string & import("effect/Brand").Brand<"RunId">;
+    readonly resolvedAt: string | null;
+}[];
+export declare function selectValidationsForRun(snapshot: EngineReadModel | null, runId: RunId | null): {
+    readonly id: string & import("effect/Brand").Brand<"ValidationResultId">;
+    readonly status: "running" | "pending" | "failed" | "passed" | "skipped";
+    readonly completedAt: string | null;
+    readonly startedAt: string;
+    readonly taskId: (string & import("effect/Brand").Brand<"TaskId">) | null;
+    readonly runId: string & import("effect/Brand").Brand<"RunId">;
+    readonly validatorKey: string;
+    readonly output: unknown;
+}[];
+export declare function selectValidationsForTask(snapshot: EngineReadModel | null, taskId: TaskId | null): {
+    readonly id: string & import("effect/Brand").Brand<"ValidationResultId">;
+    readonly status: "running" | "pending" | "failed" | "passed" | "skipped";
+    readonly completedAt: string | null;
+    readonly startedAt: string;
+    readonly taskId: (string & import("effect/Brand").Brand<"TaskId">) | null;
+    readonly runId: string & import("effect/Brand").Brand<"RunId">;
+    readonly validatorKey: string;
+    readonly output: unknown;
+}[];
+export declare function selectFailedValidations(snapshot: EngineReadModel | null, runId: RunId | null): {
+    readonly id: string & import("effect/Brand").Brand<"ValidationResultId">;
+    readonly status: "running" | "pending" | "failed" | "passed" | "skipped";
+    readonly completedAt: string | null;
+    readonly startedAt: string;
+    readonly taskId: (string & import("effect/Brand").Brand<"TaskId">) | null;
+    readonly runId: string & import("effect/Brand").Brand<"RunId">;
+    readonly validatorKey: string;
+    readonly output: unknown;
+}[];
+export declare function selectReviewsForRun(snapshot: EngineReadModel | null, runId: RunId | null): {
+    readonly id: string & import("effect/Brand").Brand<"ReviewResultId">;
+    readonly createdAt: string;
+    readonly status: "running" | "error" | "rejected" | "pending" | "approved";
+    readonly completedAt: string | null;
+    readonly summary: string | null;
+    readonly provider: string;
+    readonly mode: "required" | "off" | "advisory";
+    readonly taskId: (string & import("effect/Brand").Brand<"TaskId">) | null;
+    readonly runId: string & import("effect/Brand").Brand<"RunId">;
+    readonly output: unknown;
+}[];
+export declare function selectReviewsForTask(snapshot: EngineReadModel | null, taskId: TaskId | null): {
+    readonly id: string & import("effect/Brand").Brand<"ReviewResultId">;
+    readonly createdAt: string;
+    readonly status: "running" | "error" | "rejected" | "pending" | "approved";
+    readonly completedAt: string | null;
+    readonly summary: string | null;
+    readonly provider: string;
+    readonly mode: "required" | "off" | "advisory";
+    readonly taskId: (string & import("effect/Brand").Brand<"TaskId">) | null;
+    readonly runId: string & import("effect/Brand").Brand<"RunId">;
+    readonly output: unknown;
+}[];
+export declare function selectArtifactsForRun(snapshot: EngineReadModel | null, runId: RunId | null): ArtifactSummary[];
+export declare function selectArtifactsForTask(snapshot: EngineReadModel | null, taskId: TaskId | null): ArtifactSummary[];
+export declare function selectPolicyDecisionsForTask(snapshot: EngineReadModel | null, taskId: TaskId | null): {
+    readonly id: string;
+    readonly createdAt: string;
+    readonly decision: "allow" | "block" | "warn";
+    readonly mode: "off" | "enforce" | "observe";
+    readonly runId: string & import("effect/Brand").Brand<"RunId">;
+    readonly actionId: (string & import("effect/Brand").Brand<"ActionId">) | null;
+    readonly reason: string;
+    readonly matchedRules: readonly string[];
+}[];
+export declare function selectRemoteEndpoints(snapshot: EngineReadModel | null): readonly RemoteEndpoint[];
+export declare function selectRemoteConnections(snapshot: EngineReadModel | null): readonly RemoteConnectionSummary[];
+export declare function selectRemoteEndpoint(snapshot: EngineReadModel | null, endpointId: string | null): {
+    readonly id: string & import("effect/Brand").Brand<"RemoteEndpointId">;
+    readonly port: number;
+    readonly lastConnectedAt: string | null;
+    readonly alias: string;
+    readonly host: string;
+    readonly token: string;
+    readonly addedAt: string;
+    readonly tokenConfigured?: boolean | undefined;
+    readonly autoConnect?: boolean | undefined;
+} | null;
+export declare function selectRemoteConnection(snapshot: EngineReadModel | null, endpointId: string | null): {
+    readonly error: string | null;
+    readonly status: "error" | "disconnected" | "connecting" | "authenticating" | "connected" | "reconnecting";
+    readonly endpointId: string & import("effect/Brand").Brand<"RemoteEndpointId">;
+    readonly connectedAt: string | null;
+    readonly tokenExpiresAt: string | null;
+    readonly latencyMs: number | null;
+    readonly subscribedEvents: readonly string[];
+} | null;
+export declare function selectConnectedRemoteCount(snapshot: EngineReadModel | null): number;