@h-rig/contracts 0.0.6-alpha.18 → 0.0.6-alpha.181

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

@@ -0,0 +1,200 @@
+/**
+ * Run read-model capability vocabulary.
+ *
+ * This file defines the contracts-only service seam that run-owner plugins can
+ * provide to CLI, cockpit, supervisor, and doctor surfaces. The OMP session is
+ * the journal source of truth: read-model implementations must key projections
+ * by the canonical run id/session id (`runId === sessionId`). Dispatch handles,
+ * worktree paths, and relay metadata are metadata only, never identity keys.
+ *
+ * Pure: types + one branded id, no folding, defaults, coercion, IO, or provider
+ * implementation.
+ */
+import type { CapabilityId } from "./capability-id";
+import type { RigStatsData } from "./cli-output";
+import type { RunDiscoveryFilter, RunRuntimeActivePredicate } from "./run-discovery";
+import type { RunJournalProjection } from "./run-journal";
+import type { RunRegistryRunProjection } from "./run-registry-backbone";
+import type { RunRecord, UnifiedInboxRequest } from "./run-record";
+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 = {
+    /** Exact run id/session id, task id, or unique run-id prefix chosen by the caller. */
+    readonly id: string;
+    /** Prefer interpreting `id` as this kind when the caller already knows it. */
+    readonly kind?: "run-id" | "task-id" | "run-id-prefix" | "any";
+};
+export interface RunReadModelListInput {
+    readonly projectRoot: string;
+    readonly taskId?: string | null;
+    readonly source?: RunReadModelSource;
+    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;
+    readonly discoveryFilter?: RunDiscoveryFilter;
+}
+export interface RunReadModelProjectionInput {
+    readonly projectRoot: string;
+    /** Canonical run id/session id. */
+    readonly runId: string;
+    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;
+    /** 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;
+    readonly sessionPath?: string | null;
+    readonly cwd?: string | null;
+    readonly collabCwd?: string | null;
+    readonly dispatchHandle?: string | null;
+    readonly timelineLimit?: number;
+}
+export interface RunReadModelDetailsInput extends RunReadModelGetInput {
+    readonly includeLogs?: boolean;
+    readonly includeSourceTask?: boolean;
+}
+export interface RunReadModelInboxInput {
+    readonly projectRoot: string;
+    readonly kind?: "approval" | "input" | "all";
+    readonly runId?: string | null;
+    readonly taskId?: string | null;
+    readonly discoveryFilter?: RunDiscoveryFilter;
+}
+export interface RunReadModelStatsInput {
+    readonly projectRoot: string;
+    /** ISO timestamp lower bound, or null for all-time. */
+    readonly since?: string | null;
+    /** Optional caller-supplied records, used when the surface already listed runs. */
+    readonly runs?: readonly RunRecord[];
+    readonly discoveryFilter?: RunDiscoveryFilter;
+}
+export interface RunReadModelInspectRowsInput {
+    readonly projectRoot: string;
+    readonly runs?: readonly RunRecord[];
+    readonly pendingInbox?: number | null;
+    readonly discoveryFilter?: RunDiscoveryFilter;
+}
+export interface RunReadModelInboxCounts {
+    readonly approvals: number;
+    readonly inputs: number;
+    readonly total: number;
+}
+export interface RunReadModelInboxRecord {
+    readonly runId: string;
+    readonly taskId: string | null;
+    readonly requestId: string;
+    readonly kind: "approval" | "input";
+    readonly status: "pending";
+    readonly title: string;
+    readonly body?: string | null;
+    readonly prompt: string;
+    readonly requestedAt: string | null;
+    readonly payload: unknown;
+    readonly source: "run";
+}
+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;
+    readonly isActive: boolean;
+    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;
+    readonly currentValue: string;
+    readonly values?: readonly string[];
+    readonly heading?: boolean;
+    readonly description?: string;
+}
+export interface RunReadModelFailureSummary {
+    readonly kind: string;
+    readonly summary: string;
+    readonly detail?: string | null;
+    readonly retryable?: boolean | null;
+}
+export interface RunReadModelDetails {
+    readonly run: RunRecord;
+    readonly projection: RunJournalProjection;
+    readonly pendingInbox: readonly UnifiedInboxRequest[];
+    readonly inboxCounts: RunReadModelInboxCounts;
+    readonly sourceTask?: TaskRecord | null;
+    readonly sessionEntries?: readonly RunSessionCustomEntry[];
+    readonly failures: readonly RunReadModelFailureSummary[];
+    readonly logs: readonly string[];
+}
+export interface RunReadModelInspectResult {
+    readonly details: RunReadModelDetails;
+    readonly classification: RunReadModelRunClassification;
+    readonly rows: readonly RunReadModelInspectRow[];
+}
+/**
+ * Multi-method run read-model service capability.
+ *
+ * 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 getStats: (input: RunReadModelStatsInput) => Promise<RunReadModelStats>;
+    readonly getInspectRows: (input: RunReadModelInspectRowsInput) => Promise<readonly RunReadModelInspectRow[]>;
+    readonly isRuntimeActiveStatus: RunRuntimeActivePredicate;
+    readonly classifyRun: (run: RunRecord) => RunReadModelRunClassification;
+    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";
+/**
+ * Branded run read-model capability id. `defineCapability(RUN_READ_MODEL)`
+ * (provider and consumers independently) resolves to a `RunReadModelService`.
+ */
+export declare const RUN_READ_MODEL: CapabilityId<RunReadModelService>;

package/dist/src/run-read-model.js

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

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

@@ -0,0 +1,45 @@
+import type { RunJournalProjection } from "./run-journal";
+import type { RigRunTimelineEntry } from "./run-timeline";
+export type UnifiedInboxRequest = {
+    readonly requestId: string;
+    readonly kind: "approval" | "input";
+    readonly title: string;
+    readonly body?: string | null;
+    readonly options?: readonly string[];
+    readonly requestedAt: string | null;
+    readonly source: "run";
+};
+/** Unified operator-facing run record shared by CLI, cockpit, relay, and client projection logic. */
+export interface RunRecord {
+    readonly runId: string;
+    readonly taskId: string | null;
+    readonly title: string;
+    /** RunStatus from the folded journal, or a liveness-derived fallback. */
+    readonly status: string;
+    readonly source: "local" | "remote";
+    /** True when the run is currently discoverable (registry heartbeat or local host). */
+    readonly live: boolean;
+    readonly stale: boolean;
+    readonly startedAt: string | null;
+    readonly updatedAt: string | null;
+    readonly completedAt: string | null;
+    readonly joinLink: string | null;
+    readonly webLink: string | null;
+    readonly relayUrl: string | null;
+    readonly sessionPath: string | null;
+    readonly prUrl: string | null;
+    readonly worktreePath: string | null;
+    readonly pendingApprovals: number;
+    readonly pendingInputs: number;
+    readonly steeringCount: number;
+    readonly stallCount: number;
+    readonly errorSummary?: string | null;
+    /** Timeline entries folded from the same OMP session custom entries as the journal. */
+    readonly timeline: RigRunTimelineEntry[];
+    /** Pending rig.run.* approvals/inputs only; rig.workflow.inbox.* is intentionally dead. */
+    readonly inbox: UnifiedInboxRequest[];
+    /** Live collab cwd when present in registry/discovery. */
+    readonly collabCwd: string | null;
+    /** The full folded journal (empty projection when no journal was readable). */
+    readonly projection: RunJournalProjection;
+}

package/dist/src/run-record.js

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

package/dist/src/run-registry-backbone.d.ts

@@ -0,0 +1,56 @@
+import type { CapabilityId } from "./capability-id";
+import type { RigWorkflowOwner } from "./workflow-journal";
+import type { RunRecord } from "./run-record";
+import type { RunStatus } from "./runtime";
+/**
+ * cap:run-registry-backbone — transport-owned relay/registry room publication.
+ *
+ * The transport plugin owns the concrete @rig/relay-registry client. Run workers
+ * publish journal-derived projections through this structural seam so the worker
+ * lifecycle engine does not import the relay-registry implementation package.
+ */
+export declare const RUN_REGISTRY_BACKBONE_CAPABILITY_ID = "transport.run-registry-backbone";
+export type RunRegistryOwner = RigWorkflowOwner;
+export type RunRegistryStatus = RunStatus | "starting" | "waiting-input";
+export type RunRegistryRunProjection = Pick<RunRecord, "runId" | "taskId" | "title" | "status" | "source" | "startedAt" | "updatedAt" | "completedAt" | "joinLink" | "webLink" | "relayUrl" | "sessionPath" | "prUrl" | "worktreePath" | "pendingApprovals" | "pendingInputs" | "steeringCount" | "stallCount" | "errorSummary" | "timeline" | "collabCwd"> & {
+    readonly cwd?: string | null;
+    readonly dispatchHandle?: string | null;
+};
+export interface RunRegistryRegisterRoomInput {
+    readonly roomId: string;
+    readonly owner: RunRegistryOwner;
+    readonly repo: string;
+    readonly title: string;
+    readonly status: RunRegistryStatus;
+    readonly joinLink: string;
+    readonly webLink: string;
+    readonly relayUrl: string;
+    readonly startedAt: string;
+    readonly cwd?: string;
+    readonly sessionPath?: string;
+    readonly pid?: number;
+    readonly projection?: RunRegistryRunProjection;
+}
+export interface RunRegistryClient {
+    readonly registerRoom: (room: RunRegistryRegisterRoomInput) => Promise<unknown>;
+    readonly heartbeatRoom: (roomId: string, status: RunRegistryStatus, projection?: RunRegistryRunProjection) => Promise<unknown>;
+    readonly removeRoom: (roomId: string) => Promise<boolean>;
+}
+export interface RunWorkerProjectionConnection {
+    readonly ready: Promise<void>;
+    push(projection: RunRegistryRunProjection): void;
+    close(): void;
+}
+export interface RunRegistryBackboneService {
+    readonly createRegistryClient: (options: {
+        readonly baseUrl: string;
+        readonly namespaceKey: string;
+    }) => RunRegistryClient;
+    readonly connectWorkerProjection: (options: {
+        readonly baseUrl: string;
+        readonly namespaceKey: string;
+        readonly runId: string;
+    }) => RunWorkerProjectionConnection;
+    readonly coerceRegistryStatus: (value: unknown, fallback: RunRegistryStatus) => RunRegistryStatus;
+}
+export declare const RUN_REGISTRY_BACKBONE: CapabilityId<RunRegistryBackboneService>;

package/dist/src/run-registry-backbone.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/run-registry-backbone.ts
+var RUN_REGISTRY_BACKBONE_CAPABILITY_ID = "transport.run-registry-backbone";
+var RUN_REGISTRY_BACKBONE = makeCapabilityId(RUN_REGISTRY_BACKBONE_CAPABILITY_ID);
+export {
+  RUN_REGISTRY_BACKBONE_CAPABILITY_ID,
+  RUN_REGISTRY_BACKBONE
+};

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

@@ -0,0 +1,154 @@
+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";
+export declare const RIG_RUN_RECORD_PATCH = "rig.run.record-patch";
+export declare const RIG_RUN_TIMELINE_ENTRY = "rig.run.timeline-entry";
+export declare const RIG_RUN_LOG_ENTRY = "rig.run.log-entry";
+export declare const RIG_RUN_APPROVAL_REQUESTED = "rig.run.approval-requested";
+export declare const RIG_RUN_APPROVAL_RESOLVED = "rig.run.approval-resolved";
+export declare const RIG_RUN_INPUT_REQUESTED = "rig.run.input-requested";
+export declare const RIG_RUN_INPUT_RESOLVED = "rig.run.input-resolved";
+export declare const RIG_RUN_STEERING = "rig.run.steering";
+export declare const RIG_RUN_ADOPTED = "rig.run.adopted";
+export declare const RIG_RUN_STALL_DETECTED = "rig.run.stall-detected";
+export declare const RIG_RUN_CLOSEOUT_PHASE = "rig.run.closeout-phase";
+export declare const RIG_RUN_PIPELINE_RESOLVED = "rig.run.pipeline-resolved";
+export declare const RIG_RUN_STAGE_OUTCOME = "rig.run.stage-outcome";
+export declare const RIG_STOP_SENTINEL = "<<RIG_STOP";
+export declare const RIG_STOP_SENTINEL_END = ">>";
+export declare const RIG_PAUSE_SENTINEL = "<<RIG_PAUSE";
+export declare const RIG_RESUME_SENTINEL = "<<RIG_RESUME";
+export declare const RIG_CONTROL_SENTINEL_END = ">>";
+export type RunInboxResolutionSentinel = {
+    kind: "approval";
+    requestId: string;
+    decision: "approve" | "reject";
+    note?: string | null;
+    requestedBy: string | null;
+} | {
+    kind: "input";
+    requestId: string;
+    answers: Record<string, string>;
+    requestedBy: string | null;
+};
+export declare const RIG_INBOX_RESOLUTION_SENTINEL = "<<RIG_INBOX_RESOLUTION";
+export type RunInboxResolutionInit = {
+    kind: "approval";
+    requestId: string;
+    decision: "approve" | "reject";
+    note?: string | null;
+} | {
+    kind: "input";
+    requestId: string;
+    answers: Record<string, string>;
+};
+export declare const CUSTOM_TYPE_FOR: {
+    readonly "status-changed": "rig.run.status-changed";
+    readonly "record-patch": "rig.run.record-patch";
+    readonly "timeline-entry": "rig.run.timeline-entry";
+    readonly "log-entry": "rig.run.log-entry";
+    readonly "approval-requested": "rig.run.approval-requested";
+    readonly "approval-resolved": "rig.run.approval-resolved";
+    readonly "input-requested": "rig.run.input-requested";
+    readonly "input-resolved": "rig.run.input-resolved";
+    readonly steering: "rig.run.steering";
+    readonly adopted: "rig.run.adopted";
+    readonly "stall-detected": "rig.run.stall-detected";
+    readonly "closeout-phase": "rig.run.closeout-phase";
+    readonly "pipeline-resolved": "rig.run.pipeline-resolved";
+    readonly "stage-outcome": "rig.run.stage-outcome";
+};
+export type RunSessionCustomType = (typeof CUSTOM_TYPE_FOR)[RunJournalEvent["type"]];
+export declare const TYPE_FOR_CUSTOM: Readonly<Record<RunSessionCustomType, RunJournalEvent["type"]>>;
+export type RunSessionCustomEntry = {
+    type: string;
+    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 {};

package/dist/src/run-session-journal.js

@@ -0,0 +1,87 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/run-session-journal.ts
+var RIG_RUN_STATUS_CHANGED = "rig.run.status-changed";
+var RIG_RUN_RECORD_PATCH = "rig.run.record-patch";
+var RIG_RUN_TIMELINE_ENTRY = "rig.run.timeline-entry";
+var RIG_RUN_LOG_ENTRY = "rig.run.log-entry";
+var RIG_RUN_APPROVAL_REQUESTED = "rig.run.approval-requested";
+var RIG_RUN_APPROVAL_RESOLVED = "rig.run.approval-resolved";
+var RIG_RUN_INPUT_REQUESTED = "rig.run.input-requested";
+var RIG_RUN_INPUT_RESOLVED = "rig.run.input-resolved";
+var RIG_RUN_STEERING = "rig.run.steering";
+var RIG_RUN_ADOPTED = "rig.run.adopted";
+var RIG_RUN_STALL_DETECTED = "rig.run.stall-detected";
+var RIG_RUN_CLOSEOUT_PHASE = "rig.run.closeout-phase";
+var RIG_RUN_PIPELINE_RESOLVED = "rig.run.pipeline-resolved";
+var RIG_RUN_STAGE_OUTCOME = "rig.run.stage-outcome";
+var RIG_STOP_SENTINEL = "<<RIG_STOP";
+var RIG_STOP_SENTINEL_END = ">>";
+var RIG_PAUSE_SENTINEL = "<<RIG_PAUSE";
+var RIG_RESUME_SENTINEL = "<<RIG_RESUME";
+var RIG_CONTROL_SENTINEL_END = ">>";
+var RIG_INBOX_RESOLUTION_SENTINEL = "<<RIG_INBOX_RESOLUTION";
+var CUSTOM_TYPE_FOR = {
+  "status-changed": RIG_RUN_STATUS_CHANGED,
+  "record-patch": RIG_RUN_RECORD_PATCH,
+  "timeline-entry": RIG_RUN_TIMELINE_ENTRY,
+  "log-entry": RIG_RUN_LOG_ENTRY,
+  "approval-requested": RIG_RUN_APPROVAL_REQUESTED,
+  "approval-resolved": RIG_RUN_APPROVAL_RESOLVED,
+  "input-requested": RIG_RUN_INPUT_REQUESTED,
+  "input-resolved": RIG_RUN_INPUT_RESOLVED,
+  steering: RIG_RUN_STEERING,
+  adopted: RIG_RUN_ADOPTED,
+  "stall-detected": RIG_RUN_STALL_DETECTED,
+  "closeout-phase": RIG_RUN_CLOSEOUT_PHASE,
+  "pipeline-resolved": RIG_RUN_PIPELINE_RESOLVED,
+  "stage-outcome": RIG_RUN_STAGE_OUTCOME
+};
+var TYPE_FOR_CUSTOM = {
+  [RIG_RUN_STATUS_CHANGED]: "status-changed",
+  [RIG_RUN_RECORD_PATCH]: "record-patch",
+  [RIG_RUN_TIMELINE_ENTRY]: "timeline-entry",
+  [RIG_RUN_LOG_ENTRY]: "log-entry",
+  [RIG_RUN_APPROVAL_REQUESTED]: "approval-requested",
+  [RIG_RUN_APPROVAL_RESOLVED]: "approval-resolved",
+  [RIG_RUN_INPUT_REQUESTED]: "input-requested",
+  [RIG_RUN_INPUT_RESOLVED]: "input-resolved",
+  [RIG_RUN_STEERING]: "steering",
+  [RIG_RUN_ADOPTED]: "adopted",
+  [RIG_RUN_STALL_DETECTED]: "stall-detected",
+  [RIG_RUN_CLOSEOUT_PHASE]: "closeout-phase",
+  [RIG_RUN_PIPELINE_RESOLVED]: "pipeline-resolved",
+  [RIG_RUN_STAGE_OUTCOME]: "stage-outcome"
+};
+var RUN_SESSION_JOURNAL_CAPABILITY_ID = "rig.runs.session-journal";
+var RUN_SESSION_JOURNAL = makeCapabilityId(RUN_SESSION_JOURNAL_CAPABILITY_ID);
+export {
+  TYPE_FOR_CUSTOM,
+  RUN_SESSION_JOURNAL_CAPABILITY_ID,
+  RUN_SESSION_JOURNAL,
+  RIG_STOP_SENTINEL_END,
+  RIG_STOP_SENTINEL,
+  RIG_RUN_TIMELINE_ENTRY,
+  RIG_RUN_STEERING,
+  RIG_RUN_STATUS_CHANGED,
+  RIG_RUN_STALL_DETECTED,
+  RIG_RUN_STAGE_OUTCOME,
+  RIG_RUN_RECORD_PATCH,
+  RIG_RUN_PIPELINE_RESOLVED,
+  RIG_RUN_LOG_ENTRY,
+  RIG_RUN_INPUT_RESOLVED,
+  RIG_RUN_INPUT_REQUESTED,
+  RIG_RUN_CLOSEOUT_PHASE,
+  RIG_RUN_APPROVAL_RESOLVED,
+  RIG_RUN_APPROVAL_REQUESTED,
+  RIG_RUN_ADOPTED,
+  RIG_RESUME_SENTINEL,
+  RIG_PAUSE_SENTINEL,
+  RIG_INBOX_RESOLUTION_SENTINEL,
+  RIG_CONTROL_SENTINEL_END,
+  CUSTOM_TYPE_FOR
+};

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

@@ -0,0 +1,10 @@
+/** Operator-facing active-run classification.
+ *
+ * The canonical run-journal vocabulary intentionally keeps `needs-attention` as
+ * non-terminal so resume/steer/closeout state machines can still act on it.
+ * OpenTUI/task projections need a narrower meaning: only runs that are actively
+ * occupying a task slot should render as the task's active run. Legacy/closeout
+ * statuses from older authority files are treated conservatively as inactive so
+ * merged/closed runs do not pin task rows forever.
+ */
+export declare const OPERATOR_INACTIVE_RUN_STATUSES: ReadonlySet<string>;

package/dist/src/run-status.js

@@ -0,0 +1,27 @@
+// @bun
+// packages/contracts/src/run-status.ts
+var OPERATOR_INACTIVE_RUN_STATUSES = new Set([
+  "completed",
+  "complete",
+  "done",
+  "success",
+  "succeeded",
+  "passed",
+  "failed",
+  "failure",
+  "error",
+  "errored",
+  "stopped",
+  "cancelled",
+  "canceled",
+  "aborted",
+  "abort",
+  "merged",
+  "closed",
+  "skipped",
+  "needs-attention",
+  "needs_attention"
+]);
+export {
+  OPERATOR_INACTIVE_RUN_STATUSES
+};

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

@@ -0,0 +1,7 @@
+export type RigRunTimelineEntry = {
+    at: string | null;
+    type: string;
+    stage?: string | null;
+    status?: string | null;
+    detail?: string | null;
+};

package/dist/src/run-timeline.js

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

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

@@ -0,0 +1,10 @@
+import type { CapabilityId } from "./capability-id";
+export type RuntimeSecretKey = "ANTHROPIC_API_KEY" | "OPENAI_API_KEY" | "OPENROUTER_API_KEY" | "AI_REVIEW_MODE" | "AI_REVIEW_PROVIDER" | "GREPTILE_API_BASE" | "GREPTILE_REMOTE" | "GREPTILE_REPOSITORY" | "GREPTILE_CONTEXT_BRANCH" | "GREPTILE_DEFAULT_BRANCH" | "GREPTILE_API_KEY" | "GREPTILE_GITHUB_TOKEN" | "GREPTILE_POLL_ATTEMPTS" | "GREPTILE_POLL_INTERVAL_MS" | "GH_TOKEN" | "GITHUB_TOKEN" | "GITHUB_SSH_KEY" | "AWS_ACCESS_KEY_ID" | "AWS_SECRET_ACCESS_KEY" | "AWS_REGION" | "LINEAR_API_KEY" | "LINEAR_WEBHOOK_SECRET";
+export type RuntimeSecrets = Partial<Record<RuntimeSecretKey, string>>;
+export interface RuntimeSecretsService {
+    resolveRuntimeSecrets(env: Record<string, string | undefined>, baked?: RuntimeSecrets): RuntimeSecrets;
+    loadDotEnvSecrets(projectRoot: string, env?: Record<string, string | undefined>): RuntimeSecrets;
+    secretDefinesFromEnv(env?: Record<string, string | undefined>, projectRoot?: string): Record<string, string>;
+}
+export declare const RUNTIME_SECRETS_CAPABILITY_ID = "provider.runtime-secrets";
+export declare const RUNTIME_SECRETS: CapabilityId<RuntimeSecretsService>;

package/dist/src/runtime-secrets.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/runtime-secrets.ts
+var RUNTIME_SECRETS_CAPABILITY_ID = "provider.runtime-secrets";
+var RUNTIME_SECRETS = makeCapabilityId(RUNTIME_SECRETS_CAPABILITY_ID);
+export {
+  RUNTIME_SECRETS_CAPABILITY_ID,
+  RUNTIME_SECRETS
+};