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

package/dist/src/memory.d.ts

@@ -7,11 +7,15 @@
  * without a substrate->plugin import cycle. They carry no behaviour and import
  * nothing — exactly like `lifecycle-capabilities.ts`.
  *
- * The plugin registers its executable `MemoryService` impl under
- * {@link MEMORY_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/memory-service-port`.
+ * The plugin registers its executable `MemoryService` impl under the typed
+ * capability id {@link MEMORY} (whose string value is
+ * {@link MEMORY_SERVICE_CAPABILITY_ID}); the runtime resolves it by id from
+ * `pluginHost.listExecutableCapabilities()` via the `defineCapability` seam
+ * (`@rig/core/capability`), re-exported from the thin
+ * `@rig/runtime/control-plane/memory-service-port`.
  */
+import type { CapabilityId } from "./capability-id";
+import type { RuntimeMemoryRetrievalConfig, RuntimeTaskContext } from "./runtime-task-context";
 /** Capability id the memory plugin registers its `MemoryService` factory under. */
 export declare const MEMORY_SERVICE_CAPABILITY_ID = "memory.service";
 export declare const NO_MATCH_RETRIEVAL_CANONICAL_KEY = "__memory_recall__:none";
@@ -148,4 +152,48 @@ export type CanonicalMemorySnapshot = {
     createdFresh: boolean;
     cleanup(): Promise<void>;
 };
+/**
+ * Minimal telemetry sink the memory command emits run events through. The
+ * substrate's concrete event bus (`@rig/runtime` `EventBusLike`) is a superset
+ * and is structurally assignable to this; the memory contract only depends on
+ * `emit`, so the pure contract stays free of any runtime/behaviour import.
+ */
+export interface MemoryCommandEventSink {
+    emit<TPayload extends Record<string, unknown>>(type: string, payload: TPayload): Promise<unknown>;
+}
+/** Options for the agent-facing `rig-agent memory <verb>` command dispatch. */
+export type ExecuteMemoryCommandOptions = {
+    projectRoot: string;
+    taskId: string;
+    runtimeContext: RuntimeTaskContext | null;
+    args: string[];
+    eventBus?: MemoryCommandEventSink;
+};
+/** The retrieval-query shape the substrate passes through to the impl. */
+export type MemoryQueryPortInput = {
+    query: string;
+    limit?: number;
+    retrieval?: RuntimeMemoryRetrievalConfig;
+};
+/**
+ * The cohesive set of shared-memory operations the runtime consumers depend on.
+ * This is pure capability VOCAB: the `@rig/memory-plugin` provides a concrete
+ * impl (statically checked against this interface via `MemoryCap.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 MemoryService {
+    executeMemoryCommand(options: ExecuteMemoryCommandOptions): Promise<string>;
+    readCanonicalMemoryDb(projectRoot: string): Promise<CanonicalMemorySnapshot>;
+    openMemoryDb(dbPath: string): Promise<MemoryDb>;
+    queryRelevantMemory(db: MemoryDb, input: MemoryQueryPortInput): Promise<MemoryQueryResult[]>;
+    formatMemoryQueryResults(results: MemoryQueryResult[]): string;
+}
+/**
+ * The typed capability id the memory plugin provides and consumers require.
+ * Phantom-typed with `MemoryService` so `MemoryCap.require(host)` returns a
+ * `MemoryService` with no cast leaking to callers. Its string value is
+ * {@link MEMORY_SERVICE_CAPABILITY_ID}, so it indexes the same host entry.
+ */
+export declare const MEMORY: CapabilityId<MemoryService>;
 export {};

package/dist/src/memory.js

@@ -1,8 +1,15 @@
 // @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
 // packages/contracts/src/memory.ts
 var MEMORY_SERVICE_CAPABILITY_ID = "memory.service";
 var NO_MATCH_RETRIEVAL_CANONICAL_KEY = "__memory_recall__:none";
+var MEMORY = makeCapabilityId(MEMORY_SERVICE_CAPABILITY_ID);
 export {
   NO_MATCH_RETRIEVAL_CANONICAL_KEY,
-  MEMORY_SERVICE_CAPABILITY_ID
+  MEMORY_SERVICE_CAPABILITY_ID,
+  MEMORY
 };

package/dist/src/notify.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Pure NOTIFY capability vocab.
+ *
+ * The neutral home for the notification event/target data types and the typed
+ * capability seam so the floor (and any consumer) can resolve a notifier off a
+ * plugin host WITHOUT importing the provider package. Carries no behaviour —
+ * exactly like `browser.ts` / `memory.ts`.
+ *
+ * `@rig/notifications-plugin` provides the concrete `NotifyService` impl
+ * (config load + target selection = policy) under
+ * {@link NOTIFY_SERVICE_CAPABILITY} via the `defineCapability` seam.
+ */
+import type { CapabilityId } from "./capability-id";
+/** A Rig lifecycle event eligible for outbound notification. */
+export type RigEvent = {
+    id?: string;
+    runId?: string;
+    timestamp?: string;
+    type: string;
+    payload?: Record<string, unknown>;
+};
+/** A configured outbound notification channel. */
+export type NotificationTarget = {
+    id: string;
+    type: "slack-webhook" | "linear-webhook" | "notion-webhook" | "generic-webhook";
+    url: string;
+    enabled?: boolean;
+    events?: string[];
+    headers?: Record<string, string>;
+};
+/** The on-disk notification policy (`.rig/notifications.json`). */
+export type NotificationConfig = {
+    targets: NotificationTarget[];
+};
+/** Capability id the notifications plugin registers its `NotifyService` under. */
+export declare const NOTIFY_SERVICE_CAPABILITY_ID = "notify.dispatch";
+/**
+ * The cohesive notify operation consumers depend on. The impl owns the policy:
+ * which targets receive which events, loaded from the project's
+ * `.rig/notifications.json`. Returns the count of targets successfully notified.
+ */
+export interface NotifyService {
+    notify(event: RigEvent): Promise<number>;
+}
+/** Typed capability id the notifications plugin provides and consumers require. */
+export declare const NOTIFY_SERVICE_CAPABILITY: CapabilityId<NotifyService>;

package/dist/src/notify.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/notify.ts
+var NOTIFY_SERVICE_CAPABILITY_ID = "notify.dispatch";
+var NOTIFY_SERVICE_CAPABILITY = makeCapabilityId(NOTIFY_SERVICE_CAPABILITY_ID);
+export {
+  NOTIFY_SERVICE_CAPABILITY_ID,
+  NOTIFY_SERVICE_CAPABILITY
+};