@totalreclaw/totalreclaw 3.3.12-rc.2 → 3.3.12-rc.21

package/config.ts

@@ -102,10 +102,10 @@ export function getSessionId(): string | null {
 
 /**
  * Runtime override for chain ID, set after the relay billing response is
- * read. Free tier stays on 84532 (Base Sepolia); Pro tier flips to 100
- * (Gnosis mainnet). The relay routes Pro writes to Gnosis, so Pro-tier
- * UserOps MUST be signed against chain 100 — otherwise the bundler rejects
- * the signature with AA23.
+ * read. After the ops-1 single-chain migration (2026-05), ALL tiers (free
+ * + Pro) are on Gnosis mainnet (chain 100). The default below is 100.
+ * The relay routes all writes to Gnosis, so UserOps MUST be signed against
+ * chain 100 — otherwise the bundler rejects the signature with AA24.
  *
  * See index.ts: after the billing lookup completes, call
  * `setChainIdOverride(100)` for Pro users. Free users can leave the
@@ -148,6 +148,42 @@ export const CONFIG = {
   serverUrl: (process.env.TOTALRECLAW_SERVER_URL || 'https://api.totalreclaw.xyz').replace(/\/+$/, ''),
   selfHosted: process.env.TOTALRECLAW_SELF_HOSTED === 'true',
   credentialsPath: process.env.TOTALRECLAW_CREDENTIALS_PATH || path.join(home, '.totalreclaw', 'credentials.json'),
+  // cred-3 stage 1 — credential-provider abstraction.
+  //
+  // `file` (default) preserves the legacy behavior: read/write
+  // `credentialsPath` directly via fs-helpers.
+  //
+  // `external` instructs the plugin to load credentials from an
+  // out-of-process source at boot. Two transports are supported (mutually
+  // exclusive — JSON wins if both set):
+  //   1. `externalCredentialsJson` — raw JSON string of CredentialsFile,
+  //      injected at process start by the secret manager (Railway secrets,
+  //      Docker `--env-file`, K8s envFrom). Most ergonomic for cloud
+  //      deployments where the secret manager already exposes secrets as
+  //      env vars.
+  //   2. `externalCredentialsPath` — filesystem path to a JSON file the
+  //      secret manager mounts (Docker Compose `secrets:` block,
+  //      K8s secret volumeMount, tmpfs populated by an ops wrapper that
+  //      fetches from AWS Secrets Manager / Hetzner Vault before boot).
+  //
+  // `external` mode is read-only: write/clear are no-ops with a warning
+  // (the secret manager owns the source of truth — the plugin must not
+  // write back through this path).
+  //
+  // See `docs/guides/production-deployment.md` for the LUKS / dm-crypt
+  // pattern and managed-secret-store wiring examples.
+  credentialsProvider: (() => {
+    const v = (process.env.TOTALRECLAW_CREDENTIALS_PROVIDER ?? '').trim().toLowerCase();
+    return v === 'external' ? 'external' : 'file';
+  })() as 'file' | 'external',
+  externalCredentialsJson: (() => {
+    const v = (process.env.TOTALRECLAW_EXTERNAL_CREDENTIALS_JSON ?? '').trim();
+    return v.length > 0 ? v : null;
+  })() as string | null,
+  externalCredentialsPath: (() => {
+    const v = (process.env.TOTALRECLAW_EXTERNAL_CREDENTIALS_PATH ?? '').trim();
+    return v.length > 0 ? v : null;
+  })() as string | null,
   // 3.2.0 onboarding state file — separate from credentials.json so it
   // never contains secrets. Loaded on every plugin init + on every
   // before_tool_call gate check.
@@ -185,19 +221,19 @@ export const CONFIG = {
       : 'wss://api.totalreclaw.xyz')
   ).replace(/\/+$/, ''),
 
-  // Chain — chainId is no longer user-configurable. It is auto-detected from
-  // the relay billing response (free = Base Sepolia / 84532, Pro = Gnosis /
-  // 100). The default here is used only before the first billing lookup
+  // Chain — chainId is no longer user-configurable. After the ops-1 single-
+  // chain migration, ALL tiers are on Gnosis (100). The default here is 100.
   // completes. Self-hosted users can still point at a custom DataEdge via
   // TOTALRECLAW_DATA_EDGE_ADDRESS / TOTALRECLAW_ENTRYPOINT_ADDRESS /
   // TOTALRECLAW_RPC_URL (undocumented; internal knobs).
   //
-  // Reads the runtime override set by the billing auto-detect in index.ts.
-  // Falls back to 84532 (free tier / pre-billing-lookup). Must be a getter,
-  // not a literal — a literal would freeze all Pro-tier UserOps to the
-  // wrong chainId and AA23 at the bundler.
+  // Reads the runtime override set from the relay's authoritative chain_id
+  // (syncChainIdFromBilling). Falls back to 100 (Gnosis) pre-billing-lookup —
+  // after ops-1 both tiers are on Gnosis, so 84532 is never the default (#402).
+  // Must be a getter, not a literal — a literal would freeze UserOps to the
+  // wrong chainId and fail signature validation at the bundler.
   get chainId(): number {
-    return _chainIdOverride ?? 84532;
+    return _chainIdOverride ?? 100;
   },
   dataEdgeAddress: process.env.TOTALRECLAW_DATA_EDGE_ADDRESS || '',
   entryPointAddress: process.env.TOTALRECLAW_ENTRYPOINT_ADDRESS || '',
@@ -224,6 +260,12 @@ export const CONFIG = {
   // See: docs/specs/totalreclaw/client-consistency.md
   cosineThreshold: parseFloat(process.env.TOTALRECLAW_COSINE_THRESHOLD ?? '0.15'),
   extractInterval: parseInt(process.env.TOTALRECLAW_EXTRACT_INTERVAL ?? process.env.TOTALRECLAW_EXTRACT_EVERY_TURNS ?? '3', 10),
+  // Self-hosted fallback for max-facts-per-extraction. `undefined` when the
+  // env var is unset so getMaxFactsPerExtraction() can fall through to the
+  // billing cache then the built-in MAX_FACTS_PER_EXTRACTION constant.
+  maxFactsPerExtraction: process.env.TOTALRECLAW_MAX_FACTS_PER_EXTRACTION
+    ? parseInt(process.env.TOTALRECLAW_MAX_FACTS_PER_EXTRACTION, 10)
+    : undefined,
   relevanceThreshold: parseFloat(process.env.TOTALRECLAW_RELEVANCE_THRESHOLD ?? '0.3'),
   semanticSkipThreshold: parseFloat(process.env.TOTALRECLAW_SEMANTIC_SKIP_THRESHOLD ?? '0.85'),
   cacheTtlMs: parseInt(process.env.TOTALRECLAW_CACHE_TTL_MS ?? String(5 * 60 * 1000), 10),

package/consolidation.ts

@@ -18,11 +18,14 @@
  * and `clusterFacts` WASM functions when available, falling back to local
  * implementations that use WASM-backed `cosineSimilarity`.
  *
- * Threshold helpers remain local (they read process.env).
+ * Threshold helpers remain local; their env reads are centralized in
+ * entry.ts (env-reading seam, Task 1.3 of the OpenClaw native
+ * integration plan, 2026-06-21).
  */
 
 import { createRequire } from 'node:module';
 import { cosineSimilarity } from './reranker.js';
+import { envNumber } from './entry.js';
 
 // ---------------------------------------------------------------------------
 // Lazy-load WASM core (mirrors claims-helper.ts / contradiction-sync.ts
@@ -47,12 +50,7 @@ function getWasm(): typeof import('@totalreclaw/core') {
  * Must be a number in [0, 1]. Falls back to 0.85 if invalid or unset.
  */
 export function getStoreDedupThreshold(): number {
-  const envVal = process.env.TOTALRECLAW_STORE_DEDUP_THRESHOLD;
-  if (envVal !== undefined) {
-    const parsed = parseFloat(envVal);
-    if (!isNaN(parsed) && parsed >= 0 && parsed <= 1) return parsed;
-  }
-  return 0.85;
+  return envNumber('TOTALRECLAW_STORE_DEDUP_THRESHOLD', 0.85, { min: 0, max: 1 });
 }
 
 /**
@@ -62,12 +60,7 @@ export function getStoreDedupThreshold(): number {
  * Must be a number in [0, 1]. Falls back to 0.88 if invalid or unset.
  */
 export function getConsolidationThreshold(): number {
-  const envVal = process.env.TOTALRECLAW_CONSOLIDATION_THRESHOLD;
-  if (envVal !== undefined) {
-    const parsed = parseFloat(envVal);
-    if (!isNaN(parsed) && parsed >= 0 && parsed <= 1) return parsed;
-  }
-  return 0.88;
+  return envNumber('TOTALRECLAW_CONSOLIDATION_THRESHOLD', 0.88, { min: 0, max: 1 });
 }
 
 /** Maximum candidates to compare against during store-time dedup. */

package/contradiction-sync.ts

@@ -19,6 +19,12 @@ import { createRequire } from 'node:module';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
+import {
+  envHomedir,
+  envNumber,
+  envString,
+  envStringLower,
+} from './entry.js';
 import {
   computeEntityTrapdoor,
   isDigestBlob,
@@ -145,9 +151,9 @@ export interface DecisionLogEntry {
 
 /** Where feedback, decisions, and weights live. `~/.totalreclaw/` by default. */
 function resolveStateDir(): string {
-  const override = process.env.TOTALRECLAW_STATE_DIR;
-  if (override && override.length > 0) return override;
-  return path.join(os.homedir(), '.totalreclaw');
+  const override = envString('TOTALRECLAW_STATE_DIR');
+  if (override.length > 0) return override;
+  return path.join(envHomedir(), '.totalreclaw');
 }
 
 function ensureStateDir(): string {
@@ -508,7 +514,10 @@ function _resolveWithCandidatesCore(
       weightsJson,
       thresholdLower,
       thresholdUpper,
-      Math.floor(nowUnixSeconds),
+      // wasm-bindgen declares `now_unix` as i64 → JS BigInt. Node ≥26 rejects
+      // the implicit Number→BigInt coercion that older runtimes tolerated, so
+      // wrap explicitly (same as the legacy path below + loadWeightsFile).
+      BigInt(Math.floor(nowUnixSeconds)),
       TIE_ZONE_SCORE_TOLERANCE,
     );
   } catch (err) {
@@ -738,7 +747,7 @@ export async function detectAndResolveContradictions(
   } = input;
 
   // Read env per-call so tests can toggle without module reload.
-  const raw = (process.env.TOTALRECLAW_AUTO_RESOLVE_MODE ?? '').trim().toLowerCase();
+  const raw = envStringLower('TOTALRECLAW_AUTO_RESOLVE_MODE');
   const mode: AutoResolveMode =
     raw === 'off' ? 'off' : raw === 'shadow' ? 'shadow' : 'active';
 
@@ -1004,15 +1013,11 @@ export const TUNING_LOOP_MIN_INTERVAL_SECONDS = 3600;
  * empty, non-numeric, or negative.
  */
 export function getTuningLoopMinIntervalSeconds(): number {
-  const raw = process.env.TOTALRECLAW_TUNING_MIN_INTERVAL_OVERRIDE_SECONDS;
-  if (raw === undefined || raw === null || raw === '') {
-    return TUNING_LOOP_MIN_INTERVAL_SECONDS;
-  }
-  const parsed = Number(raw);
-  if (!Number.isFinite(parsed) || parsed < 0) {
-    return TUNING_LOOP_MIN_INTERVAL_SECONDS;
-  }
-  return parsed;
+  // envNumber returns the fallback for unset/empty/non-finite/negative —
+  // recovering the original 3-guard contract in one call.
+  return envNumber('TOTALRECLAW_TUNING_MIN_INTERVAL_OVERRIDE_SECONDS', TUNING_LOOP_MIN_INTERVAL_SECONDS, {
+    min: 0,
+  });
 }
 
 /** A single row from feedback.jsonl — matches Rust `FeedbackEntry`. */

package/credential-provider.ts

@@ -0,0 +1,184 @@
+/**
+ * credential-provider — credential source abstraction (cred-3 stage 1).
+ *
+ * The plugin needs to load its `CredentialsFile` (mnemonic + userId + salt +
+ * scope_address) from one of two sources without per-deployment forks:
+ *
+ *   1. `file` — read/write `~/.totalreclaw/credentials.json` directly
+ *      (legacy behavior; default).
+ *   2. `external` — read from a secret manager that exposes the JSON as
+ *      either an env var (Railway secrets, Docker `--env-file`, K8s
+ *      `envFrom`) OR a mounted file path (Docker Compose `secrets:`,
+ *      K8s secret volumeMount, tmpfs populated by an ops wrapper that
+ *      pulls from a managed vault before plugin start).
+ *
+ * Stage 1 introduces the abstraction + integration test. Stage 2 routes
+ * Hermes Python through the same surface; stage 3 routes MCP and ships a
+ * concrete vault adapter. Plugin call sites are not yet rewired to go
+ * through the provider — that's a follow-up so behavior under the default
+ * `file` mode is byte-identical to today.
+ *
+ * Scanner constraints (see skill/scripts/check-scanner.mjs):
+ *   - This file MUST avoid any subprocess module import. Both transport
+ *     flavors here use `node:fs` only.
+ *   - This file MUST avoid network-word substrings to keep the
+ *     exfiltration rule quiet. All env reads are centralized in
+ *     `config.ts`; we accept resolved values here.
+ *
+ * Phrase-safety:
+ *   - The mnemonic is never logged from this file. Errors reference only
+ *     transport names + sizes, never the raw payload.
+ *   - File writes preserve mode `0o600` via the existing fs-helpers
+ *     `writeCredentialsJson`.
+ *   - `external` mode is read-only by design — the secret manager owns
+ *     the source of truth; writing back would split it.
+ */
+
+import fs from 'node:fs';
+
+import { CONFIG } from './config.js';
+import {
+  loadCredentialsJson,
+  writeCredentialsJson,
+  deleteCredentialsFile,
+  type CredentialsFile,
+} from './fs-helpers.js';
+
+/**
+ * Provider interface — three methods cover the lifecycle:
+ *   - `load()` is called at boot and on every credential-dependent
+ *     pre-tool hook. Returns null when the source has no usable creds.
+ *   - `save()` persists a freshly-generated or updated `CredentialsFile`.
+ *     Returns `false` for read-only providers (caller logs a warn).
+ *   - `clear()` deletes the credentials (used by `forceReinitialization`).
+ *     Returns `false` for read-only providers.
+ *
+ * `mode` is exposed so callers can branch UI / warnings — e.g. the
+ * first-run announcement is skipped in `external` mode because the
+ * mnemonic was authored elsewhere.
+ */
+export interface CredentialProvider {
+  readonly mode: 'file' | 'external';
+  load(): CredentialsFile | null;
+  save(creds: CredentialsFile): boolean;
+  clear(): boolean;
+}
+
+/**
+ * Default provider — delegates to the existing fs-helpers functions.
+ * Behavior is identical to direct `loadCredentialsJson` / `writeCredentialsJson`
+ * / `deleteCredentialsFile` calls, so wiring a call site through this
+ * provider in `file` mode produces zero behavior delta.
+ */
+export class FileCredentialProvider implements CredentialProvider {
+  readonly mode = 'file' as const;
+
+  constructor(private readonly credentialsPath: string) {}
+
+  load(): CredentialsFile | null {
+    return loadCredentialsJson(this.credentialsPath);
+  }
+
+  save(creds: CredentialsFile): boolean {
+    return writeCredentialsJson(this.credentialsPath, creds);
+  }
+
+  clear(): boolean {
+    return deleteCredentialsFile(this.credentialsPath);
+  }
+}
+
+/**
+ * External provider — reads credentials from a secret manager via one of
+ * two transports (env-injected JSON wins if both are set).
+ *
+ *   Inline JSON  (`TOTALRECLAW_EXTERNAL_CREDENTIALS_JSON`)
+ *     The raw `CredentialsFile` JSON, injected as an env var at process
+ *     start. Most ergonomic for managed platforms that expose secrets as
+ *     env vars (Railway secrets, Heroku config vars, K8s `envFrom`).
+ *
+ *   File mount   (`TOTALRECLAW_EXTERNAL_CREDENTIALS_PATH`)
+ *     A path to a JSON file the secret manager mounts. Pattern works for
+ *     Docker Compose `secrets:` blocks, K8s secret `volumeMount`s, and
+ *     tmpfs paths populated by an ops wrapper script that fetched the
+ *     payload from a vault (AWS Secrets Manager, Hetzner Vault, etc.)
+ *     before plugin start.
+ *
+ * Both flavors are read-only — `save()` and `clear()` return `false` and
+ * the caller logs a warn. The secret manager is the canonical source;
+ * writing back would create two competing truths.
+ */
+export class ExternalCredentialProvider implements CredentialProvider {
+  readonly mode = 'external' as const;
+
+  constructor(
+    private readonly options: {
+      readonly inlineJson: string | null;
+      readonly filePath: string | null;
+    },
+  ) {}
+
+  load(): CredentialsFile | null {
+    const raw = this.readRaw();
+    if (raw === null) return null;
+    try {
+      return JSON.parse(raw) as CredentialsFile;
+    } catch {
+      // Parse error — return null so the bootstrap path can decide how to
+      // surface (typically: log + fall through to fresh-generate, same as
+      // a corrupt credentials.json on disk). We deliberately do not echo
+      // the payload here even on parse failure.
+      return null;
+    }
+  }
+
+  save(_creds: CredentialsFile): boolean {
+    return false;
+  }
+
+  clear(): boolean {
+    return false;
+  }
+
+  private readRaw(): string | null {
+    if (this.options.inlineJson !== null) {
+      return this.options.inlineJson;
+    }
+    if (this.options.filePath !== null) {
+      try {
+        if (!fs.existsSync(this.options.filePath)) return null;
+        return fs.readFileSync(this.options.filePath, 'utf-8');
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+}
+
+/**
+ * Factory — pick the configured provider. Reads from `CONFIG` (single
+ * source of truth for env vars) so tests can override by mutating the
+ * config snapshot or by passing explicit deps to the constructors.
+ *
+ * In `external` mode with neither transport set, we still return an
+ * `ExternalCredentialProvider` so the caller observes the configured
+ * mode + sees `null` from `load()`. The caller is responsible for
+ * surfacing the misconfiguration; we do not silently fall back to
+ * `file` mode (that would mask a deploy-time mistake by reading a
+ * stale `credentials.json` left on disk).
+ */
+export function getCredentialProvider(
+  config: Pick<
+    typeof CONFIG,
+    'credentialsProvider' | 'credentialsPath' | 'externalCredentialsJson' | 'externalCredentialsPath'
+  > = CONFIG,
+): CredentialProvider {
+  if (config.credentialsProvider === 'external') {
+    return new ExternalCredentialProvider({
+      inlineJson: config.externalCredentialsJson,
+      filePath: config.externalCredentialsPath,
+    });
+  }
+  return new FileCredentialProvider(config.credentialsPath);
+}

package/crypto.ts

@@ -1,161 +1,28 @@
 /**
- * TotalReclaw Plugin - Crypto Operations (WASM-backed)
- *
- * Thin re-exports over `@totalreclaw/core` WASM module. Same function
- * signatures as the previous implementation so callers don't need to change.
- *
- * The WASM module handles BIP-39 key derivation, XChaCha20-Poly1305 encrypt/
- * decrypt, SHA-256 blind indices, HMAC-SHA256 content fingerprints,
- * and LSH seed derivation.
- *
- * Key derivation chain (BIP-39 — handled by WASM):
- *   mnemonic -> BIP-39 PBKDF2 -> 512-bit seed
- *     -> HKDF-SHA256(seed, salt, "totalreclaw-auth-key-v1",       32) -> authKey
- *     -> HKDF-SHA256(seed, salt, "totalreclaw-encryption-key-v1", 32) -> encryptionKey
- *     -> HKDF-SHA256(seed, salt, "openmemory-dedup-v1",           32) -> dedupKey
- */
-
-// Lazy-load WASM. Uses createRequire so this module loads cleanly under bare
-// Node ESM — the shipped `dist/index.js` declares `"type":"module"`, where
-// the CJS `require` global is undefined at runtime. Prior to the rc.21 fix
-// this file called bare `require('@totalreclaw/core')` and every consumer
-// died with `require is not defined`. Matches the pattern already used by
-// claims-helper / consolidation / contradiction-sync / digest-sync / pin /
-// retype-setscope. See issue #124.
-import { createRequire } from 'node:module';
-const requireWasm = createRequire(import.meta.url);
-let _wasm: typeof import('@totalreclaw/core') | null = null;
-function getWasm() {
-  if (!_wasm) _wasm = requireWasm('@totalreclaw/core');
-  return _wasm;
-}
-
-// ---------------------------------------------------------------------------
-// BIP-39 Validation
-// ---------------------------------------------------------------------------
-
-/**
- * Check if the input looks like a BIP-39 mnemonic (12 or 24 words).
- *
- * Lenient: accepts phrases where all words look like valid BIP-39 words
- * (allows invalid checksums, which LLMs sometimes generate).
- */
-export function isBip39Mnemonic(input: string): boolean {
-  const words = input.trim().split(/\s+/);
-  return words.length === 12 || words.length === 24;
-}
-
-// Re-export for backward compatibility
-export const validateMnemonic = isBip39Mnemonic;
-
-// ---------------------------------------------------------------------------
-// Key Derivation
-// ---------------------------------------------------------------------------
-
-/**
- * Derive auth, encryption, and dedup keys from a recovery phrase.
- *
- * Delegates to the WASM module for BIP-39 seed derivation and HKDF
- * key separation. Uses the lenient variant for phrases where all words
- * are valid but the checksum fails.
- *
- * @param password     - BIP-39 12/24-word mnemonic
- * @param existingSalt - Ignored for BIP-39 path (salt is deterministic)
- */
-export function deriveKeys(
-  password: string,
-  existingSalt?: Buffer,
-): { authKey: Buffer; encryptionKey: Buffer; dedupKey: Buffer; salt: Buffer } {
-  const trimmed = password.trim();
-
-  // Try strict validation first, fall back to lenient
-  let result: { auth_key: string; encryption_key: string; dedup_key: string; salt: string };
-  try {
-    result = getWasm().deriveKeysFromMnemonic(trimmed);
-  } catch {
-    result = getWasm().deriveKeysFromMnemonicLenient(trimmed);
-  }
-
-  return {
-    authKey: Buffer.from(result.auth_key, 'hex'),
-    encryptionKey: Buffer.from(result.encryption_key, 'hex'),
-    dedupKey: Buffer.from(result.dedup_key, 'hex'),
-    salt: Buffer.from(result.salt, 'hex'),
-  };
-}
-
-// ---------------------------------------------------------------------------
-// LSH Seed Derivation
-// ---------------------------------------------------------------------------
-
-/**
- * Derive a 32-byte seed for the LSH hasher.
- *
- * Delegates to the WASM module.
- */
-export function deriveLshSeed(
-  password: string,
-  salt: Buffer,
-): Uint8Array {
-  const seedHex = getWasm().deriveLshSeed(password.trim(), salt.toString('hex'));
-  return new Uint8Array(Buffer.from(seedHex, 'hex'));
-}
-
-// ---------------------------------------------------------------------------
-// Auth Key Hash
-// ---------------------------------------------------------------------------
-
-/**
- * Compute the SHA-256 hash of the auth key.
- */
-export function computeAuthKeyHash(authKey: Buffer): string {
-  return getWasm().computeAuthKeyHash(authKey.toString('hex'));
-}
-
-// ---------------------------------------------------------------------------
-// XChaCha20-Poly1305 Encrypt / Decrypt
-// ---------------------------------------------------------------------------
-
-/**
- * Encrypt a UTF-8 plaintext string with XChaCha20-Poly1305.
- *
- * Wire format (base64-encoded):
- *   [nonce: 24 bytes][tag: 16 bytes][ciphertext: variable]
- */
-export function encrypt(plaintext: string, encryptionKey: Buffer): string {
-  return getWasm().encrypt(plaintext, encryptionKey.toString('hex'));
-}
-
-/**
- * Decrypt a base64-encoded XChaCha20-Poly1305 blob back to a UTF-8 string.
- */
-export function decrypt(encryptedBase64: string, encryptionKey: Buffer): string {
-  return getWasm().decrypt(encryptedBase64, encryptionKey.toString('hex'));
-}
-
-// ---------------------------------------------------------------------------
-// Blind Indices
-// ---------------------------------------------------------------------------
-
-/**
- * Generate blind indices (SHA-256 hashes of tokens) for a text string.
- *
- * Delegates to the WASM module which performs tokenization, stemming,
- * and SHA-256 hashing.
- */
-export function generateBlindIndices(text: string): string[] {
-  return getWasm().generateBlindIndices(text);
-}
-
-// ---------------------------------------------------------------------------
-// Content Fingerprint (Dedup)
-// ---------------------------------------------------------------------------
-
-/**
- * Compute an HMAC-SHA256 content fingerprint for exact-duplicate detection.
- *
- * @returns 64-character hex string.
- */
-export function generateContentFingerprint(plaintext: string, dedupKey: Buffer): string {
-  return getWasm().generateContentFingerprint(plaintext, dedupKey.toString('hex'));
-}
+ * crypto.ts — legacy re-export shim.
+ *
+ * Phase 1 (Task 1.1) of the OpenClaw native integration
+ * (docs/plans/2026-06-21-openclaw-native-integration-plan.md, 2026-06-21):
+ * the pure-compute vault primitives (XChaCha20-Poly1305 encrypt/decrypt,
+ * BIP-39 key derivation, blind indices, content fingerprints, LSH seed,
+ * auth-key hash) have moved to `vault-crypto.ts`. This file remains as a
+ * thin re-export so existing importers (`index.ts`, `tr-cli.ts`,
+ * `tr-cli-export-helper.ts`, `pair-cli-relay.ts`) do not break in this
+ * pass — a big-bang rewrite of the 331KB monolith's import graph is out
+ * of scope for the scanner-clean split.
+ *
+ * Nothing here reads the environment or hits the network; all key
+ * material and nonces are passed in by callers. See vault-crypto.ts for
+ * the implementation.
+ */
+export {
+  isBip39Mnemonic,
+  validateMnemonic,
+  deriveKeys,
+  deriveLshSeed,
+  computeAuthKeyHash,
+  encrypt,
+  decrypt,
+  generateBlindIndices,
+  generateContentFingerprint,
+} from './vault-crypto.js';

package/dist/api-client.js

@@ -1,8 +1,9 @@
 /**
  * TotalReclaw Plugin - HTTP API Client
  *
- * Communicates with the TotalReclaw server over JSON/HTTP. Uses Node.js
- * built-in `fetch` (available since Node 18).
+ * Communicates with the TotalReclaw server over JSON/HTTP. All wire I/O
+ * goes through `relay.ts` (the plugin's single network site); this module
+ * owns request/response shape, status-checking, and error context.
  *
  * All authenticated endpoints expect:
  *   Authorization: Bearer <hex-encoded-auth-key>
@@ -15,6 +16,7 @@
  * is set. See `relay-headers.ts` and internal#127.
  */
 import { buildRelayHeaders } from './relay-headers.js';
+import { relayFetch } from './relay.js';
 // ---------------------------------------------------------------------------
 // API Client Factory
 // ---------------------------------------------------------------------------
@@ -60,7 +62,8 @@ export function createApiClient(serverUrl) {
          * @returns `{ user_id }` on success.
          */
         async register(authKeyHash, saltHex) {
-            const res = await fetch(`${baseUrl}/v1/register`, {
+            const res = await relayFetch({
+                url: `${baseUrl}/v1/register`,
                 method: 'POST',
                 headers: buildRelayHeaders({ 'Content-Type': 'application/json' }),
                 body: JSON.stringify({ auth_key_hash: authKeyHash, salt: saltHex }),
@@ -84,7 +87,8 @@ export function createApiClient(serverUrl) {
          * @param authKeyHex   Hex-encoded raw auth key (64 chars) for Bearer header.
          */
         async store(userId, facts, authKeyHex) {
-            const res = await fetch(`${baseUrl}/v1/store`, {
+            const res = await relayFetch({
+                url: `${baseUrl}/v1/store`,
                 method: 'POST',
                 headers: buildRelayHeaders({
                     'Content-Type': 'application/json',
@@ -113,7 +117,8 @@ export function createApiClient(serverUrl) {
          * @returns Array of encrypted search candidates.
          */
         async search(userId, trapdoors, maxCandidates, authKeyHex) {
-            const res = await fetch(`${baseUrl}/v1/search`, {
+            const res = await relayFetch({
+                url: `${baseUrl}/v1/search`,
                 method: 'POST',
                 headers: buildRelayHeaders({
                     'Content-Type': 'application/json',
@@ -140,7 +145,8 @@ export function createApiClient(serverUrl) {
          * @param authKeyHex  Hex-encoded raw auth key for Bearer header.
          */
         async deleteFact(factId, authKeyHex) {
-            const res = await fetch(`${baseUrl}/v1/facts/${encodeURIComponent(factId)}`, {
+            const res = await relayFetch({
+                url: `${baseUrl}/v1/facts/${encodeURIComponent(factId)}`,
                 method: 'DELETE',
                 headers: buildRelayHeaders({
                     Authorization: `Bearer ${authKeyHex}`,
@@ -161,7 +167,8 @@ export function createApiClient(serverUrl) {
          * @returns The number of facts that were actually deleted.
          */
         async batchDelete(factIds, authKeyHex) {
-            const res = await fetch(`${baseUrl}/v1/facts/batch-delete`, {
+            const res = await relayFetch({
+                url: `${baseUrl}/v1/facts/batch-delete`,
                 method: 'POST',
                 headers: buildRelayHeaders({
                     'Content-Type': 'application/json',
@@ -189,7 +196,8 @@ export function createApiClient(serverUrl) {
             const params = new URLSearchParams({ limit: String(limit) });
             if (cursor)
                 params.set('cursor', cursor);
-            const res = await fetch(`${baseUrl}/v1/export?${params.toString()}`, {
+            const res = await relayFetch({
+                url: `${baseUrl}/v1/export?${params.toString()}`,
                 method: 'GET',
                 headers: buildRelayHeaders({
                     Authorization: `Bearer ${authKeyHex}`,
@@ -215,7 +223,7 @@ export function createApiClient(serverUrl) {
          */
         async health() {
             try {
-                const res = await fetch(`${baseUrl}/health`, { method: 'GET' });
+                const res = await relayFetch({ url: `${baseUrl}/health`, method: 'GET' });
                 return res.status === 200;
             }
             catch {