@h-rig/contracts 0.0.6-alpha.164 → 0.0.6-alpha.166

package/dist/src/index.js

@@ -1430,7 +1430,7 @@ var GitHubProjectStatusConfig = Schema13.Struct({
   }))
 });
 var GitHubConfig = Schema13.Struct({
-  issueUpdates: Schema13.optional(Schema13.Literals(["lifecycle", "minimal", "off"])),
+  issueUpdates: Schema13.optional(Schema13.Literals(["all", "lifecycle", "minimal", "off"])),
   projects: Schema13.optional(GitHubProjectStatusConfig)
 });
 var AutomationConfig = Schema13.Struct({
@@ -2387,11 +2387,43 @@ var RUN_IDENTITY_ENV = makeCapabilityId(RUN_IDENTITY_ENV_CAPABILITY_ID);
 var PRIOR_PROGRESS_PROMPT_CAPABILITY_ID = "prompt.prior-progress";
 var PRIOR_PROGRESS_PROMPT = makeCapabilityId(PRIOR_PROGRESS_PROMPT_CAPABILITY_ID);
 // packages/contracts/src/task-source.ts
+var TASK_SOURCE_UPDATE_CAPABILITY_ID = "task-sources.update";
+var TASK_SOURCE_UPDATE = makeCapabilityId(TASK_SOURCE_UPDATE_CAPABILITY_ID);
 var TASK_IO_SERVICE_CAPABILITY_ID = "task-sources.task-io";
 var TASK_IO_SERVICE_CAPABILITY = makeCapabilityId(TASK_IO_SERVICE_CAPABILITY_ID);
 // packages/contracts/src/task-data.ts
 var TASK_DATA_SERVICE_CAPABILITY_ID = "task-sources.task-data";
 var TASK_DATA_SERVICE_CAPABILITY = makeCapabilityId(TASK_DATA_SERVICE_CAPABILITY_ID);
+// packages/contracts/src/task-state-store.ts
+var TASK_STATE_STORE_CAPABILITY_ID = "task-state.store";
+var TASK_STATE_STORE = makeCapabilityId(TASK_STATE_STORE_CAPABILITY_ID);
+// packages/contracts/src/task-artifacts.ts
+var TASK_ARTIFACTS_CAPABILITY_ID = "task-state.artifacts";
+var TASK_ARTIFACTS = makeCapabilityId(TASK_ARTIFACTS_CAPABILITY_ID);
+// packages/contracts/src/task-context-renderer.ts
+var TASK_CONTEXT_RENDERER_CAPABILITY_ID = "provider.task-context-renderer";
+var TASK_CONTEXT_RENDERER = makeCapabilityId(TASK_CONTEXT_RENDERER_CAPABILITY_ID);
+// packages/contracts/src/task-tracker-state.ts
+var TASK_TRACKER_LIFECYCLE_STATUSES = [
+  "draft",
+  "open",
+  "ready",
+  "queued",
+  "in_progress",
+  "under_review",
+  "blocked",
+  "completed",
+  "cancelled"
+];
+var TASK_TRACKER_STALE_CLAIM_MS = 24 * 60 * 60 * 1000;
+var TASK_TRACKER_RECONCILIATION_POLICY_CAPABILITY_ID = "lifecycle.task-tracker-reconciliation-policy";
+var TASK_TRACKER_RECONCILIATION_POLICY = makeCapabilityId(TASK_TRACKER_RECONCILIATION_POLICY_CAPABILITY_ID);
+var TASK_TRACKER_READINESS_POLICY_CAPABILITY_ID = "scheduler.task-tracker-readiness-policy";
+var TASK_TRACKER_READINESS_POLICY = makeCapabilityId(TASK_TRACKER_READINESS_POLICY_CAPABILITY_ID);
+var TASK_TRACKER_REPO_LOCATOR_CAPABILITY_ID = "task-state.tracker-repo-locator";
+var TASK_TRACKER_REPO_LOCATOR = makeCapabilityId(TASK_TRACKER_REPO_LOCATOR_CAPABILITY_ID);
+var TASK_TRACKER_STATE_CAPABILITY_ID = "task-state.tracker-state";
+var TASK_TRACKER_STATE = makeCapabilityId(TASK_TRACKER_STATE_CAPABILITY_ID);
 // packages/contracts/src/cli-output.ts
 import { Schema as Schema26 } from "effect";
 var CLI_OUTPUT_VERSION = 1;
@@ -2683,12 +2715,16 @@ class CliError extends Error {
 }
 // packages/contracts/src/lifecycle-capabilities.ts
 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 TASK_SOURCE_REFLECTION_CAPABILITY_ID = "default-lifecycle.task-source-reflection";
 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 RUN_CLOSEOUT_CAPABILITY = makeCapabilityId(RUN_CLOSEOUT_CAPABILITY_ID);
 // packages/contracts/src/browser.ts
 var BROWSER_CONTRACT_SERVICE_CAPABILITY_ID = "browser.contract";
@@ -2713,6 +2749,14 @@ var SESSION_ASSET_MATERIALIZER = makeCapabilityId(SESSION_ASSET_MATERIALIZER_CAP
 var ISOLATION_BACKEND_CAPABILITY_ID = "isolation.backend";
 var ISOLATION_BACKEND = makeCapabilityId(ISOLATION_BACKEND_CAPABILITY_ID);
 // packages/contracts/src/managed-repos.ts
+var REPO_NATIVE_GIT_CAPABILITY_ID = "native-toolchain.git";
+var REPO_NATIVE_GIT = makeCapabilityId(REPO_NATIVE_GIT_CAPABILITY_ID);
+var NATIVE_TOOLCHAIN_GIT_CAPABILITY_ID = REPO_NATIVE_GIT_CAPABILITY_ID;
+var NATIVE_TOOLCHAIN_GIT = REPO_NATIVE_GIT;
+var REPO_GIT_BINARY_CAPABILITY_ID = "repos.git-binary";
+var REPO_GIT_BINARY = makeCapabilityId(REPO_GIT_BINARY_CAPABILITY_ID);
+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 MANAGED_REPO_SERVICE_CAPABILITY_ID = "managed-repos.service";
@@ -2742,6 +2786,17 @@ var GUARD_TOOLCHAIN_SOURCES_CAPABILITY_ID = "rig.toolchain.sources.guard";
 var LIFECYCLE_TOOLCHAIN_SOURCES_CAPABILITY_ID = "rig.toolchain.sources.lifecycle";
 var GUARD_TOOLCHAIN_SOURCES = makeCapabilityId(GUARD_TOOLCHAIN_SOURCES_CAPABILITY_ID);
 var LIFECYCLE_TOOLCHAIN_SOURCES = makeCapabilityId(LIFECYCLE_TOOLCHAIN_SOURCES_CAPABILITY_ID);
+// packages/contracts/src/native-toolchain.ts
+var NATIVE_TOOLCHAIN_BINARY_BUILD_CAPABILITY_ID = "native-toolchain.binary-build";
+var NATIVE_TOOLCHAIN_BINARY_BUILD = makeCapabilityId(NATIVE_TOOLCHAIN_BINARY_BUILD_CAPABILITY_ID);
+// packages/contracts/src/cockpit.ts
+var TASK_PROJECTION_CAPABILITY_ID = makeCapabilityId("rig:task-projection");
+var DISPATCH_OUTCOME_CAPABILITY_ID = makeCapabilityId("rig:dispatch-outcome");
+// packages/contracts/src/docs-drift.ts
+var DOCS_DRIFT_VALIDATOR_ID = "std:docs-drift";
+var DOCS_DRIFT_CLI_ID = "std:drift";
+var DOCS_DRIFT_STAGE_ID = "docs-drift";
+var DOCS_DRIFT_CAPABILITY_ID = "std:docs-drift-capability";
 // packages/contracts/src/cli-runner.ts
 var CLI_RUNNER_CAPABILITY_ID = "rig.cli.runner";
 var CLI_RUNNER = makeCapabilityId(CLI_RUNNER_CAPABILITY_ID);
@@ -2809,12 +2864,35 @@ export {
   TOOL_MATERIALIZER,
   TASK_VERIFY_CAPABILITY_ID,
   TASK_VERIFY_CAPABILITY,
+  TASK_VALIDATION_CAPABILITY_ID,
+  TASK_VALIDATION_CAPABILITY,
+  TASK_TRACKER_STATE_CAPABILITY_ID,
+  TASK_TRACKER_STATE,
+  TASK_TRACKER_STALE_CLAIM_MS,
+  TASK_TRACKER_REPO_LOCATOR_CAPABILITY_ID,
+  TASK_TRACKER_REPO_LOCATOR,
+  TASK_TRACKER_RECONCILIATION_POLICY_CAPABILITY_ID,
+  TASK_TRACKER_RECONCILIATION_POLICY,
+  TASK_TRACKER_READINESS_POLICY_CAPABILITY_ID,
+  TASK_TRACKER_READINESS_POLICY,
+  TASK_TRACKER_LIFECYCLE_STATUSES,
+  TASK_STATE_STORE_CAPABILITY_ID,
+  TASK_STATE_STORE,
+  TASK_SOURCE_UPDATE_CAPABILITY_ID,
+  TASK_SOURCE_UPDATE,
+  TASK_SOURCE_REFLECTION_CAPABILITY_ID,
+  TASK_SOURCE_REFLECTION,
   TASK_SELECTION_CAPABILITY_ID,
   TASK_SELECTION,
+  TASK_PROJECTION_CAPABILITY_ID,
   TASK_IO_SERVICE_CAPABILITY_ID,
   TASK_IO_SERVICE_CAPABILITY,
   TASK_DATA_SERVICE_CAPABILITY_ID,
   TASK_DATA_SERVICE_CAPABILITY,
+  TASK_CONTEXT_RENDERER_CAPABILITY_ID,
+  TASK_CONTEXT_RENDERER,
+  TASK_ARTIFACTS_CAPABILITY_ID,
+  TASK_ARTIFACTS,
   SupervisorStoppedEvent,
   SupervisorStopReason,
   SupervisorStatus,
@@ -3009,6 +3087,12 @@ export {
   RIG_ARTIFACTS_DIRNAME,
   REPO_OPERATIONS_CAPABILITY_ID,
   REPO_OPERATIONS_CAPABILITY,
+  REPO_NATIVE_GIT_CAPABILITY_ID,
+  REPO_NATIVE_GIT,
+  REPO_GIT_BINARY_CAPABILITY_ID,
+  REPO_GIT_BINARY,
+  REPO_CHANGE_SET_CAPABILITY_ID,
+  REPO_CHANGE_SET,
   REASONING_EFFORT_OPTIONS_BY_PROVIDER,
   QueueEntry,
   PullRequestConfig,
@@ -3075,6 +3159,10 @@ export {
   NO_MATCH_RETRIEVAL_CANONICAL_KEY,
   NOTIFY_SERVICE_CAPABILITY_ID,
   NOTIFY_SERVICE_CAPABILITY,
+  NATIVE_TOOLCHAIN_GIT_CAPABILITY_ID,
+  NATIVE_TOOLCHAIN_GIT,
+  NATIVE_TOOLCHAIN_BINARY_BUILD_CAPABILITY_ID,
+  NATIVE_TOOLCHAIN_BINARY_BUILD,
   MissingCapability,
   MessageId,
   MergeConfig,
@@ -3173,6 +3261,11 @@ export {
   DependencyEdge,
   DOCTOR_RUNNER_CAPABILITY_ID,
   DOCTOR,
+  DOCS_DRIFT_VALIDATOR_ID,
+  DOCS_DRIFT_STAGE_ID,
+  DOCS_DRIFT_CLI_ID,
+  DOCS_DRIFT_CAPABILITY_ID,
+  DISPATCH_OUTCOME_CAPABILITY_ID,
   DEPENDENCY_PREFLIGHT_CAPABILITY_ID,
   DEPENDENCY_PREFLIGHT_CAPABILITY,
   DEFAULT_TERMINAL_ID,

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

@@ -12,12 +12,17 @@ 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";
 /** 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. */
+export declare const TASK_VALIDATION_CAPABILITY_ID = "default-lifecycle.task-validation";
 /** Capability id the bundle registers the completion-verification gate under. */
 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 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 agent-facing git helper surface under. */
 export declare const LIFECYCLE_GIT_AGENT_CAPABILITY_ID = "default-lifecycle.git-agent";
 export interface TaskVerifyCapabilityInput {
@@ -33,6 +38,14 @@ export type TaskVerifyCapabilityRun = (input: TaskVerifyCapabilityInput) => Prom
  * is {@link TASK_VERIFY_CAPABILITY_ID}, so it indexes the same host entry.
  */
 export declare const TASK_VERIFY_CAPABILITY: CapabilityId<TaskVerifyCapabilityRun>;
+export interface TaskValidationCapabilityInput {
+    readonly projectRoot: string;
+    readonly taskId?: string;
+    readonly validatorRegistry?: unknown;
+}
+/** Resolves true when task validation passes or is skipped, false on validation failures. */
+export type TaskValidationCapabilityRun = (input: TaskValidationCapabilityInput) => Promise<boolean>;
+export declare const TASK_VALIDATION_CAPABILITY: CapabilityId<TaskValidationCapabilityRun>;
 export interface CompletionVerificationCapabilityInput {
     readonly projectRoot: string;
     readonly taskId?: string;
@@ -88,6 +101,51 @@ export type LifecycleGitAgentService = {
 };
 export declare const LIFECYCLE_GIT_AGENT: CapabilityId<LifecycleGitAgentService>;
 export type RunTaskSourceReflectStatus = "under_review" | "ci_fixing" | "merging" | "closed" | "needs_attention";
+export type RunTaskSourceLifecycleStatus = "running" | RunTaskSourceReflectStatus | "cancelled";
+export type RunTaskSourceLifecycleRun = {
+    runId?: string | null;
+    taskId?: string | null;
+    sourceTask?: unknown;
+    worktreePath?: string | null;
+    logRoot?: string | null;
+    sessionPath?: string | null;
+    errorText?: string | null;
+};
+export type RunTaskSourceLifecycleOptions = {
+    errorText?: string | null;
+};
+export type TaskSourceReflectionInput = {
+    readonly projectRoot: string;
+    readonly taskId: string;
+    readonly sourceTask?: unknown;
+    readonly runId?: string | null;
+    /** Generic source status to write. Omit/null for comment-only reflection. */
+    readonly status?: string | null;
+    /** Status text rendered in the lifecycle comment; defaults to `status`. */
+    readonly commentStatus?: string | null;
+    readonly summary: string;
+    readonly runtimeWorkspace?: string | null;
+    readonly logsDir?: string | null;
+    readonly sessionDir?: string | null;
+    readonly errorText?: string | null;
+    readonly prUrl?: string | null;
+};
+export type TaskSourceMergedPrReflectionInput = {
+    readonly projectRoot: string;
+    readonly taskId: string;
+    readonly runId: string;
+    readonly prUrl: string;
+    readonly sourceTask?: unknown;
+};
+export type TaskSourceReflectionResult = TaskSourceUpdateResult & {
+    readonly status?: unknown;
+};
+export interface TaskSourceReflectionService {
+    reflectTaskSourceStatus(input: TaskSourceReflectionInput): 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 type RunCloseoutResultStatus = "merged" | "opened" | "skipped" | "needs-attention";
 export type RunCloseoutResult = {
     status: RunCloseoutResultStatus;

package/dist/src/lifecycle-capabilities.js

@@ -6,16 +6,24 @@ function makeCapabilityId(id) {
 
 // packages/contracts/src/lifecycle-capabilities.ts
 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 TASK_SOURCE_REFLECTION_CAPABILITY_ID = "default-lifecycle.task-source-reflection";
 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 RUN_CLOSEOUT_CAPABILITY = makeCapabilityId(RUN_CLOSEOUT_CAPABILITY_ID);
 export {
   TASK_VERIFY_CAPABILITY_ID,
   TASK_VERIFY_CAPABILITY,
+  TASK_VALIDATION_CAPABILITY_ID,
+  TASK_VALIDATION_CAPABILITY,
+  TASK_SOURCE_REFLECTION_CAPABILITY_ID,
+  TASK_SOURCE_REFLECTION,
   RUN_CLOSEOUT_CAPABILITY_ID,
   RUN_CLOSEOUT_CAPABILITY,
   LIFECYCLE_GIT_AGENT_CAPABILITY_ID,

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

@@ -1,11 +1,15 @@
 /**
- * Pure managed-repo and repo-operation contract types + capability ids.
+ * Pure managed-repo, repo-operation, and repo-native git contract types + capability ids.
  *
  * `@rig/repos-plugin` owns the concrete implementations. It contributes:
  * - `ManagedRepoService` under {@link MANAGED_REPO_SERVICE_CAPABILITY_ID} for
- *   registry/layout/mirror state, and
+ *   registry/layout/mirror state,
  * - `RepoOperationsService` under {@link REPO_OPERATIONS_CAPABILITY_ID} for
- *   task repo pinning, baseline reset, and project-main pre-run sync.
+ *   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
+ * - `RepoGitBinaryService` under {@link REPO_GIT_BINARY_CAPABILITY_ID} for
+ *   the repo-owned rig-git helper binary.
  *
  * This module carries no behaviour and imports only pure sibling types, so
  * consumers resolve typed ids through `@rig/core` without importing the provider
@@ -13,6 +17,8 @@
  */
 import type { CapabilityId } from "./capability-id";
 import type { RepoSourceRegistration } from "./plugin";
+import type { GitWorkingTreeFileChange } from "./git";
+import type { NativeToolchainBinaryArtifact, NativeToolchainTarget } from "./native-toolchain";
 export type ManagedRepoId = string;
 export type ManagedRepoAlias = string;
 export type ManagedRepoHealth = "missing" | "ready" | "stale" | "misconfigured";
@@ -91,6 +97,61 @@ export interface ManagedRepoService {
     syncManagedRepo(projectRoot: string, repoId: ManagedRepoId): ManagedRepoSyncResult;
 }
 export type RepoPins = Record<string, string>;
+export type RepoNativeGitTreeCommitUpdate = {
+    readonly path: string;
+    readonly content: string;
+    readonly executable?: boolean;
+} | {
+    readonly path: string;
+    readonly delete: true;
+};
+/**
+ * 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.
+ */
+export interface RepoNativeGitService {
+    fetchRef(repoPath: string, remote: string, branch: string): string;
+    readBlobAtRef(repoPath: string, ref: string, path: string): string;
+    writeTreeCommit(repoPath: string, baseRef: string, updates: readonly RepoNativeGitTreeCommitUpdate[], message: string): string;
+    pushRefWithLease(repoPath: string, localOid: string, remoteRef: string, expectedOldOid: string, remote?: string): string;
+}
+/**
+ * Repo-native git is intentionally named from repos contracts. The capability id
+ * remains `native-toolchain.git` for compatibility with already published
+ * providers/consumers; treat that string as a legacy wire id, not ownership.
+ */
+export declare const REPO_NATIVE_GIT_CAPABILITY_ID = "native-toolchain.git";
+export declare const REPO_NATIVE_GIT: CapabilityId<RepoNativeGitService>;
+/** @deprecated Use RepoNativeGitTreeCommitUpdate. */
+export type NativeGitTreeCommitUpdate = RepoNativeGitTreeCommitUpdate;
+/** @deprecated Use RepoNativeGitService. */
+export type NativeGitService = RepoNativeGitService;
+/** @deprecated Use REPO_NATIVE_GIT_CAPABILITY_ID; this is the legacy wire id. */
+export declare const NATIVE_TOOLCHAIN_GIT_CAPABILITY_ID = "native-toolchain.git";
+/** @deprecated Use REPO_NATIVE_GIT. */
+export declare const NATIVE_TOOLCHAIN_GIT: CapabilityId<RepoNativeGitService>;
+export interface RepoGitBinaryResolveInput {
+    readonly projectRoot?: string;
+    readonly target?: NativeToolchainTarget;
+}
+export interface RepoGitBinaryMaterializeInput {
+    readonly projectRoot: string;
+    readonly targetDir: string;
+    readonly target?: NativeToolchainTarget;
+}
+export interface RepoGitBinaryArtifact extends NativeToolchainBinaryArtifact {
+    readonly name: "rig-git";
+    readonly kind: "executable";
+    readonly commandName: string;
+}
+export interface RepoGitBinaryService {
+    gitHelperBinaryName(input?: RepoGitBinaryResolveInput): string;
+    resolveGitHelperBinary(input?: RepoGitBinaryResolveInput): RepoGitBinaryArtifact | null | Promise<RepoGitBinaryArtifact | null>;
+    materializeGitHelperBinary(input: RepoGitBinaryMaterializeInput): Promise<RepoGitBinaryArtifact>;
+}
+export declare const REPO_GIT_BINARY_CAPABILITY_ID = "repos.git-binary";
+export declare const REPO_GIT_BINARY: CapabilityId<RepoGitBinaryService>;
 export type ProjectMainPreRunSyncResult = {
     status: "disabled";
 } | {
@@ -111,6 +172,48 @@ export type ProjectMainPreRunSyncOptions = {
     runBootstrap: () => Promise<void>;
     syncMonorepo?: (projectRoot: string) => void | Promise<void>;
 };
+export type RepoChangeSetSelector = {
+    readonly kind: "task";
+    readonly taskId: string;
+    readonly scoped: boolean;
+} | {
+    readonly kind: "scope";
+    readonly paths: readonly string[];
+} | {
+    readonly kind: "workspace";
+};
+export type RepoChangeSetTarget = {
+    readonly kind: "project";
+    readonly projectRoot: string;
+} | {
+    readonly kind: "managed-repo";
+    readonly projectRoot: string;
+    readonly repoId: ManagedRepoId;
+} | {
+    readonly kind: "repo-root";
+    readonly repoRoot: string;
+    readonly projectRoot?: string;
+};
+export interface RepoChangeSetInput {
+    readonly projectRoot: string;
+    readonly selector: RepoChangeSetSelector;
+    readonly target?: RepoChangeSetTarget;
+}
+export interface RepoChangeSetFile extends GitWorkingTreeFileChange {
+    readonly repoRoot: string;
+    readonly repoId?: ManagedRepoId;
+}
+export interface RepoChangeSet {
+    readonly changedFiles: readonly RepoChangeSetFile[];
+    readonly pendingFiles: readonly RepoChangeSetFile[];
+}
+export interface RepoChangeSetService {
+    collectChangeSet(input: RepoChangeSetInput): RepoChangeSet | Promise<RepoChangeSet>;
+    changedFiles(input: RepoChangeSetInput): readonly RepoChangeSetFile[] | Promise<readonly RepoChangeSetFile[]>;
+    pendingFiles(input: RepoChangeSetInput): readonly RepoChangeSetFile[] | Promise<readonly RepoChangeSetFile[]>;
+}
+export declare const REPO_CHANGE_SET_CAPABILITY_ID = "repos.change-set";
+export declare const REPO_CHANGE_SET: CapabilityId<RepoChangeSetService>;
 export interface RepoOperationsService {
     repoEnsure(projectRoot: string, taskId?: string): void;
     repoPins(projectRoot: string, taskId?: string): RepoPins;

package/dist/src/managed-repos.js

@@ -5,6 +5,14 @@ function makeCapabilityId(id) {
 }
 
 // packages/contracts/src/managed-repos.ts
+var REPO_NATIVE_GIT_CAPABILITY_ID = "native-toolchain.git";
+var REPO_NATIVE_GIT = makeCapabilityId(REPO_NATIVE_GIT_CAPABILITY_ID);
+var NATIVE_TOOLCHAIN_GIT_CAPABILITY_ID = REPO_NATIVE_GIT_CAPABILITY_ID;
+var NATIVE_TOOLCHAIN_GIT = REPO_NATIVE_GIT;
+var REPO_GIT_BINARY_CAPABILITY_ID = "repos.git-binary";
+var REPO_GIT_BINARY = makeCapabilityId(REPO_GIT_BINARY_CAPABILITY_ID);
+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 MANAGED_REPO_SERVICE_CAPABILITY_ID = "managed-repos.service";
@@ -12,6 +20,14 @@ var MANAGED_REPO_SERVICE_CAPABILITY = makeCapabilityId(MANAGED_REPO_SERVICE_CAPA
 export {
   REPO_OPERATIONS_CAPABILITY_ID,
   REPO_OPERATIONS_CAPABILITY,
+  REPO_NATIVE_GIT_CAPABILITY_ID,
+  REPO_NATIVE_GIT,
+  REPO_GIT_BINARY_CAPABILITY_ID,
+  REPO_GIT_BINARY,
+  REPO_CHANGE_SET_CAPABILITY_ID,
+  REPO_CHANGE_SET,
+  NATIVE_TOOLCHAIN_GIT_CAPABILITY_ID,
+  NATIVE_TOOLCHAIN_GIT,
   MANAGED_REPO_SERVICE_CAPABILITY_ID,
   MANAGED_REPO_SERVICE_CAPABILITY
 };

package/dist/src/native-toolchain.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Mechanical native-toolchain capability seams.
+ *
+ * These contracts describe binary build/materialization services only. Repo
+ * meaning, task scoping, repo-native git wrappers, and git workflow semantics
+ * belong to repo contracts; native-toolchain providers only locate, compile, or
+ * materialize binaries.
+ *
+ * Pure: types + branded ids, no behaviour.
+ */
+import type { CapabilityId } from "./capability-id";
+export type NativeToolchainBinaryKind = "executable" | "dynamic-library";
+export interface NativeToolchainTarget {
+    readonly platform: string;
+    readonly arch: string;
+    readonly triple?: string;
+    readonly abi?: string;
+}
+export interface NativeToolchainBinaryArtifact {
+    readonly name: string;
+    readonly path: string;
+    readonly kind: NativeToolchainBinaryKind;
+    readonly target?: NativeToolchainTarget;
+}
+export interface NativeToolchainBinaryBuildInput {
+    readonly projectRoot: string;
+    readonly name: string;
+    readonly sourcePath: string;
+    readonly outputPath: string;
+    readonly kind: NativeToolchainBinaryKind;
+    readonly target?: NativeToolchainTarget;
+    readonly buildArgs?: readonly string[];
+    readonly defines?: Readonly<Record<string, string>>;
+}
+export interface NativeToolchainBinaryMaterializeInput {
+    readonly projectRoot: string;
+    readonly name: string;
+    readonly targetDir: string;
+    readonly target?: NativeToolchainTarget;
+}
+export interface NativeToolchainBinaryBuildService {
+    buildNativeBinary(input: NativeToolchainBinaryBuildInput): Promise<NativeToolchainBinaryArtifact>;
+    materializeNativeBinary(input: NativeToolchainBinaryMaterializeInput): Promise<NativeToolchainBinaryArtifact>;
+}
+export declare const NATIVE_TOOLCHAIN_BINARY_BUILD_CAPABILITY_ID = "native-toolchain.binary-build";
+export declare const NATIVE_TOOLCHAIN_BINARY_BUILD: CapabilityId<NativeToolchainBinaryBuildService>;

package/dist/src/native-toolchain.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/native-toolchain.ts
+var NATIVE_TOOLCHAIN_BINARY_BUILD_CAPABILITY_ID = "native-toolchain.binary-build";
+var NATIVE_TOOLCHAIN_BINARY_BUILD = makeCapabilityId(NATIVE_TOOLCHAIN_BINARY_BUILD_CAPABILITY_ID);
+export {
+  NATIVE_TOOLCHAIN_BINARY_BUILD_CAPABILITY_ID,
+  NATIVE_TOOLCHAIN_BINARY_BUILD
+};

package/dist/src/plugin-hooks.d.ts

@@ -5,14 +5,14 @@ export type HookToolInput = typeof HookToolInput.Type;
 /**
  * Parsed hook invocation handed to a typed hook implementation.
  *
- * Derived from the Claude Code hook stdin payload (see @rig/hook-kit's
- * `readHookInput`) plus the runner's resolved environment:
+ * Derived from the Claude Code hook stdin payload (see
+ * @rig/core/hook-protocol's `readHookInput`) plus the runner's resolved
+ * environment:
  * - `event`        — the lifecycle event the hook fired on
  * - `toolName`     — `tool_name` from the payload (absent for non-tool events)
  * - `toolInput`    — `tool_input` from the payload (`{}` when absent)
  * - `filePaths`    — file path candidates extracted from the tool input
- *                    (@rig/hook-kit's `extractToolFilePaths`)
- * - `projectRoot`  — resolved project root (@rig/hook-kit's `resolveProjectRoot`)
+ * - `projectRoot`  — resolved project root
  * - `taskId`       — current Rig task id, `""` when not running inside a task
  */
 export declare const HookContext: Schema.Struct<{
@@ -29,8 +29,8 @@ export type HookDecision = typeof HookDecision.Type;
 /**
  * Result returned by a typed hook implementation.
  *
- * Serialized to the same stdout/exit-code protocol that @rig/hook-kit's
- * `block()` uses (the contract Claude Code's hook runner expects):
+ * Serialized to the same stdout/exit-code protocol that
+ * @rig/core/hook-protocol's `block()` uses:
  * - `decision: "block"` → `BLOCKED: <reason>` on stdout, non-zero exit
  * - `decision: "allow"` → exit 0; `systemMessage` (when set) on stdout
  */

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

@@ -14,6 +14,8 @@ import type { CapabilityId } from "./capability-id";
 import type { RigStatsData } from "./cli-output";
 import type { RunDiscoveryFilter } 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 { TaskRecord } from "./task-source";
@@ -43,6 +45,24 @@ export interface RunReadModelProjectionInput {
     readonly sessionPath?: string | null;
     readonly discoveryFilter?: RunDiscoveryFilter;
 }
+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 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;
+    /** Optional caller-supplied timeline for compatibility; providers should prefer entries. */
+    readonly timeline?: readonly RigRunTimelineEntry[];
+}
 export interface RunReadModelDetailsInput extends RunReadModelGetInput {
     readonly includeLogs?: boolean;
     readonly includeSourceTask?: boolean;
@@ -213,6 +233,7 @@ export interface RunReadModelService {
     readonly listRuns: (input: RunReadModelListInput) => Promise<readonly RunRecord[]>;
     readonly getRun: (input: RunReadModelGetInput) => Promise<RunRecord | null>;
     readonly getRunProjection: (input: RunReadModelProjectionInput) => Promise<RunJournalProjection | null>;
+    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[]>;

package/dist/src/setup.d.ts

@@ -8,6 +8,7 @@
  * function-laden deps (those are the impl's concern, not the cross-plugin seam).
  */
 import type { CapabilityId } from "./capability-id";
+import type { GitHubAuthStatus } from "./github";
 /** Capability id the init/setup plugin registers its setup runner under. */
 export declare const PROJECT_SETUP_CAPABILITY_ID = "cap:project-setup";
 /**
@@ -17,7 +18,7 @@ export declare const PROJECT_SETUP_CAPABILITY_ID = "cap:project-setup";
  */
 export type ProjectSetupPlacement = {
     readonly alias: string;
-    readonly kind: string;
+    readonly kind: "local" | "remote";
     readonly host?: string;
     readonly port?: number;
     readonly token?: string | null;
@@ -33,14 +34,54 @@ export type ProjectSetupInput = {
     readonly githubToken?: string | null;
     readonly importGhToken?: boolean;
 };
-/** Pure summary of a project-setup pass. */
+export type ProjectRepoSlug = {
+    readonly owner: string;
+    readonly repo: string;
+    readonly slug: string;
+};
+export type RigConfigStatus = {
+    readonly exists: boolean;
+    readonly valid: boolean;
+    readonly path: string;
+    readonly slug: string | null;
+    readonly reason?: string;
+};
+export type RigStateStatus = {
+    readonly valid: boolean;
+    readonly selected: string | null;
+    readonly project: string | null;
+    readonly reason?: string;
+};
+export type RigAuthValidation = {
+    readonly ok: boolean;
+    readonly source: "stored-token" | "gh" | "missing";
+    readonly login?: string | null;
+    readonly detail: string;
+    readonly status?: GitHubAuthStatus;
+};
+export type RigSetupStatus = {
+    readonly configured: boolean;
+    readonly projectRoot: string;
+    readonly slug: string | null;
+    readonly config: RigConfigStatus;
+    readonly state: RigStateStatus;
+    readonly auth: RigAuthValidation;
+    readonly reasons: readonly string[];
+};
 export type ProjectSetupResult = {
     readonly repoSlug: string;
     readonly placement: string;
     readonly configWritten: boolean;
+    readonly labels: unknown;
+    readonly pi: unknown;
+    readonly status: RigSetupStatus;
 };
-/** The cohesive project-setup operation the CLI surface depends on. Async (does IO). */
+/** The cohesive project-setup operation the CLI surface depends on. Async methods do IO. */
 export interface ProjectSetupService {
+    parseRepoSlug(value: string): ProjectRepoSlug;
+    detectStartupStatus(input: {
+        readonly projectRoot: string;
+    }): Promise<RigSetupStatus>;
     runSetup(input: ProjectSetupInput): Promise<ProjectSetupResult>;
 }
 /** Typed capability id; string value is {@link PROJECT_SETUP_CAPABILITY_ID}. */