@remnic/core 9.69.56 → 9.69.58

package/dist/work-product-ledger.d.ts

@@ -1,7 +1,7 @@
-type WorkProductLedgerSource = "tool_result" | "cli" | "system" | "manual";
-type WorkProductLedgerKind = "artifact" | "file" | "record" | "report" | "workspace";
-type WorkProductLedgerAction = "created" | "updated" | "deleted" | "referenced" | "published";
-interface WorkProductLedgerEntry {
+export type WorkProductLedgerSource = "tool_result" | "cli" | "system" | "manual";
+export type WorkProductLedgerKind = "artifact" | "file" | "record" | "report" | "workspace";
+export type WorkProductLedgerAction = "created" | "updated" | "deleted" | "referenced" | "published";
+export interface WorkProductLedgerEntry {
     schemaVersion: 1;
     entryId: string;
     recordedAt: string;
@@ -17,7 +17,7 @@ interface WorkProductLedgerEntry {
     tags?: string[];
     metadata?: Record<string, string>;
 }
-interface WorkProductLedgerStatus {
+export interface WorkProductLedgerStatus {
     enabled: boolean;
     rootDir: string;
     entriesDir: string;
@@ -37,29 +37,28 @@ interface WorkProductLedgerStatus {
         error: string;
     }>;
 }
-interface WorkProductLedgerSearchResult {
+export interface WorkProductLedgerSearchResult {
     entry: WorkProductLedgerEntry;
     score: number;
     matchedFields: string[];
 }
-declare function resolveWorkProductLedgerDir(memoryDir: string, overrideDir?: string): string;
-declare function validateWorkProductLedgerEntry(raw: unknown): WorkProductLedgerEntry;
-declare function recordWorkProductLedgerEntry(options: {
+export declare function resolveWorkProductLedgerDir(memoryDir: string, overrideDir?: string): string;
+export declare function validateWorkProductLedgerEntry(raw: unknown): WorkProductLedgerEntry;
+export declare function recordWorkProductLedgerEntry(options: {
     memoryDir: string;
     workProductLedgerDir?: string;
     entry: WorkProductLedgerEntry;
 }): Promise<string>;
-declare function searchWorkProductLedgerEntries(options: {
+export declare function searchWorkProductLedgerEntries(options: {
     memoryDir: string;
     workProductLedgerDir?: string;
     query: string;
     maxResults: number;
     sessionKey?: string;
 }): Promise<WorkProductLedgerSearchResult[]>;
-declare function getWorkProductLedgerStatus(options: {
+export declare function getWorkProductLedgerStatus(options: {
     memoryDir: string;
     workProductLedgerDir?: string;
     enabled: boolean;
 }): Promise<WorkProductLedgerStatus>;
-
-export { type WorkProductLedgerAction, type WorkProductLedgerEntry, type WorkProductLedgerKind, type WorkProductLedgerSearchResult, type WorkProductLedgerSource, type WorkProductLedgerStatus, getWorkProductLedgerStatus, recordWorkProductLedgerEntry, resolveWorkProductLedgerDir, searchWorkProductLedgerEntries, validateWorkProductLedgerEntry };
+//# sourceMappingURL=work-product-ledger.d.ts.map

package/dist/work-product-ledger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"work-product-ledger.d.ts","sourceRoot":"","sources":["../src/work-product-ledger.ts"],"names":[],"mappings":"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"}

package/dist/write-envelope.d.ts

@@ -1,22 +1,3 @@
-import { u as MemoryCategory, N as MemorySubject } from './types-Du6VdoAg.js';
-import './message-parts/index.js';
-import './bounded-jsonl-state.js';
-import './operator-doctor-types.js';
-import './external-wiki-config.js';
-import './recall-state-view.js';
-import './contradiction-config.js';
-import './graph-path-scoring-config.js';
-import './background-generation-config.js';
-import './deep-recall-config.js';
-import './recall-navigation-config.js';
-import './recall-recognition-tier.js';
-import './causal-trajectory.js';
-import './objective-state.js';
-import './active-context-config.js';
-import './local-llm-config.js';
-import './semantic-merge-config.js';
-import './types-continuity.js';
-
 /**
  * Sealed memory-write envelope (issue #1989, umbrella #1988).
  *
@@ -42,7 +23,7 @@ import './types-continuity.js';
  * payload builder, fully tested. PR2–PR4 migrate storage entry points and
  * the write call sites onto this module (see #1989 for the slicing).
  */
-
+import type { MemoryCategory, MemorySubject } from "./types.js";
 /**
  * Every cross-cutting memory-creation field lives HERE and only here.
  *
@@ -50,7 +31,7 @@ import './types-continuity.js';
  * `WRITE_FINGERPRINT_FIELDS` or `FINGERPRINT_EXEMPT_FIELDS` — the
  * exhaustiveness guard below makes forgetting a compile error.
  */
-interface MemoryWriteInput {
+export interface MemoryWriteInput {
     /** Raw memory content. Must be non-empty after trimming. */
     content: string;
     /** Memory category — validated against the canonical category set. */
@@ -77,27 +58,27 @@ interface MemoryWriteInput {
     sourceReason?: string;
 }
 /** Context supplied by the write path, not by the payload author. */
-interface WriteContext {
+export interface WriteContext {
     /** Frontmatter `source` string (e.g. `extraction`, `wearable:bee`). */
     source: string;
     /** Clock override for tests. */
     now?: () => Date;
 }
 /** Scope facts that participate in idempotency but never in frontmatter. */
-interface FingerprintScope {
+export interface FingerprintScope {
     /** Access surface performing the write (e.g. `memory_store`, `observe`). */
     surface: string;
     namespace?: string;
     principal?: string;
     codingContext?: string;
 }
-declare const TAG_LIMITS: Readonly<{
+export declare const TAG_LIMITS: Readonly<{
     /** Maximum number of tags persisted per memory. */
     maxTags: 50;
     /** Maximum length of a single tag. */
     maxTagLength: 256;
 }>;
-declare const STRUCTURED_ATTRIBUTE_LIMITS: Readonly<{
+export declare const STRUCTURED_ATTRIBUTE_LIMITS: Readonly<{
     /** Maximum number of structured attributes per memory. */
     maxEntries: 64;
     /** Maximum length of one attribute key. */
@@ -110,8 +91,8 @@ declare const STRUCTURED_ATTRIBUTE_LIMITS: Readonly<{
  * `MemoryCategory` union for error messages and cross-module consistency
  * checks (issue #2829).
  */
-declare const MEMORY_CATEGORY_NAMES: string[];
-declare function isMemoryCategory(value: string): value is MemoryCategory;
+export declare const MEMORY_CATEGORY_NAMES: string[];
+export declare function isMemoryCategory(value: string): value is MemoryCategory;
 declare const sealed: unique symbol;
 /**
  * A normalized, validated memory-write envelope.
@@ -120,7 +101,7 @@ declare const sealed: unique symbol;
  * entry points accept this type (PR2), so every write path is forced
  * through the composer at compile time.
  */
-interface SealedMemoryEnvelope {
+export interface SealedMemoryEnvelope {
     readonly [sealed]: true;
     /**
      * Caller-supplied content VERBATIM (validated non-empty-after-trim).
@@ -188,7 +169,7 @@ interface SealedMemoryEnvelope {
  *   FATAL in both modes (legacy writeMemory also throws on bad validAt, and
  *   a write without valid content/category cannot proceed).
  */
-interface ComposeEnvelopeOptions {
+export interface ComposeEnvelopeOptions {
     salvage?: boolean;
 }
 /**
@@ -200,7 +181,7 @@ interface ComposeEnvelopeOptions {
  * fields with notes on `envelope.salvageNotes` instead of aborting the
  * batch; content/category/source/validAt stay fatal in both modes.
  */
-declare function composeMemoryEnvelope(input: MemoryWriteInput, ctx: WriteContext, opts?: ComposeEnvelopeOptions): SealedMemoryEnvelope;
+export declare function composeMemoryEnvelope(input: MemoryWriteInput, ctx: WriteContext, opts?: ComposeEnvelopeOptions): SealedMemoryEnvelope;
 /**
  * Runtime check (belt) — the compile-time brand is the real fence.
  *
@@ -221,14 +202,14 @@ declare function composeMemoryEnvelope(input: MemoryWriteInput, ctx: WriteContex
  * clean) surviving fields yields none. Notes are advisory provenance, not
  * identity — every load-bearing field is still verified.
  */
-declare function isSealedMemoryEnvelope(value: unknown): value is SealedMemoryEnvelope;
+export declare function isSealedMemoryEnvelope(value: unknown): value is SealedMemoryEnvelope;
 /**
  * The ONE mapping from a sealed envelope (+ extras) to the legacy
  * `writeMemory(category, content, options)` argument shape. Used by
  * `StorageManager.writeSealedMemory` AND by test doubles that stub storage —
  * so mock fidelity (AGENTS.md §21) cannot drift from production.
  */
-declare function sealedWriteToLegacyArgs(envelope: SealedMemoryEnvelope, extras?: Record<string, unknown>): {
+export declare function sealedWriteToLegacyArgs(envelope: SealedMemoryEnvelope, extras?: Record<string, unknown>): {
     category: MemoryCategory;
     content: string;
     options: Record<string, unknown>;
@@ -239,15 +220,15 @@ declare function sealedWriteToLegacyArgs(envelope: SealedMemoryEnvelope, extras?
  * surface that builds its payload via `buildWriteIdempotencyPayload()` picks
  * it up automatically.
  */
-declare const WRITE_FINGERPRINT_FIELDS: readonly ["content", "category", "tags", "structuredAttributes", "entityRef", "ttl", "validAt", "sourceConnector"];
+export declare const WRITE_FINGERPRINT_FIELDS: readonly ["content", "category", "tags", "structuredAttributes", "entityRef", "ttl", "validAt", "sourceConnector"];
 /**
  * Envelope fields deliberately EXCLUDED from fingerprints. Exempting a field
  * is a visible, reviewable decision — this list exists so the exhaustiveness
  * guard can force every new `MemoryWriteInput` field to be classified.
  */
-declare const FINGERPRINT_EXEMPT_FIELDS: readonly ["confidence", "origin", "subject", "sourceReason"];
+export declare const FINGERPRINT_EXEMPT_FIELDS: readonly ["confidence", "origin", "subject", "sourceReason"];
 /** Scope keys always folded into the fingerprint payload. */
-declare const FINGERPRINT_SCOPE_FIELDS: readonly ["surface", "namespace", "principal", "codingContext"];
+export declare const FINGERPRINT_SCOPE_FIELDS: readonly ["surface", "namespace", "principal", "codingContext"];
 /**
  * Build the canonical write-idempotency payload for a sealed envelope.
  *
@@ -262,9 +243,9 @@ declare const FINGERPRINT_SCOPE_FIELDS: readonly ["surface", "namespace", "princ
  * Feed the result to `hashAccessIdempotencyPayload()` — this module does
  * not hash so surfaces keep a single hashing implementation.
  */
-declare function buildWriteIdempotencyPayload(envelope: SealedMemoryEnvelope, scope: FingerprintScope): Record<string, unknown>;
+export declare function buildWriteIdempotencyPayload(envelope: SealedMemoryEnvelope, scope: FingerprintScope): Record<string, unknown>;
 /** The raw request fields the write surfaces fingerprint (legacy shape). */
-interface AccessWriteFingerprintParts {
+export interface AccessWriteFingerprintParts {
     schemaVersion: number;
     namespace: string;
     content: string;
@@ -284,9 +265,9 @@ interface AccessWriteFingerprintParts {
  * keys and drops `undefined`, so optional absent fields hash identically
  * to the old shape.
  */
-declare function buildAccessWriteRequestFingerprint(parts: AccessWriteFingerprintParts): Record<string, unknown>;
+export declare function buildAccessWriteRequestFingerprint(parts: AccessWriteFingerprintParts): Record<string, unknown>;
 /** The raw request fields the observe surface fingerprints (legacy shape). */
-interface ObserveFingerprintParts {
+export interface ObserveFingerprintParts {
     sessionKey: string;
     messages: unknown;
     namespace?: string;
@@ -303,6 +284,6 @@ interface ObserveFingerprintParts {
  * so it fingerprints session/message identity rather than MemoryWriteInput
  * fields. Shape reproduces the historical inline literal exactly.
  */
-declare function buildObserveRequestFingerprint(parts: ObserveFingerprintParts): Record<string, unknown>;
-
-export { type AccessWriteFingerprintParts, type ComposeEnvelopeOptions, FINGERPRINT_EXEMPT_FIELDS, FINGERPRINT_SCOPE_FIELDS, type FingerprintScope, MEMORY_CATEGORY_NAMES, type MemoryWriteInput, type ObserveFingerprintParts, STRUCTURED_ATTRIBUTE_LIMITS, type SealedMemoryEnvelope, TAG_LIMITS, WRITE_FINGERPRINT_FIELDS, type WriteContext, buildAccessWriteRequestFingerprint, buildObserveRequestFingerprint, buildWriteIdempotencyPayload, composeMemoryEnvelope, isMemoryCategory, isSealedMemoryEnvelope, sealedWriteToLegacyArgs };
+export declare function buildObserveRequestFingerprint(parts: ObserveFingerprintParts): Record<string, unknown>;
+export {};
+//# sourceMappingURL=write-envelope.d.ts.map

package/dist/write-envelope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"write-envelope.d.ts","sourceRoot":"","sources":["../src/write-envelope.ts"],"names":[],"mappings":"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"}

package/dist/write-quarantine.d.ts

@@ -18,8 +18,8 @@
  * a symlinked `state`/`quarantine` cannot redirect writes outside the memory
  * directory. The store never re-routes a payload into a writable namespace.
  */
-type QuarantineOperation = "observe" | "memory_store" | "suggestion_submit";
-interface QuarantineEntryInput {
+export type QuarantineOperation = "observe" | "memory_store" | "suggestion_submit";
+export interface QuarantineEntryInput {
     operation: QuarantineOperation;
     /** Authenticated principal the write was attributed to, if any. */
     principal: string | undefined;
@@ -30,7 +30,7 @@ interface QuarantineEntryInput {
     /** ISO timestamp; defaults to now. Injectable for deterministic tests. */
     timestamp?: string;
 }
-interface QuarantinedRecord {
+export interface QuarantinedRecord {
     operation: QuarantineOperation;
     principal: string | null;
     attemptedNamespace: string;
@@ -38,18 +38,18 @@ interface QuarantinedRecord {
     payload: unknown;
 }
 /** A quarantined record paired with the absolute on-disk path it was read from. */
-interface QuarantineEntry {
+export interface QuarantineEntry {
     record: QuarantinedRecord;
     path: string;
 }
-interface QuarantineCaps {
+export interface QuarantineCaps {
     /** Keep at most this many records per principal (newest win). */
     maxEntriesPerPrincipal: number;
     /** Drop records older than this many milliseconds. */
     maxAgeMs: number;
 }
-declare const DEFAULT_QUARANTINE_CAPS: QuarantineCaps;
-declare class WriteQuarantineStore {
+export declare const DEFAULT_QUARANTINE_CAPS: QuarantineCaps;
+export declare class WriteQuarantineStore {
     private readonly caps;
     private readonly memoryDir;
     constructor(memoryDir: string, caps?: QuarantineCaps);
@@ -90,5 +90,4 @@ declare class WriteQuarantineStore {
     private entryFiles;
     private pruneDir;
 }
-
-export { DEFAULT_QUARANTINE_CAPS, type QuarantineCaps, type QuarantineEntry, type QuarantineEntryInput, type QuarantineOperation, type QuarantinedRecord, WriteQuarantineStore };
+//# sourceMappingURL=write-quarantine.d.ts.map

package/dist/write-quarantine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"write-quarantine.d.ts","sourceRoot":"","sources":["../src/write-quarantine.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AASH,MAAM,MAAM,mBAAmB,GAAG,SAAS,GAAG,cAAc,GAAG,mBAAmB,CAAC;AAEnF,MAAM,WAAW,oBAAoB;IACnC,SAAS,EAAE,mBAAmB,CAAC;IAC/B,mEAAmE;IACnE,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,8DAA8D;IAC9D,kBAAkB,EAAE,MAAM,CAAC;IAC3B,mEAAmE;IACnE,OAAO,EAAE,OAAO,CAAC;IACjB,0EAA0E;IAC1E,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,mBAAmB,CAAC;IAC/B,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,mFAAmF;AACnF,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,iBAAiB,CAAC;IAC1B,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,cAAc;IAC7B,iEAAiE;IACjE,sBAAsB,EAAE,MAAM,CAAC;IAC/B,sDAAsD;IACtD,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,eAAO,MAAM,uBAAuB,EAAE,cAGrC,CAAC;AA+BF,qBAAa,oBAAoB;IAK7B,OAAO,CAAC,QAAQ,CAAC,IAAI;IAJvB,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;gBAGjC,SAAS,EAAE,MAAM,EACA,IAAI,GAAE,cAAwC;IAMjE,iEAAiE;IACjE,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;;;OAIG;IACH,OAAO,CAAC,OAAO;IAIf;;;OAGG;IACG,UAAU,CAAC,KAAK,EAAE,oBAAoB,GAAG,OAAO,CAAC,MAAM,CAAC;IAyB9D;;;;;OAKG;IACG,OAAO,IAAI,OAAO,CAAC,eAAe,EAAE,CAAC;IA4B3C,mFAAmF;IAC7E,IAAI,IAAI,OAAO,CAAC,iBAAiB,EAAE,CAAC;IAI1C;;;;;OAKG;IACG,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IA2BtD,gFAAgF;IAC1E,KAAK,IAAI,OAAO,CAAC,MAAM,CAAC;IAI9B,iEAAiE;YACnD,SAAS;YAKT,aAAa;YAoBb,UAAU;YAeV,QAAQ;CAoBvB"}

package/dist/write-rate-limiter.d.ts

@@ -15,11 +15,11 @@
 type Slot = {
     readonly recordedAt: number;
 };
-interface WriteRateLimitReservation {
+export interface WriteRateLimitReservation {
     commit(): void;
     release(): void;
 }
-declare class WriteRateLimiter {
+export declare class WriteRateLimiter {
     readonly maxRequests: number;
     readonly windowMs: number;
     private readonly buckets;
@@ -47,5 +47,5 @@ declare class WriteRateLimiter {
     reserve(principal?: string): WriteRateLimitReservation | null;
     private logRejected;
 }
-
-export { type WriteRateLimitReservation, WriteRateLimiter };
+export {};
+//# sourceMappingURL=write-rate-limiter.d.ts.map

package/dist/write-rate-limiter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"write-rate-limiter.d.ts","sourceRoot":"","sources":["../src/write-rate-limiter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAcH,KAAK,IAAI,GAAG;IAAE,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC;AAE5C,MAAM,WAAW,yBAAyB;IACxC,MAAM,IAAI,IAAI,CAAC;IACf,OAAO,IAAI,IAAI,CAAC;CACjB;AAMD,qBAAa,gBAAgB;IAC3B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAG1B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA6B;IACrD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA6B;IACtD,OAAO,CAAC,SAAS,CAAK;IACtB,OAAO,CAAC,UAAU,CAAK;gBAEX,WAAW,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM;IAKnD,OAAO,CAAC,GAAG;IAIX,OAAO,CAAC,KAAK;IAMb,4EAA4E;IAC5E,OAAO,CAAC,KAAK;IAOb,4DAA4D;IAC5D,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,aAAa,CAAC,IAAI,CAAC;IAIjD,WAAW,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM;IAIvC,0EAA0E;IAC1E,UAAU,IAAI,MAAM;IAQpB,8EAA8E;IAC9E,WAAW,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO;IAWxC,uEAAuE;IACvE,MAAM,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI;IAWhC;;;OAGG;IACH,OAAO,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,yBAAyB,GAAG,IAAI;IAgB7D,OAAO,CAAC,WAAW;CAYpB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/core",
-  "version": "9.69.56",
+  "version": "9.69.58",
   "description": "Framework-agnostic Remnic memory engine — orchestrator, storage, extraction, search, trust zones",
   "type": "module",
   "main": "dist/index.js",
@@ -3307,7 +3307,7 @@
     "core"
   ],
   "peerDependencies": {
-    "@remnic/coding-graph": "^9.69.56"
+    "@remnic/coding-graph": "^9.69.58"
   },
   "peerDependenciesMeta": {
     "@remnic/coding-graph": {

package/scripts/build-with-heap.mjs

@@ -1,31 +1,52 @@
 #!/usr/bin/env node
-// Runs tsup with deterministic heap headroom for its DTS worker.
-// The DTS build sits near the default V8 heap cliff (see PR #1562):
-// unrelated lockfile refreshes flipped it to ERR_WORKER_OUT_OF_MEMORY.
-// A Node wrapper (not a NODE_OPTIONS= shell prefix) keeps the build
-// script portable to Windows' cmd.exe script shell.
+// Builds @remnic/core: JS bundle via tsup, declarations via tsc.
+//
+// History: tsup emitted declarations through rollup-plugin-dts, which runs ONE
+// type rollup per entry point. This package declares 438 entries over a
+// ~375k-line type graph, so that is 438 rollups sharing a program inside a
+// single worker thread. It sat on the V8 heap cliff from PR #1562 onward and
+// was kept alive by raising --max-old-space-size (4096 -> 8192 -> 12288);
+// unrelated lockfile refreshes were enough to flip it to
+// ERR_WORKER_OUT_OF_MEMORY, and it stopped completing at any heap size.
+//
+// `tsc --emitDeclarationOnly` builds the program once and writes one .d.ts per
+// source file. Measured on the same tree:
+//
+//   rollup-plugin-dts @ 8192 MB   -> OOM after ~170s
+//   rollup-plugin-dts @ 12288 MB  -> OOM / dts error
+//   tsc --emitDeclarationOnly     -> 0 errors, 1096 files, ~19s, DEFAULT heap
+//
+// Per-file output is also the shape this package's `exports` map already wants
+// (`./foo` -> `./dist/foo.js`), so the rollup was doing bundling work that no
+// consumer reads. No heap flag is needed for either step now.
+//
+// A Node wrapper (not a NODE_OPTIONS= shell prefix) keeps this portable to
+// Windows' cmd.exe script shell.
 import { spawnSync } from "node:child_process";
 import { cp, mkdir, rm } from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 
-const HEAP_DEFAULT = "--max-old-space-size=12288";
-const existing = process.env.NODE_OPTIONS?.trim();
-// Caller-supplied NODE_OPTIONS goes last so V8's last-wins parsing lets
-// callers override the default heap limit.
-const nodeOptions = existing ? `${HEAP_DEFAULT} ${existing}` : HEAP_DEFAULT;
+// .bin shims are .cmd files on Windows and need a shell to execute.
+const useShell = process.platform === "win32";
 
-const result = spawnSync("tsup", process.argv.slice(2), {
-  stdio: "inherit",
-  env: { ...process.env, NODE_OPTIONS: nodeOptions },
-  // .bin shims are .cmd files on Windows and need a shell to execute.
-  shell: process.platform === "win32",
-});
+function run(command, args) {
+  const result = spawnSync(command, args, { stdio: "inherit", shell: useShell });
+  if (result.error) {
+    console.error(`[build] failed to launch ${command}: ${result.error.message}`);
+    process.exit(1);
+  }
+  if (result.status !== 0) process.exit(result.status ?? 1);
+}
+
+// 1. JS bundle. tsup's own dts is off (see tsup.config.ts).
+run("tsup", process.argv.slice(2));
 
-if (result.error) {
-  console.error(`[build-with-heap] failed to launch tsup: ${result.error.message}`);
+// 2. Declarations. Skipped for the runtime-only container image, which ships
+//    no types — same condition tsup's dts flag used.
+if (process.env.REMNIC_DOCKER_RUNTIME_BUILD !== "1") {
+  run("tsc", ["-p", "tsconfig.dts.json"]);
 }
-if (result.status !== 0) process.exit(result.status ?? 1);
 
 const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 const sourceDir = path.resolve(packageRoot, "../../admin-console/public/what-helps-me");

package/src/access-boundary.ts

@@ -67,6 +67,7 @@ export const OPERATION_NAMES = [
   "set_coding_context",
   "recall_tier_explain",
   "recall_xray",
+  "recall_why",
   "who_knows",
   "promotion_candidates",
   "namespace_writable",

package/src/access-errors.test.ts

@@ -0,0 +1,182 @@
+/**
+ * Tests for the enriched error builders (issue #3035).
+ *
+ * Covers: nearest-tool suggestions, alias-family awareness,
+ * invalid-arg hints, schema round-trip, and deterministic ordering.
+ * Every test is mutation-proven (checklist 6).
+ */
+
+import assert from "node:assert/strict";
+import test from "node:test";
+import { z } from "zod";
+
+import { invalidArgsError, levenshtein, nearestSuggestions, unknownToolError } from "./access-errors.js";
+
+// ─── Levenshtein ──────────────────────────────────────────────────────────
+
+test("levenshtein: exact match is distance 0", () => {
+  assert.equal(levenshtein("engram.recall", "engram.recall"), 0);
+});
+
+test("levenshtein: one character off", () => {
+  assert.equal(levenshtein("engram.recall", "engram.recal"), 1);
+});
+
+test("levenshtein: three characters off", () => {
+  assert.equal(levenshtein("engram.recall", "engram.recbl"), 2);
+});
+
+test("levenshtein: completely different string", () => {
+  assert.ok(levenshtein("engram.recall", "zzzzzzzzz") > 3);
+});
+
+// ─── nearestSuggestions ───────────────────────────────────────────────────
+
+const TOOLS = [
+  "engram.recall",
+  "remnic.recall",
+  "engram.recall_xray",
+  "remnic.recall_xray",
+  "engram.recall_why",
+  "remnic.recall_why",
+  "engram.memory_get",
+  "remnic.memory_get",
+  "engram.memory_search",
+  "remnic.memory_search",
+];
+
+test("nearestSuggestions: close typo suggests the correct name", () => {
+  const result = nearestSuggestions("engram.recal", TOOLS);
+  assert.ok(result.length > 0, "should find a suggestion");
+  assert.equal(result[0].name, "engram.recall");
+  assert.equal(result[0].distance, 1);
+});
+
+test("nearestSuggestions: alias-family hint — a remnic-prefix request stays in the family", () => {
+  const result = nearestSuggestions("remnic.recal", TOOLS);
+  const first = result[0];
+  assert.ok(first, "should find a suggestion");
+  assert.ok(first.name.startsWith("remnic."), "a remnic-prefix request should suggest a remnic-prefix name");
+  assert.equal(first.distance, 1);
+});
+
+test("nearestSuggestions: wholly unrelated name returns empty", () => {
+  const result = nearestSuggestions("zzzzzzzzz", TOOLS);
+  assert.equal(result.length, 0, "nothing should be close enough");
+});
+
+test("nearestSuggestions: equal-distance suggestions are deterministic across runs", () => {
+  // "engram.recall_why" and "engram.recall_why" are the same, so use
+  // names at equal distance from "engram.recall": "engram.recall_xray" (10)
+  // vs "engram.recall_why" (10) — but distance is not the same.
+  // Instead use a query equidistant from two names.
+  const result1 = nearestSuggestions("engram.recall", TOOLS);
+  const result2 = nearestSuggestions("engram.recall", TOOLS);
+  assert.deepEqual(result1, result2);
+});
+
+// ─── unknownToolError ─────────────────────────────────────────────────────
+
+test("unknownToolError: close typo includes a suggestion", () => {
+  const msg = unknownToolError("engram.recal", TOOLS);
+  assert.match(msg, /Unknown tool/);
+  assert.match(msg, /engram\.recall/);
+  assert.match(msg, /Did you mean/);
+});
+
+test("unknownToolError: wholly unrelated name lists the full tool set", () => {
+  const msg = unknownToolError("zzzzzzzzz", TOOLS);
+  assert.match(msg, /Unknown tool/);
+  assert.match(msg, /Registered tools/);
+  assert.match(msg, /engram\.recall/);
+  assert.doesNotMatch(msg, /Did you mean/);
+});
+
+// ─── invalidArgsError ─────────────────────────────────────────────────────
+
+const MEMORY_GET_SCHEMA = z.object({
+  memory_id: z.string().describe("Memory id to retrieve"),
+  validate: z.boolean().optional().describe("Validate the memory id"),
+}).strict();
+
+test("invalidArgsError: names the failing field path", () => {
+  const parse = MEMORY_GET_SCHEMA.safeParse({});
+  assert.equal(parse.success, false);
+  const msg = invalidArgsError("engram.memory_get", parse.error, MEMORY_GET_SCHEMA);
+  assert.match(msg, /memory_id/);
+  assert.match(msg, /required/i);
+});
+
+test("invalidArgsError: the shown example actually parses against the schema", () => {
+  const parse = MEMORY_GET_SCHEMA.safeParse({});
+  assert.equal(parse.success, false);
+  const msg = invalidArgsError("engram.memory_get", parse.error, MEMORY_GET_SCHEMA);
+
+  // Anti-drift guarantee, asserted rather than asserted-about: extract the
+  // JSON the message advertises and feed it back through the SAME schema.
+  const match = msg.match(/Example arguments: (\{.*\})$/);
+  assert.ok(match, `message must carry an example object; got: ${msg}`);
+  const example: unknown = JSON.parse(match[1]);
+
+  const reparsed = MEMORY_GET_SCHEMA.safeParse(example);
+  assert.equal(
+    reparsed.success,
+    true,
+    `the advertised example must round-trip through its own schema; zod said: ${JSON.stringify(reparsed.error?.issues)}`,
+  );
+
+  // And it must not smuggle the tool name in as an unrecognized property.
+  assert.ok(
+    typeof example === "object" && example !== null && !("engram.memory_get" in example),
+    "the example must not contain the tool name as a property",
+  );
+});
+
+test("invalidArgsError: an example that cannot round-trip is withheld, not shown", () => {
+  // A schema whose safeParse always fails must produce no example section
+  // rather than an example the caller cannot use.
+  const alwaysFails = {
+    _def: { typeName: "ZodObject", shape: () => ({ field: { _def: { typeName: "ZodString" } } }) },
+    safeParse: () => ({ success: false }),
+  };
+  const parse = MEMORY_GET_SCHEMA.safeParse({});
+  assert.equal(parse.success, false);
+  if (parse.success) return;
+  const msg = invalidArgsError("engram.memory_get", parse.error, alwaysFails);
+  assert.doesNotMatch(msg, /Example arguments/, "a non-parsing example must be withheld");
+});
+
+// ─── Rejection semantics are unchanged ─────────────────────────────────────
+
+test("invalidArgsError: invalid args still reject — the error is enriched, not accepted", () => {
+  const parse = MEMORY_GET_SCHEMA.safeParse({});
+  assert.equal(parse.success, false, "a missing required field must still reject");
+  const msg = invalidArgsError("engram.memory_get", parse.error, MEMORY_GET_SCHEMA);
+  assert.ok(msg.length > 0, "error message is non-empty");
+});
+
+// ─── Privacy: no secrets in error messages ─────────────────────────────────
+
+test("unknownToolError: no sentinel secret values appear in the message", () => {
+  const msg = unknownToolError("engram.recal", TOOLS);
+  // No absolute paths, no credentials, no internal values
+  assert.doesNotMatch(msg, /\/home\//);
+  assert.doesNotMatch(msg, /\/Users\//);
+  assert.doesNotMatch(msg, /api_key|token|secret|password/i);
+});
+// ─── Cap on requested tool name (#3042 P2) ──────────────────────────────────
+
+test("nearestSuggestions: refuses overlong requests without running Levenshtein", () => {
+  const huge = "x".repeat(10_000);
+  // Direct helper: defense-in-depth. The size of the registered set does
+  // not matter; an overlong request returns empty.
+  assert.deepEqual(nearestSuggestions(huge, ["alpha", "beta", "gamma"]), []);
+});
+
+test("unknownToolError: rejects overlong names with a teaching message", () => {
+  const huge = "x".repeat(200);
+  const msg = unknownToolError(huge, ["alpha", "beta"]);
+  assert.match(msg, /exceeds 64 characters/);
+  // Should NOT run a suggestion pass over a 200-char name.
+  assert.doesNotMatch(msg, /Did you mean/);
+});