@h-rig/contracts 0.0.6-alpha.175 → 0.0.6-alpha.177

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

@@ -12,7 +12,9 @@ import type { CapabilityId } from "./capability-id";
 import type { JournalCapability } from "./kernel";
 import type { RigAutomationConfig, StrictPrGreptileApiOptions } from "./control-plane-types";
 import type { RunCloseoutPhase, RunCloseoutPhaseOutcome } from "./run-journal";
-import type { TaskSourceUpdateResult } from "./task-source";
+import type { RunJournal, RunJournalSessionManager } from "./run-session-journal";
+import type { TaskSourceUpdateResult, TaskTerminalStateInput } from "./task-source";
+import type { TaskReopenSummary } from "./task-data";
 /** 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 its task validation runner under. */
@@ -21,8 +23,14 @@ export declare const TASK_VALIDATION_CAPABILITY_ID = "default-lifecycle.task-val
 export declare const COMPLETION_VERIFICATION_CAPABILITY_ID = "default-lifecycle.completion-verification";
 /** Capability id the bundle registers its run-worker closeout driver under. */
 export declare const RUN_CLOSEOUT_CAPABILITY_ID = "default-lifecycle.run-closeout";
+/** Capability id @rig/run-worker registers for writable run-session journal binding. */
+export declare const RUN_SESSION_JOURNAL_WRITER_CAPABILITY_ID = "run-worker.run-session-journal-writer";
 /** Capability id the bundle registers its lifecycle-owned task-source reflection under. */
 export declare const TASK_SOURCE_REFLECTION_CAPABILITY_ID = "default-lifecycle.task-source-reflection";
+/** Capability id the bundle registers its lifecycle-owned task terminal-state policy under. */
+export declare const TASK_TERMINAL_STATE_CAPABILITY_ID = "default-lifecycle.task-terminal-state";
+/** Capability id the bundle registers its lifecycle-owned task reopen policy under. */
+export declare const TASK_REOPEN_CAPABILITY_ID = "default-lifecycle.task-reopen";
 /** Capability id the bundle registers its agent-facing git helper surface under. */
 export declare const LIFECYCLE_GIT_AGENT_CAPABILITY_ID = "default-lifecycle.git-agent";
 export interface TaskVerifyCapabilityInput {
@@ -114,6 +122,9 @@ export type RunTaskSourceLifecycleRun = {
 export type RunTaskSourceLifecycleOptions = {
     errorText?: string | null;
 };
+export type RunTaskSourceStoppedOptions = RunTaskSourceLifecycleOptions & {
+    reason?: string | null;
+};
 export type TaskSourceReflectionInput = {
     readonly projectRoot: string;
     readonly taskId: string;
@@ -138,14 +149,41 @@ export type TaskSourceMergedPrReflectionInput = {
     readonly sourceTask?: unknown;
 };
 export type TaskSourceReflectionResult = TaskSourceUpdateResult & {
-    readonly status?: unknown;
+    /** Lifecycle-owned status projected into the source update request. */
+    readonly projectedStatus?: RunTaskSourceLifecycleStatus | null;
 };
 export interface TaskSourceReflectionService {
     reflectTaskSourceStatus(input: TaskSourceReflectionInput): Promise<TaskSourceReflectionResult | null>;
+    reflectRunStarted(projectRoot: string, run: RunTaskSourceLifecycleRun, options?: RunTaskSourceLifecycleOptions): Promise<TaskSourceReflectionResult | null>;
+    reflectRunStopped(projectRoot: string, run: RunTaskSourceLifecycleRun, options?: RunTaskSourceStoppedOptions): Promise<TaskSourceReflectionResult | null>;
     updateRunTaskSourceLifecycle(projectRoot: string, run: RunTaskSourceLifecycleRun, status: RunTaskSourceLifecycleStatus, summary: string, options?: RunTaskSourceLifecycleOptions): Promise<TaskSourceReflectionResult | null>;
     closeMergedPr(input: TaskSourceMergedPrReflectionInput): Promise<TaskSourceReflectionResult | null>;
 }
 export declare const TASK_SOURCE_REFLECTION: CapabilityId<TaskSourceReflectionService>;
+export interface TaskTerminalStateService {
+    isTaskTerminal(input: TaskTerminalStateInput): Promise<boolean>;
+}
+export declare const TASK_TERMINAL_STATE: CapabilityId<TaskTerminalStateService>;
+export type TaskReopenInput = {
+    readonly projectRoot: string;
+    readonly all: boolean;
+    readonly taskId?: string;
+    readonly dryRun?: boolean;
+};
+/** Lifecycle-owned reopen policy for legacy `task reopen`; source plugin only performs config IO. */
+export interface TaskReopenService {
+    reopenTasks(input: TaskReopenInput): TaskReopenSummary;
+}
+export declare const TASK_REOPEN: CapabilityId<TaskReopenService>;
+export interface RunSessionJournalWriterService {
+    createRunJournal(sessionManager: RunJournalSessionManager, runId: string): Promise<RunJournal | null>;
+}
+/**
+ * Writable run-session journal factory. Kept separate from RUN_SESSION_JOURNAL so
+ * the read-model plugin remains projection/read-only and append ownership lives
+ * with the run-worker lifecycle package.
+ */
+export declare const RUN_SESSION_JOURNAL_WRITER: CapabilityId<RunSessionJournalWriterService>;
 export type RunCloseoutResultStatus = "merged" | "opened" | "skipped" | "needs-attention";
 export type RunCloseoutResult = {
     status: RunCloseoutResultStatus;

package/dist/src/lifecycle-capabilities.js

@@ -9,21 +9,33 @@ var TASK_VERIFY_CAPABILITY_ID = "default-lifecycle.task-verify";
 var TASK_VALIDATION_CAPABILITY_ID = "default-lifecycle.task-validation";
 var COMPLETION_VERIFICATION_CAPABILITY_ID = "default-lifecycle.completion-verification";
 var RUN_CLOSEOUT_CAPABILITY_ID = "default-lifecycle.run-closeout";
+var RUN_SESSION_JOURNAL_WRITER_CAPABILITY_ID = "run-worker.run-session-journal-writer";
 var TASK_SOURCE_REFLECTION_CAPABILITY_ID = "default-lifecycle.task-source-reflection";
+var TASK_TERMINAL_STATE_CAPABILITY_ID = "default-lifecycle.task-terminal-state";
+var TASK_REOPEN_CAPABILITY_ID = "default-lifecycle.task-reopen";
 var LIFECYCLE_GIT_AGENT_CAPABILITY_ID = "default-lifecycle.git-agent";
 var TASK_VERIFY_CAPABILITY = makeCapabilityId(TASK_VERIFY_CAPABILITY_ID);
 var TASK_VALIDATION_CAPABILITY = makeCapabilityId(TASK_VALIDATION_CAPABILITY_ID);
 var COMPLETION_VERIFICATION_CAPABILITY = makeCapabilityId(COMPLETION_VERIFICATION_CAPABILITY_ID);
 var LIFECYCLE_GIT_AGENT = makeCapabilityId(LIFECYCLE_GIT_AGENT_CAPABILITY_ID);
 var TASK_SOURCE_REFLECTION = makeCapabilityId(TASK_SOURCE_REFLECTION_CAPABILITY_ID);
+var TASK_TERMINAL_STATE = makeCapabilityId(TASK_TERMINAL_STATE_CAPABILITY_ID);
+var TASK_REOPEN = makeCapabilityId(TASK_REOPEN_CAPABILITY_ID);
+var RUN_SESSION_JOURNAL_WRITER = makeCapabilityId(RUN_SESSION_JOURNAL_WRITER_CAPABILITY_ID);
 var RUN_CLOSEOUT_CAPABILITY = makeCapabilityId(RUN_CLOSEOUT_CAPABILITY_ID);
 export {
   TASK_VERIFY_CAPABILITY_ID,
   TASK_VERIFY_CAPABILITY,
   TASK_VALIDATION_CAPABILITY_ID,
   TASK_VALIDATION_CAPABILITY,
+  TASK_TERMINAL_STATE_CAPABILITY_ID,
+  TASK_TERMINAL_STATE,
   TASK_SOURCE_REFLECTION_CAPABILITY_ID,
   TASK_SOURCE_REFLECTION,
+  TASK_REOPEN_CAPABILITY_ID,
+  TASK_REOPEN,
+  RUN_SESSION_JOURNAL_WRITER_CAPABILITY_ID,
+  RUN_SESSION_JOURNAL_WRITER,
   RUN_CLOSEOUT_CAPABILITY_ID,
   RUN_CLOSEOUT_CAPABILITY,
   LIFECYCLE_GIT_AGENT_CAPABILITY_ID,

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

@@ -7,9 +7,11 @@
  * - `RepoOperationsService` under {@link REPO_OPERATIONS_CAPABILITY_ID} for
  *   task repo pinning, baseline reset, and project-main pre-run sync,
  * - `RepoNativeGitService` under {@link REPO_NATIVE_GIT_CAPABILITY_ID} for
- *   repo-native git command wrappers, and
+ *   repo-native git command wrappers,
  * - `RepoGitBinaryService` under {@link REPO_GIT_BINARY_CAPABILITY_ID} for
- *   the repo-owned rig-git helper binary.
+ *   the repo-owned rig-git helper binary, and
+ * - `RepoTrackerPersistenceService` under {@link REPO_TRACKER_PERSISTENCE_CAPABILITY_ID}
+ *   for mechanical tracker snapshot reads and owner-supplied mutation persistence.
  *
  * This module carries no behaviour and imports only pure sibling types, so
  * consumers resolve typed ids through `@rig/core` without importing the provider
@@ -19,6 +21,8 @@ import type { CapabilityId } from "./capability-id";
 import type { RepoSourceRegistration } from "./plugin";
 import type { GitWorkingTreeFileChange } from "./git";
 import type { NativeToolchainBinaryArtifact, NativeToolchainTarget } from "./native-toolchain";
+import type { SyncedTrackerSnapshot, ReadSyncedTrackerOptions } from "./task-data";
+import type { CanonicalTaskLifecycleStatus, TaskStateMetadata } from "./task-state-metadata";
 export type ManagedRepoId = string;
 export type ManagedRepoAlias = string;
 export type ManagedRepoHealth = "missing" | "ready" | "stale" | "misconfigured";
@@ -101,18 +105,90 @@ export type RepoNativeGitTreeCommitUpdate = {
     readonly path: string;
     readonly content: string;
     readonly executable?: boolean;
+} | {
+    readonly path: string;
+    readonly sourceFilePath: string;
+    readonly executable?: boolean;
 } | {
     readonly path: string;
     readonly delete: true;
 };
+export type RepoNativeGitPendingFile = {
+    readonly path: string;
+    readonly status: string;
+};
+export type RepoNativeGitCommandResult = {
+    readonly exitCode: number;
+    readonly stdout: string;
+    readonly stderr: string;
+};
+export type RepoNativeGitRunOptions = {
+    /** Project root used to derive runtime git environment/secrets when different from repoPath. */
+    readonly projectRoot?: string;
+    readonly input?: string;
+    readonly env?: Readonly<Record<string, string | undefined>>;
+};
+export type RepoNativeGitCommitOptions = {
+    readonly message: string;
+    readonly allowEmpty?: boolean;
+    /** Explicit repo-relative paths to stage. Provider may use pathspec files to avoid argv limits. */
+    readonly paths?: readonly string[];
+    /** Stage all repo changes except excludes when no explicit paths are provided. */
+    readonly stageAll?: boolean;
+    readonly excludePathspecs?: readonly string[];
+    readonly projectRoot?: string;
+};
+export type RepoNativeGitCommitResult = {
+    readonly committed: boolean;
+    readonly status: string;
+    readonly stagedChangeCount: number;
+    readonly stagedPathCount: number;
+};
+export type RepoNativeGitCheckoutOptions = {
+    readonly createIfMissing?: boolean;
+    readonly resetIfDetachedExisting?: boolean;
+    readonly projectRoot?: string;
+};
+export type RepoNativeGitPushBranchOptions = {
+    readonly remote?: string;
+    readonly setUpstream?: boolean;
+    readonly forceWithLease?: boolean;
+    readonly projectRoot?: string;
+};
+export type RepoNativeGitRemoteDispatchCheckoutInput = {
+    /**
+     * Shell expression for the checkout path, e.g. "$CHECKOUT" or "$HOME/.rig/checkouts/repo".
+     * The caller owns quoting this path expression before passing it across the seam.
+     */
+    readonly checkoutExpression: string;
+    /** Shell expression that points at the materialized github-auth.json temp file. */
+    readonly authStateFileExpression: string;
+    /** Shell expression that points at a temp executable credential-helper file. */
+    readonly credentialHelperFileExpression: string;
+    readonly originUrl?: string | null;
+    readonly operatorHead: string;
+};
 /**
  * Repo-owned native git command seam. Implementations live in `@rig/repos-plugin`;
  * native-toolchain only builds/materializes binaries and does not own repo or git
- * workflow semantics.
+ * workflow semantics. Lifecycle and other consumers keep policy decisions but
+ * delegate checkout/stage/commit/fetch/push mechanics through this capability.
  */
 export interface RepoNativeGitService {
+    run(repoPath: string, args: readonly string[], options?: RepoNativeGitRunOptions): RepoNativeGitCommandResult;
+    branchName(repoPath: string, projectRoot?: string): string | null;
+    headOid(repoPath: string, projectRoot?: string): string | null;
+    githubOriginSlug(repoPath: string, projectRoot?: string): string | null;
+    changeCount(repoPath: string, projectRoot?: string): number | null;
+    pendingFiles(repoPath: string, projectRoot?: string): readonly RepoNativeGitPendingFile[] | null;
+    fileHasChanges(repoPath: string, filePath: string, projectRoot?: string): boolean | null;
+    checkoutBranch(repoPath: string, branch: string, options?: RepoNativeGitCheckoutOptions): RepoNativeGitCommandResult;
+    commit(repoPath: string, options: RepoNativeGitCommitOptions): RepoNativeGitCommitResult;
+    pushBranch(repoPath: string, branch: string, options?: RepoNativeGitPushBranchOptions): RepoNativeGitCommandResult;
+    remoteDispatchCheckoutShell(input: RepoNativeGitRemoteDispatchCheckoutInput): readonly string[];
     fetchRef(repoPath: string, remote: string, branch: string): string;
     readBlobAtRef(repoPath: string, ref: string, path: string): string;
+    readBlobBytesAtRef(repoPath: string, ref: string, path: string): Uint8Array;
     writeTreeCommit(repoPath: string, baseRef: string, updates: readonly RepoNativeGitTreeCommitUpdate[], message: string): string;
     pushRefWithLease(repoPath: string, localOid: string, remoteRef: string, expectedOldOid: string, remote?: string): string;
 }
@@ -220,11 +296,35 @@ export interface RepoOperationsService {
     repoVerify(projectRoot: string, taskId?: string): boolean;
     repoDiscover(projectRoot: string, taskId?: string): RepoPins;
     repoBaseline(projectRoot: string, refresh?: boolean): RepoPins;
+    recordTaskRepoCommits(projectRoot: string, taskId: string): void;
     resetBaseline(projectRoot: string, keepTaskStatus: boolean): void;
     ensureProjectMainFreshBeforeRun(options: ProjectMainPreRunSyncOptions): Promise<ProjectMainPreRunSyncResult>;
 }
 export declare const REPO_OPERATIONS_CAPABILITY_ID = "repos.operations";
 export declare const REPO_OPERATIONS_CAPABILITY: CapabilityId<RepoOperationsService>;
+export type RepoTrackerPersistenceMutationResult = {
+    readonly outcome: "applied" | "noop";
+    readonly snapshot: SyncedTrackerSnapshot;
+    readonly commitOid: string | null;
+};
+export type RepoTrackerPersistenceMutation = {
+    readonly taskId: string;
+    readonly lifecycleStatus: CanonicalTaskLifecycleStatus;
+    readonly metadata?: TaskStateMetadata | null;
+    /** Mechanical owner-supplied compare-and-set precondition. */
+    readonly expectedLifecycleStatus?: CanonicalTaskLifecycleStatus | readonly CanonicalTaskLifecycleStatus[];
+};
+export type RepoTrackerPersistenceMutationsInput = {
+    readonly projectRoot: string;
+    readonly mutations: readonly RepoTrackerPersistenceMutation[];
+    readonly reason?: string;
+};
+export interface RepoTrackerPersistenceService {
+    readSnapshot(projectRoot: string, options?: ReadSyncedTrackerOptions): SyncedTrackerSnapshot;
+    persistMutations(input: RepoTrackerPersistenceMutationsInput): RepoTrackerPersistenceMutationResult;
+}
+export declare const REPO_TRACKER_PERSISTENCE_CAPABILITY_ID = "repos.tracker-persistence";
+export declare const REPO_TRACKER_PERSISTENCE: CapabilityId<RepoTrackerPersistenceService>;
 /** The capability `run` shape the plugin registers: a (lazy) service factory. */
 export type ManagedRepoServiceCapabilityRun = () => ManagedRepoService | Promise<ManagedRepoService>;
 /** Capability id the managed-repo service plugin registers its factory under. */

package/dist/src/managed-repos.js

@@ -15,9 +15,13 @@ var REPO_CHANGE_SET_CAPABILITY_ID = "repos.change-set";
 var REPO_CHANGE_SET = makeCapabilityId(REPO_CHANGE_SET_CAPABILITY_ID);
 var REPO_OPERATIONS_CAPABILITY_ID = "repos.operations";
 var REPO_OPERATIONS_CAPABILITY = makeCapabilityId(REPO_OPERATIONS_CAPABILITY_ID);
+var REPO_TRACKER_PERSISTENCE_CAPABILITY_ID = "repos.tracker-persistence";
+var REPO_TRACKER_PERSISTENCE = makeCapabilityId(REPO_TRACKER_PERSISTENCE_CAPABILITY_ID);
 var MANAGED_REPO_SERVICE_CAPABILITY_ID = "managed-repos.service";
 var MANAGED_REPO_SERVICE_CAPABILITY = makeCapabilityId(MANAGED_REPO_SERVICE_CAPABILITY_ID);
 export {
+  REPO_TRACKER_PERSISTENCE_CAPABILITY_ID,
+  REPO_TRACKER_PERSISTENCE,
   REPO_OPERATIONS_CAPABILITY_ID,
   REPO_OPERATIONS_CAPABILITY,
   REPO_NATIVE_GIT_CAPABILITY_ID,

package/dist/src/model.d.ts

@@ -1,77 +1,13 @@
 import { Schema } from "effect";
-import { ProviderKind } from "./orchestration";
-export declare const CODEX_REASONING_EFFORT_OPTIONS: readonly ["xhigh", "high", "medium", "low"];
-export type CodexReasoningEffort = (typeof CODEX_REASONING_EFFORT_OPTIONS)[number];
-export declare const CodexModelOptions: Schema.Struct<{
-    readonly reasoningEffort: Schema.optional<Schema.Literals<readonly ["xhigh", "high", "medium", "low"]>>;
-    readonly fastMode: Schema.optional<Schema.Boolean>;
-}>;
-export type CodexModelOptions = typeof CodexModelOptions.Type;
-export declare const ClaudeModelOptions: Schema.Struct<{}>;
-export type ClaudeModelOptions = typeof ClaudeModelOptions.Type;
-export declare const ProviderModelOptions: Schema.Struct<{
-    readonly codex: Schema.optional<Schema.Struct<{
-        readonly reasoningEffort: Schema.optional<Schema.Literals<readonly ["xhigh", "high", "medium", "low"]>>;
-        readonly fastMode: Schema.optional<Schema.Boolean>;
-    }>>;
-    readonly claude: Schema.optional<Schema.Struct<{}>>;
-}>;
+/**
+ * Provider model vocabulary shared by the transport contract.
+ *
+ * Concrete model catalogs, aliases, defaults, and reasoning-effort policy are
+ * runtime/provider ownership concerns and live in `@rig/provider-plugin/model`.
+ * The contract layer intentionally accepts opaque model slugs/options so new
+ * provider packages can evolve without changing the floor package.
+ */
+export declare const ModelSlug: Schema.String;
+export type ModelSlug = typeof ModelSlug.Type;
+export declare const ProviderModelOptions: Schema.$Record<Schema.String, Schema.Unknown>;
 export type ProviderModelOptions = typeof ProviderModelOptions.Type;
-export declare const MODEL_OPTIONS_BY_PROVIDER: {
-    readonly codex: readonly [{
-        readonly slug: "gpt-5.4";
-        readonly name: "GPT-5.4";
-    }, {
-        readonly slug: "gpt-5.3-codex";
-        readonly name: "GPT-5.3 Codex";
-    }, {
-        readonly slug: "gpt-5.3-codex-spark";
-        readonly name: "GPT-5.3 Codex Spark";
-    }, {
-        readonly slug: "gpt-5.2-codex";
-        readonly name: "GPT-5.2 Codex";
-    }, {
-        readonly slug: "gpt-5.2";
-        readonly name: "GPT-5.2";
-    }];
-    readonly claude: readonly [{
-        readonly slug: "claude-sonnet-4-6";
-        readonly name: "Claude Sonnet 4.6";
-    }, {
-        readonly slug: "claude-opus-4-1";
-        readonly name: "Claude Opus 4.1";
-    }, {
-        readonly slug: "claude-3-7-sonnet-latest";
-        readonly name: "Claude 3.7 Sonnet";
-    }];
-};
-export type ModelOptionsByProvider = typeof MODEL_OPTIONS_BY_PROVIDER;
-type BuiltInModelSlug = ModelOptionsByProvider[ProviderKind][number]["slug"];
-export type ModelSlug = BuiltInModelSlug | (string & {});
-export declare const DEFAULT_MODEL_BY_PROVIDER: {
-    readonly codex: "gpt-5.4";
-    readonly claude: "claude-sonnet-4-6";
-};
-export declare const MODEL_SLUG_ALIASES_BY_PROVIDER: {
-    readonly codex: {
-        readonly "5.4": "gpt-5.4";
-        readonly "5.3": "gpt-5.3-codex";
-        readonly "gpt-5.3": "gpt-5.3-codex";
-        readonly "5.3-spark": "gpt-5.3-codex-spark";
-        readonly "gpt-5.3-spark": "gpt-5.3-codex-spark";
-    };
-    readonly claude: {
-        readonly sonnet: "claude-sonnet-4-6";
-        readonly opus: "claude-opus-4-1";
-        readonly "3.7-sonnet": "claude-3-7-sonnet-latest";
-    };
-};
-export declare const REASONING_EFFORT_OPTIONS_BY_PROVIDER: {
-    readonly codex: readonly ["xhigh", "high", "medium", "low"];
-    readonly claude: readonly [];
-};
-export declare const DEFAULT_REASONING_EFFORT_BY_PROVIDER: {
-    readonly codex: "high";
-    readonly claude: null;
-};
-export {};

package/dist/src/model.js

@@ -1,64 +1,9 @@
 // @bun
 // packages/contracts/src/model.ts
 import { Schema } from "effect";
-var CODEX_REASONING_EFFORT_OPTIONS = ["xhigh", "high", "medium", "low"];
-var CodexModelOptions = Schema.Struct({
-  reasoningEffort: Schema.optional(Schema.Literals(CODEX_REASONING_EFFORT_OPTIONS)),
-  fastMode: Schema.optional(Schema.Boolean)
-});
-var ClaudeModelOptions = Schema.Struct({});
-var ProviderModelOptions = Schema.Struct({
-  codex: Schema.optional(CodexModelOptions),
-  claude: Schema.optional(ClaudeModelOptions)
-});
-var MODEL_OPTIONS_BY_PROVIDER = {
-  codex: [
-    { slug: "gpt-5.4", name: "GPT-5.4" },
-    { slug: "gpt-5.3-codex", name: "GPT-5.3 Codex" },
-    { slug: "gpt-5.3-codex-spark", name: "GPT-5.3 Codex Spark" },
-    { slug: "gpt-5.2-codex", name: "GPT-5.2 Codex" },
-    { slug: "gpt-5.2", name: "GPT-5.2" }
-  ],
-  claude: [
-    { slug: "claude-sonnet-4-6", name: "Claude Sonnet 4.6" },
-    { slug: "claude-opus-4-1", name: "Claude Opus 4.1" },
-    { slug: "claude-3-7-sonnet-latest", name: "Claude 3.7 Sonnet" }
-  ]
-};
-var DEFAULT_MODEL_BY_PROVIDER = {
-  codex: "gpt-5.4",
-  claude: "claude-sonnet-4-6"
-};
-var MODEL_SLUG_ALIASES_BY_PROVIDER = {
-  codex: {
-    "5.4": "gpt-5.4",
-    "5.3": "gpt-5.3-codex",
-    "gpt-5.3": "gpt-5.3-codex",
-    "5.3-spark": "gpt-5.3-codex-spark",
-    "gpt-5.3-spark": "gpt-5.3-codex-spark"
-  },
-  claude: {
-    sonnet: "claude-sonnet-4-6",
-    opus: "claude-opus-4-1",
-    "3.7-sonnet": "claude-3-7-sonnet-latest"
-  }
-};
-var REASONING_EFFORT_OPTIONS_BY_PROVIDER = {
-  codex: CODEX_REASONING_EFFORT_OPTIONS,
-  claude: []
-};
-var DEFAULT_REASONING_EFFORT_BY_PROVIDER = {
-  codex: "high",
-  claude: null
-};
+var ModelSlug = Schema.String;
+var ProviderModelOptions = Schema.Record(Schema.String, Schema.Unknown);
 export {
-  REASONING_EFFORT_OPTIONS_BY_PROVIDER,
   ProviderModelOptions,
-  MODEL_SLUG_ALIASES_BY_PROVIDER,
-  MODEL_OPTIONS_BY_PROVIDER,
-  DEFAULT_REASONING_EFFORT_BY_PROVIDER,
-  DEFAULT_MODEL_BY_PROVIDER,
-  CodexModelOptions,
-  ClaudeModelOptions,
-  CODEX_REASONING_EFFORT_OPTIONS
+  ModelSlug
 };

package/dist/src/placement.d.ts

@@ -0,0 +1,47 @@
+import type { CapabilityId } from "./capability-id";
+export type PlacementKind = "local" | "remote";
+export type Placement = {
+    readonly alias: string;
+    readonly kind: PlacementKind;
+    readonly host?: string | null;
+    readonly port?: number | null;
+    readonly baseUrl?: string | null;
+    readonly projectRoot?: string | null;
+    readonly status?: string | null;
+    readonly taskSource?: string | null;
+};
+export type AddPlacementInput = {
+    readonly alias: string;
+    readonly host: string;
+    readonly port?: number;
+    readonly token?: string | null;
+    readonly select?: boolean;
+};
+export interface PlacementService {
+    readonly readPlacement: (input: {
+        readonly projectRoot: string;
+    }) => Promise<Placement>;
+    readonly listPlacements: (input: {
+        readonly projectRoot: string;
+    }) => Promise<readonly Placement[]>;
+    readonly selectPlacement: (input: {
+        readonly projectRoot: string;
+        readonly alias: string;
+        readonly dryRun?: boolean;
+    }) => Promise<Placement>;
+    readonly addPlacement: (input: {
+        readonly projectRoot: string;
+        readonly placement: AddPlacementInput;
+        readonly dryRun?: boolean;
+    }) => Promise<Placement>;
+    readonly removePlacement: (input: {
+        readonly projectRoot: string;
+        readonly alias: string;
+        readonly dryRun?: boolean;
+    }) => Promise<{
+        readonly alias: string;
+        readonly removed: boolean;
+    }>;
+}
+export declare const PLACEMENT_SERVICE_CAPABILITY_ID = "rig.transport.placement";
+export declare const PLACEMENT_SERVICE: CapabilityId<PlacementService>;

package/dist/src/placement.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/placement.ts
+var PLACEMENT_SERVICE_CAPABILITY_ID = "rig.transport.placement";
+var PLACEMENT_SERVICE = makeCapabilityId(PLACEMENT_SERVICE_CAPABILITY_ID);
+export {
+  PLACEMENT_SERVICE_CAPABILITY_ID,
+  PLACEMENT_SERVICE
+};

package/dist/src/product-entrypoint.d.ts

@@ -0,0 +1,22 @@
+/**
+ * product-entrypoint.ts — pure capability vocabulary for product-owned session entrypoints.
+ *
+ * The implementation lives in @rig/product-entrypoint-plugin. CLI consumers resolve
+ * this capability from the project plugin host instead of importing product runtime
+ * entrypoint code directly.
+ */
+import type { CapabilityId } from "./capability-id";
+export interface ProductEntrypointJoinSessionInput {
+    readonly projectRoot: string;
+    readonly link: string;
+}
+export interface ProductEntrypointJoinSessionResult {
+    readonly ok: true;
+    readonly group: "product";
+    readonly command: "join";
+}
+export interface ProductEntrypointService {
+    readonly joinSession: (input: ProductEntrypointJoinSessionInput) => Promise<ProductEntrypointJoinSessionResult>;
+}
+export declare const PRODUCT_ENTRYPOINT_CAPABILITY_ID = "rig.product.entrypoint";
+export declare const PRODUCT_ENTRYPOINT: CapabilityId<ProductEntrypointService>;

package/dist/src/product-entrypoint.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/product-entrypoint.ts
+var PRODUCT_ENTRYPOINT_CAPABILITY_ID = "rig.product.entrypoint";
+var PRODUCT_ENTRYPOINT = makeCapabilityId(PRODUCT_ENTRYPOINT_CAPABILITY_ID);
+export {
+  PRODUCT_ENTRYPOINT_CAPABILITY_ID,
+  PRODUCT_ENTRYPOINT
+};

package/dist/src/provider.d.ts

@@ -1,4 +1,5 @@
 import { Schema } from "effect";
+import type { CapabilityId } from "./capability-id";
 export declare const ProviderSession: Schema.Struct<{
     readonly provider: Schema.Literals<readonly ["codex", "claude"]>;
     readonly status: Schema.Literals<readonly ["connecting", "ready", "running", "error", "closed"]>;
@@ -18,13 +19,7 @@ export declare const ProviderSessionStartInput: Schema.Struct<{
     readonly provider: Schema.optional<Schema.Literals<readonly ["codex", "claude"]>>;
     readonly cwd: Schema.optional<Schema.Trim>;
     readonly model: Schema.optional<Schema.Trim>;
-    readonly modelOptions: Schema.optional<Schema.Struct<{
-        readonly codex: Schema.optional<Schema.Struct<{
-            readonly reasoningEffort: Schema.optional<Schema.Literals<readonly ["xhigh", "high", "medium", "low"]>>;
-            readonly fastMode: Schema.optional<Schema.Boolean>;
-        }>>;
-        readonly claude: Schema.optional<Schema.Struct<{}>>;
-    }>>;
+    readonly modelOptions: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
     readonly resumeCursor: Schema.optional<Schema.Unknown>;
     readonly serviceTier: Schema.optional<Schema.NullOr<Schema.Literals<readonly ["fast", "flex"]>>>;
     readonly approvalPolicy: Schema.optional<Schema.Literals<readonly ["untrusted", "on-failure", "on-request", "never"]>>;
@@ -50,13 +45,7 @@ export declare const ProviderSendTurnInput: Schema.Struct<{
     }>]>>>;
     readonly model: Schema.optional<Schema.Trim>;
     readonly serviceTier: Schema.optional<Schema.NullOr<Schema.Literals<readonly ["fast", "flex"]>>>;
-    readonly modelOptions: Schema.optional<Schema.Struct<{
-        readonly codex: Schema.optional<Schema.Struct<{
-            readonly reasoningEffort: Schema.optional<Schema.Literals<readonly ["xhigh", "high", "medium", "low"]>>;
-            readonly fastMode: Schema.optional<Schema.Boolean>;
-        }>>;
-        readonly claude: Schema.optional<Schema.Struct<{}>>;
-    }>>;
+    readonly modelOptions: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
     readonly interactionMode: Schema.optional<Schema.Literals<readonly ["default", "plan"]>>;
 }>;
 export type ProviderSendTurnInput = typeof ProviderSendTurnInput.Type;
@@ -103,3 +92,14 @@ export declare const ProviderEvent: Schema.Struct<{
     readonly payload: Schema.optional<Schema.Unknown>;
 }>;
 export type ProviderEvent = typeof ProviderEvent.Type;
+export interface AgentHarnessRunWrapperInput {
+    readonly argv: readonly string[];
+}
+export interface AgentHarnessService {
+    /** Provider-owned source entrypoint used when a project-local rig-agent binary must be materialized from source. */
+    readonly resolveAgentWrapperEntrypoint: () => string;
+    readonly runAgentWrapper: (input: AgentHarnessRunWrapperInput) => Promise<number>;
+    readonly runRigAgentEntrypoint: () => Promise<void>;
+}
+export declare const AGENT_HARNESS_CAPABILITY_ID = "rig.provider.agent-harness";
+export declare const AGENT_HARNESS: CapabilityId<AgentHarnessService>;

package/dist/src/provider.js

@@ -2,6 +2,11 @@
 // packages/contracts/src/provider.ts
 import { Schema as Schema4 } from "effect";
 
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
 // packages/contracts/src/baseSchemas.ts
 import { Schema } from "effect";
 var TrimmedString = Schema.Trim;
@@ -41,16 +46,8 @@ var RemoteEndpointId = makeEntityId("RemoteEndpointId");
 
 // packages/contracts/src/model.ts
 import { Schema as Schema2 } from "effect";
-var CODEX_REASONING_EFFORT_OPTIONS = ["xhigh", "high", "medium", "low"];
-var CodexModelOptions = Schema2.Struct({
-  reasoningEffort: Schema2.optional(Schema2.Literals(CODEX_REASONING_EFFORT_OPTIONS)),
-  fastMode: Schema2.optional(Schema2.Boolean)
-});
-var ClaudeModelOptions = Schema2.Struct({});
-var ProviderModelOptions = Schema2.Struct({
-  codex: Schema2.optional(CodexModelOptions),
-  claude: Schema2.optional(ClaudeModelOptions)
-});
+var ModelSlug = Schema2.String;
+var ProviderModelOptions = Schema2.Record(Schema2.String, Schema2.Unknown);
 
 // packages/contracts/src/orchestration.ts
 import { Schema as Schema3 } from "effect";
@@ -180,6 +177,8 @@ var ProviderEvent = Schema4.Struct({
   textDelta: Schema4.optional(Schema4.String),
   payload: Schema4.optional(Schema4.Unknown)
 });
+var AGENT_HARNESS_CAPABILITY_ID = "rig.provider.agent-harness";
+var AGENT_HARNESS = makeCapabilityId(AGENT_HARNESS_CAPABILITY_ID);
 export {
   ProviderTurnStartResult,
   ProviderStopSessionInput,
@@ -189,5 +188,7 @@ export {
   ProviderRespondToUserInputInput,
   ProviderRespondToRequestInput,
   ProviderInterruptTurnInput,
-  ProviderEvent
+  ProviderEvent,
+  AGENT_HARNESS_CAPABILITY_ID,
+  AGENT_HARNESS
 };