@h-rig/memory-plugin 0.0.6-alpha.156

package/dist/src/query.d.ts

@@ -0,0 +1,12 @@
+import type { MemoryDb, MemoryEmbedder, MemoryQueryResult } from "@rig/contracts";
+import { type RuntimeMemoryRetrievalConfig } from "@rig/runtime/control-plane/runtime/context";
+export type { MemoryQueryResult };
+export type MemoryQueryInput = {
+    query: string;
+    limit?: number;
+    embedder?: MemoryEmbedder;
+    retrieval?: RuntimeMemoryRetrievalConfig;
+    now?: string | Date;
+};
+export declare function queryRelevantMemory(db: MemoryDb, input: MemoryQueryInput): Promise<MemoryQueryResult[]>;
+export declare function formatMemoryQueryResults(results: MemoryQueryResult[]): string;

package/dist/src/query.js

@@ -0,0 +1,291 @@
+// @bun
+// packages/memory-plugin/src/embed.ts
+import { createHash } from "crypto";
+
+// packages/memory-plugin/src/db.ts
+import {
+  NO_MATCH_RETRIEVAL_CANONICAL_KEY
+} from "@rig/contracts";
+function parseJsonRecord(value) {
+  if (typeof value !== "string" || value.length === 0) {
+    return null;
+  }
+  return JSON.parse(value);
+}
+function parseEmbedding(value) {
+  if (typeof value !== "string" || value.length === 0) {
+    return null;
+  }
+  return JSON.parse(value);
+}
+function rowString(row, key) {
+  const value = row[key];
+  return value == null ? null : String(value);
+}
+function toMemoryItemRow(row) {
+  return {
+    canonicalKey: String(row.canonical_key),
+    summary: String(row.summary),
+    kind: rowString(row, "kind"),
+    category: rowString(row, "category"),
+    status: String(row.status),
+    confidence: Number(row.confidence),
+    sourceRunId: rowString(row, "source_run_id"),
+    sourceTaskId: rowString(row, "source_task_id"),
+    branch: rowString(row, "branch"),
+    details: parseJsonRecord(row.details_json),
+    createdAt: String(row.created_at),
+    updatedAt: String(row.updated_at),
+    lastEventId: String(row.last_event_id),
+    supersededBy: rowString(row, "superseded_by"),
+    embedding: parseEmbedding(row.embedding)
+  };
+}
+async function listActiveMemoryItems(db) {
+  const result = await db.client.execute(`
+    SELECT
+      canonical_key,
+      summary,
+      kind,
+      category,
+      status,
+      confidence,
+      source_run_id,
+      source_task_id,
+      branch,
+      details_json,
+      created_at,
+      updated_at,
+      last_event_id,
+      superseded_by,
+      embedding
+    FROM memory_items
+    WHERE status = 'active'
+    ORDER BY canonical_key
+  `);
+  return result.rows.map((row) => toMemoryItemRow(row));
+}
+
+// packages/memory-plugin/src/embed.ts
+var DEFAULT_EMBEDDING_API_BASE_URL = "https://api.openai.com/v1";
+var DEFAULT_EMBEDDING_MODEL = "text-embedding-3-small";
+var DETERMINISTIC_EMBEDDER_MODE = "deterministic";
+var DETERMINISTIC_VECTOR_DIMS = 32;
+function tokenizeForDeterministicEmbedding(text) {
+  const tokens = text.toLowerCase().match(/[a-z0-9_./:-]+/g) ?? [];
+  return tokens.length > 0 ? tokens : [text.toLowerCase()];
+}
+function deterministicTokenVector(token) {
+  const hash = createHash("sha256").update(token).digest();
+  const vector = new Array(DETERMINISTIC_VECTOR_DIMS).fill(0);
+  for (let index = 0;index < 8; index += 1) {
+    const slot = (hash[index] ?? 0) % DETERMINISTIC_VECTOR_DIMS;
+    const sign = ((hash[index + 8] ?? 0) & 1) === 0 ? 1 : -1;
+    const magnitude = ((hash[index + 16] ?? 0) + 1) / 256;
+    vector[slot] = (vector[slot] ?? 0) + sign * magnitude;
+  }
+  return vector;
+}
+function normalizeVector(vector) {
+  const norm = Math.sqrt(vector.reduce((sum, value) => sum + value * value, 0));
+  if (norm === 0) {
+    return vector.map(() => 0);
+  }
+  return vector.map((value) => Number((value / norm).toFixed(6)));
+}
+function createDeterministicMemoryEmbedder() {
+  return {
+    async embed(texts) {
+      return texts.map((text) => {
+        const vector = new Array(DETERMINISTIC_VECTOR_DIMS).fill(0);
+        for (const token of tokenizeForDeterministicEmbedding(text)) {
+          const tokenVector = deterministicTokenVector(token);
+          for (let index = 0;index < tokenVector.length; index += 1) {
+            vector[index] = (vector[index] ?? 0) + (tokenVector[index] ?? 0);
+          }
+        }
+        return normalizeVector(vector);
+      });
+    }
+  };
+}
+function embeddingResponseMessage(payload, status) {
+  if (typeof payload === "object" && payload !== null) {
+    const maybeMessage = payload.error?.message;
+    if (maybeMessage) {
+      return maybeMessage;
+    }
+  }
+  return `memory embedding request failed with status ${status}`;
+}
+function createOpenAiMemoryEmbedder(options) {
+  const apiKey = options.apiKey.trim();
+  const model = options.model?.trim() || DEFAULT_EMBEDDING_MODEL;
+  const apiBaseUrl = (options.apiBaseUrl?.trim() || DEFAULT_EMBEDDING_API_BASE_URL).replace(/\/+$/, "");
+  const fetchImpl = options.fetchImpl ?? fetch;
+  if (!apiKey) {
+    throw new Error("memory embedding api key must be non-empty");
+  }
+  return {
+    async embed(texts) {
+      if (texts.length === 0) {
+        return [];
+      }
+      const response = await fetchImpl(`${apiBaseUrl}/embeddings`, {
+        method: "POST",
+        headers: {
+          authorization: `Bearer ${apiKey}`,
+          "content-type": "application/json"
+        },
+        body: JSON.stringify({
+          input: texts,
+          model
+        })
+      });
+      const payload = await response.json();
+      if (!response.ok) {
+        throw new Error(embeddingResponseMessage(payload, response.status));
+      }
+      if (!Array.isArray(payload.data) || payload.data.length !== texts.length) {
+        throw new Error(`memory embedding provider returned ${payload.data?.length ?? 0} embeddings for ${texts.length} inputs`);
+      }
+      const byIndex = new Map;
+      for (const row of payload.data) {
+        if (typeof row.index !== "number" || !Array.isArray(row.embedding)) {
+          throw new Error("memory embedding provider returned an invalid response payload");
+        }
+        byIndex.set(row.index, row.embedding);
+      }
+      return texts.map((_text, index) => {
+        const embedding = byIndex.get(index);
+        if (!embedding) {
+          throw new Error(`memory embedding provider omitted embedding ${index}`);
+        }
+        return embedding;
+      });
+    }
+  };
+}
+function createConfiguredMemoryEmbedder(options = {}) {
+  const env = options.env ?? process.env;
+  const mode = env.RIG_MEMORY_EMBEDDER?.trim();
+  if (mode === DETERMINISTIC_EMBEDDER_MODE) {
+    return createDeterministicMemoryEmbedder();
+  }
+  const apiKey = env.OPENAI_API_KEY?.trim();
+  if (!apiKey) {
+    throw new Error("memory embeddings require OPENAI_API_KEY or RIG_MEMORY_EMBEDDER=deterministic");
+  }
+  return createOpenAiMemoryEmbedder({
+    apiKey,
+    model: env.RIG_MEMORY_EMBEDDING_MODEL?.trim() || DEFAULT_EMBEDDING_MODEL,
+    apiBaseUrl: options.apiBaseUrl ?? env.RIG_MEMORY_EMBEDDING_API_BASE_URL?.trim() ?? DEFAULT_EMBEDDING_API_BASE_URL,
+    fetchImpl: options.fetchImpl
+  });
+}
+
+// packages/memory-plugin/src/query.ts
+import {
+  DEFAULT_RUNTIME_MEMORY_RETRIEVAL
+} from "@rig/runtime/control-plane/runtime/context";
+var DEFAULT_RESULT_LIMIT = DEFAULT_RUNTIME_MEMORY_RETRIEVAL.topK;
+var DAY_MS = 24 * 60 * 60 * 1000;
+var MIN_VECTOR_MATCH_SCORE = 0.2;
+function tokenize(text) {
+  return (text.toLowerCase().match(/[a-z0-9_./:-]+/g) ?? []).flatMap((token) => {
+    const split = token.split(/[./:_-]+/).filter(Boolean);
+    return split.length > 0 ? [token, ...split] : [token];
+  });
+}
+function lexicalScore(query, item) {
+  const queryTokens = [...new Set(tokenize(query))];
+  if (queryTokens.length === 0) {
+    return 0;
+  }
+  const haystackTokens = new Set(tokenize(item.summary));
+  let matched = 0;
+  for (const token of queryTokens) {
+    if (haystackTokens.has(token)) {
+      matched += 1;
+    }
+  }
+  return matched / queryTokens.length;
+}
+function cosineSimilarity(left, right) {
+  if (left.length === 0 || left.length !== right.length) {
+    return 0;
+  }
+  let dot = 0;
+  let leftNorm = 0;
+  let rightNorm = 0;
+  for (let index = 0;index < left.length; index += 1) {
+    const l = left[index] ?? 0;
+    const r = right[index] ?? 0;
+    dot += l * r;
+    leftNorm += l * l;
+    rightNorm += r * r;
+  }
+  if (leftNorm === 0 || rightNorm === 0) {
+    return 0;
+  }
+  return dot / Math.sqrt(leftNorm * rightNorm);
+}
+function recencyScore(item, now) {
+  const updatedAt = Date.parse(item.updatedAt);
+  if (Number.isNaN(updatedAt)) {
+    return 0;
+  }
+  const ageMs = Math.max(0, now.getTime() - updatedAt);
+  return 1 / (1 + ageMs / DAY_MS);
+}
+async function maybeEmbedQuery(items, query, embedder) {
+  if (!items.some((item) => Array.isArray(item.embedding) && item.embedding.length > 0)) {
+    return null;
+  }
+  try {
+    const resolvedEmbedder = embedder ?? createConfiguredMemoryEmbedder();
+    const [queryEmbedding] = await resolvedEmbedder.embed([query]);
+    return queryEmbedding ?? null;
+  } catch {
+    return null;
+  }
+}
+async function queryRelevantMemory(db, input) {
+  const retrieval = input.retrieval ?? DEFAULT_RUNTIME_MEMORY_RETRIEVAL;
+  const now = input.now instanceof Date ? input.now : new Date(input.now ?? Date.now());
+  const items = await listActiveMemoryItems(db);
+  if (items.length === 0) {
+    return [];
+  }
+  const queryEmbedding = await maybeEmbedQuery(items, input.query, input.embedder);
+  const scored = items.map((item) => {
+    const lexical = lexicalScore(input.query, item);
+    const vector = queryEmbedding && item.embedding ? cosineSimilarity(queryEmbedding, item.embedding) : 0;
+    const recency = recencyScore(item, now);
+    const score = retrieval.lexicalWeight * lexical + retrieval.vectorWeight * vector + retrieval.recencyWeight * recency + retrieval.confidenceWeight * item.confidence;
+    return {
+      canonicalKey: item.canonicalKey,
+      summary: item.summary,
+      kind: item.kind,
+      category: item.category,
+      confidence: item.confidence,
+      updatedAt: item.updatedAt,
+      score,
+      lexicalScore: lexical,
+      vectorScore: vector,
+      recencyScore: recency
+    };
+  }).filter((item) => item.lexicalScore > 0 || item.vectorScore >= MIN_VECTOR_MATCH_SCORE).sort((left, right) => right.score - left.score || Date.parse(right.updatedAt) - Date.parse(left.updatedAt) || right.confidence - left.confidence || left.canonicalKey.localeCompare(right.canonicalKey));
+  return scored.slice(0, input.limit ?? retrieval.topK ?? DEFAULT_RESULT_LIMIT);
+}
+function formatMemoryQueryResults(results) {
+  if (results.length === 0) {
+    return "No shared memories matched.";
+  }
+  return results.map((result, index) => `${index + 1}. [${result.canonicalKey}] ${result.summary} (confidence ${result.confidence.toFixed(2)})`).join(`
+`);
+}
+export {
+  queryRelevantMemory,
+  formatMemoryQueryResults
+};

package/dist/src/read.d.ts

@@ -0,0 +1,12 @@
+import { nativeFetchRef, nativeReadBlobBytesAtRef } from "@rig/runtime/control-plane/native/git-native";
+import { openMemoryDb } from "./db";
+import type { CanonicalMemorySnapshot } from "@rig/contracts";
+export type { CanonicalMemorySnapshot };
+type CanonicalMemoryReadDeps = {
+    fetchRef: typeof nativeFetchRef;
+    readBlobBytesAtRef: typeof nativeReadBlobBytesAtRef;
+    openMemoryDb: typeof openMemoryDb;
+    makeTempDir: () => string;
+    removeDir: (path: string) => void;
+};
+export declare function readCanonicalMemoryDb(projectRoot: string, deps?: Partial<CanonicalMemoryReadDeps>): Promise<CanonicalMemorySnapshot>;

package/dist/src/read.js

@@ -0,0 +1,314 @@
+// @bun
+// packages/memory-plugin/src/read.ts
+import { mkdtempSync, rmSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import { nativeFetchRef, nativeReadBlobBytesAtRef } from "@rig/runtime/control-plane/native/git-native";
+import { resolveMonorepoRoot } from "@rig/runtime/control-plane/native/utils";
+
+// packages/memory-plugin/src/db.ts
+import { Database } from "bun:sqlite";
+import { mkdirSync } from "fs";
+import { dirname } from "path";
+import {
+  NO_MATCH_RETRIEVAL_CANONICAL_KEY
+} from "@rig/contracts";
+var SCHEMA_STATEMENTS = [
+  `CREATE TABLE IF NOT EXISTS memory_events (
+    event_id TEXT PRIMARY KEY,
+    event_type TEXT NOT NULL,
+    canonical_key TEXT NOT NULL,
+    summary TEXT,
+    kind TEXT,
+    category TEXT,
+    confidence REAL,
+    source_run_id TEXT,
+    source_task_id TEXT,
+    branch TEXT,
+    source_canonical_key TEXT,
+    replacement_canonical_key TEXT,
+    retrieval_query TEXT,
+    retrieval_rank INTEGER,
+    feedback_outcome TEXT,
+    details_json TEXT,
+    created_at TEXT NOT NULL
+  )`,
+  `CREATE TABLE IF NOT EXISTS memory_items (
+    canonical_key TEXT PRIMARY KEY,
+    summary TEXT NOT NULL,
+    kind TEXT,
+    category TEXT,
+    status TEXT NOT NULL,
+    confidence REAL NOT NULL,
+    source_run_id TEXT,
+    source_task_id TEXT,
+    branch TEXT,
+    details_json TEXT,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    last_event_id TEXT NOT NULL,
+    superseded_by TEXT,
+    embedding TEXT
+  )`,
+  `CREATE TABLE IF NOT EXISTS memory_links (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    from_key TEXT NOT NULL,
+    to_key TEXT NOT NULL,
+    relation TEXT NOT NULL,
+    source_event_id TEXT NOT NULL,
+    created_at TEXT NOT NULL
+  )`,
+  `CREATE TABLE IF NOT EXISTS task_runs (
+    run_id TEXT PRIMARY KEY,
+    task_id TEXT,
+    branch TEXT,
+    first_event_id TEXT,
+    last_event_id TEXT,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  )`,
+  `CREATE TABLE IF NOT EXISTS retrieval_feedback (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    canonical_key TEXT NOT NULL,
+    outcome TEXT NOT NULL,
+    retrieval_rank INTEGER,
+    source_run_id TEXT,
+    source_task_id TEXT,
+    query_text TEXT,
+    source_event_id TEXT NOT NULL,
+    created_at TEXT NOT NULL
+  )`
+];
+var MEMORY_EVENT_COLUMNS = [
+  ["summary", "TEXT"],
+  ["kind", "TEXT"],
+  ["category", "TEXT"],
+  ["confidence", "REAL"],
+  ["source_run_id", "TEXT"],
+  ["source_task_id", "TEXT"],
+  ["branch", "TEXT"],
+  ["source_canonical_key", "TEXT"],
+  ["replacement_canonical_key", "TEXT"],
+  ["retrieval_query", "TEXT"],
+  ["retrieval_rank", "INTEGER"],
+  ["feedback_outcome", "TEXT"],
+  ["details_json", "TEXT"]
+];
+var MEMORY_ITEM_COLUMNS = [
+  ["kind", "TEXT"],
+  ["category", "TEXT"],
+  ["branch", "TEXT"],
+  ["details_json", "TEXT"],
+  ["superseded_by", "TEXT"],
+  ["embedding", "TEXT"]
+];
+function normalizeStatement(statement, args) {
+  if (typeof statement === "string") {
+    return { sql: statement, args };
+  }
+  return {
+    sql: statement.sql,
+    args: statement.args ?? args
+  };
+}
+function normalizeBindings(bindings) {
+  return (bindings ?? []).map((binding) => binding === undefined ? null : binding);
+}
+function statementVerb(sql) {
+  const match = sql.trim().match(/^[A-Za-z]+/);
+  return match ? match[0].toUpperCase() : "";
+}
+function isMutationStatement(sql) {
+  return new Set([
+    "ALTER",
+    "ATTACH",
+    "BEGIN",
+    "COMMIT",
+    "CREATE",
+    "DELETE",
+    "DETACH",
+    "DROP",
+    "END",
+    "INSERT",
+    "REINDEX",
+    "RELEASE",
+    "REPLACE",
+    "ROLLBACK",
+    "SAVEPOINT",
+    "UPDATE",
+    "VACUUM"
+  ]).has(statementVerb(sql));
+}
+function executeSqlite(sqlite, statement, args) {
+  const normalized = normalizeStatement(statement, args);
+  const bindings = normalizeBindings(normalized.args);
+  if (isMutationStatement(normalized.sql)) {
+    const result = bindings.length > 0 ? sqlite.run(normalized.sql, ...bindings) : sqlite.run(normalized.sql);
+    return {
+      rows: [],
+      rowsAffected: Number(result.changes)
+    };
+  }
+  const query = sqlite.query(normalized.sql);
+  const rows = bindings.length > 0 ? query.all(...bindings) : query.all();
+  return {
+    rows,
+    rowsAffected: 0
+  };
+}
+function createTransaction(sqlite, mode) {
+  sqlite.run(mode === "write" ? "BEGIN IMMEDIATE" : "BEGIN");
+  let active = true;
+  return {
+    async execute(statement, args) {
+      if (!active) {
+        throw new Error("memory transaction is closed");
+      }
+      return executeSqlite(sqlite, statement, args);
+    },
+    async commit() {
+      if (!active) {
+        return;
+      }
+      sqlite.run("COMMIT");
+      active = false;
+    },
+    async rollback() {
+      if (!active) {
+        return;
+      }
+      sqlite.run("ROLLBACK");
+      active = false;
+    },
+    close() {
+      if (!active) {
+        return;
+      }
+      try {
+        sqlite.run("ROLLBACK");
+      } catch {} finally {
+        active = false;
+      }
+    }
+  };
+}
+function createMemoryDbClient(sqlite) {
+  return {
+    async execute(statement, args) {
+      return executeSqlite(sqlite, statement, args);
+    },
+    async transaction(mode) {
+      return createTransaction(sqlite, mode);
+    },
+    close() {
+      sqlite.close();
+    }
+  };
+}
+async function listColumns(executor, tableName) {
+  const result = await executor.execute(`PRAGMA table_info(${tableName})`);
+  return new Set(result.rows.map((row) => String(row.name)));
+}
+async function ensureColumns(executor, tableName, columns) {
+  const existing = await listColumns(executor, tableName);
+  for (const [columnName, definition] of columns) {
+    if (!existing.has(columnName)) {
+      await executor.execute(`ALTER TABLE ${tableName} ADD COLUMN ${columnName} ${definition}`);
+    }
+  }
+}
+async function ensureSchema(db) {
+  for (const statement of SCHEMA_STATEMENTS) {
+    await db.client.execute(statement);
+  }
+  await ensureColumns(db.client, "memory_events", MEMORY_EVENT_COLUMNS);
+  await ensureColumns(db.client, "memory_items", MEMORY_ITEM_COLUMNS);
+}
+async function openMemoryDb(dbPath) {
+  mkdirSync(dirname(dbPath), { recursive: true });
+  const sqlite = new Database(dbPath, { create: true, strict: true });
+  const client = createMemoryDbClient(sqlite);
+  const db = {
+    path: dbPath,
+    client,
+    async close() {
+      client.close();
+    }
+  };
+  await ensureSchema(db);
+  return db;
+}
+
+// packages/memory-plugin/src/read.ts
+var CANONICAL_MEMORY_DB_PATH = "rig/memory/project-memory.db";
+var DEFAULT_READ_DEPS = {
+  fetchRef: nativeFetchRef,
+  readBlobBytesAtRef: nativeReadBlobBytesAtRef,
+  openMemoryDb,
+  makeTempDir: () => mkdtempSync(join(tmpdir(), "memory-sync-read-")),
+  removeDir: (path) => rmSync(path, { recursive: true, force: true })
+};
+function isMissingCanonicalMemoryBlobError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.includes(`path '${CANONICAL_MEMORY_DB_PATH}' does not exist in`) || message.includes(`path '${CANONICAL_MEMORY_DB_PATH}' exists on disk, but not in`) || message.includes(`pathspec '${CANONICAL_MEMORY_DB_PATH}' did not match any file(s) known to git`);
+}
+async function validateReadableDatabase(dbPath, open) {
+  const db = await open(dbPath);
+  await db.close();
+}
+async function readCanonicalMemoryDb(projectRoot, deps = {}) {
+  const readDeps = { ...DEFAULT_READ_DEPS, ...deps };
+  const repoPath = resolveMonorepoRoot(projectRoot);
+  let baseOid;
+  let remoteUnavailable = false;
+  try {
+    baseOid = readDeps.fetchRef(repoPath, "origin", "main");
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const originAbsent = /no such remote|remote (?:'|")?origin(?:'|")? not found/i.test(message);
+    if (!originAbsent) {
+      console.warn(`[rig-memory] canonical project memory unavailable (origin/main): ${message.split(`
+`)[0]} \u2014 starting this run with empty project memory.`);
+    }
+    baseOid = "";
+    remoteUnavailable = true;
+  }
+  const tempDir = readDeps.makeTempDir();
+  const dbPath = join(tempDir, "project-memory.db");
+  let createdFresh = false;
+  try {
+    if (remoteUnavailable) {
+      const db = await readDeps.openMemoryDb(dbPath);
+      await db.close();
+      createdFresh = true;
+    } else {
+      try {
+        const bytes = readDeps.readBlobBytesAtRef(repoPath, baseOid, CANONICAL_MEMORY_DB_PATH);
+        writeFileSync(dbPath, bytes);
+      } catch (error) {
+        if (!isMissingCanonicalMemoryBlobError(error)) {
+          throw error;
+        }
+        const db = await readDeps.openMemoryDb(dbPath);
+        await db.close();
+        createdFresh = true;
+      }
+    }
+    await validateReadableDatabase(dbPath, readDeps.openMemoryDb);
+    return {
+      repoPath,
+      baseOid,
+      dbPath,
+      createdFresh,
+      async cleanup() {
+        readDeps.removeDir(tempDir);
+      }
+    };
+  } catch (error) {
+    readDeps.removeDir(tempDir);
+    throw error;
+  }
+}
+export {
+  readCanonicalMemoryDb
+};

package/dist/src/service.d.ts

@@ -0,0 +1,14 @@
+/**
+ * service.ts — the concrete shared-memory implementation the runtime port
+ * resolves and consumes.
+ *
+ * CONFIG-LIGHT: this module top-level-imports the heavy impl (db.ts pulls
+ * bun:sqlite, query/read/cli pull fs + embed). It is loaded LAZILY by the
+ * capability `run()` in plugin.ts (`(await import("./service")).svc`), so merely
+ * evaluating rig.config.ts never drags the memory impl into scope.
+ */
+import type { MemoryService } from "@rig/runtime/control-plane/memory-service-port";
+/** The concrete shared-memory service the runtime port resolves and consumes. */
+export declare const svc: MemoryService;
+/** Back-compat alias. */
+export declare const memoryService: MemoryService;