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

package/dist/src/agent-roles.d.ts

@@ -0,0 +1,8 @@
+import type { AgentRoleRegistration } from "./plugin";
+export interface ResolvedAgentRole extends AgentRoleRegistration {
+    model: string;
+}
+export interface AgentRoleRegistry {
+    resolve(id: string): ResolvedAgentRole;
+    list(): readonly ResolvedAgentRole[];
+}

package/dist/src/browser.d.ts

@@ -8,11 +8,14 @@
  * no behaviour and import nothing — exactly like `memory.ts` /
  * `lifecycle-capabilities.ts`.
  *
- * The plugin registers its executable `BrowserContractService` impl under
- * {@link BROWSER_CONTRACT_SERVICE_CAPABILITY_ID} on `contributes.capabilities[].run`;
- * the runtime resolves it by id from `pluginHost.listExecutableCapabilities()`
- * via the typed port in `@rig/runtime/control-plane/browser-contract-port`.
+ * The plugin registers its executable `BrowserContractService` impl under the
+ * typed capability id {@link BROWSER_CONTRACT_SERVICE_CAPABILITY} (whose string
+ * value is {@link BROWSER_CONTRACT_SERVICE_CAPABILITY_ID}) via the
+ * `defineCapability` seam (`@rig/core/capability`); the runtime resolves it by id
+ * from `pluginHost.listExecutableCapabilities()` via the thin typed port in
+ * `@rig/runtime/control-plane/browser-contract-port`.
  */
+import type { CapabilityId } from "./capability-id";
 /** Capability id the browser plugin registers its `BrowserContractService` factory under. */
 export declare const BROWSER_CONTRACT_SERVICE_CAPABILITY_ID = "browser.contract";
 /** Author-facing browser config attached to a task entry (rig.config / task source). */
@@ -48,3 +51,30 @@ export type RuntimeBrowserContext = {
     e2eHelper: string;
     resetProfileHelper: string;
 };
+/** Options for deriving the runtime-effective browser context. */
+export type ResolveTaskBrowserContextOptions = {
+    hostProjectRoot?: string;
+    runtimeId?: string;
+};
+/**
+ * The cohesive set of browser-contract operations the runtime consumers depend
+ * on. This is pure capability VOCAB: the `@rig/browser-plugin` provides a
+ * concrete impl (statically checked against this interface via
+ * `BrowserContractCap.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 BrowserContractService {
+    /** Resolve an author-facing `TaskBrowserConfig` into the runtime-effective context. */
+    resolveTaskBrowserContext(browser: TaskBrowserConfig | undefined, options?: ResolveTaskBrowserContextOptions): RuntimeBrowserContext | undefined;
+    /** Render the `task info` guidance lines for a resolved browser context. */
+    buildBrowserGuidanceLines(browser: RuntimeBrowserContext): string[];
+}
+/**
+ * The typed capability id the browser plugin provides and consumers require.
+ * Phantom-typed with {@link BrowserContractService} so
+ * `BrowserContractCap.require(host)` returns a `BrowserContractService` with no
+ * cast leaking to callers. Its string value is
+ * {@link BROWSER_CONTRACT_SERVICE_CAPABILITY_ID}, so it indexes the same host
+ * entry.
+ */
+export declare const BROWSER_CONTRACT_SERVICE_CAPABILITY: CapabilityId<BrowserContractService>;

package/dist/src/browser.js

@@ -1,6 +1,13 @@
 // @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
 // packages/contracts/src/browser.ts
 var BROWSER_CONTRACT_SERVICE_CAPABILITY_ID = "browser.contract";
+var BROWSER_CONTRACT_SERVICE_CAPABILITY = makeCapabilityId(BROWSER_CONTRACT_SERVICE_CAPABILITY_ID);
 export {
-  BROWSER_CONTRACT_SERVICE_CAPABILITY_ID
+  BROWSER_CONTRACT_SERVICE_CAPABILITY_ID,
+  BROWSER_CONTRACT_SERVICE_CAPABILITY
 };

package/dist/src/capability-id.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Capability-seam vocabulary.
+ *
+ * A `CapabilityId<T>` is a plain id string branded (phantom-typed) with the
+ * service type `T` it resolves to. `defineCapability<T>` (in `@rig/core`) reads
+ * this brand so `resolve`/`require` are typed as `T` with the `unknown → T` cast
+ * contained ONCE inside the helper — callers never cast.
+ *
+ * Pure: no imports, no behaviour. The brand lives only in an OPTIONAL phantom
+ * property so a plain `string` is still assignable to `CapabilityId<T>` via the
+ * `makeCapabilityId` cast, and a `CapabilityId<T>` is usable anywhere a `string`
+ * is (equality checks against `host` capability ids, `.toString()`, etc.).
+ */
+declare const CapabilityIdBrand: unique symbol;
+/** A capability id string branded with the service type `T` it resolves to. */
+export type CapabilityId<T> = string & {
+    /** Phantom — never present at runtime; carries `T` for `defineCapability<T>`. */
+    readonly [CapabilityIdBrand]?: T;
+};
+/** Brand a plain id string as a `CapabilityId<T>`. */
+export declare function makeCapabilityId<T>(id: string): CapabilityId<T>;
+export {};

package/dist/src/capability-id.js

@@ -0,0 +1,8 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+export {
+  makeCapabilityId
+};

package/dist/src/cli-output.d.ts

@@ -322,3 +322,27 @@ export declare const RigStatsOutput: Schema.Struct<{
     }>;
 }>;
 export type RigStatsOutput = typeof RigStatsOutput.Type;
+export type OutputMode = "text" | "json";
+export type CommandExecutionResult = {
+    command: string[];
+    formattedCommand: string;
+    exitCode: number;
+    durationMs: number;
+    startedAt: string;
+    finishedAt: string;
+    stdout?: string;
+    stderr?: string;
+};
+/** Structured outcome a `rig <group> <command>` handler returns to the runner. */
+export type CommandOutcome = {
+    readonly ok: boolean;
+    readonly group: string;
+    readonly command: string;
+    readonly details?: Record<string, unknown>;
+};
+export type PluginValidatorResult = {
+    id: string;
+    passed: boolean;
+    summary: string;
+    details?: string;
+};

package/dist/src/cli-runner.d.ts

@@ -0,0 +1,43 @@
+import type { CapabilityId } from "./capability-id";
+import type { CommandExecutionResult, OutputMode } from "./cli-output";
+import type { HarnessEvent, HarnessEventType } from "./harness-events";
+import type { PolicyConfig, PolicyMode } from "./guard";
+export type CliRuntimeInitializeOptions = {
+    readonly projectRoot: string;
+    readonly dryRun: boolean;
+    readonly outputMode: OutputMode;
+    readonly runId?: string;
+    readonly policyMode?: PolicyMode;
+};
+export type CliRuntimeContext = {
+    readonly projectRoot: string;
+    readonly dryRun: boolean;
+    readonly outputMode: OutputMode;
+    readonly runId: string;
+    readonly policyMode?: PolicyMode;
+    readonly eventBus: {
+        getRunId(): string;
+        getEventsFile(): string;
+        getMemoryEvents(): HarnessEvent[];
+        emit<TPayload extends Record<string, unknown>>(type: HarnessEventType, payload: TPayload): Promise<HarnessEvent<TPayload>>;
+    };
+    readonly emitEvent: <TPayload extends Record<string, unknown>>(type: HarnessEventType, payload: TPayload) => Promise<void>;
+    readonly runCommand: (parts: string[]) => Promise<CommandExecutionResult>;
+};
+export type AgentShellMaterializationOptions = {
+    readonly env?: Record<string, string | undefined>;
+    readonly cwd?: string;
+    readonly moduleDir?: string;
+    readonly build?: (entrypoint: string, output: string, cwd: string, define?: Record<string, string>) => Promise<void>;
+};
+export interface CliRunnerService {
+    initializeRuntime(options: CliRuntimeInitializeOptions): Promise<CliRuntimeContext>;
+    runCommand(context: CliRuntimeContext, parts: string[]): Promise<CommandExecutionResult>;
+    ensureAgentShellBinary(projectRoot: string, options?: AgentShellMaterializationOptions): Promise<string>;
+    resolveAgentMaterializationSourceRoot(projectRoot: string, options?: AgentShellMaterializationOptions): string;
+    withProjectRoot(projectRoot: string): void;
+    formatCommand(parts: string[]): string;
+    loadPolicy(projectRoot: string): PolicyConfig;
+}
+export declare const CLI_RUNNER_CAPABILITY_ID = "rig.cli.runner";
+export declare const CLI_RUNNER: CapabilityId<CliRunnerService>;

package/dist/src/cli-runner.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/cli-runner.ts
+var CLI_RUNNER_CAPABILITY_ID = "rig.cli.runner";
+var CLI_RUNNER = makeCapabilityId(CLI_RUNNER_CAPABILITY_ID);
+export {
+  CLI_RUNNER_CAPABILITY_ID,
+  CLI_RUNNER
+};

package/dist/src/collab-session-viewer.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Pure collab-session-viewer surface vocab.
+ *
+ * The neutral seam for the browser collab-session viewer SPA (the `collab-web`
+ * client, owned by `@rig/collab-session-browser-plugin`). Consumers resolve the
+ * surface off a plugin host without importing the plugin or the SPA. Carries no
+ * behaviour — like `browser.ts` / `notify.ts`.
+ *
+ * The plugin provides the concrete impl (built `dist/` location + the pi-wire
+ * link grammar) under {@link COLLAB_SESSION_VIEWER_CAPABILITY} via the
+ * `defineCapability` seam.
+ */
+import type { CapabilityId } from "./capability-id";
+/** Inputs to format a shareable collab-session viewer link (pi-wire grammar). */
+export interface CollabSessionViewerLinkInput {
+    relayUrl: string;
+    roomId: string;
+    key: Uint8Array;
+    writeToken?: Uint8Array;
+}
+/** Capability id the collab-session-browser plugin registers its surface under. */
+export declare const COLLAB_SESSION_VIEWER_CAPABILITY_ID = "collab.session-viewer";
+/**
+ * The browser collab-session viewer surface. `distDir()` is the built SPA static
+ * root (serve it to hand a browser the live transcript viewer); `formatViewerLink`
+ * preserves the exact `@oh-my-pi/pi-wire` link grammar so a `roomId.key` link
+ * opens the streaming session.
+ */
+export interface CollabSessionViewerSurface {
+    /** Absolute path to the built browser SPA dist directory (static assets). */
+    distDir(): string;
+    /** Format the shareable viewer link using the preserved pi-wire link grammar. */
+    formatViewerLink(input: CollabSessionViewerLinkInput): string;
+}
+/** Typed capability id the plugin provides and consumers require. */
+export declare const COLLAB_SESSION_VIEWER_CAPABILITY: CapabilityId<CollabSessionViewerSurface>;

package/dist/src/collab-session-viewer.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/collab-session-viewer.ts
+var COLLAB_SESSION_VIEWER_CAPABILITY_ID = "collab.session-viewer";
+var COLLAB_SESSION_VIEWER_CAPABILITY = makeCapabilityId(COLLAB_SESSION_VIEWER_CAPABILITY_ID);
+export {
+  COLLAB_SESSION_VIEWER_CAPABILITY_ID,
+  COLLAB_SESSION_VIEWER_CAPABILITY
+};

package/dist/src/config.d.ts

@@ -316,6 +316,9 @@ export declare const RigConfig: Schema.Struct<{
                 readonly usage: Schema.optional<Schema.String>;
                 readonly aliases: Schema.optional<Schema.$Array<Schema.String>>;
                 readonly projectRequired: Schema.optional<Schema.Boolean>;
+                readonly rootDefault: Schema.optional<Schema.Boolean>;
+                readonly productRoot: Schema.optional<Schema.Boolean>;
+                readonly subcommands: Schema.optional<Schema.$Array<Schema.String>>;
             }>>>;
             readonly stages: Schema.optional<Schema.$Array<Schema.Struct<{
                 readonly id: Schema.brand<Schema.Trim, "StageId">;
@@ -373,6 +376,7 @@ export declare const RigConfig: Schema.Struct<{
                 readonly description: Schema.optional<Schema.String>;
                 readonly commandId: Schema.optional<Schema.String>;
                 readonly panelId: Schema.optional<Schema.String>;
+                readonly run: Schema.optional<Schema.declare<import("./plugin").CapabilityRun, import("./plugin").CapabilityRun>>;
             }>>>;
             readonly panels: Schema.optional<Schema.$Array<Schema.Struct<{
                 readonly id: Schema.String;
@@ -392,6 +396,13 @@ export declare const RigConfig: Schema.Struct<{
                 readonly id: Schema.String;
                 readonly description: Schema.optional<Schema.String>;
             }>>>;
+            readonly seedEntrypoints: Schema.optional<Schema.$Array<Schema.Struct<{
+                readonly id: Schema.String;
+                readonly description: Schema.optional<Schema.String>;
+                readonly basename: Schema.optional<Schema.String>;
+                readonly workerArg: Schema.optional<Schema.String>;
+                readonly insidePty: Schema.optional<Schema.Boolean>;
+            }>>>;
         }>>;
     }>>;
     readonly taskSource: Schema.Struct<{