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

package/dist/src/control-plane-types.d.ts

@@ -9,6 +9,7 @@
  * substrate (git-ops, task-ops) all reference one canonical definition without
  * importing each other.
  */
+import type { CapabilityId } from "./capability-id";
 export type GitHubCommandResult = {
     readonly exitCode: number;
     readonly stdout?: string;
@@ -280,4 +281,43 @@ export type VerifyOutcome = {
     reviewFeedbackPath: string;
     reviewStatePath: string;
 };
-export declare function strictMergeHeadShaFromGate(result: StrictPrMergeGateResult, prUrl: string, requireGreptile?: boolean): string;
+/** Capability id the pr-review plugin registers its merge-head-SHA resolver under. */
+export declare const PR_MERGE_GATE_CAPABILITY_ID = "rig.mergeGate.resolveHeadSha";
+/** Pure input to the merge-head-SHA resolver: the gate result + target PR. */
+export type ResolveMergeHeadShaInput = {
+    readonly result: StrictPrMergeGateResult;
+    readonly prUrl: string;
+    /** Defaults to true at the impl; gate enforces Greptile freshness when set. */
+    readonly requireGreptile?: boolean;
+};
+/**
+ * The cohesive merge-gate seam the default lifecycle bundle depends on. Owned +
+ * provided by `@rig/pr-review-plugin` under {@link PR_MERGE_GATE_CAPABILITY_ID};
+ * `@rig/bundle-default-lifecycle` resolves it off the host instead of importing
+ * `@rig/pr-review-plugin`. Surfaces exactly the merge-gate operations the bundle
+ * uses (gate run + head-SHA resolution + the evidence-collection/evaluation
+ * primitives the verifier composes). Types only here — VOCAB, no behaviour.
+ */
+export interface PrMergeGateService {
+    /**
+     * Given an approved gate result + PR url, return the raw 40-char head SHA it
+     * is safe to merge (throws when not approved / not tied to head). Pure.
+     */
+    resolveHeadSha(input: ResolveMergeHeadShaInput): string;
+    /** Run the full strict merge gate (collect evidence + evaluate + artifacts). */
+    runGate(input: StrictPrMergeGateInput): Promise<StrictPrMergeGateResult>;
+    /** Collect the PR review evidence the gate evaluates (IO). */
+    collectEvidence(input: StrictPrMergeGateInput): Promise<PrReviewEvidence>;
+    /** Evaluate already-collected evidence into a gate decision (pure). */
+    evaluateGate(evidence: PrReviewEvidence, requireGreptile?: boolean): Omit<StrictPrMergeGateResult, "artifacts" | "steeringPrompt">;
+    /** Parse a Greptile review score from a review body (pure). */
+    parseGreptileScore(input: string): GreptileScore | null;
+    /** Strip HTML to plain text (pure). */
+    stripHtml(input: string): string;
+}
+/**
+ * Typed capability id, phantom-typed with {@link PrMergeGateService} so
+ * `defineCapability(PR_MERGE_GATE)` resolves with no cast leaking to callers.
+ * String value is {@link PR_MERGE_GATE_CAPABILITY_ID}.
+ */
+export declare const PR_MERGE_GATE: CapabilityId<PrMergeGateService>;

package/dist/src/control-plane-types.js

@@ -1,29 +1,13 @@
 // @bun
-// packages/contracts/src/control-plane-types.ts
-function strictMergeHeadShaFromGate(result, prUrl, requireGreptile = true) {
-  if (!result.approved) {
-    throw new Error(`Refusing to merge ${prUrl}: strict merge gate is not approved.`);
-  }
-  if (result.evidence.prUrl !== prUrl) {
-    throw new Error(`Refusing to merge ${prUrl}: strict merge gate evidence belongs to ${result.evidence.prUrl}.`);
-  }
-  const headSha = result.evidence.headSha?.trim();
-  if (!headSha) {
-    throw new Error(`Refusing to merge ${prUrl}: strict merge gate did not provide a current head SHA.`);
-  }
-  if (!/^[0-9a-f]{40}$/i.test(headSha)) {
-    throw new Error(`Refusing to merge ${prUrl}: strict merge gate head is not a raw 40-character commit SHA.`);
-  }
-  if (requireGreptile) {
-    if (!result.evidence.greptile.fresh || result.evidence.greptile.currentHeadSha !== headSha) {
-      throw new Error(`Refusing to merge ${prUrl}: strict merge gate approval is not tied to head ${headSha}.`);
-    }
-    if (result.evidence.greptile.mapping !== "score-5-of-5" && result.evidence.greptile.mapping !== "explicit-approved") {
-      throw new Error(`Refusing to merge ${prUrl}: strict merge gate mapping is ${result.evidence.greptile.mapping}.`);
-    }
-  }
-  return headSha;
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
 }
+
+// packages/contracts/src/control-plane-types.ts
+var PR_MERGE_GATE_CAPABILITY_ID = "rig.mergeGate.resolveHeadSha";
+var PR_MERGE_GATE = makeCapabilityId(PR_MERGE_GATE_CAPABILITY_ID);
 export {
-  strictMergeHeadShaFromGate
+  PR_MERGE_GATE_CAPABILITY_ID,
+  PR_MERGE_GATE
 };

package/dist/src/dependency-preflight.d.ts

@@ -0,0 +1,43 @@
+/**
+ * The `workspace.dependency-preflight` capability seam.
+ *
+ * Pure capability VOCAB (no impl). The init/setup plugin (@rig/init-plugin)
+ * PROVIDES the concrete service — it mutates `package.json` to pin the project's
+ * `@rig/*` config deps and runs the package manager's install — and the CLI seed
+ * (`packages/cli/bin/rig.ts`) RESOLVES it by id off a plugin host built from the
+ * embedded standard plugins, invoking it only on the rig.config.ts power-path
+ * fallback (a code config present that the project-binary build did not handle).
+ *
+ * The heavy install/mutate impl therefore lives in the setup plugin, NOT in a
+ * CLI seed module on the hot path: the seed neither imports nor bundles it
+ * eagerly — it is reached purely through this typed seam.
+ */
+import type { CapabilityId } from "./capability-id";
+/** Inputs the CLI seed hands the preflight. The CLI owns version detection (it
+ *  reads its OWN installed version), so it passes the resolved values in rather
+ *  than the floor library reaching back into CLI-specific version resolution. */
+export type RigConfigDependencyPreflightInput = {
+    /** Project root whose `package.json` / config deps are reconciled. */
+    readonly projectRoot: string;
+    /** The CLI's own resolved installed version (drives the `@rig/*` dep pin). */
+    readonly installedCliVersion: string;
+    /** Whether {@link installedCliVersion} is a published (non source/dev) version;
+     *  when false the deps pin to `latest`. */
+    readonly isInstalledCliVersionPublished: boolean;
+};
+/** Outcome of a dependency preflight pass. */
+export type RigConfigDependencyPreflightResult = {
+    readonly rewroteManifest: boolean;
+    readonly ranInstall: boolean;
+    readonly command: string | null;
+    readonly version: string;
+};
+/** The dependency-preflight service the setup plugin provides and the CLI seed
+ *  resolves by id off a host. */
+export interface RigConfigDependencyPreflightService {
+    ensureInstalled(input: RigConfigDependencyPreflightInput): RigConfigDependencyPreflightResult;
+}
+/** The capability id string the setup plugin provides and the CLI seed resolves. */
+export declare const DEPENDENCY_PREFLIGHT_CAPABILITY_ID = "workspace.dependency-preflight";
+/** The typed capability id, phantom-typed with {@link RigConfigDependencyPreflightService}. */
+export declare const DEPENDENCY_PREFLIGHT_CAPABILITY: CapabilityId<RigConfigDependencyPreflightService>;

package/dist/src/dependency-preflight.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/dependency-preflight.ts
+var DEPENDENCY_PREFLIGHT_CAPABILITY_ID = "workspace.dependency-preflight";
+var DEPENDENCY_PREFLIGHT_CAPABILITY = makeCapabilityId(DEPENDENCY_PREFLIGHT_CAPABILITY_ID);
+export {
+  DEPENDENCY_PREFLIGHT_CAPABILITY_ID,
+  DEPENDENCY_PREFLIGHT_CAPABILITY
+};

package/dist/src/doctor.d.ts

@@ -9,6 +9,7 @@
  * {@link DOCTOR_RUNNER_CAPABILITY_ID}. This file holds ONLY the pure types and
  * pure helpers shared by producer and consumers — no IO, no plugin imports.
  */
+import type { CapabilityId } from "./capability-id";
 /** The capability id the doctor plugin registers its runner under. */
 export declare const DOCTOR_RUNNER_CAPABILITY_ID = "doctor.runner";
 export type DoctorStatus = "pass" | "warn" | "fail";
@@ -21,7 +22,69 @@ export type DoctorCheck = {
     readonly detail?: string;
     readonly remediation?: string;
 };
-/** Normalize the legacy `level` field to the canonical `status`. */
-export declare function doctorLevelToStatus(level: DoctorLevel): DoctorStatus;
-/** Count checks that resolve to a `fail` status (across status/level shapes). */
-export declare function countDoctorFailures(checks: readonly DoctorCheck[]): number;
+/**
+ * Structural mirror of the runtime's `RigIdentityContext` (in
+ * `@rig/runtime/control-plane/identity`). The diagnostic runner reads the
+ * GitHub/session identity off this context; the field references a runtime
+ * shape, so — exactly like memory's `MemoryCommandEventSink` — it is typed here
+ * as a minimal contracts-owned interface carrying only the structure the runner
+ * needs. The runtime's `RigIdentityContext` is structurally identical and so
+ * flows in/out without a cast, keeping the contract free of any runtime import.
+ */
+export interface DoctorIdentityContext {
+    readonly sessionManager: {
+        getCwd(): string;
+        getSessionId(): string;
+        getBranch(): readonly {
+            type: string;
+            customType?: string;
+            data?: unknown;
+        }[];
+    };
+    readonly modelRegistry?: {
+        readonly authStorage?: {
+            getOAuthAccountIdentity?: (provider: string, sessionId?: string) => unknown;
+        };
+    };
+}
+/**
+ * Options the substrate passes through to the diagnostic runner. The function
+ * fields are typed loosely (the consumers only read `.length`/labels); the
+ * plugin impl supplies concrete client-backed defaults. Keeping these signatures
+ * free of @rig/client types keeps the contract (and runtime) decoupled from
+ * client.
+ */
+export type RunDoctorChecksOptions = {
+    readonly projectRoot: string;
+    readonly requestJson?: (pathname: string, init?: RequestInit) => Promise<unknown>;
+    readonly piChecks?: () => Promise<readonly {
+        ok: boolean;
+        label: string;
+        detail?: string;
+        hint?: string;
+    }[]>;
+    readonly which?: (binary: string) => string | null;
+    readonly bunVersion?: string;
+    readonly loadConfig?: (projectRoot: string) => Promise<unknown>;
+    readonly onProgress?: (label: string) => void;
+    readonly identityContext?: DoctorIdentityContext;
+    readonly listRuns?: (projectRoot: string) => Promise<readonly unknown[]>;
+    readonly listPlacements?: (projectRoot: string) => readonly unknown[];
+};
+/**
+ * The cohesive diagnostic operation the substrate depends on. This is pure
+ * capability VOCAB: `@rig/doctor-plugin` provides a concrete impl (statically
+ * checked against this interface via `DoctorCap.provide`), and the substrate
+ * only ever sees this contract — resolved by id off a plugin host with no
+ * `as unknown as` at any call site.
+ */
+export interface DoctorService {
+    runDoctorChecks(options: RunDoctorChecksOptions): Promise<DoctorCheck[]>;
+}
+/**
+ * The typed capability id the doctor plugin provides and consumers require.
+ * Phantom-typed with {@link DoctorService} so `DoctorCap.require(host)` returns
+ * a `DoctorService` with no cast leaking to callers. Its string value is
+ * {@link DOCTOR_RUNNER_CAPABILITY_ID}, so it indexes the same host entry.
+ */
+export declare const DOCTOR: CapabilityId<DoctorService>;

package/dist/src/doctor.js

@@ -1,14 +1,13 @@
 // @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
 // packages/contracts/src/doctor.ts
 var DOCTOR_RUNNER_CAPABILITY_ID = "doctor.runner";
-function doctorLevelToStatus(level) {
-  return level === "ok" ? "pass" : level;
-}
-function countDoctorFailures(checks) {
-  return checks.filter((entry) => (entry.status ?? doctorLevelToStatus(entry.level ?? "warn")) === "fail").length;
-}
+var DOCTOR = makeCapabilityId(DOCTOR_RUNNER_CAPABILITY_ID);
 export {
-  doctorLevelToStatus,
-  countDoctorFailures,
-  DOCTOR_RUNNER_CAPABILITY_ID
+  DOCTOR_RUNNER_CAPABILITY_ID,
+  DOCTOR
 };

package/dist/src/errors.d.ts

@@ -0,0 +1,13 @@
+export declare class CliError extends Error {
+    readonly exitCode: number;
+    /**
+     * Optional remediation hint. Rendered on its own `Next: <hint>` line (and
+     * carried in the `--json` error payload) so a failure can name the next
+     * command to run. Pure vocab — the exec machinery (now in @rig/guard-plugin)
+     * throws this with a hint without importing a CLI-seed error class.
+     */
+    readonly hint?: string;
+    constructor(message: string, exitCode?: number, options?: {
+        readonly hint?: string;
+    });
+}

package/dist/src/errors.js

@@ -0,0 +1,17 @@
+// @bun
+// packages/contracts/src/errors.ts
+class CliError extends Error {
+  exitCode;
+  hint;
+  constructor(message, exitCode = 1, options = {}) {
+    super(message);
+    this.name = "CliError";
+    this.exitCode = exitCode;
+    if (options.hint?.trim()) {
+      this.hint = options.hint.trim();
+    }
+  }
+}
+export {
+  CliError
+};

package/dist/src/github.d.ts

@@ -17,6 +17,7 @@
  * @rig/runtime/control-plane/github/token-env as a dumb reader; the policy that
  * produces that token lives in this plugin.)
  */
+import type { CapabilityId } from "./capability-id";
 /** Capability id the GitHub-provider plugin registers its service factory under. */
 export declare const GITHUB_PROVIDER_CAPABILITY_ID = "github.provider";
 export type GitHubCredentialPurpose = "selected-repo" | "admin-fallback";
@@ -101,3 +102,45 @@ export interface GitHubProviderService {
 }
 /** The capability `run` shape the plugin registers: a zero-arg service factory. */
 export type GitHubProviderServiceRun = () => GitHubProviderService;
+/**
+ * Typed capability id, phantom-typed with {@link GitHubProviderService} so
+ * consumers (task-sources/doctor/init) resolve it off the host with no cast.
+ * String value is {@link GITHUB_PROVIDER_CAPABILITY_ID}.
+ */
+export declare const GITHUB_PROVIDER: CapabilityId<GitHubProviderService>;
+/** Capability id the issue-triage provider registers its runner under. */
+export declare const ISSUE_TRIAGE_CAPABILITY_ID = "cap:issue-triage";
+/** Pure input to a triage pass: which project + an optional reason label. */
+export type IssueTriageInput = {
+    readonly projectRoot: string;
+    readonly reason?: string;
+};
+/**
+ * Pure summary of a triage pass. Contracts-owned mirror of the plugin's
+ * `IssueAnalysisTriageRunResult` so substrate consumers read the outcome
+ * without importing the plugin. Structurally compatible with the impl result.
+ */
+export type IssueTriageResult = {
+    readonly ok: true;
+    readonly enabled: boolean;
+    readonly reason: string;
+    readonly sourceId: string | null;
+    readonly sourceKind: string | null;
+    readonly analyzedIssues: number;
+    readonly metadataPatches: number;
+    readonly labelsAdded: number;
+    readonly labelsRemoved: number;
+    readonly generatedIssues: number;
+    readonly writeBackRefreshes: number;
+    readonly refreshedIssueCount: number | null;
+    readonly skippedReason?: "no-config" | "disabled";
+};
+/** The cohesive triage operation the CLI surface depends on. Async (does IO). */
+export interface IssueTriageService {
+    runTriage(input: IssueTriageInput): Promise<IssueTriageResult>;
+}
+/**
+ * Typed capability id, phantom-typed with {@link IssueTriageService}. String
+ * value is {@link ISSUE_TRIAGE_CAPABILITY_ID}.
+ */
+export declare const ISSUE_TRIAGE: CapabilityId<IssueTriageService>;

package/dist/src/github.js

@@ -1,6 +1,17 @@
 // @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
 // packages/contracts/src/github.ts
 var GITHUB_PROVIDER_CAPABILITY_ID = "github.provider";
+var GITHUB_PROVIDER = makeCapabilityId(GITHUB_PROVIDER_CAPABILITY_ID);
+var ISSUE_TRIAGE_CAPABILITY_ID = "cap:issue-triage";
+var ISSUE_TRIAGE = makeCapabilityId(ISSUE_TRIAGE_CAPABILITY_ID);
 export {
-  GITHUB_PROVIDER_CAPABILITY_ID
+  ISSUE_TRIAGE_CAPABILITY_ID,
+  ISSUE_TRIAGE,
+  GITHUB_PROVIDER_CAPABILITY_ID,
+  GITHUB_PROVIDER
 };

package/dist/src/graph.d.ts

@@ -1,4 +1,5 @@
 import { Schema } from "effect";
+import type { CapabilityId } from "./capability-id";
 export declare const TaskStatus: Schema.Literals<readonly ["draft", "open", "ready", "queued", "running", "in_progress", "under_review", "blocked", "unknown", "completed", "failed", "cancelled", "closed"]>;
 export type TaskStatus = typeof TaskStatus.Type;
 export declare const GraphSummary: Schema.Struct<{
@@ -321,3 +322,39 @@ export declare const DependencyGraphModel: Schema.Struct<{
     readonly generatedAt: Schema.String;
 }>;
 export type DependencyGraphModel = typeof DependencyGraphModel.Type;
+/** Capability id the dependency-graph plugin registers its project-graph builder under. */
+export declare const GRAPH_PROJECT_CAPABILITY_ID = "rig.graph.project";
+/** Pure input to the project-graph builder: which workspace to analyze. */
+export type GraphProjectInput = {
+    readonly projectRoot: string;
+};
+/** The cohesive project-graph operation the substrate depends on. Async (does IO). */
+export interface GraphProjectService {
+    buildProjectGraph(input: GraphProjectInput): Promise<DependencyGraphModel>;
+}
+/** Typed capability id; string value is {@link GRAPH_PROJECT_CAPABILITY_ID}. */
+export declare const GRAPH_PROJECT: CapabilityId<GraphProjectService>;
+/** Capability id the dependency-graph plugin registers its task selector under. */
+export declare const TASK_SELECTION_CAPABILITY_ID = "cap:task-selection";
+/** Pure filters narrowing which tasks are eligible for selection. */
+export type TaskSelectionFilters = {
+    readonly assignee?: string;
+    readonly state?: "open" | "closed";
+    readonly search?: string;
+};
+/** Pure input to task selection: which workspace + optional filters. */
+export type TaskSelectionInput = {
+    readonly projectRoot: string;
+    readonly filters?: TaskSelectionFilters;
+};
+/** Pure result of task selection: the next ready task + the ready set it came from. */
+export type TaskSelectionResult = {
+    readonly selected: TaskSummary | null;
+    readonly ready: readonly TaskSummary[];
+};
+/** The cohesive task-selection operation the CLI surface depends on. Async (does IO). */
+export interface TaskSelectionService {
+    selectNextReadyTask(input: TaskSelectionInput): Promise<TaskSelectionResult>;
+}
+/** Typed capability id; string value is {@link TASK_SELECTION_CAPABILITY_ID}. */
+export declare const TASK_SELECTION: CapabilityId<TaskSelectionService>;

package/dist/src/graph.js

@@ -39,6 +39,11 @@ var ApprovalRequestId = makeEntityId("ApprovalRequestId");
 var CheckpointRef = makeEntityId("CheckpointRef");
 var RemoteEndpointId = makeEntityId("RemoteEndpointId");
 
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
 // packages/contracts/src/graph.ts
 var TaskStatus = Schema2.Literals([
   "draft",
@@ -196,6 +201,10 @@ var DependencyGraphModel = Schema2.Struct({
   degraded: Schema2.Boolean,
   generatedAt: IsoDateTime
 });
+var GRAPH_PROJECT_CAPABILITY_ID = "rig.graph.project";
+var GRAPH_PROJECT = makeCapabilityId(GRAPH_PROJECT_CAPABILITY_ID);
+var TASK_SELECTION_CAPABILITY_ID = "cap:task-selection";
+var TASK_SELECTION = makeCapabilityId(TASK_SELECTION_CAPABILITY_ID);
 export {
   TaskSummary,
   TaskStatus,
@@ -204,8 +213,12 @@ export {
   TaskGraphLayout,
   TaskGraphLane,
   TaskGraphEdge,
+  TASK_SELECTION_CAPABILITY_ID,
+  TASK_SELECTION,
   QueueEntry,
   GraphSummary,
+  GRAPH_PROJECT_CAPABILITY_ID,
+  GRAPH_PROJECT,
   DependencyNode,
   DependencyGraphModel,
   DependencyEdgeType,

package/dist/src/guard.d.ts

@@ -0,0 +1,111 @@
+import type { PolicyMode } from "./policy";
+export declare const POLICY_VERSION: 1;
+export type PolicyVersion = typeof POLICY_VERSION;
+export type { PolicyMode };
+export type RuleCategory = "command" | "content" | "import" | "test-integrity";
+export type RuleAction = "block" | "warn";
+export type RuleAppliesTo = "test-files";
+export type RuleMatch = {
+    pattern?: string;
+    regex?: string;
+};
+export type RuleUnless = {
+    regex?: string;
+    task_in?: string[];
+};
+export type PolicyRule = {
+    id: string;
+    category: RuleCategory;
+    description?: string;
+    match: RuleMatch;
+    unless?: RuleUnless;
+    action: RuleAction;
+    applies_to?: RuleAppliesTo;
+    compiledRegex?: RegExp;
+    compiledUnlessRegex?: RegExp;
+};
+export type ScopeConfig = {
+    fail_closed: boolean;
+    harness_paths_exempt: boolean;
+    runtime_paths_exempt: boolean;
+};
+export type SandboxConfig = {
+    mode: PolicyMode;
+    network: boolean;
+    read_deny: string[];
+    write_allow_from_runtime: boolean;
+};
+export type IsolationConfig = {
+    default_mode: "worktree";
+    repo_symlink_fallback: boolean;
+    strict_provisioning: boolean;
+    fail_closed_on_provision_error: boolean;
+};
+export type CompletionConfig = {
+    derive_checks_from_scope: boolean;
+    checks: string[];
+    typescript_config_probe: string[];
+    eslint_config_probe: string[];
+};
+export type RuntimeImageDeps = {
+    monorepo_install: boolean;
+    hp_next_install: boolean;
+};
+export type RuntimeImageConfig = {
+    deps: RuntimeImageDeps;
+    plugins_require_binaries: boolean;
+};
+export type RuntimeSnapshotConfig = {
+    enabled: boolean;
+};
+export type PolicyConfig = {
+    version: PolicyVersion;
+    mode: PolicyMode;
+    scope: ScopeConfig;
+    rules: PolicyRule[];
+    sandbox: SandboxConfig;
+    isolation: IsolationConfig;
+    completion: CompletionConfig;
+    runtime_image?: RuntimeImageConfig;
+    runtime_snapshot?: RuntimeSnapshotConfig;
+};
+export type ToolCallEvaluation = {
+    type: "tool-call";
+    tool_name: string;
+    tool_input: Record<string, unknown>;
+};
+export type CommandEvaluation = {
+    type: "command";
+    command: string;
+};
+export type ContentWriteEvaluation = {
+    type: "content-write";
+    file_path: string;
+    content: string;
+};
+export type FileAccessEvaluation = {
+    type: "file-access";
+    file_path: string;
+    access: "read" | "write";
+};
+export type GuardEvaluation = ToolCallEvaluation | CommandEvaluation | ContentWriteEvaluation | FileAccessEvaluation;
+export type GuardContext = {
+    projectRoot: string;
+    monorepoRoot?: string;
+    taskId?: string;
+    taskScopes?: string[];
+    taskWorkspace?: string;
+    evaluation: GuardEvaluation;
+};
+export type MatchedRule = {
+    id: string;
+    category: RuleCategory;
+    description?: string;
+    reason: string;
+};
+export type GuardDecision = {
+    allowed: boolean;
+    matchedRules: MatchedRule[];
+    action: "allow" | "block" | "warn";
+    failClosed: boolean;
+};

package/dist/src/guard.js

@@ -0,0 +1,6 @@
+// @bun
+// packages/contracts/src/guard.ts
+var POLICY_VERSION = 1;
+export {
+  POLICY_VERSION
+};

package/dist/src/harness-events.d.ts

@@ -0,0 +1,8 @@
+export type HarnessEventType = "runtime.init" | "command.received" | "policy.decision" | "command.started" | "command.finished" | "command.failed" | "plugin.loaded" | "plugin.error" | "validator.started" | "validator.finished" | "queue.started" | "queue.task.started" | "queue.task.finished" | "queue.finished" | "memory.command.requested" | "memory.command.applied" | "memory.command.failed";
+export type HarnessEvent<TPayload = Record<string, unknown>> = {
+    id: string;
+    runId: string;
+    timestamp: string;
+    type: HarnessEventType;
+    payload: TPayload;
+};

package/dist/src/harness-events.js

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

package/dist/src/help-catalog.d.ts

@@ -1,3 +1,4 @@
+import type { CapabilityId } from "./capability-id";
 export type HelpCommand = {
     command: string;
     description: string;
@@ -21,14 +22,20 @@ export type TopLevelSection = {
     subtitle: string;
     commands: HelpCommand[];
 };
-/** Catalog DATA for the app's help view — the view builds its own layout
- * from these; the render* functions below remain for plain/script output. */
-export declare function helpCatalog(): {
-    sections: readonly TopLevelSection[];
-    groups: readonly HelpGroup[];
+/** The full help catalog payload: top-level sections + command groups. */
+export type HelpCatalog = {
+    readonly sections: readonly TopLevelSection[];
+    readonly groups: readonly HelpGroup[];
+    /** Compatibility/internal commands shown only from advanced help. */
+    readonly advancedCommands?: readonly HelpCommand[];
+    /** Group names shown under advanced help; omitted means every group is shown. */
+    readonly advancedGroupNames?: readonly string[];
 };
-export declare const TOP_LEVEL_SECTIONS: TopLevelSection[];
-export declare const PRIMARY_GROUPS: HelpGroup[];
-export declare const ADVANCED_GROUPS: HelpGroup[];
-export declare const ADVANCED_COMMANDS: HelpCommand[];
-export declare const ALL_GROUPS: HelpGroup[];
+/** Capability id the CLI-surface plugin registers its help-catalog provider under. */
+export declare const HELP_CATALOG_CAPABILITY_ID = "rig.help.catalog";
+/** The cohesive help-catalog operation the cockpit depends on. Pure (data only). */
+export interface HelpCatalogService {
+    helpCatalog(): HelpCatalog;
+}
+/** Typed capability id; string value is {@link HELP_CATALOG_CAPABILITY_ID}. */
+export declare const HELP_CATALOG: CapabilityId<HelpCatalogService>;