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

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

@@ -0,0 +1,18 @@
+import { RigConfig } from "@rig/contracts";
+/**
+ * Author-facing config input: `plugins` and `workspace` are optional and
+ * default to a plugin-less worktree setup, so the minimal documented config
+ * (project + taskSource) works out of the box.
+ */
+export type RigConfigInput = Omit<RigConfig, "plugins" | "workspace"> & {
+    plugins?: RigConfig["plugins"];
+    workspace?: RigConfig["workspace"];
+};
+/** Fill optional top-level sections before Schema decode (which requires them). */
+export declare function applyConfigDefaults(raw: unknown): unknown;
+/**
+ * Validate a Rig config and decode through Schema, preserving each plugin's
+ * `__runtime` channel. Schema decode strips unknown fields, so we capture
+ * the runtime objects before decoding and re-attach them after.
+ */
+export declare function defineConfig(cfg: RigConfigInput): RigConfig;

package/dist/src/define-config.js

@@ -2,6 +2,23 @@
 // 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)
+  };
+}
 function defineConfig(cfg) {
   const runtimeByName = new Map;
   const plugins = cfg.plugins ?? [];
@@ -10,7 +27,7 @@ function defineConfig(cfg) {
       runtimeByName.set(plugin.name, plugin.__runtime);
     }
   }
-  const decoded = Schema.decodeUnknownSync(RigConfig)(cfg);
+  const decoded = Schema.decodeUnknownSync(RigConfig)(applyConfigDefaults(cfg));
   const decodedPlugins = decoded.plugins.map((p) => {
     const runtime = runtimeByName.get(p.name);
     if (!runtime)
@@ -20,5 +37,6 @@ function defineConfig(cfg) {
   return { ...decoded, plugins: decodedPlugins };
 }
 export {
-  defineConfig
+  defineConfig,
+  applyConfigDefaults
 };

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

@@ -0,0 +1,9 @@
+import { RigPlugin } from "@rig/contracts";
+import type { RigPluginRuntime, RigPluginWithRuntime } from "./plugin-runtime";
+/**
+ * Define a Rig plugin. The first argument is the schema-validated metadata
+ * (id strings, version, contributions). The optional second argument carries
+ * executable bits (validator `run` functions, etc.) that Schema cannot
+ * represent — they travel alongside the validated metadata as `__runtime`.
+ */
+export declare function definePlugin(meta: RigPlugin, runtime?: RigPluginRuntime): RigPluginWithRuntime;

package/dist/src/define-plugin.js

@@ -43,6 +43,23 @@ function definePlugin(meta, runtime) {
       }
     }
   }
+  const declaredHooks = new Map((validated.contributes?.hooks ?? []).map((h) => [h.id, h]));
+  for (const hookId of Object.keys(runtime.hooks ?? {})) {
+    const metadata = declaredHooks.get(hookId);
+    if (!metadata) {
+      throw new Error(`definePlugin(${validated.name}): typed hook "${hookId}" has no matching metadata entry in contributes.hooks`);
+    }
+    if (metadata.command) {
+      throw new Error(`definePlugin(${validated.name}): hook "${hookId}" has both a typed implementation and a command string \u2014 pick one`);
+    }
+  }
+  if (runtime.hooks) {
+    for (const h of declaredHooks.values()) {
+      if (!runtime.hooks[h.id] && !h.command) {
+        throw new Error(`definePlugin(${validated.name}): hook metadata "${h.id}" has no implementation (typed function or command)`);
+      }
+    }
+  }
   return { ...validated, __runtime: runtime };
 }
 export {

package/dist/src/engineReadModelReducer.d.ts

@@ -0,0 +1,12 @@
+import { EngineEvent, EngineReadModel, QueueEntry, RunSummary, TaskSummary } from "@rig/contracts";
+type EngineApplyStatus = "applied" | "ignored" | "requires-resync";
+export type ApplyStatus = EngineApplyStatus;
+export interface EngineEventApplyResult {
+    readonly status: EngineApplyStatus;
+    readonly snapshot: EngineReadModel;
+}
+export declare function mapTaskStatusFromRunStatus(status: RunSummary["status"], fallback: TaskSummary["status"]): TaskSummary["status"];
+export declare function applyEngineEvent(snapshot: EngineReadModel, event: EngineEvent): EngineEventApplyResult;
+export declare function applyEngineEvents(snapshot: EngineReadModel, events: ReadonlyArray<EngineEvent>): EngineEventApplyResult;
+export declare function pruneQueueEntries(snapshot: EngineReadModel): QueueEntry[];
+export {};

package/dist/src/engineReadModelReducer.js

@@ -149,7 +149,7 @@ function mapLegacySessionStatusToRunStatus(status) {
     case "error":
       return "failed";
     case "stopped":
-      return "cancelled";
+      return "stopped";
     default:
       return "created";
   }
@@ -185,12 +185,15 @@ function mapTaskStatusFromRunStatus(status, fallback) {
     case "paused":
       return "in_progress";
     case "reviewing":
+    case "closing-out":
       return "under_review";
+    case "needs-attention":
+      return "blocked";
     case "completed":
       return "completed";
     case "failed":
       return "ready";
-    case "cancelled":
+    case "stopped":
       return "cancelled";
   }
 }
@@ -1040,7 +1043,7 @@ function applyEngineEvent(snapshot, event) {
           ...base,
           runs: patchById(base.runs, payload.runId, (run) => ({
             ...run,
-            status: "cancelled",
+            status: "stopped",
             updatedAt: payload.createdAt,
             completedAt: payload.createdAt
           }))

package/dist/src/index.d.ts

@@ -0,0 +1,12 @@
+export declare const RIG_CORE_PACKAGE = "@rig/core";
+export { definePlugin } from "./define-plugin";
+export { defineConfig } from "./define-config";
+export { createPluginHost } from "./plugin-host";
+export type { PluginHost } from "./plugin-host";
+export { buildRigInitConfigSource, type RigInitConfigInput, } from "./rig-init-builder";
+export type { RegisteredValidator, RigPluginRuntime, RigPluginWithRuntime, TaskSourceFactoryContext, TaskSourceFactoryEntry, ValidatorContext, ValidatorResult, } from "./plugin-runtime";
+export { applyEngineEvent, applyEngineEvents, applyEngineEvent as applyRigEvent, pruneQueueEntries, type ApplyStatus, type EngineEventApplyResult, type EngineEventApplyResult as RigEventApplyResult, } from "./engineReadModelReducer";
+export { pickDefaultWorkspaceId, selectAdhocRuns, selectAdhocRunsForWorkspace, selectApprovalsForRun, selectApprovalsForWorkspace, selectGraphsForWorkspace, selectPendingApprovals, selectPrimaryWorkspace, selectQueueForWorkspace, selectRun, selectRunsByTask, selectRunsForTask, selectRunsForWorkspace, selectTask, selectTasksByStatus, selectTasksByWorkspace, selectTasksForWorkspace, selectTasksGroupedByStatus, selectUserInputsForRun, selectUserInputsForWorkspace, selectWorkspace, selectWorkspaces, } from "./rigSelectors";
+export { buildTaskReferenceIndex, computeTaskBlockingDepths, readTaskMetadataStringList, readTaskSourceIssueId, resolveTaskReference, } from "./taskGraph";
+export { extractTaskCode, extractTaskGroupKey, stripTaskCode, } from "./taskGraphCodes";
+export { buildTaskGraphLayout, type TaskGraphEdge, type TaskGraphLane, type TaskGraphLayout, type TaskGraphNode, type TaskGraphStage, } from "./taskGraphLayout";

package/dist/src/index.js

@@ -43,11 +43,45 @@ function definePlugin(meta, runtime) {
       }
     }
   }
+  const declaredHooks = new Map((validated.contributes?.hooks ?? []).map((h) => [h.id, h]));
+  for (const hookId of Object.keys(runtime.hooks ?? {})) {
+    const metadata = declaredHooks.get(hookId);
+    if (!metadata) {
+      throw new Error(`definePlugin(${validated.name}): typed hook "${hookId}" has no matching metadata entry in contributes.hooks`);
+    }
+    if (metadata.command) {
+      throw new Error(`definePlugin(${validated.name}): hook "${hookId}" has both a typed implementation and a command string \u2014 pick one`);
+    }
+  }
+  if (runtime.hooks) {
+    for (const h of declaredHooks.values()) {
+      if (!runtime.hooks[h.id] && !h.command) {
+        throw new Error(`definePlugin(${validated.name}): hook metadata "${h.id}" has no implementation (typed function or command)`);
+      }
+    }
+  }
   return { ...validated, __runtime: runtime };
 }
 // packages/core/src/define-config.ts
 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";
+  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)
+  };
+}
 function defineConfig(cfg) {
   const runtimeByName = new Map;
   const plugins = cfg.plugins ?? [];
@@ -56,7 +90,7 @@ function defineConfig(cfg) {
       runtimeByName.set(plugin.name, plugin.__runtime);
     }
   }
-  const decoded = Schema2.decodeUnknownSync(RigConfig)(cfg);
+  const decoded = Schema2.decodeUnknownSync(RigConfig)(applyConfigDefaults(cfg));
   const decodedPlugins = decoded.plugins.map((p) => {
     const runtime = runtimeByName.get(p.name);
     if (!runtime)
@@ -124,6 +158,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);
@@ -263,7 +315,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" },`);
@@ -422,7 +474,7 @@ function mapLegacySessionStatusToRunStatus(status) {
     case "error":
       return "failed";
     case "stopped":
-      return "cancelled";
+      return "stopped";
     default:
       return "created";
   }
@@ -458,12 +510,15 @@ function mapTaskStatusFromRunStatus(status, fallback) {
     case "paused":
       return "in_progress";
     case "reviewing":
+    case "closing-out":
       return "under_review";
+    case "needs-attention":
+      return "blocked";
     case "completed":
       return "completed";
     case "failed":
       return "ready";
-    case "cancelled":
+    case "stopped":
       return "cancelled";
   }
 }
@@ -1313,7 +1368,7 @@ function applyEngineEvent(snapshot, event) {
           ...base,
           runs: patchById(base.runs, payload.runId, (run) => ({
             ...run,
-            status: "cancelled",
+            status: "stopped",
             updatedAt: payload.createdAt,
             completedAt: payload.createdAt
           }))

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

@@ -0,0 +1,2 @@
+import { RigConfig } from "@rig/contracts";
+export declare function loadConfig(cwd: string): Promise<RigConfig>;

package/dist/src/load-config.js

@@ -1,17 +1,145 @@
 // @bun
 // packages/core/src/load-config.ts
-import { existsSync, readFileSync } from "fs";
-import { join } from "path";
-import { pathToFileURL } from "url";
+import { existsSync, mkdtempSync, readFileSync, 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");
+}
+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, configDir],
+          [args.path, hostDir],
+          [args.path.replace(/^@rig\//, "@h-rig/"), hostDir]
+        ];
+        for (const [specifier, parent] of candidates) {
+          try {
+            const resolved = bun.resolveSync?.(specifier, parent);
+            if (resolved)
+              return { path: resolved };
+          } catch {}
+        }
+        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);
+          if (resolved)
+            return { path: resolved };
+        } catch {
+          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);
+        }
+        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 +163,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,58 @@
+import type { HookImplementation, RegisteredTaskSource, 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;
+}
+/**
+ * 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,194 @@
+import type { ArtifactSummary, ApprovalSummary, EngineReadModel, GraphSummary, QueueEntry, RemoteConnectionSummary, RemoteEndpoint, RunId, RunSummary, TaskId, TaskStatus, TaskSummary, UserInputRequestSummary, WorkspaceId, WorkspaceSummary } from "@rig/contracts";
+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 declare function selectTasksGroupedByStatus(snapshot: EngineReadModel | null, workspaceId: WorkspaceId | null): Array<{
+    status: string;
+    tasks: readonly TaskSummary[];
+}>;
+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;

package/dist/src/taskGraph.d.ts

@@ -0,0 +1,28 @@
+import type { TaskSummary } from "@rig/contracts";
+export declare function readTaskMetadataStringList(task: TaskSummary, key: "dependencies" | "parentChildDeps" | "labels"): string[];
+export declare function readTaskSourceIssueId(task: TaskSummary): string | null;
+export declare function resolveTaskReference(ref: string, tasksById: ReadonlyMap<string, TaskSummary>, taskIdByExternalRef: ReadonlyMap<string, string>, taskIdBySourceIssueId: ReadonlyMap<string, string>): string | null;
+export declare function buildTaskReferenceIndex(tasks: readonly TaskSummary[]): {
+    tasksById: Map<string, {
+        readonly id: string & import("effect/Brand").Brand<"TaskId">;
+        readonly title: string;
+        readonly createdAt: string;
+        readonly updatedAt: string;
+        readonly role: string | null;
+        readonly status: "running" | "ready" | "completed" | "failed" | "draft" | "open" | "queued" | "in_progress" | "under_review" | "blocked" | "unknown" | "cancelled" | "closed";
+        readonly metadata: unknown;
+        readonly description: string;
+        readonly workspaceId: string & import("effect/Brand").Brand<"WorkspaceId">;
+        readonly graphId: (string & import("effect/Brand").Brand<"GraphId">) | null;
+        readonly externalId: string | null;
+        readonly priority: number | null;
+        readonly scope: readonly string[];
+        readonly validationKeys: readonly string[];
+        readonly dependencies?: readonly string[] | undefined;
+        readonly sourceIssueId?: string | null | undefined;
+        readonly parentChildDeps?: readonly string[] | undefined;
+    }>;
+    taskIdByExternalRef: Map<string, string & import("effect/Brand").Brand<"TaskId">>;
+    taskIdBySourceIssueId: Map<string, string & import("effect/Brand").Brand<"TaskId">>;
+};
+export declare function computeTaskBlockingDepths(tasks: readonly TaskSummary[]): Map<string, number>;

package/dist/src/taskGraphCodes.d.ts

@@ -0,0 +1,3 @@
+export declare function extractTaskCode(title: string): string | null;
+export declare function extractTaskGroupKey(title: string): string | null;
+export declare function stripTaskCode(label: string): string;

package/dist/src/taskGraphLayout.d.ts

@@ -0,0 +1,60 @@
+import type { EngineReadModel, TaskSummary } from "@rig/contracts";
+export type TaskGraphLane = Readonly<{
+    key: string;
+    label: string;
+    rowIndex: number;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    color: string;
+    taskCount: number;
+}>;
+export type TaskGraphStage = Readonly<{
+    index: number;
+    label: string;
+    x: number;
+    width: number;
+}>;
+export type TaskGraphNode = Readonly<{
+    id: string;
+    task: TaskSummary;
+    rowKey: string;
+    rowLabel: string;
+    rowIndex: number;
+    stage: number;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    color: string;
+    taskCode: string | null;
+    strippedTitle: string;
+    depsIn: number;
+    depsOut: number;
+    runCount: number;
+    hasApprovals: boolean;
+    hasPendingUserInput: boolean;
+    hasRejectedReview: boolean;
+    hasFailedValidations: boolean;
+    artifactCount: number;
+}>;
+export type TaskGraphEdge = Readonly<{
+    id: string;
+    sourceId: string;
+    targetId: string;
+    color: string;
+    kind: "blocking" | "parent-child";
+}>;
+export type TaskGraphLayout = Readonly<{
+    lanes: readonly TaskGraphLane[];
+    stages: readonly TaskGraphStage[];
+    nodes: readonly TaskGraphNode[];
+    edges: readonly TaskGraphEdge[];
+    totalWidth: number;
+    totalHeight: number;
+    taskCount: number;
+}>;
+export declare function buildTaskGraphLayout(snapshot: EngineReadModel | null, tasks: readonly TaskSummary[], options?: {
+    showParentChild?: boolean;
+}): TaskGraphLayout;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@h-rig/core",
-  "version": "0.0.6-alpha.9",
+  "version": "0.0.6-alpha.90",
   "type": "module",
   "description": "Rig package",
   "license": "UNLICENSED",
@@ -10,18 +10,23 @@
   ],
   "exports": {
     ".": {
+      "types": "./dist/src/index.d.ts",
       "import": "./dist/src/index.js"
     },
     "./load-config": {
+      "types": "./dist/src/load-config.d.ts",
       "import": "./dist/src/load-config.js"
     },
     "./engineReadModelReducer": {
+      "types": "./dist/src/engineReadModelReducer.d.ts",
       "import": "./dist/src/engineReadModelReducer.js"
     },
     "./rigSelectors": {
+      "types": "./dist/src/rigSelectors.d.ts",
       "import": "./dist/src/rigSelectors.js"
     },
     "./taskGraph": {
+      "types": "./dist/src/taskGraph.d.ts",
       "import": "./dist/src/taskGraph.js"
     }
   },
@@ -30,8 +35,9 @@
   },
   "main": "./dist/src/index.js",
   "module": "./dist/src/index.js",
+  "types": "./dist/src/index.d.ts",
   "dependencies": {
-    "@rig/contracts": "npm:@h-rig/contracts@0.0.6-alpha.9",
+    "@rig/contracts": "npm:@h-rig/contracts@0.0.6-alpha.90",
     "effect": "4.0.0-beta.78"
   }
 }