@h-rig/contracts 0.0.6-alpha.155 → 0.0.6-alpha.157

package/dist/src/kernel.d.ts

@@ -1,4 +1,5 @@
 import { Schema } from "effect";
+import type { RigPlugin } from "./plugin";
 import { ResolvedPipeline, StageContext, StageDescriptor, StageMutation, StageResult, StageRunOutcome } from "./stage";
 export declare const CapabilityTag: Schema.Literals<readonly ["kernel", "journal", "stage-runner", "transport", "loader-policy"]>;
 export type CapabilityTag = typeof CapabilityTag.Type;
@@ -17,33 +18,6 @@ export declare const CapabilityReplacementSpec: Schema.Union<readonly [Schema.St
     readonly providerPluginId: Schema.Trim;
 }>, Schema.Trim]>;
 export type CapabilityReplacementSpec = typeof CapabilityReplacementSpec.Type;
-export declare const PluginMeta: Schema.Struct<{
-    readonly id: Schema.Trim;
-    readonly version: Schema.Trim;
-    readonly provides: Schema.$Array<Schema.Literals<readonly ["kernel", "journal", "stage-runner", "transport", "loader-policy"]>>;
-    readonly requires: Schema.optional<Schema.$Array<Schema.Literals<readonly ["kernel", "journal", "stage-runner", "transport", "loader-policy"]>>>;
-    readonly replaces: Schema.optional<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-        readonly capability: Schema.Literals<readonly ["kernel", "journal", "stage-runner", "transport", "loader-policy"]>;
-        readonly providerPluginId: Schema.Trim;
-    }>, Schema.Trim]>>>;
-}>;
-export type PluginMeta = typeof PluginMeta.Type;
-export declare const LoadedPluginDescriptor: Schema.Struct<{
-    readonly meta: Schema.Struct<{
-        readonly id: Schema.Trim;
-        readonly version: Schema.Trim;
-        readonly provides: Schema.$Array<Schema.Literals<readonly ["kernel", "journal", "stage-runner", "transport", "loader-policy"]>>;
-        readonly requires: Schema.optional<Schema.$Array<Schema.Literals<readonly ["kernel", "journal", "stage-runner", "transport", "loader-policy"]>>>;
-        readonly replaces: Schema.optional<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-            readonly capability: Schema.Literals<readonly ["kernel", "journal", "stage-runner", "transport", "loader-policy"]>;
-            readonly providerPluginId: Schema.Trim;
-        }>, Schema.Trim]>>>;
-    }>;
-    readonly provides: Schema.$Array<Schema.Literals<readonly ["kernel", "journal", "stage-runner", "transport", "loader-policy"]>>;
-    readonly contributes: Schema.Unknown;
-    readonly runtime: Schema.Unknown;
-}>;
-export type LoadedPluginDescriptor = typeof LoadedPluginDescriptor.Type;
 export declare const KernelReplacementGrant: Schema.Struct<{
     readonly pluginId: Schema.Trim;
     readonly grantedBy: Schema.optional<Schema.Trim>;
@@ -182,12 +156,6 @@ export declare const JournalEvent: Schema.Struct<{
     readonly payload: Schema.Unknown;
 }>;
 export type JournalEvent = typeof JournalEvent.Type;
-export interface LoadedPlugin {
-    meta: PluginMeta;
-    provides: ReadonlySet<CapabilityTag>;
-    contributes: unknown;
-    runtime: unknown;
-}
 export interface JournalCapability {
     append(event: unknown): Promise<void>;
     recordPipeline(runId: string, pipeline: ResolvedPipeline): Promise<void>;
@@ -204,7 +172,7 @@ export interface TransportCapability {
     serve?(): Promise<void>;
 }
 export interface LoaderPolicyCapability {
-    resolveCapability(plugins: readonly PluginMeta[], capability: CapabilityTag, grants?: CapabilityGrants): CapabilityResolutionRecord;
+    resolveCapability(plugins: readonly RigPlugin[], capability: CapabilityTag, grants?: CapabilityGrants): CapabilityResolutionRecord;
 }
 export interface KernelCapability {
     journal: JournalCapability;
@@ -215,7 +183,7 @@ export interface KernelCapability {
 }
 export interface BootResult {
     kernel: KernelCapability;
-    plugins: readonly LoadedPlugin[];
+    plugins: readonly RigPlugin[];
     capabilityProviderIds: Readonly<Record<CapabilityTag, string>>;
 }
 export type StageExecutor = (ctx: StageContext) => Promise<StageResult> | StageResult;

package/dist/src/kernel.js

@@ -163,19 +163,6 @@ var CapabilityReplacementSpec = Schema3.Union([
   CapabilityReplacement,
   TrimmedNonEmptyString
 ]);
-var PluginMeta = Schema3.Struct({
-  id: TrimmedNonEmptyString,
-  version: TrimmedNonEmptyString,
-  provides: Schema3.Array(CapabilityTag),
-  requires: Schema3.optional(Schema3.Array(CapabilityTag)),
-  replaces: Schema3.optional(Schema3.Array(CapabilityReplacementSpec))
-});
-var LoadedPluginDescriptor = Schema3.Struct({
-  meta: PluginMeta,
-  provides: Schema3.Array(CapabilityTag),
-  contributes: Schema3.Unknown,
-  runtime: Schema3.Unknown
-});
 var KernelReplacementGrant = Schema3.Struct({
   pluginId: TrimmedNonEmptyString,
   grantedBy: Schema3.optional(TrimmedNonEmptyString),
@@ -246,10 +233,8 @@ var JournalEvent = Schema3.Struct({
   payload: Schema3.Unknown
 });
 export {
-  PluginMeta,
   PipelineUnresolvable,
   MissingCapability,
-  LoadedPluginDescriptor,
   KernelResolutionRecord,
   KernelReplacementGrant,
   KernelReplacementDenied,

package/dist/src/lifecycle-capabilities.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Typed ports for the default-lifecycle bundle's verification services.
+ *
+ * The dumb runtime substrate (rig-agent, harness-cli) must NOT import the
+ * lifecycle bundle (substrate->plugin cycle). Instead the bundle plugin
+ * registers executable impls under these ids on its
+ * `contributes.capabilities[].run`, and the runtime resolves them by id from
+ * `pluginHost.listExecutableCapabilities()`. These pure types are the shared
+ * contract for that seam — they carry no behaviour and import nothing.
+ */
+/** Capability id the bundle registers its `taskVerify` orchestration under. */
+export declare const TASK_VERIFY_CAPABILITY_ID = "default-lifecycle.task-verify";
+/** Capability id the bundle registers the completion-verification gate under. */
+export declare const COMPLETION_VERIFICATION_CAPABILITY_ID = "default-lifecycle.completion-verification";
+export interface TaskVerifyCapabilityInput {
+    readonly projectRoot: string;
+    readonly taskId?: string;
+}
+/** Resolves true when the task is approved, false when verification rejects. */
+export type TaskVerifyCapabilityRun = (input: TaskVerifyCapabilityInput) => Promise<boolean>;
+export interface CompletionVerificationCapabilityInput {
+    readonly projectRoot: string;
+    readonly taskId?: string;
+}
+export interface CompletionVerificationCapabilityResult {
+    /** True when every completion gate passed; false when the gate blocks. */
+    readonly ok: boolean;
+}
+export type CompletionVerificationCapabilityRun = (input: CompletionVerificationCapabilityInput) => Promise<CompletionVerificationCapabilityResult>;

package/dist/src/lifecycle-capabilities.js

@@ -0,0 +1,8 @@
+// @bun
+// packages/contracts/src/lifecycle-capabilities.ts
+var TASK_VERIFY_CAPABILITY_ID = "default-lifecycle.task-verify";
+var COMPLETION_VERIFICATION_CAPABILITY_ID = "default-lifecycle.completion-verification";
+export {
+  TASK_VERIFY_CAPABILITY_ID,
+  COMPLETION_VERIFICATION_CAPABILITY_ID
+};

package/dist/src/managed-repos.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Pure managed-repo contract types + the managed-repo service capability id.
+ *
+ * The neutral home for the managed-repo (registry / layout / mirror) domain.
+ * The implementation lives in `@rig/repos-plugin`, which registers an
+ * executable `ManagedRepoService` factory under {@link MANAGED_REPO_SERVICE_CAPABILITY_ID}
+ * on `contributes.capabilities[].run`. The dumb runtime substrate (plugin-host
+ * boot wiring, the pre-run monorepo sync, native repo-ops pin recording, and the
+ * state-sync tracker-path resolver) resolves the service by this id from a
+ * plugin host built off the project's rig.config — exactly the seam shape of
+ * {@link MEMORY_SERVICE_CAPABILITY_ID} / ISOLATION_BACKEND_CAPABILITY_ID. This
+ * module carries no behaviour and imports only pure sibling types, so both the
+ * substrate and the plugin can reference these without a substrate->plugin
+ * import cycle.
+ *
+ * The service interface (`ManagedRepoService`) itself lives in the runtime port
+ * module `@rig/runtime/control-plane/managed-repo-service-port`, mirroring how
+ * `MemoryService` lives in the runtime port while only the pure data types live
+ * here.
+ */
+import type { RepoSourceRegistration } from "./plugin";
+export type ManagedRepoId = string;
+export type ManagedRepoAlias = string;
+export type ManagedRepoHealth = "missing" | "ready" | "stale" | "misconfigured";
+export type ManagedRepoRegistryEntry = {
+    id: ManagedRepoId;
+    alias: ManagedRepoAlias;
+    defaultBranch: string;
+    defaultRemoteUrl: string;
+    remoteEnvVar?: string;
+    checkoutEnvVar?: string;
+};
+export type ManagedRepoLayout = {
+    projectRoot: string;
+    repoId: ManagedRepoId;
+    alias: ManagedRepoAlias;
+    defaultBranch: string;
+    remoteUrl: string;
+    checkoutRoot: string;
+    worktreesRoot: string;
+    stateDir: string;
+    metadataRoot: string;
+    metadataRelativePath: string;
+    mirrorRoot: string;
+    mirrorStatePath: string;
+    mirrorStateRelativePath: string;
+};
+export type ManagedRepoMirrorState = {
+    version: 1;
+    repoId: ManagedRepoId;
+    remoteUrl: string;
+    defaultBranch: string;
+    initializedAt?: string;
+    lastSyncedAt?: string;
+    headRef?: string;
+    headCommit?: string;
+};
+export type ManagedRepoSyncResult = {
+    layout: ManagedRepoLayout;
+    headCommit: string;
+};
+/** A repo registration plus an optional computed local checkout path. */
+export interface RepoEntry extends RepoSourceRegistration {
+    /** Optional computed local checkout path (runtime-specific, may be set by caller). */
+    localPath?: string;
+}
+/** An immutable, id-indexed view over plugin-contributed repo sources. */
+export interface RepoRegistry {
+    getById(id: string): RepoEntry | undefined;
+    list(): readonly RepoEntry[];
+}
+/** Capability id the managed-repo service plugin registers its factory under. */
+export declare const MANAGED_REPO_SERVICE_CAPABILITY_ID = "managed-repos.service";

package/dist/src/managed-repos.js

@@ -0,0 +1,6 @@
+// @bun
+// packages/contracts/src/managed-repos.ts
+var MANAGED_REPO_SERVICE_CAPABILITY_ID = "managed-repos.service";
+export {
+  MANAGED_REPO_SERVICE_CAPABILITY_ID
+};

package/dist/src/memory.d.ts

@@ -0,0 +1,151 @@
+/**
+ * Pure memory-service contract types.
+ *
+ * These types are the neutral home for the shared-memory data model so that the
+ * dumb runtime substrate (hooks, harness-cli, isolation, rig-agent) and the
+ * @rig/memory-plugin that owns the implementation can both reference them
+ * without a substrate->plugin import cycle. They carry no behaviour and import
+ * nothing — exactly like `lifecycle-capabilities.ts`.
+ *
+ * The plugin registers its executable `MemoryService` impl under
+ * {@link MEMORY_SERVICE_CAPABILITY_ID} on `contributes.capabilities[].run`; the
+ * runtime resolves it by id from `pluginHost.listExecutableCapabilities()` via
+ * the typed port in `@rig/runtime/control-plane/memory-service-port`.
+ */
+/** Capability id the memory plugin registers its `MemoryService` factory under. */
+export declare const MEMORY_SERVICE_CAPABILITY_ID = "memory.service";
+export declare const NO_MATCH_RETRIEVAL_CANONICAL_KEY = "__memory_recall__:none";
+export type MemoryDbStatement = {
+    sql: string;
+    args?: unknown[];
+};
+export type MemoryDbExecuteResult = {
+    rows: Array<Record<string, unknown>>;
+    rowsAffected?: number;
+};
+export type MemoryDbTransaction = {
+    execute(statement: MemoryDbStatement | string, args?: unknown[]): Promise<MemoryDbExecuteResult>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    close(): void;
+};
+export type MemoryDbClient = {
+    execute(statement: MemoryDbStatement | string, args?: unknown[]): Promise<MemoryDbExecuteResult>;
+    transaction(mode: "write"): Promise<MemoryDbTransaction>;
+    close(): void;
+};
+export type MemoryEventType = "observed" | "promoted" | "corrected" | "superseded" | "retracted" | "reinforced" | "retrieved" | "feedback_recorded";
+export type MemoryStatus = "active" | "superseded" | "retracted";
+export type RetrievalFeedbackOutcome = "helpful" | "ignored" | "incorrect";
+type MemoryEventBase = {
+    eventId: string;
+    canonicalKey: string;
+    sourceRunId?: string | null;
+    sourceTaskId?: string | null;
+    branch?: string | null;
+    createdAt: string;
+};
+type MemoryProjectionSeed = {
+    summary: string;
+    kind: string;
+    category?: string | null;
+    confidence: number;
+    details?: Record<string, unknown> | null;
+};
+export type MemoryEventInput = (MemoryEventBase & MemoryProjectionSeed & {
+    eventType: "observed";
+}) | (MemoryEventBase & MemoryProjectionSeed & {
+    eventType: "promoted";
+    sourceCanonicalKey: string;
+}) | (MemoryEventBase & MemoryProjectionSeed & {
+    eventType: "corrected";
+    sourceCanonicalKey: string;
+}) | (MemoryEventBase & {
+    eventType: "superseded";
+    replacementCanonicalKey: string;
+}) | (MemoryEventBase & {
+    eventType: "retracted";
+}) | (MemoryEventBase & {
+    eventType: "reinforced";
+    confidence: number;
+}) | (MemoryEventBase & {
+    eventType: "retrieved";
+    retrievalQuery: string;
+    retrievalRank: number;
+}) | (MemoryEventBase & {
+    eventType: "feedback_recorded";
+    feedbackOutcome: RetrievalFeedbackOutcome;
+    retrievalRank: number;
+    retrievalQuery?: string | null;
+});
+export type MemoryEventMetadata = {
+    sourceCanonicalKey?: string | null;
+    replacementCanonicalKey?: string | null;
+    retrievalQuery?: string | null;
+    retrievalRank?: number | null;
+    feedbackOutcome?: RetrievalFeedbackOutcome | null;
+    summary?: string | null;
+    kind?: string | null;
+    category?: string | null;
+    confidence?: number | null;
+    details?: Record<string, unknown> | null;
+};
+export type MemoryEventRow = {
+    eventId: string;
+    eventType: MemoryEventType;
+    canonicalKey: string;
+    summary: string;
+    createdAt: string;
+};
+export type MemoryItemRow = {
+    canonicalKey: string;
+    summary: string;
+    kind: string | null;
+    category: string | null;
+    status: MemoryStatus;
+    confidence: number;
+    sourceRunId: string | null;
+    sourceTaskId: string | null;
+    branch: string | null;
+    details: Record<string, unknown> | null;
+    createdAt: string;
+    updatedAt: string;
+    lastEventId: string;
+    supersededBy: string | null;
+    embedding: number[] | null;
+};
+export type MemoryQueryOptions = {
+    canonicalKey?: string;
+    includeInactive?: boolean;
+};
+export type MemoryDb = {
+    path: string;
+    client: MemoryDbClient;
+    close(): Promise<void>;
+};
+/** A scored, ranked shared-memory item returned by the retrieval query. */
+export type MemoryQueryResult = {
+    canonicalKey: string;
+    summary: string;
+    kind: string | null;
+    category: string | null;
+    confidence: number;
+    updatedAt: string;
+    score: number;
+    lexicalScore: number;
+    vectorScore: number;
+    recencyScore: number;
+};
+/** Embeds text into vectors for memory retrieval; provider-agnostic. */
+export type MemoryEmbedder = {
+    embed(texts: string[]): Promise<number[][]>;
+};
+/** A materialized read-only snapshot of the canonical project-memory database. */
+export type CanonicalMemorySnapshot = {
+    repoPath: string;
+    baseOid: string;
+    dbPath: string;
+    createdFresh: boolean;
+    cleanup(): Promise<void>;
+};
+export {};

package/dist/src/memory.js

@@ -0,0 +1,8 @@
+// @bun
+// packages/contracts/src/memory.ts
+var MEMORY_SERVICE_CAPABILITY_ID = "memory.service";
+var NO_MATCH_RETRIEVAL_CANONICAL_KEY = "__memory_recall__:none";
+export {
+  NO_MATCH_RETRIEVAL_CANONICAL_KEY,
+  MEMORY_SERVICE_CAPABILITY_ID
+};

package/dist/src/panel-protocol.d.ts

@@ -0,0 +1,17 @@
+import type { RunJournalProjection } from "./run-journal";
+/**
+ * Cross-package panel-protocol vocabulary shared by the run-worker (panel
+ * producer side) and the plugins that contribute the supervisor panel
+ * registration. Lives in @rig/contracts so neither side has to depend on the
+ * other's package for these constants.
+ */
+export declare const RIG_RUN_STOP_PANEL_ACTION = "rig-run:stop";
+export declare const RIG_CAPABILITY_PANEL_SLOT = "capability";
+export declare const RIG_SUPERVISOR_PANEL_ID = "supervisor";
+export interface WorkerPanelProducerContext {
+    readonly projectRoot: string;
+    readonly runId: string;
+    readonly folded: RunJournalProjection;
+    readonly taskIdAtStart?: string | null;
+    readonly runDisplayTitle: string;
+}

package/dist/src/panel-protocol.js

@@ -0,0 +1,10 @@
+// @bun
+// packages/contracts/src/panel-protocol.ts
+var RIG_RUN_STOP_PANEL_ACTION = "rig-run:stop";
+var RIG_CAPABILITY_PANEL_SLOT = "capability";
+var RIG_SUPERVISOR_PANEL_ID = "supervisor";
+export {
+  RIG_SUPERVISOR_PANEL_ID,
+  RIG_RUN_STOP_PANEL_ACTION,
+  RIG_CAPABILITY_PANEL_SLOT
+};

package/dist/src/plugin-hooks.js

@@ -170,19 +170,6 @@ var CapabilityReplacementSpec = Schema3.Union([
   CapabilityReplacement,
   TrimmedNonEmptyString
 ]);
-var PluginMeta = Schema3.Struct({
-  id: TrimmedNonEmptyString,
-  version: TrimmedNonEmptyString,
-  provides: Schema3.Array(CapabilityTag),
-  requires: Schema3.optional(Schema3.Array(CapabilityTag)),
-  replaces: Schema3.optional(Schema3.Array(CapabilityReplacementSpec))
-});
-var LoadedPluginDescriptor = Schema3.Struct({
-  meta: PluginMeta,
-  provides: Schema3.Array(CapabilityTag),
-  contributes: Schema3.Unknown,
-  runtime: Schema3.Unknown
-});
 var KernelReplacementGrant = Schema3.Struct({
   pluginId: TrimmedNonEmptyString,
   grantedBy: Schema3.optional(TrimmedNonEmptyString),
@@ -327,6 +314,10 @@ var BlockerClassifierRegistration = Schema4.Struct({
   description: Schema4.optional(Schema4.String),
   priority: Schema4.optional(Schema4.Number)
 });
+var SessionExtensionRegistration = Schema4.Struct({
+  id: Schema4.String,
+  description: Schema4.optional(Schema4.String)
+});
 var PluginContributes = Schema4.Struct({
   validators: Schema4.optional(Schema4.Array(ValidatorRegistration)),
   hooks: Schema4.optional(Schema4.Array(HookRegistration)),
@@ -340,7 +331,8 @@ var PluginContributes = Schema4.Struct({
   stageMutations: Schema4.optional(Schema4.Array(StageMutation)),
   capabilities: Schema4.optional(Schema4.Array(ProductCapabilityRegistration)),
   panels: Schema4.optional(Schema4.Array(PanelRegistration)),
-  blockerClassifiers: Schema4.optional(Schema4.Array(BlockerClassifierRegistration))
+  blockerClassifiers: Schema4.optional(Schema4.Array(BlockerClassifierRegistration)),
+  sessionExtensions: Schema4.optional(Schema4.Array(SessionExtensionRegistration))
 });
 var RigPlugin = Schema4.Struct({
   name: Schema4.String,

package/dist/src/plugin.d.ts

@@ -118,6 +118,11 @@ export declare const BlockerClassifierRegistration: Schema.Struct<{
     readonly priority: Schema.optional<Schema.Number>;
 }>;
 export type BlockerClassifierRegistration = typeof BlockerClassifierRegistration.Type;
+export declare const SessionExtensionRegistration: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly description: Schema.optional<Schema.String>;
+}>;
+export type SessionExtensionRegistration = typeof SessionExtensionRegistration.Type;
 export declare const PluginContributes: Schema.Struct<{
     readonly validators: Schema.optional<Schema.$Array<Schema.Struct<{
         readonly id: Schema.String;
@@ -259,6 +264,10 @@ export declare const PluginContributes: Schema.Struct<{
         readonly description: Schema.optional<Schema.String>;
         readonly priority: Schema.optional<Schema.Number>;
     }>>>;
+    readonly sessionExtensions: Schema.optional<Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly description: Schema.optional<Schema.String>;
+    }>>>;
 }>;
 export type PluginContributes = typeof PluginContributes.Type;
 export declare const RigPlugin: Schema.Struct<{
@@ -411,6 +420,10 @@ export declare const RigPlugin: Schema.Struct<{
             readonly description: Schema.optional<Schema.String>;
             readonly priority: Schema.optional<Schema.Number>;
         }>>>;
+        readonly sessionExtensions: Schema.optional<Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly description: Schema.optional<Schema.String>;
+        }>>>;
     }>>;
 }>;
 export type RigPlugin = typeof RigPlugin.Type;

package/dist/src/plugin.js

@@ -167,19 +167,6 @@ var CapabilityReplacementSpec = Schema3.Union([
   CapabilityReplacement,
   TrimmedNonEmptyString
 ]);
-var PluginMeta = Schema3.Struct({
-  id: TrimmedNonEmptyString,
-  version: TrimmedNonEmptyString,
-  provides: Schema3.Array(CapabilityTag),
-  requires: Schema3.optional(Schema3.Array(CapabilityTag)),
-  replaces: Schema3.optional(Schema3.Array(CapabilityReplacementSpec))
-});
-var LoadedPluginDescriptor = Schema3.Struct({
-  meta: PluginMeta,
-  provides: Schema3.Array(CapabilityTag),
-  contributes: Schema3.Unknown,
-  runtime: Schema3.Unknown
-});
 var KernelReplacementGrant = Schema3.Struct({
   pluginId: TrimmedNonEmptyString,
   grantedBy: Schema3.optional(TrimmedNonEmptyString),
@@ -325,6 +312,10 @@ var BlockerClassifierRegistration = Schema4.Struct({
   description: Schema4.optional(Schema4.String),
   priority: Schema4.optional(Schema4.Number)
 });
+var SessionExtensionRegistration = Schema4.Struct({
+  id: Schema4.String,
+  description: Schema4.optional(Schema4.String)
+});
 var PluginContributes = Schema4.Struct({
   validators: Schema4.optional(Schema4.Array(ValidatorRegistration)),
   hooks: Schema4.optional(Schema4.Array(HookRegistration)),
@@ -338,7 +329,8 @@ var PluginContributes = Schema4.Struct({
   stageMutations: Schema4.optional(Schema4.Array(StageMutation)),
   capabilities: Schema4.optional(Schema4.Array(ProductCapabilityRegistration)),
   panels: Schema4.optional(Schema4.Array(PanelRegistration)),
-  blockerClassifiers: Schema4.optional(Schema4.Array(BlockerClassifierRegistration))
+  blockerClassifiers: Schema4.optional(Schema4.Array(BlockerClassifierRegistration)),
+  sessionExtensions: Schema4.optional(Schema4.Array(SessionExtensionRegistration))
 });
 var RigPlugin = Schema4.Struct({
   name: Schema4.String,
@@ -355,6 +347,7 @@ export {
   TaskSourceKind,
   TaskFieldExtension,
   SkillRegistration,
+  SessionExtensionRegistration,
   RigPlugin,
   RepoSourceRegistration,
   ProductCapabilityRegistration,

package/dist/src/provider-instructions.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Pure provider-instruction contract types.
+ *
+ * Neutral home for the agent-harness provider identity so the dumb runtime
+ * substrate (native/task-ops, hooks/inject-context) and the
+ * @rig/provider-plugin that owns the instruction text can both reference it
+ * without a substrate->plugin import cycle. Carries no behaviour and imports
+ * nothing — exactly like `memory.ts` / `lifecycle-capabilities.ts`.
+ *
+ * The plugin registers its executable `RuntimeInstructionService` impl under
+ * {@link RUNTIME_INSTRUCTION_SERVICE_CAPABILITY_ID} on
+ * `contributes.capabilities[].run`; the runtime resolves it by id from
+ * `pluginHost.listExecutableCapabilities()` via the typed port in
+ * `@rig/runtime/control-plane/provider-instruction-port`.
+ */
+/** Capability id the provider plugin registers its instruction service under. */
+export declare const RUNTIME_INSTRUCTION_SERVICE_CAPABILITY_ID = "provider.runtime-instructions";
+/** The agent harness adapter the runtime is currently wired to. */
+export type RuntimeInstructionProvider = "pi";

package/dist/src/provider-instructions.js

@@ -0,0 +1,6 @@
+// @bun
+// packages/contracts/src/provider-instructions.ts
+var RUNTIME_INSTRUCTION_SERVICE_CAPABILITY_ID = "provider.runtime-instructions";
+export {
+  RUNTIME_INSTRUCTION_SERVICE_CAPABILITY_ID
+};

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

@@ -744,7 +744,7 @@ export declare const decodeRunJournalEvent: (input: unknown, options?: import("e
     readonly v: 1;
     readonly type: "approval-resolved";
     readonly requestId: string;
-    readonly decision: "approve" | "reject";
+    readonly decision: "reject" | "approve";
     readonly actor: {
         readonly kind: "server" | "system" | "agent" | "operator";
         readonly id?: string | null | undefined;

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

@@ -43,3 +43,14 @@ export interface RunRecord {
     /** The full folded journal (empty projection when no journal was readable). */
     readonly projection: RunJournalProjection;
 }
+/**
+ * Index runs by their task id, keeping only the most-recently-updated run per
+ * task. Pure run primitive relocated out of the dissolved @rig/client facade
+ * (the META vocabulary floor is the correct home for a typed, policy-free run
+ * coercion that multiple plugins build projections on).
+ */
+export declare function latestRunByTaskId<T extends {
+    readonly taskId: string | null;
+    readonly updatedAt: string | null;
+    readonly startedAt: string | null;
+}>(runs: readonly T[]): Map<string, T>;

package/dist/src/run-record.js

@@ -1 +1,17 @@
 // @bun
+// packages/contracts/src/run-record.ts
+function latestRunByTaskId(runs) {
+  const byTask = new Map;
+  const stamp = (run) => Date.parse(run.updatedAt ?? run.startedAt ?? "") || 0;
+  for (const run of runs) {
+    if (!run.taskId)
+      continue;
+    const current = byTask.get(run.taskId);
+    if (!current || stamp(run) >= stamp(current))
+      byTask.set(run.taskId, run);
+  }
+  return byTask;
+}
+export {
+  latestRunByTaskId
+};

package/dist/src/supervisor-journal.d.ts

@@ -202,4 +202,3 @@ export declare const SupervisorProjection: Schema.Struct<{
     readonly anomalies: Schema.$Array<Schema.String>;
 }>;
 export type SupervisorProjection = typeof SupervisorProjection.Type;
-export declare function reduceSupervisorJournal(events: readonly SupervisorEvent[]): SupervisorProjection;