@h-rig/contracts 0.0.6-alpha.176 → 0.0.6-alpha.178

package/dist/src/remote-control.d.ts

@@ -0,0 +1,93 @@
+import type { CapabilityId } from "./capability-id";
+export type RemoteControlEnv = Readonly<Record<string, string | undefined>>;
+export type RemoteControlJsonRecord = Record<string, unknown>;
+export type RemoteControlMessage = {
+    readonly type: string;
+    readonly id?: string;
+    readonly timestamp?: string;
+} & RemoteControlJsonRecord;
+export type RemoteControlEndpointSelection = {
+    readonly projectRoot: string;
+    readonly host?: string | undefined;
+    readonly port?: string | undefined;
+    readonly token?: string | undefined;
+    readonly remoteAlias?: string | undefined;
+    readonly env?: RemoteControlEnv | undefined;
+};
+export type RemoteControlRemote = {
+    readonly source: "flags" | "alias" | "env";
+    readonly alias?: string | undefined;
+    readonly host: string;
+    readonly port: number;
+};
+export type RemoteControlEndpoint = RemoteControlRemote & {
+    readonly token: string;
+};
+export type RemoteControlEvent = {
+    readonly receivedAt: string;
+    readonly message: RemoteControlMessage;
+};
+export type RemoteControlWatchEvent = RemoteControlEvent & {
+    readonly summary: string;
+};
+export type RemoteControlOperationResult = {
+    readonly remote: RemoteControlRemote;
+    readonly response: RemoteControlMessage;
+};
+export type RemoteControlEndpointTestResult = RemoteControlOperationResult & {
+    readonly latencyMs: number;
+};
+export type RemoteControlWatchOptions = RemoteControlEndpointSelection & {
+    readonly eventType?: string | undefined;
+    readonly seconds?: number | undefined;
+    readonly maxCaptured?: number | undefined;
+    readonly shouldStop?: (() => boolean) | undefined;
+    readonly onEvent?: ((event: RemoteControlWatchEvent) => void) | undefined;
+};
+export type RemoteControlWatchResult = {
+    readonly remote: RemoteControlRemote;
+    readonly received: number;
+    readonly dropped: number;
+    readonly captured: readonly RemoteControlMessage[];
+    readonly event: string | null;
+    readonly seconds: number | null;
+};
+export type RemoteControlStartOrchestrationOptions = {
+    readonly maxWorkers?: number | undefined;
+    readonly maxIterations?: number | undefined;
+    readonly directMerge?: boolean | undefined;
+};
+export interface RemoteControlClient {
+    readonly remote: RemoteControlRemote;
+    readonly ping: () => Promise<RemoteControlMessage>;
+    readonly getState: () => Promise<RemoteControlMessage>;
+    readonly getTasks: () => Promise<RemoteControlMessage>;
+    readonly pause: () => Promise<RemoteControlMessage>;
+    readonly resume: () => Promise<RemoteControlMessage>;
+    readonly stop: () => Promise<RemoteControlMessage>;
+    readonly continueExecution: () => Promise<RemoteControlMessage>;
+    readonly refreshTasks: () => Promise<RemoteControlMessage>;
+    readonly addIterations: (count: number) => Promise<RemoteControlMessage>;
+    readonly removeIterations: (count: number) => Promise<RemoteControlMessage>;
+    readonly getPromptPreview: (taskId: string) => Promise<RemoteControlMessage>;
+    readonly getIterationOutput: (taskId: string) => Promise<RemoteControlMessage>;
+    readonly startOrchestration: (options: RemoteControlStartOrchestrationOptions) => Promise<RemoteControlMessage>;
+    readonly pauseOrchestration: (orchestrationId: string) => Promise<RemoteControlMessage>;
+    readonly resumeOrchestration: (orchestrationId: string) => Promise<RemoteControlMessage>;
+    readonly stopOrchestration: (orchestrationId: string) => Promise<RemoteControlMessage>;
+    readonly getOrchestrationState: (orchestrationId: string) => Promise<RemoteControlMessage>;
+}
+export interface RemoteControlService {
+    readonly resolveEndpoint: (input: RemoteControlEndpointSelection) => RemoteControlRemote;
+    readonly withClient: <T>(input: RemoteControlEndpointSelection, runner: (client: RemoteControlClient) => Promise<T>) => Promise<T>;
+    readonly testEndpoint: (input: RemoteControlEndpointSelection) => Promise<RemoteControlEndpointTestResult>;
+    readonly watch: (input: RemoteControlWatchOptions) => Promise<RemoteControlWatchResult>;
+}
+export declare class RemoteControlError extends Error {
+    readonly code: string;
+    readonly exitCode: number;
+    readonly details: RemoteControlJsonRecord | undefined;
+    constructor(code: string, message: string, exitCode?: number, details?: RemoteControlJsonRecord);
+}
+export declare const REMOTE_CONTROL_CAPABILITY_ID = "rig.remote.control";
+export declare const REMOTE_CONTROL: CapabilityId<RemoteControlService>;

package/dist/src/remote-control.js

@@ -0,0 +1,26 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/remote-control.ts
+class RemoteControlError extends Error {
+  code;
+  exitCode;
+  details;
+  constructor(code, message, exitCode = 1, details) {
+    super(message);
+    this.name = "RemoteControlError";
+    this.code = code;
+    this.exitCode = exitCode;
+    this.details = details;
+  }
+}
+var REMOTE_CONTROL_CAPABILITY_ID = "rig.remote.control";
+var REMOTE_CONTROL = makeCapabilityId(REMOTE_CONTROL_CAPABILITY_ID);
+export {
+  RemoteControlError,
+  REMOTE_CONTROL_CAPABILITY_ID,
+  REMOTE_CONTROL
+};

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

@@ -0,0 +1,164 @@
+/**
+ * run-control.ts - typed run control capability vocabulary.
+ *
+ * RUN_READ_MODEL is projection-oriented. Operators that plan launches, deliver
+ * control frames, resolve inbox requests, compute resume actions, or remove
+ * registry entries use this control seam instead of mutating through read-model
+ * consumers.
+ */
+import type { CapabilityId } from "./capability-id";
+import type { RunDiscoveryFilter } from "./run-discovery";
+import type { RunRecord } from "./run-record";
+import type { RunInboxResolutionInit } from "./run-session-journal";
+export type RunControl = {
+    readonly kind: "steer";
+    readonly message: string;
+} | {
+    readonly kind: "stop";
+    readonly reason: string;
+} | {
+    readonly kind: "pause";
+} | {
+    readonly kind: "resume";
+};
+export interface RunControlTargetInput {
+    readonly projectRoot: string;
+    /** Canonical run id/session id. */
+    readonly runId: string;
+    readonly taskId?: string | null;
+    readonly purpose?: "attach" | "steer" | "stop" | "pause" | "resume" | "restart" | "delete" | "prune" | "resolve-inbox";
+    readonly discoveryFilter?: RunDiscoveryFilter;
+}
+export interface RunControlTarget {
+    /** Canonical run id/session id. */
+    readonly runId: string;
+    readonly taskId: string | null;
+    readonly sessionId: string | null;
+    readonly sessionPath: string | null;
+    readonly joinLink: string | null;
+    readonly webLink: string | null;
+    readonly relayUrl: string | null;
+    readonly collabCwd: string | null;
+    readonly live: boolean;
+    readonly stale: boolean;
+    readonly canDeliver: boolean;
+    readonly reason?: string | null;
+}
+export interface RunControlInput {
+    readonly projectRoot: string;
+    /** Canonical run id/session id. */
+    readonly runId: string;
+    readonly control: RunControl;
+    readonly requestedBy?: string | null;
+    readonly discoveryFilter?: RunDiscoveryFilter;
+}
+export interface RunControlResult {
+    readonly runId: string;
+    readonly kind: RunControl["kind"];
+    readonly status: "delivered" | "not-found" | "not-live" | "unsupported";
+    readonly delivered: boolean;
+    readonly detail?: string | null;
+}
+export interface RunInboxResolutionInput {
+    readonly projectRoot: string;
+    /** Canonical run id/session id. */
+    readonly runId: string;
+    readonly resolution: RunInboxResolutionInit;
+    readonly requestedBy?: string | null;
+    readonly discoveryFilter?: RunDiscoveryFilter;
+}
+export interface RunInboxResolutionResult {
+    readonly runId: string;
+    readonly requestId: string;
+    readonly kind: "approval" | "input";
+    readonly status: "resolved" | "not-found" | "not-live" | "unsupported";
+    readonly delivered: boolean;
+    readonly detail?: string | null;
+}
+export interface RunResumePlanInput {
+    readonly projectRoot: string;
+    /** Canonical run id/session id. */
+    readonly runId: string;
+    readonly discoveryFilter?: RunDiscoveryFilter;
+}
+export interface RunLaunchCandidate {
+    readonly taskId: string;
+    readonly title?: string | null;
+}
+export interface RunLaunchPlanInput {
+    readonly projectRoot: string;
+    readonly candidates: readonly RunLaunchCandidate[];
+    /** Force means all candidates remain launchable; owners may still annotate results. */
+    readonly force?: boolean;
+    readonly discoveryFilter?: RunDiscoveryFilter;
+}
+export type RunLaunchPlanEntry = {
+    readonly kind: "launch";
+    readonly taskId: string;
+    readonly title: string | null;
+} | {
+    readonly kind: "skipped";
+    readonly taskId: string;
+    readonly title: string | null;
+    readonly reason: string;
+    readonly activeRunId?: string | null;
+};
+export interface RunLaunchPlan {
+    readonly entries: readonly RunLaunchPlanEntry[];
+    readonly launch: readonly Extract<RunLaunchPlanEntry, {
+        readonly kind: "launch";
+    }>[];
+    readonly skipped: readonly Extract<RunLaunchPlanEntry, {
+        readonly kind: "skipped";
+    }>[];
+    readonly force: boolean;
+}
+export type RunResumePlan = {
+    readonly kind: "deliver-control";
+    readonly runId: string;
+    readonly run: RunRecord;
+} | {
+    readonly kind: "redispatch-task";
+    readonly runId: string;
+    readonly taskId: string;
+    readonly title: string;
+} | {
+    readonly kind: "unavailable";
+    readonly runId: string;
+    readonly reason: string;
+};
+export interface RunRegistryRemovalInput {
+    readonly projectRoot: string;
+    /** Canonical run id/session id. */
+    readonly runId: string;
+}
+export interface RunRegistryRemovalResult {
+    /** Canonical run id/session id. */
+    readonly runId: string;
+    readonly removed: boolean;
+}
+export interface RunDeadPidReconciliationInput {
+    readonly projectRoot: string;
+    /** Canonical run id/session id. */
+    readonly runId: string;
+    readonly sessionPath: string;
+    readonly reason?: "lazy-reconcile:dead-pid";
+}
+export interface RunDeadPidReconciliationResult {
+    /** Canonical run id/session id. */
+    readonly runId: string;
+    readonly updated: boolean;
+    readonly status: "reconciled" | "not-found" | "unavailable";
+    readonly detail?: string | null;
+}
+export interface RunControlService {
+    readonly resolveControlTarget: (input: RunControlTargetInput) => Promise<RunControlTarget | null>;
+    readonly deliverControl: (input: RunControlInput) => Promise<RunControlResult>;
+    readonly resolveInboxRequest: (input: RunInboxResolutionInput) => Promise<RunInboxResolutionResult>;
+    readonly planLaunches: (input: RunLaunchPlanInput) => Promise<RunLaunchPlan>;
+    readonly resolveResumePlan: (input: RunResumePlanInput) => Promise<RunResumePlan | null>;
+    readonly removeRunRegistryEntry: (input: RunRegistryRemovalInput) => Promise<RunRegistryRemovalResult>;
+    readonly reconcileDeadPid: (input: RunDeadPidReconciliationInput) => Promise<RunDeadPidReconciliationResult>;
+}
+export declare const RUN_CONTROL_CAPABILITY_ID = "rig.runs.control";
+export declare const RUN_CONTROL: CapabilityId<RunControlService>;

package/dist/src/run-control.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/run-control.ts
+var RUN_CONTROL_CAPABILITY_ID = "rig.runs.control";
+var RUN_CONTROL = makeCapabilityId(RUN_CONTROL_CAPABILITY_ID);
+export {
+  RUN_CONTROL_CAPABILITY_ID,
+  RUN_CONTROL
+};

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

@@ -22,6 +22,10 @@ export interface RunDiscoveryFilter {
     selectedRepo?: string;
     cwd?: string;
 }
+export type RunRuntimeActivePredicate = (status: unknown) => boolean;
+export interface RunDiscoveryStaleOptions {
+    readonly isRuntimeActiveStatus?: RunRuntimeActivePredicate;
+}
 /** Structural equivalent of @oh-my-pi LiveCollabOwner. */
 export interface RunDiscoveryOwner {
     githubUserId?: string;
@@ -66,7 +70,7 @@ export interface RigRunAttachResult {
  * need snapshot frames must cast through the transport-plugin's richer type.
  */
 export interface RunDiscoveryService {
-    readonly listActiveRunCollab: (projectRoot: string, filter: RunDiscoveryFilter) => Promise<readonly LiveRunCollabProjection[]>;
+    readonly listActiveRunCollab: (projectRoot: string, filter: RunDiscoveryFilter, options?: RunDiscoveryStaleOptions) => Promise<readonly LiveRunCollabProjection[]>;
     readonly runDiscoveryStream: (projectRoot: string) => Stream.Stream<void>;
     readonly attachViaRelay: (input: RigRunAttachInput) => Promise<RigRunAttachResult | null>;
 }

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

@@ -0,0 +1,36 @@
+/**
+ * run-queue.ts — scheduler-owned run queue capability vocabulary.
+ *
+ * Contracts keeps only the typed id and data shapes. Ranking, packing, and
+ * admission behavior lives in @rig/scheduler-plugin and is consumed by
+ * supervisor/CLI surfaces through this capability.
+ */
+import type { CapabilityId } from "./capability-id";
+import type { TaskDependencyProjection } from "./task-graph-primitives";
+import type { SupervisorSelectionPolicy } from "./supervisor-journal";
+export interface RunQueueRankedTask<T extends TaskDependencyProjection = TaskDependencyProjection> {
+    readonly task: T;
+    readonly score: number;
+    readonly priority: number;
+    readonly unblockCount: number;
+    readonly scope: readonly string[];
+}
+export interface RunQueuePlanInput<T extends TaskDependencyProjection = TaskDependencyProjection> {
+    readonly tasks: readonly T[];
+    readonly activeTaskIds?: Iterable<string>;
+    readonly excludeTaskIds?: Iterable<string>;
+    readonly candidateTaskIds?: Iterable<string>;
+    readonly selectionPolicy?: SupervisorSelectionPolicy;
+    readonly requireDisjointScopes?: boolean;
+    readonly disjointWithScopes?: Iterable<string>;
+    readonly limit?: number;
+}
+export interface RunQueuePlan<T extends TaskDependencyProjection = TaskDependencyProjection> {
+    readonly plannedOrder: readonly string[];
+    readonly ranked: readonly RunQueueRankedTask<T>[];
+}
+export interface RunQueueService {
+    readonly planReadyTasks: <T extends TaskDependencyProjection>(input: RunQueuePlanInput<T>) => RunQueuePlan<T>;
+}
+export declare const RUN_QUEUE_CAPABILITY_ID = "rig.scheduler.run-queue";
+export declare const RUN_QUEUE: CapabilityId<RunQueueService>;

package/dist/src/run-queue.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/run-queue.ts
+var RUN_QUEUE_CAPABILITY_ID = "rig.scheduler.run-queue";
+var RUN_QUEUE = makeCapabilityId(RUN_QUEUE_CAPABILITY_ID);
+export {
+  RUN_QUEUE_CAPABILITY_ID,
+  RUN_QUEUE
+};

package/dist/src/run-read-model.d.ts

@@ -12,12 +12,12 @@
  */
 import type { CapabilityId } from "./capability-id";
 import type { RigStatsData } from "./cli-output";
-import type { RunDiscoveryFilter } from "./run-discovery";
+import type { RunDiscoveryFilter, RunRuntimeActivePredicate } from "./run-discovery";
 import type { RunJournalProjection } from "./run-journal";
 import type { RunRegistryRunProjection } from "./run-registry-backbone";
-import type { RigRunTimelineEntry } from "./run-timeline";
 import type { RunRecord, UnifiedInboxRequest } from "./run-record";
-import type { RunInboxResolutionInit, RunSessionCustomEntry } from "./run-session-journal";
+import type { RunStatus } from "./runtime";
+import type { RunSessionCustomEntry } from "./run-session-journal";
 import type { TaskRecord } from "./task-source";
 export type RunReadModelSource = RunRecord["source"] | "all";
 export type RunReadModelRunSelector = {
@@ -33,6 +33,13 @@ export interface RunReadModelListInput {
     readonly includeInactive?: boolean;
     readonly discoveryFilter?: RunDiscoveryFilter;
 }
+export type RunReadModelRepresentativePurpose = "inspect";
+export interface RunReadModelRepresentativeRunInput {
+    readonly projectRoot: string;
+    readonly taskId: string;
+    readonly purpose: RunReadModelRepresentativePurpose;
+    readonly discoveryFilter?: RunDiscoveryFilter;
+}
 export interface RunReadModelGetInput {
     readonly projectRoot: string;
     readonly selector: RunReadModelRunSelector;
@@ -45,13 +52,19 @@ export interface RunReadModelProjectionInput {
     readonly sessionPath?: string | null;
     readonly discoveryFilter?: RunDiscoveryFilter;
 }
+export interface RunReadModelSessionProjectionInput {
+    /** Canonical run id/session id. */
+    readonly runId: string;
+    /** Raw run-session custom entries; RUN_READ_MODEL owns the fold into a journal projection. */
+    readonly entries: readonly RunSessionCustomEntry[];
+}
 export interface RunReadModelRegistryProjectionInput {
     /** Canonical run id/session id. */
     readonly runId: string;
-    readonly folded: RunJournalProjection;
     /** Raw run-session custom entries; providers own timeline extraction from them. */
     readonly entries: readonly RunSessionCustomEntry[];
     readonly title: string;
+    readonly taskId?: string | null;
     readonly joinLink?: string | null;
     readonly webLink?: string | null;
     readonly relayUrl?: string | null;
@@ -60,8 +73,6 @@ export interface RunReadModelRegistryProjectionInput {
     readonly collabCwd?: string | null;
     readonly dispatchHandle?: string | null;
     readonly timelineLimit?: number;
-    /** Optional caller-supplied timeline for compatibility; providers should prefer entries. */
-    readonly timeline?: readonly RigRunTimelineEntry[];
 }
 export interface RunReadModelDetailsInput extends RunReadModelGetInput {
     readonly includeLogs?: boolean;
@@ -88,58 +99,6 @@ export interface RunReadModelInspectRowsInput {
     readonly pendingInbox?: number | null;
     readonly discoveryFilter?: RunDiscoveryFilter;
 }
-export interface RunReadModelControlTargetInput {
-    readonly projectRoot: string;
-    /** Canonical run id/session id. */
-    readonly runId: string;
-    readonly taskId?: string | null;
-    readonly purpose?: "attach" | "steer" | "stop" | "pause" | "resume" | "resolve-inbox";
-    readonly discoveryFilter?: RunDiscoveryFilter;
-}
-export type RunReadModelControl = {
-    readonly kind: "steer";
-    readonly message: string;
-} | {
-    readonly kind: "stop";
-    readonly reason: string;
-} | {
-    readonly kind: "pause";
-} | {
-    readonly kind: "resume";
-};
-export interface RunReadModelControlInput {
-    readonly projectRoot: string;
-    /** Canonical run id/session id. */
-    readonly runId: string;
-    readonly control: RunReadModelControl;
-    readonly requestedBy?: string | null;
-    readonly discoveryFilter?: RunDiscoveryFilter;
-}
-export interface RunReadModelControlResult {
-    readonly runId: string;
-    readonly kind: RunReadModelControl["kind"];
-    readonly status: "delivered" | "not-found" | "not-live" | "unsupported";
-    readonly delivered: boolean;
-    readonly detail?: string | null;
-}
-export interface RunReadModelInboxResolutionInput {
-    readonly projectRoot: string;
-    /** Canonical run id/session id. */
-    readonly runId: string;
-    readonly resolution: RunInboxResolutionInit;
-    readonly requestedBy?: string | null;
-    readonly discoveryFilter?: RunDiscoveryFilter;
-}
-export interface RunReadModelRemoveRegistryEntryInput {
-    readonly projectRoot: string;
-    /** Canonical run id/session id. */
-    readonly runId: string;
-}
-export interface RunReadModelRemoveRegistryEntryResult {
-    /** Canonical run id/session id. */
-    readonly runId: string;
-    readonly removed: boolean;
-}
 export interface RunReadModelInboxCounts {
     readonly approvals: number;
     readonly inputs: number;
@@ -158,34 +117,13 @@ export interface RunReadModelInboxRecord {
     readonly payload: unknown;
     readonly source: "run";
 }
-export interface RunReadModelInboxResolutionResult {
-    readonly runId: string;
-    readonly requestId: string;
-    readonly kind: "approval" | "input";
-    readonly status: "resolved" | "not-found" | "not-live" | "unsupported";
-    readonly delivered: boolean;
-    readonly detail?: string | null;
-}
-export interface RunReadModelControlTarget {
-    /** Canonical run id/session id. */
-    readonly runId: string;
-    readonly taskId: string | null;
-    readonly sessionId: string | null;
-    readonly sessionPath: string | null;
-    readonly joinLink: string | null;
-    readonly webLink: string | null;
-    readonly relayUrl: string | null;
-    readonly collabCwd: string | null;
-    readonly live: boolean;
-    readonly stale: boolean;
-    readonly canDeliver: boolean;
-    readonly reason?: string | null;
-}
 export type RunReadModelStats = RigStatsData;
 export type RunReadModelStatusPhase = "starting" | "active" | "waiting" | "paused" | "needs-attention" | "completed" | "failed" | "stopped" | "unknown";
 export type RunReadModelStatusRole = "success" | "action-yellow" | "active-cyan" | "failure" | "muted" | "neutral";
 export interface RunReadModelRunClassification {
     readonly status: string;
+    /** RUN_READ_MODEL-owned canonical status for consumers that must emit typed run status events. */
+    readonly runStatus: RunStatus;
     readonly phase: RunReadModelStatusPhase;
     readonly role: RunReadModelStatusRole;
     readonly rank: number;
@@ -193,6 +131,13 @@ export interface RunReadModelRunClassification {
     readonly isTerminal: boolean;
     readonly isNeedsAttention: boolean;
 }
+export type RunReadModelStageStatus = "pending" | "running" | "completed" | "needs-attention" | "failed" | "stopped" | "paused" | "waiting-approval" | "waiting-input" | "waiting-user-input";
+export interface RunReadModelStageRow {
+    readonly id: string;
+    readonly label: string;
+    readonly currentValue: RunReadModelStageStatus;
+    readonly description?: string;
+}
 export interface RunReadModelInspectRow {
     readonly id: string;
     readonly label: string;
@@ -225,26 +170,26 @@ export interface RunReadModelInspectResult {
 /**
  * Multi-method run read-model service capability.
  *
- * Providers own the executable discovery/folding/classification/control-target
- * lookup. Consumers depend only on this contracts vocabulary and resolve the
- * provider through the typed capability seam.
+ * Providers own executable discovery, session folding, classification, inbox
+ * read projection, stats, and stage/inspect rows. Consumers depend only on this
+ * contracts vocabulary and resolve the provider through the typed capability seam.
  */
 export interface RunReadModelService {
     readonly listRuns: (input: RunReadModelListInput) => Promise<readonly RunRecord[]>;
+    readonly getRepresentativeRun: (input: RunReadModelRepresentativeRunInput) => Promise<RunRecord | null>;
     readonly getRun: (input: RunReadModelGetInput) => Promise<RunRecord | null>;
     readonly getRunProjection: (input: RunReadModelProjectionInput) => Promise<RunJournalProjection | null>;
+    readonly buildSessionProjection: (input: RunReadModelSessionProjectionInput) => RunJournalProjection;
     readonly buildRegistryProjection: (input: RunReadModelRegistryProjectionInput) => RunRegistryRunProjection;
     readonly getRunDetails: (input: RunReadModelDetailsInput) => Promise<RunReadModelDetails | null>;
     readonly inspectRun: (input: RunReadModelDetailsInput) => Promise<RunReadModelInspectResult | null>;
     readonly listInboxRecords: (input: RunReadModelInboxInput) => Promise<readonly RunReadModelInboxRecord[]>;
     readonly getInboxCounts: (input: RunReadModelInboxInput) => Promise<RunReadModelInboxCounts>;
-    readonly resolveInboxRequest: (input: RunReadModelInboxResolutionInput) => Promise<RunReadModelInboxResolutionResult>;
     readonly getStats: (input: RunReadModelStatsInput) => Promise<RunReadModelStats>;
     readonly getInspectRows: (input: RunReadModelInspectRowsInput) => Promise<readonly RunReadModelInspectRow[]>;
-    readonly deliverControl: (input: RunReadModelControlInput) => Promise<RunReadModelControlResult>;
+    readonly isRuntimeActiveStatus: RunRuntimeActivePredicate;
     readonly classifyRun: (run: RunRecord) => RunReadModelRunClassification;
-    readonly resolveControlTarget: (input: RunReadModelControlTargetInput) => Promise<RunReadModelControlTarget | null>;
-    readonly removeRunRegistryEntry: (input: RunReadModelRemoveRegistryEntryInput) => Promise<RunReadModelRemoveRegistryEntryResult>;
+    readonly projectRunStages: (run: RunRecord) => readonly RunReadModelStageRow[];
 }
 /** Stable id string for the run read-model service capability. */
 export declare const RUN_READ_MODEL_CAPABILITY_ID = "rig.runs.read-model";

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

@@ -1,4 +1,9 @@
-import { type RunJournalEvent } from "./run-journal";
+import type { CapabilityId } from "./capability-id";
+import type { JournalCapability } from "./kernel";
+import { type ApprovalDecision, type RunActor, type RunCloseoutPhase, type RunCloseoutPhaseOutcome, type RunJournalEvent, type RunJournalProjection } from "./run-journal";
+import type { RigRunTimelineEntry } from "./run-timeline";
+import type { RunStatus } from "./runtime";
+import type { RigWorkflowStatusChanged } from "./workflow-journal";
 type DistributiveOmit<T, K extends PropertyKey> = T extends unknown ? Omit<T, K> : never;
 export type RunJournalEventInit = DistributiveOmit<RunJournalEvent, "v" | "seq" | "at" | "runId">;
 export declare const RIG_RUN_STATUS_CHANGED = "rig.run.status-changed";
@@ -66,4 +71,84 @@ export type RunSessionCustomEntry = {
     customType?: string;
     data?: unknown;
 };
+/** Minimal session surface a run-journal writer reads from when binding to an OMP
+ *  session. The writable append surface is intentionally not part of the
+ *  read-model codec; the run-worker-owned writer narrows live session managers
+ *  internally so contracts stays free of any `@oh-my-pi` dependency. */
+export interface RunJournalSessionManager {
+    getEntries?(): readonly unknown[];
+    getBranch?(): readonly unknown[];
+}
+/** A run journal provider bound to one session + run: the kernel `JournalCapability`
+ *  plus run-event append and the live projection read. */
+export type JournalSessionProvider = JournalCapability & {
+    readonly runId: string;
+    readonly appendRunEvent: (event: RunJournalEventInit) => Promise<void>;
+    readonly readEntries: () => readonly RunSessionCustomEntry[];
+    readonly readProjection: () => RunJournalProjection;
+};
+/** The bound run-journal WRITER handed to the run worker. */
+export type RunJournal = {
+    readonly kernel: JournalSessionProvider;
+    appendStatus(to: RunStatus, opts?: {
+        reason?: string | null;
+        actor?: RunActor;
+        errorText?: string | null;
+        force?: boolean;
+    }): void;
+    appendTimeline(payload: unknown): void;
+    appendCloseoutPhase(input: {
+        phase: RunCloseoutPhase;
+        outcome: RunCloseoutPhaseOutcome;
+        detail?: string | null;
+    }): void;
+    appendApprovalResolved(input: {
+        requestId: string;
+        decision: ApprovalDecision;
+        note?: string | null;
+        actor: RunActor;
+    }): void;
+    appendInputResolved(input: {
+        requestId: string;
+        answers: Record<string, string>;
+        actor: RunActor;
+    }): void;
+    appendStall(input: {
+        detail: string;
+    }): void;
+};
+/**
+ * The run-session journal codec: fold/projection (read), timeline extraction, and
+ * control-sentinel parse. Owned by `@rig/run-read-model-plugin`, consumed
+ * provider-anonymously through `RUN_SESSION_JOURNAL`. Writable journal binding is
+ * exposed separately by the run-worker/lifecycle writer capability.
+ */
+export interface RunSessionJournalCodec {
+    foldRunSessionEntries(entries: readonly RunSessionCustomEntry[], runId: string): RunJournalProjection;
+    projectRunFromSession(source: {
+        getEntries(): readonly RunSessionCustomEntry[];
+    } | readonly RunSessionCustomEntry[], runId: string): RunJournalProjection;
+    isTerminalRunStatus(status: RunStatus): boolean;
+    sessionIdFromSessionFile(sessionPath: string | null | undefined): string | null;
+    timelineEntriesFromCustomEntries(entries: readonly RunSessionCustomEntry[]): readonly RigRunTimelineEntry[];
+    latestTimelineEntriesFromCustomEntries(entries: readonly RunSessionCustomEntry[], limit: number): readonly RigRunTimelineEntry[];
+    parseStopSentinel(text: string, expectedRunId: string): {
+        reason: string | null;
+    } | null;
+    parsePauseSentinel(text: string, expectedRunId: string): {
+        requestedBy: string | null;
+    } | null;
+    parseResumeSentinel(text: string, expectedRunId: string): {
+        requestedBy: string | null;
+    } | null;
+    parseInboxResolutionSentinel(text: string, expectedRunId: string): RunInboxResolutionSentinel | null;
+    createWorkflowStatusChanged(input: Omit<RigWorkflowStatusChanged, "schemaVersion" | "changedAt"> & {
+        changedAt?: string;
+    }): RigWorkflowStatusChanged;
+}
+export declare const RUN_SESSION_JOURNAL_CAPABILITY_ID = "rig.runs.session-journal";
+/** Branded read-only run session-journal codec capability id. The read-model
+ *  plugin provides it; run surfaces resolve it instead of importing the codec
+ *  implementation. */
+export declare const RUN_SESSION_JOURNAL: CapabilityId<RunSessionJournalCodec>;
 export {};