@h-rig/contracts 0.0.0-e2e-live.20260630085347

package/dist/src/graph.js

@@ -0,0 +1,229 @@
+// @bun
+// packages/contracts/src/graph.ts
+import { Schema as Schema2 } from "effect";
+
+// packages/contracts/src/baseSchemas.ts
+import { Schema } from "effect";
+var TrimmedString = Schema.Trim;
+var TrimmedNonEmptyString = TrimmedString.check(Schema.isNonEmpty());
+var NonNegativeInt = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
+var PositiveInt = Schema.Int.check(Schema.isGreaterThanOrEqualTo(1));
+var IsoDateTime = Schema.String;
+var makeEntityId = (brand) => TrimmedNonEmptyString.pipe(Schema.brand(brand));
+var ThreadId = makeEntityId("ThreadId");
+var ProjectId = makeEntityId("ProjectId");
+var WorkspaceId = makeEntityId("WorkspaceId");
+var GraphId = makeEntityId("GraphId");
+var TaskId = makeEntityId("TaskId");
+var RunId = makeEntityId("RunId");
+var SafePathSegment = TrimmedNonEmptyString.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/)).pipe(Schema.brand("SafePathSegment"));
+var SafeRunId = TrimmedNonEmptyString.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/)).pipe(Schema.brand("SafeRunId"));
+var SafeGitRefComponent = TrimmedNonEmptyString.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/)).pipe(Schema.brand("SafeGitRefComponent"));
+var EngineRuntimeId = makeEntityId("EngineRuntimeId");
+var ConversationId = makeEntityId("ConversationId");
+var ActionId = makeEntityId("ActionId");
+var ArtifactId = makeEntityId("ArtifactId");
+var WorktreeId = makeEntityId("WorktreeId");
+var ValidationResultId = makeEntityId("ValidationResultId");
+var ReviewResultId = makeEntityId("ReviewResultId");
+var CommandId = makeEntityId("CommandId");
+var EventId = makeEntityId("EventId");
+var MessageId = makeEntityId("MessageId");
+var TurnId = makeEntityId("TurnId");
+var ProviderItemId = makeEntityId("ProviderItemId");
+var RuntimeSessionId = makeEntityId("RuntimeSessionId");
+var RuntimeItemId = makeEntityId("RuntimeItemId");
+var RuntimeRequestId = makeEntityId("RuntimeRequestId");
+var RuntimeTaskId = makeEntityId("RuntimeTaskId");
+var ApprovalRequestId = makeEntityId("ApprovalRequestId");
+var CheckpointRef = makeEntityId("CheckpointRef");
+var RemoteEndpointId = makeEntityId("RemoteEndpointId");
+
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/graph.ts
+var TaskStatus = Schema2.Literals([
+  "draft",
+  "open",
+  "ready",
+  "queued",
+  "running",
+  "in_progress",
+  "under_review",
+  "blocked",
+  "unknown",
+  "completed",
+  "failed",
+  "cancelled",
+  "closed"
+]);
+var GraphSummary = Schema2.Struct({
+  id: GraphId,
+  workspaceId: WorkspaceId,
+  title: TrimmedNonEmptyString,
+  description: Schema2.NullOr(Schema2.String),
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime
+});
+var TaskSummary = Schema2.Struct({
+  id: TaskId,
+  workspaceId: WorkspaceId,
+  graphId: Schema2.NullOr(GraphId),
+  externalId: Schema2.NullOr(TrimmedNonEmptyString),
+  title: TrimmedNonEmptyString,
+  description: Schema2.String,
+  status: TaskStatus,
+  priority: Schema2.NullOr(PositiveInt),
+  role: Schema2.NullOr(TrimmedNonEmptyString),
+  scope: Schema2.Array(TrimmedNonEmptyString),
+  validationKeys: Schema2.Array(TrimmedNonEmptyString),
+  sourceIssueId: Schema2.optional(Schema2.NullOr(TrimmedNonEmptyString)),
+  dependencies: Schema2.optional(Schema2.Array(TrimmedNonEmptyString)),
+  parentChildDeps: Schema2.optional(Schema2.Array(TrimmedNonEmptyString)),
+  metadata: Schema2.Unknown,
+  createdAt: IsoDateTime,
+  updatedAt: IsoDateTime
+});
+var QueueEntry = Schema2.Struct({
+  taskId: TaskId,
+  score: NonNegativeInt,
+  unblockCount: NonNegativeInt,
+  position: NonNegativeInt
+});
+var DependencyEdgeType = Schema2.Literals(["blocks", "parent-child", "related"]);
+var DependencyEdge = Schema2.Struct({
+  fromTaskId: TaskId,
+  toTaskId: TaskId,
+  type: DependencyEdgeType
+});
+var BlockerClass = Schema2.Literals([
+  "not-blocked",
+  "task-blocked",
+  "human-decision",
+  "human-approval",
+  "external-input",
+  "unknown"
+]);
+var ActionRiskTier = Schema2.Literals(["t1-read", "t2-reversible", "t3-external", "t4-irreversible"]);
+var BlockerClassification = Schema2.Struct({
+  taskId: TaskId,
+  blockerClass: BlockerClass,
+  actionRiskTier: Schema2.NullOr(ActionRiskTier),
+  rationale: Schema2.String,
+  source: Schema2.Literals(["elimination", "label", "status", "llm"]),
+  autoApplied: Schema2.Boolean
+});
+var DependencyNode = Schema2.Struct({
+  taskId: TaskId,
+  title: TrimmedNonEmptyString,
+  status: TaskStatus,
+  priority: Schema2.NullOr(PositiveInt),
+  assignee: Schema2.NullOr(TrimmedNonEmptyString),
+  blockedBy: Schema2.Array(TaskId),
+  blocks: Schema2.Array(TaskId),
+  blockingDepth: NonNegativeInt,
+  blockerClass: Schema2.NullOr(BlockerClass),
+  actionRiskTier: Schema2.NullOr(ActionRiskTier),
+  epicKey: Schema2.NullOr(TrimmedNonEmptyString),
+  groupKey: Schema2.optional(Schema2.NullOr(TrimmedNonEmptyString)),
+  externalId: Schema2.optional(Schema2.NullOr(TrimmedNonEmptyString)),
+  sourceIssueId: Schema2.optional(Schema2.NullOr(TrimmedNonEmptyString)),
+  scope: Schema2.optional(Schema2.Array(TrimmedNonEmptyString)),
+  validationKeys: Schema2.optional(Schema2.Array(TrimmedNonEmptyString))
+});
+var TaskGraphLane = Schema2.Struct({
+  key: TrimmedNonEmptyString,
+  label: TrimmedNonEmptyString,
+  rowIndex: NonNegativeInt,
+  x: Schema2.Number,
+  y: Schema2.Number,
+  width: NonNegativeInt,
+  height: NonNegativeInt,
+  color: Schema2.String,
+  taskCount: NonNegativeInt
+});
+var TaskGraphStage = Schema2.Struct({
+  index: NonNegativeInt,
+  label: TrimmedNonEmptyString,
+  x: Schema2.Number,
+  width: NonNegativeInt
+});
+var TaskGraphNode = Schema2.Struct({
+  id: TrimmedNonEmptyString,
+  taskId: TaskId,
+  task: Schema2.optional(TaskSummary),
+  rowKey: TrimmedNonEmptyString,
+  rowLabel: TrimmedNonEmptyString,
+  rowIndex: NonNegativeInt,
+  stage: NonNegativeInt,
+  x: Schema2.Number,
+  y: Schema2.Number,
+  width: NonNegativeInt,
+  height: NonNegativeInt,
+  color: Schema2.optional(Schema2.String),
+  taskCode: Schema2.optional(Schema2.NullOr(Schema2.String)),
+  strippedTitle: Schema2.optional(Schema2.String),
+  depsIn: Schema2.optional(NonNegativeInt),
+  depsOut: Schema2.optional(NonNegativeInt),
+  runCount: Schema2.optional(NonNegativeInt),
+  hasApprovals: Schema2.optional(Schema2.Boolean),
+  hasPendingUserInput: Schema2.optional(Schema2.Boolean),
+  hasRejectedReview: Schema2.optional(Schema2.Boolean),
+  hasFailedValidations: Schema2.optional(Schema2.Boolean),
+  artifactCount: Schema2.optional(NonNegativeInt)
+});
+var TaskGraphEdge = Schema2.Struct({
+  id: TrimmedNonEmptyString,
+  sourceId: TrimmedNonEmptyString,
+  targetId: TrimmedNonEmptyString,
+  color: Schema2.String,
+  kind: Schema2.Literals(["blocking", "parent-child"])
+});
+var TaskGraphLayout = Schema2.Struct({
+  lanes: Schema2.Array(TaskGraphLane),
+  stages: Schema2.Array(TaskGraphStage),
+  nodes: Schema2.Array(TaskGraphNode),
+  edges: Schema2.Array(TaskGraphEdge),
+  totalWidth: NonNegativeInt,
+  totalHeight: NonNegativeInt,
+  taskCount: NonNegativeInt
+});
+var DependencyGraphModel = Schema2.Struct({
+  graphId: GraphId,
+  nodes: Schema2.Array(DependencyNode),
+  edges: Schema2.Array(DependencyEdge),
+  layout: TaskGraphLayout,
+  cycles: Schema2.Array(Schema2.Array(TaskId)),
+  unresolvedRefs: Schema2.Array(TrimmedNonEmptyString),
+  degraded: Schema2.Boolean,
+  generatedAt: IsoDateTime
+});
+var GRAPH_PROJECT_CAPABILITY_ID = "rig.graph.project";
+var GRAPH_PROJECT = makeCapabilityId(GRAPH_PROJECT_CAPABILITY_ID);
+var TASK_SELECTION_CAPABILITY_ID = "cap:task-selection";
+var TASK_SELECTION = makeCapabilityId(TASK_SELECTION_CAPABILITY_ID);
+export {
+  TaskSummary,
+  TaskStatus,
+  TaskGraphStage,
+  TaskGraphNode,
+  TaskGraphLayout,
+  TaskGraphLane,
+  TaskGraphEdge,
+  TASK_SELECTION_CAPABILITY_ID,
+  TASK_SELECTION,
+  QueueEntry,
+  GraphSummary,
+  GRAPH_PROJECT_CAPABILITY_ID,
+  GRAPH_PROJECT,
+  DependencyNode,
+  DependencyGraphModel,
+  DependencyEdgeType,
+  DependencyEdge,
+  BlockerClassification,
+  BlockerClass,
+  ActionRiskTier
+};

package/dist/src/guard.d.ts

@@ -0,0 +1,118 @@
+import type { PolicyMode } from "./policy";
+import type { CapabilityId } from "./capability-id";
+export declare const POLICY_VERSION: 1;
+export type PolicyVersion = typeof POLICY_VERSION;
+export type { PolicyMode };
+export type RuleCategory = "command" | "content" | "import" | "test-integrity";
+export type RuleAction = "block" | "warn";
+export type RuleAppliesTo = "test-files";
+export type RuleMatch = {
+    pattern?: string;
+    regex?: string;
+};
+export type RuleUnless = {
+    regex?: string;
+    task_in?: string[];
+};
+export type PolicyRule = {
+    id: string;
+    category: RuleCategory;
+    description?: string;
+    match: RuleMatch;
+    unless?: RuleUnless;
+    action: RuleAction;
+    applies_to?: RuleAppliesTo;
+    compiledRegex?: RegExp;
+    compiledUnlessRegex?: RegExp;
+};
+export type ScopeConfig = {
+    fail_closed: boolean;
+    harness_paths_exempt: boolean;
+    runtime_paths_exempt: boolean;
+};
+export type SandboxConfig = {
+    mode: PolicyMode;
+    network: boolean;
+    read_deny: string[];
+    write_allow_from_runtime: boolean;
+};
+export type IsolationConfig = {
+    default_mode: "worktree";
+    repo_symlink_fallback: boolean;
+    strict_provisioning: boolean;
+    fail_closed_on_provision_error: boolean;
+};
+export type CompletionConfig = {
+    derive_checks_from_scope: boolean;
+    checks: string[];
+    typescript_config_probe: string[];
+    eslint_config_probe: string[];
+};
+export type RuntimeImageDeps = {
+    monorepo_install: boolean;
+    hp_next_install: boolean;
+};
+export type RuntimeImageConfig = {
+    deps: RuntimeImageDeps;
+    plugins_require_binaries: boolean;
+};
+export type RuntimeSnapshotConfig = {
+    enabled: boolean;
+};
+export type PolicyConfig = {
+    version: PolicyVersion;
+    mode: PolicyMode;
+    scope: ScopeConfig;
+    rules: PolicyRule[];
+    sandbox: SandboxConfig;
+    isolation: IsolationConfig;
+    completion: CompletionConfig;
+    runtime_image?: RuntimeImageConfig;
+    runtime_snapshot?: RuntimeSnapshotConfig;
+};
+export type ToolCallEvaluation = {
+    type: "tool-call";
+    tool_name: string;
+    tool_input: Record<string, unknown>;
+};
+export type CommandEvaluation = {
+    type: "command";
+    command: string;
+};
+export type ContentWriteEvaluation = {
+    type: "content-write";
+    file_path: string;
+    content: string;
+};
+export type FileAccessEvaluation = {
+    type: "file-access";
+    file_path: string;
+    access: "read" | "write";
+};
+export type GuardEvaluation = ToolCallEvaluation | CommandEvaluation | ContentWriteEvaluation | FileAccessEvaluation;
+export type GuardContext = {
+    projectRoot: string;
+    monorepoRoot?: string;
+    taskId?: string;
+    taskScopes?: string[];
+    taskWorkspace?: string;
+    evaluation: GuardEvaluation;
+};
+export type MatchedRule = {
+    id: string;
+    category: RuleCategory;
+    description?: string;
+    reason: string;
+};
+export type GuardDecision = {
+    allowed: boolean;
+    matchedRules: MatchedRule[];
+    action: "allow" | "block" | "warn";
+    failClosed: boolean;
+};
+export interface GuardService {
+    readonly loadPolicy: (projectRoot: string) => PolicyConfig;
+    readonly evaluate: (context: GuardContext) => GuardDecision;
+}
+export declare const GUARD_CAPABILITY_ID = "rig.guard.service";
+export declare const GUARD: CapabilityId<GuardService>;

package/dist/src/guard.js

@@ -0,0 +1,15 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/guard.ts
+var POLICY_VERSION = 1;
+var GUARD_CAPABILITY_ID = "rig.guard.service";
+var GUARD = makeCapabilityId(GUARD_CAPABILITY_ID);
+export {
+  POLICY_VERSION,
+  GUARD_CAPABILITY_ID,
+  GUARD
+};

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

@@ -0,0 +1,8 @@
+export type HarnessEventType = "runtime.init" | "command.received" | "policy.decision" | "command.started" | "command.finished" | "command.failed" | "plugin.loaded" | "plugin.error" | "validator.started" | "validator.finished" | "queue.started" | "queue.task.started" | "queue.task.finished" | "queue.finished" | "memory.command.requested" | "memory.command.applied" | "memory.command.failed";
+export type HarnessEvent<TPayload = Record<string, unknown>> = {
+    id: string;
+    runId: string;
+    timestamp: string;
+    type: HarnessEventType;
+    payload: TPayload;
+};

package/dist/src/harness-events.js

@@ -0,0 +1 @@
+// @bun

package/dist/src/harness-profile-state.d.ts

@@ -0,0 +1,10 @@
+import type { CapabilityId } from "./capability-id";
+type JsonObject = object;
+export interface HarnessProfileStateService {
+    harnessStateJsonPath(projectRoot: string, filename: string): string;
+    readHarnessStateJson<T extends JsonObject>(projectRoot: string, filename: string): Partial<T> | null;
+    writeHarnessStateJson<T extends JsonObject>(projectRoot: string, filename: string, value: T): string;
+}
+export declare const HARNESS_PROFILE_STATE_CAPABILITY_ID = "provider.harness-profile-state";
+export declare const HARNESS_PROFILE_STATE: CapabilityId<HarnessProfileStateService>;
+export {};

package/dist/src/harness-profile-state.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/harness-profile-state.ts
+var HARNESS_PROFILE_STATE_CAPABILITY_ID = "provider.harness-profile-state";
+var HARNESS_PROFILE_STATE = makeCapabilityId(HARNESS_PROFILE_STATE_CAPABILITY_ID);
+export {
+  HARNESS_PROFILE_STATE_CAPABILITY_ID,
+  HARNESS_PROFILE_STATE
+};

package/dist/src/help-catalog.d.ts

@@ -0,0 +1,41 @@
+import type { CapabilityId } from "./capability-id";
+export type HelpCommand = {
+    command: string;
+    description: string;
+    primary?: boolean;
+    /** Concrete invocations + variations (shown indented under the command). */
+    examples?: readonly string[];
+    /** When to reach for it (one line, shown after the description). */
+    usecase?: string;
+};
+export type HelpGroup = {
+    name: string;
+    summary: string;
+    usage: string[];
+    commands: HelpCommand[];
+    examples?: string[];
+    next?: string[];
+    advanced?: string[];
+};
+export type TopLevelSection = {
+    title: string;
+    subtitle: string;
+    commands: HelpCommand[];
+};
+/** The full help catalog payload: top-level sections + command groups. */
+export type HelpCatalog = {
+    readonly sections: readonly TopLevelSection[];
+    readonly groups: readonly HelpGroup[];
+    /** Compatibility/internal commands shown only from advanced help. */
+    readonly advancedCommands?: readonly HelpCommand[];
+    /** Group names shown under advanced help; omitted means every group is shown. */
+    readonly advancedGroupNames?: readonly string[];
+};
+/** Capability id the CLI-surface plugin registers its help-catalog provider under. */
+export declare const HELP_CATALOG_CAPABILITY_ID = "rig.help.catalog";
+/** The cohesive help-catalog operation the cockpit depends on. Pure (data only). */
+export interface HelpCatalogService {
+    helpCatalog(): HelpCatalog;
+}
+/** Typed capability id; string value is {@link HELP_CATALOG_CAPABILITY_ID}. */
+export declare const HELP_CATALOG: CapabilityId<HelpCatalogService>;

package/dist/src/help-catalog.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/help-catalog.ts
+var HELP_CATALOG_CAPABILITY_ID = "rig.help.catalog";
+var HELP_CATALOG = makeCapabilityId(HELP_CATALOG_CAPABILITY_ID);
+export {
+  HELP_CATALOG_CAPABILITY_ID,
+  HELP_CATALOG
+};

package/dist/src/host.d.ts

@@ -0,0 +1,41 @@
+/**
+ * cap:host-run — the OMP run-host seam.
+ *
+ * `@rig/rig-host` is reclassified MOSTLY floor-neutral-exec (its generic
+ * session/pty/protocol/workspace launch plumbing is product-agnostic). The
+ * OMP-SPECIFIC runner (provision an isolated workspace + spawn the PTY-hosted
+ * OMP run process) is NOT baked into the floor — it is contributed as a host
+ * plugin capability under this id. Consumers (a dispatch surface) resolve this
+ * capability off the host instead of importing the runner impl.
+ *
+ * This file holds ONLY the pure seam vocabulary — no IO, no runner deps (those
+ * belong to the impl in `@rig/rig-host`, never to the cross-package seam).
+ */
+import type { CapabilityId } from "./capability-id";
+/** Capability id the OMP run-host plugin registers its runner under. */
+export declare const HOST_RUN_CAPABILITY_ID = "cap:host-run";
+/** Pure input describing the run to host. */
+export type HostRunProcessInput = {
+    readonly projectRoot?: string;
+    readonly taskId: string;
+    /** Dispatch/worktree handle (historical external name); not the OMP session id. */
+    readonly runId?: string;
+    readonly title?: string | null;
+    readonly model?: string | null;
+    readonly prompt?: string | null;
+    readonly forceSteerOnce?: boolean;
+    /** Optional sink for the bootstrap launcher's stdout. */
+    readonly writeStdout?: (text: string) => void;
+};
+/** Pure summary of a hosted run bootstrap (impl-internal runtime handle omitted). */
+export type HostRunProcessResult = {
+    readonly dispatchHandle: string;
+    readonly pid: number;
+    readonly sessionName: string;
+};
+/** The cohesive run-host operation a dispatch surface depends on. Async (does IO). */
+export interface HostRunService {
+    runHostProcess(input: HostRunProcessInput): Promise<HostRunProcessResult>;
+}
+/** Typed capability id; string value is {@link HOST_RUN_CAPABILITY_ID}. */
+export declare const HOST_RUN: CapabilityId<HostRunService>;

package/dist/src/host.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/host.ts
+var HOST_RUN_CAPABILITY_ID = "cap:host-run";
+var HOST_RUN = makeCapabilityId(HOST_RUN_CAPABILITY_ID);
+export {
+  HOST_RUN_CAPABILITY_ID,
+  HOST_RUN
+};

package/dist/src/identity.d.ts

@@ -0,0 +1,44 @@
+/**
+ * identity.ts — pure structural vocabulary for Rig run identity resolution.
+ *
+ * The identity resolver implementation (`resolveRigIdentity` /
+ * `resolveRigIdentityFilter`) is the GitHub provider's SCM-identity domain and
+ * is exposed through the `RUN_IDENTITY_ENV` capability. Only the structural
+ * TYPES the resolver reads/returns live here, so any consumer can name the
+ * shapes without importing a plugin.
+ *
+ * The session-manager / auth-storage shapes are deliberately minimal
+ * (read-only, structural) so they stay decoupled from the concrete OMP
+ * session-manager class — exactly the slice the identity resolver needs.
+ */
+import type { RigWorkflowOwner } from "./workflow-journal";
+/** Read-only slice of an OMP session manager the identity resolver reads. */
+export type ReadonlySessionIdentityManager = {
+    getCwd(): string;
+    getSessionId(): string;
+    getBranch(): readonly {
+        type: string;
+        customType?: string;
+        data?: unknown;
+    }[];
+};
+/** Read-only slice of OMP auth storage the identity resolver probes for github-copilot identity. */
+export type OmpAuthStorage = {
+    getOAuthAccountIdentity?: (provider: string, sessionId?: string) => unknown;
+};
+/** The structural context the Rig identity resolver reads to derive run owner identity. */
+export type RigIdentityContext = {
+    sessionManager: ReadonlySessionIdentityManager;
+    modelRegistry?: {
+        authStorage?: OmpAuthStorage;
+    };
+};
+/** A resolved Rig run identity: the selected repo and its github-derived owner. */
+export type RigIdentity = {
+    selectedRepo: string;
+    owner: RigWorkflowOwner;
+};
+/** A `RigIdentity` annotated with the `+`-joined provenance of the inputs that produced it. */
+export type RigResolvedIdentity = RigIdentity & {
+    source: string;
+};

package/dist/src/identity.js

@@ -0,0 +1 @@
+// @bun

package/dist/src/index.d.ts

@@ -0,0 +1,98 @@
+export { Schema } from "effect";
+export * from "./baseSchemas";
+export * from "./workspace";
+export * from "./graph";
+export * from "./runtime";
+export * from "./run-journal";
+export * from "./run-session-journal";
+export * from "./workflow-journal";
+export * from "./run-timeline";
+export * from "./run-record";
+export * from "./run-status";
+export * from "./run-read-model";
+export * from "./run-control";
+export * from "./runtime-secrets";
+export * from "./conversation";
+export * from "./plugin";
+export * from "./agent-roles";
+export * from "./plugin-hooks";
+export * from "./config";
+export * from "./blocker-classifier";
+export * from "./policy";
+export * from "./guard";
+export * from "./tool-registry";
+export * from "./validation";
+export * from "./review";
+export * from "./artifact";
+export * from "./remote";
+export * from "./terminal";
+export * from "./provider";
+export * from "./model";
+export * from "./keybindings";
+export * from "./git";
+export * from "./orchestration";
+export * from "./editor";
+export * from "./project";
+export * from "./setup";
+export * from "./host";
+export * from "./run-identity";
+export * from "./prompt";
+export * from "./task-source";
+export * from "./task-config";
+export * from "./task-state-metadata";
+export * from "./task-data";
+export * from "./task-state-store";
+export * from "./task-state-paths";
+export * from "./task-artifacts";
+export * from "./task-context-renderer";
+export * from "./task-tracker-state";
+export * from "./cli-output";
+export * from "./pi-session";
+export * from "./protocol-version";
+export * from "./help-catalog";
+export * from "./stage";
+export * from "./kernel";
+export * from "./supervisor-journal";
+export * from "./planning";
+export * from "./drift";
+export * from "./rollups";
+export * from "./panel-protocol";
+export * from "./control-plane-types";
+export * from "./capability-id";
+export * from "./dependency-preflight";
+export * from "./workspace-config";
+export * from "./workspace-service";
+export * from "./runtime-task-context";
+export * from "./layout";
+export * from "./errors";
+export * from "./harness-events";
+export * from "./lifecycle-capabilities";
+export * from "./browser";
+export * from "./memory";
+export * from "./notify";
+export * from "./collab-session-viewer";
+export * from "./provider-instructions";
+export * from "./session-asset-materializer";
+export * from "./session-hook-materializer";
+export * from "./isolation";
+export * from "./managed-repos";
+export * from "./task-graph-primitives";
+export * from "./github";
+export * from "./harness-profile-state";
+export * from "./doctor";
+export * from "./run-dispatch";
+export * from "./transport-config";
+export * from "./placement";
+export * from "./run-queue";
+export * from "./supervisor-loop";
+export * from "./identity";
+export * from "./run-discovery";
+export * from "./run-registry-backbone";
+export * from "./remote-control";
+export * from "./tool-materializer";
+export * from "./toolchain-sources";
+export * from "./native-toolchain";
+export * from "./cockpit";
+export * from "./docs-drift";
+export * from "./product-entrypoint";
+export * from "./cli-runner";