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

package/dist/src/index.js

@@ -76,11 +76,12 @@ function eventFeedbackOutcome(event) {
 }
 function normalizeStatement(statement, args) {
   if (typeof statement === "string") {
-    return { sql: statement, args };
+    return { sql: statement, ...args !== undefined ? { args } : {} };
   }
+  const resolvedArgs = statement.args ?? args;
   return {
     sql: statement.sql,
-    args: statement.args ?? args
+    ...resolvedArgs !== undefined ? { args: resolvedArgs } : {}
   };
 }
 function normalizeBindings(bindings) {
@@ -115,7 +116,7 @@ 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);
+    const result = bindings.length > 0 ? sqlite.run(normalized.sql, bindings) : sqlite.run(normalized.sql);
     return {
       rows: [],
       rowsAffected: Number(result.changes)
@@ -876,7 +877,7 @@ function createConfiguredMemoryEmbedder(options = {}) {
     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
+    ...options.fetchImpl ? { fetchImpl: options.fetchImpl } : {}
   });
 }
 function warnMissingMemoryEmbedderOnce(warn) {
@@ -952,12 +953,412 @@ var init_embed = __esm(() => {
   init_db();
 });
 
-// packages/memory-plugin/src/read.ts
-import { mkdtempSync, rmSync, writeFileSync } from "fs";
+// packages/memory-plugin/src/embedded-native-assets.ts
+var embeddedNatives = null;
+
+// packages/memory-plugin/src/native-extract.ts
+import { existsSync, mkdirSync as mkdirSync2, readFileSync, renameSync, statSync, writeFileSync } from "fs";
 import { tmpdir } from "os";
+import { resolve } from "path";
+function extractEmbeddedNative(name) {
+  if (name in extractionCache) {
+    return extractionCache[name] ?? null;
+  }
+  const entry = embeddedNatives?.[name];
+  if (!entry) {
+    extractionCache[name] = null;
+    return null;
+  }
+  try {
+    const targetPath = resolve(sharedNativeOutputDir, entry.fileName);
+    mkdirSync2(sharedNativeOutputDir, { recursive: true });
+    const upToDate = existsSync(targetPath) && statSync(targetPath).size === entry.size;
+    if (!upToDate) {
+      const bytes = readFileSync(entry.filePath);
+      const tempPath = `${targetPath}.${process.pid}.${Date.now()}.tmp`;
+      writeFileSync(tempPath, bytes, { mode: 493 });
+      renameSync(tempPath, targetPath);
+    }
+    extractionCache[name] = targetPath;
+  } catch {
+    extractionCache[name] = null;
+  }
+  return extractionCache[name] ?? null;
+}
+var sharedNativeOutputDir, extractionCache;
+var init_native_extract = __esm(() => {
+  sharedNativeOutputDir = resolve(tmpdir(), "rig-native");
+  extractionCache = {};
+});
+
+// packages/memory-plugin/src/native-git.ts
+import { chmodSync, copyFileSync, existsSync as existsSync2, mkdirSync as mkdirSync3, readFileSync as readFileSync2, renameSync as renameSync2, rmSync, writeFileSync as writeFileSync2 } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import { dirname as dirname2, isAbsolute, resolve as resolve2 } from "path";
+import { createHash as createHash2 } from "crypto";
+function isTextTreeCommitUpdate(update) {
+  return typeof update.content === "string";
+}
+function temporaryGitBinaryOutputPath(outputPath) {
+  const suffix = process.platform === "win32" ? ".exe" : "";
+  return resolve2(dirname2(outputPath), `.rig-git-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}${suffix}`);
+}
+function publishGitBinary(tempOutputPath, outputPath) {
+  try {
+    renameSync2(tempOutputPath, outputPath);
+  } catch (error) {
+    if (process.platform === "win32" && existsSync2(outputPath)) {
+      rmSync(outputPath, { force: true });
+      renameSync2(tempOutputPath, outputPath);
+      return;
+    }
+    throw error;
+  }
+}
+function isSharedGitNativeOutputPath(outputPath) {
+  return resolve2(outputPath) === sharedGitNativeOutputPath;
+}
+function materializeFromSharedGitBinarySync(outputPath, buildKey) {
+  if (isSharedGitNativeOutputPath(outputPath))
+    return null;
+  const sharedManifest = nativeBuildManifestPath(sharedGitNativeOutputPath);
+  if (!existsSync2(sharedGitNativeOutputPath) || !hasMatchingNativeBuildManifestSync(sharedManifest, buildKey) || !binarySupportsTrackerCommandsSync(sharedGitNativeOutputPath)) {
+    return null;
+  }
+  mkdirSync3(dirname2(outputPath), { recursive: true });
+  copyFileSync(sharedGitNativeOutputPath, outputPath);
+  chmodSync(outputPath, 493);
+  writeFileSync2(nativeBuildManifestPath(outputPath), `${JSON.stringify({ version: 1, buildKey }, null, 2)}
+`, "utf8");
+  return outputPath;
+}
+function runtimeRigGitFileName() {
+  return `rig-git${process.platform === "win32" ? ".exe" : ""}`;
+}
+function rigGitSourceCandidates() {
+  const execDir = process.execPath?.trim() ? dirname2(process.execPath.trim()) : "";
+  const cwd = process.cwd()?.trim() || "";
+  const projectRoot = process.env.PROJECT_RIG_ROOT?.trim() || "";
+  const hostProjectRoot = process.env.RIG_HOST_PROJECT_ROOT?.trim() || "";
+  const moduleRelativeSource = resolve2(import.meta.dir, "../native/rig-git.zig");
+  return [...new Set([
+    process.env.RIG_NATIVE_GIT_SOURCE?.trim() || "",
+    moduleRelativeSource,
+    projectRoot ? resolve2(projectRoot, "packages/memory-plugin/native/rig-git.zig") : "",
+    hostProjectRoot ? resolve2(hostProjectRoot, "packages/memory-plugin/native/rig-git.zig") : "",
+    cwd ? resolve2(cwd, "packages/memory-plugin/native/rig-git.zig") : "",
+    execDir ? resolve2(execDir, "..", "..", "packages/memory-plugin/native/rig-git.zig") : "",
+    execDir ? resolve2(execDir, "..", "native", "rig-git.zig") : ""
+  ].filter(Boolean))];
+}
+function nativePackageBinaryCandidates(fromDir, fileName) {
+  const candidates = [];
+  let cursor = resolve2(fromDir);
+  for (let index = 0;index < 8; index += 1) {
+    candidates.push(resolve2(cursor, "native", `${process.platform}-${process.arch}`, fileName), resolve2(cursor, "native", `${process.platform}-${process.arch}`, "bin", fileName), resolve2(cursor, "native", fileName), resolve2(cursor, "native", "bin", fileName));
+    const parent = dirname2(cursor);
+    if (parent === cursor)
+      break;
+    cursor = parent;
+  }
+  return candidates;
+}
+function rigGitBinaryCandidates() {
+  const execDir = process.execPath?.trim() ? dirname2(process.execPath.trim()) : "";
+  const fileName = runtimeRigGitFileName();
+  const explicit = process.env.RIG_NATIVE_GIT_BIN?.trim() || "";
+  return [...new Set([
+    explicit,
+    ...nativePackageBinaryCandidates(import.meta.dir, fileName),
+    execDir ? resolve2(execDir, fileName) : "",
+    execDir ? resolve2(execDir, "..", fileName) : "",
+    execDir ? resolve2(execDir, "..", "bin", fileName) : "",
+    sharedGitNativeOutputPath
+  ].filter(Boolean))];
+}
+function resolveGitSourcePath() {
+  for (const candidate of rigGitSourceCandidates()) {
+    if (candidate && existsSync2(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function resolveGitBinaryPath() {
+  if (process.env.RIG_DISABLE_ZIG_NATIVE === "1") {
+    return null;
+  }
+  for (const candidate of rigGitBinaryCandidates()) {
+    if (candidate && existsSync2(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function preferredGitBinaryOutputPath() {
+  const explicit = process.env.RIG_NATIVE_GIT_BIN?.trim() || "";
+  return explicit || sharedGitNativeOutputPath;
+}
+function binarySupportsTrackerCommandsSync(binaryPath) {
+  try {
+    const probe = Bun.spawnSync([binaryPath, "fetch-ref", "."], {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const stdout = probe.stdout.toString().trim();
+    const stderr = probe.stderr.toString().trim();
+    if (stdout.includes('"error":"unknown command"')) {
+      return false;
+    }
+    return probe.exitCode === 2 && stderr.includes(trackerCommandUsageProbe);
+  } catch {
+    return false;
+  }
+}
+function nativeBuildManifestPath(outputPath) {
+  return `${outputPath}.build-manifest.json`;
+}
+function hasMatchingNativeBuildManifestSync(manifestPath, buildKey) {
+  if (!existsSync2(manifestPath)) {
+    return false;
+  }
+  try {
+    const manifest = JSON.parse(readFileSync2(manifestPath, "utf8"));
+    return manifest.version === 1 && manifest.buildKey === buildKey;
+  } catch {
+    return false;
+  }
+}
+function sha256FileSync(path) {
+  return createHash2("sha256").update(readFileSync2(path)).digest("hex");
+}
+function ensureRigGitBinaryPathSync(outputPath = preferredGitBinaryOutputPath()) {
+  if (process.env.RIG_DISABLE_ZIG_NATIVE === "1") {
+    throw new Error("Zig native git is disabled via RIG_DISABLE_ZIG_NATIVE=1");
+  }
+  const explicitBin = process.env.RIG_NATIVE_GIT_BIN?.trim();
+  if (explicitBin && existsSync2(explicitBin)) {
+    return explicitBin;
+  }
+  const embedded = extractEmbeddedNative("rig-git");
+  if (embedded) {
+    return embedded;
+  }
+  const sourcePath = resolveGitSourcePath();
+  if (!sourcePath) {
+    const binaryPath = resolveGitBinaryPath();
+    if (binaryPath) {
+      return binaryPath;
+    }
+    throw new Error("rig-git.zig source file not found.");
+  }
+  const zigBinary = Bun.which("zig");
+  if (!zigBinary) {
+    throw new Error("zig is required to build native Rig git tools.");
+  }
+  mkdirSync3(dirname2(outputPath), { recursive: true });
+  const sourceDigest = sha256FileSync(sourcePath);
+  const buildKey = JSON.stringify({
+    version: 1,
+    zigBinary,
+    platform: process.platform,
+    arch: process.arch,
+    sourcePath,
+    sourceDigest
+  });
+  const manifestPath = nativeBuildManifestPath(outputPath);
+  const needsBuild = !existsSync2(outputPath) || !hasMatchingNativeBuildManifestSync(manifestPath, buildKey) || !binarySupportsTrackerCommandsSync(outputPath);
+  if (!needsBuild) {
+    chmodSync(outputPath, 493);
+    return outputPath;
+  }
+  const materialized = materializeFromSharedGitBinarySync(outputPath, buildKey);
+  if (materialized)
+    return materialized;
+  const tempOutputPath = temporaryGitBinaryOutputPath(outputPath);
+  const build = Bun.spawnSync([
+    zigBinary,
+    "build-exe",
+    sourcePath,
+    "-O",
+    "ReleaseFast",
+    `-femit-bin=${tempOutputPath}`
+  ], {
+    cwd: dirname2(sourcePath),
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  if (build.exitCode !== 0 || !existsSync2(tempOutputPath)) {
+    const stderr = build.stderr.toString().trim();
+    const stdout = build.stdout.toString().trim();
+    const details = [stderr, stdout].filter(Boolean).join(`
+`);
+    throw new Error(`Failed to build native Rig git tools: ${details || `zig exited with code ${build.exitCode}`}`);
+  }
+  chmodSync(tempOutputPath, 493);
+  if (existsSync2(outputPath) && hasMatchingNativeBuildManifestSync(manifestPath, buildKey)) {
+    rmSync(tempOutputPath, { force: true });
+    chmodSync(outputPath, 493);
+    return outputPath;
+  }
+  publishGitBinary(tempOutputPath, outputPath);
+  if (!binarySupportsTrackerCommandsSync(outputPath)) {
+    rmSync(outputPath, { force: true });
+    throw new Error("Failed to build native Rig git tools: tracker command probe failed");
+  }
+  writeFileSync2(manifestPath, `${JSON.stringify({ version: 1, buildKey }, null, 2)}
+`, "utf8");
+  return outputPath;
+}
+function gitNativeEnv() {
+  const env = { ...process.env };
+  const token = env.GITHUB_TOKEN?.trim() || env.GH_TOKEN?.trim() || env.RIG_GITHUB_TOKEN?.trim() || "";
+  if (token) {
+    env.RIG_GITHUB_TOKEN = env.RIG_GITHUB_TOKEN || token;
+    env.GITHUB_TOKEN = env.GITHUB_TOKEN || token;
+    env.GH_TOKEN = env.GH_TOKEN || token;
+    env.GIT_TERMINAL_PROMPT = "0";
+    env.GIT_CONFIG_COUNT = "2";
+    env.GIT_CONFIG_KEY_0 = "credential.helper";
+    env.GIT_CONFIG_VALUE_0 = "";
+    env.GIT_CONFIG_KEY_1 = "credential.helper";
+    env.GIT_CONFIG_VALUE_1 = '!f() { test "$1" = get || exit 0; token="${GITHUB_TOKEN:-${GH_TOKEN:-${RIG_GITHUB_TOKEN:-}}}"; test -n "$token" || exit 0; echo username=x-access-token; echo password="$token"; }; f';
+  }
+  return env;
+}
+function runGitNative(command, args) {
+  if (process.env.RIG_DISABLE_ZIG_NATIVE === "1") {
+    return { ok: false, error: "rig-git native disabled" };
+  }
+  const trackerCommand = command === "fetch-ref" || command === "read-blob-at-ref" || command === "write-tree-commit" || command === "push-ref-with-lease";
+  let binaryPath = null;
+  if (trackerCommand) {
+    try {
+      binaryPath = ensureRigGitBinaryPathSync(preferredGitBinaryOutputPath());
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (message.includes("rig-git.zig source file not found")) {
+        return { ok: false, error: "rig-git binary not found" };
+      }
+      return { ok: false, error: message };
+    }
+  } else {
+    const explicitBinaryPath = process.env.RIG_NATIVE_GIT_BIN?.trim() || "";
+    binaryPath = explicitBinaryPath && existsSync2(explicitBinaryPath) ? explicitBinaryPath : !explicitBinaryPath ? resolveGitBinaryPath() : null;
+    if (!binaryPath) {
+      try {
+        binaryPath = ensureRigGitBinaryPathSync(preferredGitBinaryOutputPath());
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (message.includes("rig-git.zig source file not found")) {
+          return { ok: false, error: "rig-git binary not found" };
+        }
+        return { ok: false, error: message };
+      }
+    }
+  }
+  try {
+    const proc = Bun.spawnSync([binaryPath, command, ...args], {
+      stdout: "pipe",
+      stderr: "pipe",
+      env: gitNativeEnv()
+    });
+    if (proc.exitCode !== 0) {
+      const stdoutText = proc.stdout.toString().trim();
+      if (stdoutText) {
+        try {
+          const parsed = JSON.parse(stdoutText);
+          if (!parsed.ok) {
+            return parsed;
+          }
+        } catch {}
+      }
+      const errText = proc.stderr.toString().trim() || `exit code ${proc.exitCode}`;
+      return { ok: false, error: errText };
+    }
+    const output = proc.stdout.toString().trim();
+    return JSON.parse(output);
+  } catch (err) {
+    return { ok: false, error: String(err) };
+  }
+}
+function requireGitNative(command, args) {
+  const result = runGitNative(command, args);
+  if (result.ok === false) {
+    throw new Error(`rig-git ${command} failed: ${result.error}`);
+  }
+  return result;
+}
+function requireGitNativeString(command, args) {
+  const result = requireGitNative(command, args);
+  if ("value" in result && typeof result.value === "string") {
+    return result.value;
+  }
+  throw new Error(`rig-git ${command} returned an unexpected result payload`);
+}
+function nativeFetchRef(repoPath, remote, branch) {
+  return requireGitNativeString("fetch-ref", [repoPath, remote, branch]);
+}
+function nativeReadBlobBytesAtRef(repoPath, ref, path) {
+  const requestDir = resolve2(sharedGitNativeOutputDir, "reads", `${Date.now()}-${Math.random().toString(36).slice(2, 10)}`);
+  mkdirSync3(requestDir, { recursive: true });
+  const outputPath = resolve2(requestDir, "blob.bin");
+  try {
+    requireGitNative("read-blob-at-ref", [repoPath, ref, path, outputPath]);
+    return readFileSync2(outputPath);
+  } finally {
+    rmSync(requestDir, { recursive: true, force: true });
+  }
+}
+function serializeTreeCommitUpdates(updates) {
+  return updates.map((update) => {
+    if (isTextTreeCommitUpdate(update)) {
+      return { path: update.path, kind: "text", content: update.content };
+    }
+    if (!isAbsolute(update.sourceFilePath)) {
+      throw new Error("tree commit binary updates require an absolute sourceFilePath");
+    }
+    return { path: update.path, kind: "file", sourceFilePath: update.sourceFilePath };
+  });
+}
+function buildTreeCommitUpdatesJson(updates) {
+  return `${JSON.stringify(serializeTreeCommitUpdates(updates), null, 2)}
+`;
+}
+function nativeWriteTreeCommit(repoPath, baseRef, updates, message) {
+  const requestDir = resolve2(sharedGitNativeOutputDir, "requests", `${Date.now()}-${Math.random().toString(36).slice(2, 10)}`);
+  mkdirSync3(requestDir, { recursive: true });
+  const messagePath = resolve2(requestDir, "message.txt");
+  const updatesPath = resolve2(requestDir, "updates.json");
+  try {
+    writeFileSync2(messagePath, message, "utf8");
+    writeFileSync2(updatesPath, buildTreeCommitUpdatesJson(updates), "utf8");
+    return requireGitNativeString("write-tree-commit", [repoPath, baseRef, messagePath, updatesPath]);
+  } finally {
+    rmSync(requestDir, { recursive: true, force: true });
+  }
+}
+function nativePushRefWithLease(repoPath, localOid, remoteRef, expectedOldOid, remote = "origin") {
+  return requireGitNativeString("push-ref-with-lease", [
+    repoPath,
+    localOid,
+    remoteRef,
+    expectedOldOid,
+    remote
+  ]);
+}
+var sharedGitNativeOutputDir, sharedGitNativeOutputPath, trackerCommandUsageProbe = "usage: rig-git fetch-ref <repo-path> <remote> <branch>";
+var init_native_git = __esm(() => {
+  init_native_extract();
+  sharedGitNativeOutputDir = resolve2(tmpdir2(), "rig-native");
+  sharedGitNativeOutputPath = resolve2(sharedGitNativeOutputDir, `rig-git-${process.platform}-${process.arch}${process.platform === "win32" ? ".exe" : ""}`);
+});
+
+// packages/memory-plugin/src/read.ts
+import { mkdtempSync, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "fs";
+import { tmpdir as tmpdir3 } 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";
+import { resolveCheckoutRoot as resolveMonorepoRoot } from "@rig/core/checkout-root";
 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`);
@@ -994,7 +1395,7 @@ async function readCanonicalMemoryDb(projectRoot, deps = {}) {
     } else {
       try {
         const bytes = readDeps.readBlobBytesAtRef(repoPath, baseOid, CANONICAL_MEMORY_DB_PATH);
-        writeFileSync(dbPath, bytes);
+        writeFileSync3(dbPath, bytes);
       } catch (error) {
         if (!isMissingCanonicalMemoryBlobError(error)) {
           throw error;
@@ -1021,18 +1422,18 @@ async function readCanonicalMemoryDb(projectRoot, deps = {}) {
 }
 var CANONICAL_MEMORY_DB_PATH = "rig/memory/project-memory.db", DEFAULT_READ_DEPS;
 var init_read = __esm(() => {
+  init_native_git();
   init_db();
   DEFAULT_READ_DEPS = {
     fetchRef: nativeFetchRef,
     readBlobBytesAtRef: nativeReadBlobBytesAtRef,
     openMemoryDb,
-    makeTempDir: () => mkdtempSync(join(tmpdir(), "memory-sync-read-")),
-    removeDir: (path) => rmSync(path, { recursive: true, force: true })
+    makeTempDir: () => mkdtempSync(join(tmpdir3(), "memory-sync-read-")),
+    removeDir: (path) => rmSync2(path, { recursive: true, force: true })
   };
 });
 
 // packages/memory-plugin/src/write.ts
-import { nativePushRefWithLease, nativeWriteTreeCommit } from "@rig/runtime/control-plane/native/git-native";
 async function promoteCanonicalMemoryEvent(projectRoot, input, deps = {}) {
   const writeDeps = { ...DEFAULT_WRITE_DEPS, ...deps };
   let lastError;
@@ -1081,6 +1482,7 @@ async function promoteCanonicalMemoryEvent(projectRoot, input, deps = {}) {
 }
 var CANONICAL_MEMORY_DB_PATH2 = "rig/memory/project-memory.db", MAX_PROMOTION_ATTEMPTS = 2, DEFAULT_WRITE_DEPS;
 var init_write = __esm(() => {
+  init_native_git();
   init_db();
   init_embed();
   init_read();
@@ -1098,7 +1500,7 @@ var init_write = __esm(() => {
 // packages/memory-plugin/src/query.ts
 import {
   DEFAULT_RUNTIME_MEMORY_RETRIEVAL
-} from "@rig/runtime/control-plane/runtime/context";
+} from "@rig/core/runtime-context";
 function tokenize(text) {
   return (text.toLowerCase().match(/[a-z0-9_./:-]+/g) ?? []).flatMap((token) => {
     const split = token.split(/[./:_-]+/).filter(Boolean);
@@ -1202,9 +1604,11 @@ var init_query = __esm(() => {
 });
 
 // packages/memory-plugin/src/cli.ts
-import { existsSync } from "fs";
+import { existsSync as existsSync3 } from "fs";
 import { randomUUID } from "crypto";
-import { NO_MATCH_RETRIEVAL_CANONICAL_KEY as NO_MATCH_RETRIEVAL_CANONICAL_KEY2 } from "@rig/contracts";
+import {
+  NO_MATCH_RETRIEVAL_CANONICAL_KEY as NO_MATCH_RETRIEVAL_CANONICAL_KEY2
+} from "@rig/contracts";
 function takeOption(args, option) {
   const rest = [];
   let value;
@@ -1226,7 +1630,7 @@ function takeOption(args, option) {
       rest.push(current);
     }
   }
-  return { value, rest };
+  return { ...value !== undefined ? { value } : {}, rest };
 }
 function usage(verb) {
   switch (verb) {
@@ -1278,7 +1682,7 @@ function requireRuntimeMemoryContext(runtimeContext) {
 }
 async function ensureRuntimeMemoryUsable(runtimeContext) {
   const memory = requireRuntimeMemoryContext(runtimeContext);
-  if (!existsSync(memory.hydratedPath)) {
+  if (!existsSync3(memory.hydratedPath)) {
     throw new Error(`Shared memory database is missing: ${memory.hydratedPath}`);
   }
   const db = await openMemoryDb(memory.hydratedPath);
@@ -1354,7 +1758,7 @@ function requestedPayload(verb, mutationKind, canonicalKey, extra) {
   return {
     command: verb,
     mutationKind,
-    canonicalKey,
+    ...canonicalKey !== undefined ? { canonicalKey } : {},
     ...extra
   };
 }
@@ -1580,19 +1984,19 @@ init_service();
 
 // packages/memory-plugin/src/plugin.ts
 import { definePlugin } from "@rig/core/config";
-import { MEMORY_SERVICE_CAPABILITY_ID } from "@rig/contracts";
+import { defineCapability } from "@rig/core/capability";
+import { MEMORY } from "@rig/contracts";
 var MEMORY_PLUGIN_NAME = "@rig/memory-plugin";
+var MemoryCap = defineCapability(MEMORY);
 var memoryPlugin = definePlugin({
   name: MEMORY_PLUGIN_NAME,
   version: "0.0.0-alpha.1",
   contributes: {
     capabilities: [
-      {
-        id: MEMORY_SERVICE_CAPABILITY_ID,
+      MemoryCap.provide(async () => (await Promise.resolve().then(() => (init_service(), exports_service))).svc, {
         title: "Shared project memory",
-        description: "Observe/recall/supersede shared project memory and hydrate runtime memory snapshots.",
-        run: async () => (await Promise.resolve().then(() => (init_service(), exports_service))).svc
-      }
+        description: "Observe/recall/supersede shared project memory and hydrate runtime memory snapshots."
+      })
     ]
   }
 });

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

@@ -0,0 +1,2 @@
+export declare function hasEmbeddedNatives(): boolean;
+export declare function extractEmbeddedNative(name: string): string | null;

package/dist/src/native-extract.js

@@ -0,0 +1,44 @@
+// @bun
+// packages/memory-plugin/src/native-extract.ts
+import { existsSync, mkdirSync, readFileSync, renameSync, statSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { resolve } from "path";
+
+// packages/memory-plugin/src/embedded-native-assets.ts
+var embeddedNatives = null;
+
+// packages/memory-plugin/src/native-extract.ts
+var sharedNativeOutputDir = resolve(tmpdir(), "rig-native");
+var extractionCache = {};
+function hasEmbeddedNatives() {
+  return embeddedNatives != null;
+}
+function extractEmbeddedNative(name) {
+  if (name in extractionCache) {
+    return extractionCache[name] ?? null;
+  }
+  const entry = embeddedNatives?.[name];
+  if (!entry) {
+    extractionCache[name] = null;
+    return null;
+  }
+  try {
+    const targetPath = resolve(sharedNativeOutputDir, entry.fileName);
+    mkdirSync(sharedNativeOutputDir, { recursive: true });
+    const upToDate = existsSync(targetPath) && statSync(targetPath).size === entry.size;
+    if (!upToDate) {
+      const bytes = readFileSync(entry.filePath);
+      const tempPath = `${targetPath}.${process.pid}.${Date.now()}.tmp`;
+      writeFileSync(tempPath, bytes, { mode: 493 });
+      renameSync(tempPath, targetPath);
+    }
+    extractionCache[name] = targetPath;
+  } catch {
+    extractionCache[name] = null;
+  }
+  return extractionCache[name] ?? null;
+}
+export {
+  hasEmbeddedNatives,
+  extractEmbeddedNative
+};

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

@@ -0,0 +1,28 @@
+export type PendingFile = {
+    path: string;
+    status: string;
+};
+export type TreeCommitUpdate = {
+    path: string;
+    content: string;
+    sourceFilePath?: never;
+} | {
+    path: string;
+    sourceFilePath: string;
+    content?: never;
+};
+export declare function runtimeRigGitFileName(): string;
+export declare function ensureRigGitBinaryPath(outputPath?: string): Promise<string>;
+export declare function ensureRigGitBinaryPathSync(outputPath?: string): string;
+export declare function materializeRigGitBinary(targetDir: string): Promise<string>;
+export declare function nativeBranchName(repoPath: string): string | null;
+export declare function nativeHeadOid(repoPath: string): string | null;
+export declare function nativeChangeCount(repoPath: string): number | null;
+export declare function nativePendingFiles(repoPath: string): PendingFile[] | null;
+export declare function nativeFileHasChanges(repoPath: string, filePath: string): boolean | null;
+export declare function nativeFetchRef(repoPath: string, remote: string, branch: string): string;
+export declare function nativeReadBlobAtRef(repoPath: string, ref: string, path: string): string;
+export declare function nativeReadBlobBytesAtRef(repoPath: string, ref: string, path: string): Uint8Array;
+export declare function buildTreeCommitUpdatesJson(updates: TreeCommitUpdate[]): string;
+export declare function nativeWriteTreeCommit(repoPath: string, baseRef: string, updates: TreeCommitUpdate[], message: string): string;
+export declare function nativePushRefWithLease(repoPath: string, localOid: string, remoteRef: string, expectedOldOid: string, remote?: string): string;