@remnic/core 10.0.84 → 10.0.86

package/dist/{chunk-LGEH473S.js → chunk-CJCTKL6Y.js}

@@ -13,6 +13,12 @@ var NamespaceNotWritableError = class extends EngramAccessInputError {
   attemptedNamespace;
   principal;
 };
+var RESERVED_PROTO_KEYS = ["__proto__", "constructor", "prototype"];
+function rejectReservedArgumentKey(key) {
+  if (RESERVED_PROTO_KEYS.includes(key)) {
+    throw new EngramAccessInputError(`${key} is not a permitted argument key`);
+  }
+}
 function levenshtein(a, b) {
   const an = a.length;
   const bn = b.length;
@@ -143,10 +149,12 @@ export {
   EngramAccessForbiddenError,
   EngramAccessInputError,
   NamespaceNotWritableError,
+  RESERVED_PROTO_KEYS,
+  rejectReservedArgumentKey,
   levenshtein,
   SUGGESTION_REQUEST_MAX_LEN,
   nearestSuggestions,
   unknownToolError,
   invalidArgsError
 };
-//# sourceMappingURL=chunk-LGEH473S.js.map
+//# sourceMappingURL=chunk-CJCTKL6Y.js.map

package/dist/chunk-CJCTKL6Y.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/access-errors.ts"],"sourcesContent":["/**\n * Tool-surface error enrichment: nearest-tool suggestions and arg-shape hints.\n *\n * Each function is a pure message builder — it returns a better error string\n * without changing semantics, status codes, or rejection behavior.\n *\n * @module access-errors\n */\n\nimport type { ZodError } from \"zod\";\n\n// ─── Existing error classes (restored from pre-#3042) ─────────────────────\n\n/** Authenticated caller lacks the required authorization (HTTP 403). */\nexport class EngramAccessForbiddenError extends Error {}\n\n/** Invalid caller input (HTTP 400). */\nexport class EngramAccessInputError extends Error {}\n\n/**\n * A write rejected by the namespace write-ACL (issue #1888). Subclasses\n * EngramAccessInputError so every existing catch/HTTP-400 mapping still\n * applies, but carries the attempted namespace + principal so the observe/\n * write surfaces can dead-letter the payload before re-throwing (fail-closed\n * placement is unchanged; only the destroyed-payload behavior is fixed).\n */\nexport class NamespaceNotWritableError extends EngramAccessInputError {\n  constructor(\n    readonly attemptedNamespace: string,\n    readonly principal: string | undefined,\n    message?: string,\n  ) {\n    super(message ?? `namespace is not writable: ${attemptedNamespace}`);\n    this.name = \"NamespaceNotWritableError\";\n  }\n}\n\n// ─── Reserved argument keys (issue #3225 B1) ──────────────────────────────\n\n/**\n * Dictionary keys that change object shape or prototype resolution. A JSON\n * body can carry them as own members; the request preprocessors reject them\n * before copying, so a decoded `__proto__` member cannot become an inherited\n * schema field. Lives in this lowest module so the boundary and wire schema\n * layers share one implementation without an import cycle.\n */\nexport const RESERVED_PROTO_KEYS: readonly string[] = [\"__proto__\", \"constructor\", \"prototype\"];\n\n/**\n * Reject the reserved keys with the input-error type, so a client that\n * submits a magic dictionary key gets a validation error instead of a\n * silently reshaped request object.\n */\nexport function rejectReservedArgumentKey(key: string): void {\n  if (RESERVED_PROTO_KEYS.includes(key)) {\n    throw new EngramAccessInputError(`${key} is not a permitted argument key`);\n  }\n}\n\n// ─── Levenshtein distance ─────────────────────────────────────────────────\n\n/**\n * Standard Levenshtein edit distance. O(n*m) over bounded inputs.\n * Exported so the test can verify it without importing private helpers.\n */\nexport function levenshtein(a: string, b: string): number {\n  const an = a.length;\n  const bn = b.length;\n  // Fast paths for empty strings.\n  if (an === 0) return bn;\n  if (bn === 0) return an;\n\n  // Use two rows to keep memory O(min(n,m)).\n  let prev: number[] = [];\n  let curr: number[] = [];\n\n  // Align loops to the shorter string.\n  const [shorter, longer, sn, ln] =\n    an < bn ? [a, b, an, bn] : [b, a, bn, an];\n\n  for (let i = 0; i <= sn; i++) prev[i] = i;\n\n  for (let j = 1; j <= ln; j++) {\n    curr[0] = j;\n    for (let i = 1; i <= sn; i++) {\n      const cost = shorter[i - 1] === longer[j - 1] ? 0 : 1;\n      curr[i] = Math.min(\n        prev[i] + 1,       // deletion\n        curr[i - 1] + 1,   // insertion\n        prev[i - 1] + cost, // substitution\n      );\n    }\n    [prev, curr] = [curr, prev];\n  }\n  return prev[sn];\n}\n\n// ─── Similar-name helpers ─────────────────────────────────────────────────\n\nconst SUGGESTION_DISTANCE_CAP = 3;\n/**\n * Upper bound on the requested tool name. Anything longer is rejected before\n * the O(n*m) Levenshtein pass (#3042 review, P2): a 128 KB request over ~30\n * tools would otherwise run hundreds of millions of comparisons and block\n * the server event loop. The repo documents 64 chars as the tool-name shape;\n * this matches the limit enforced by every published surface.\n */\nexport const SUGGESTION_REQUEST_MAX_LEN = 64;\n\nexport interface SuggestionCandidate {\n  name: string;\n  distance: number;\n}\n\n/**\n * Find the nearest registered tool names by Levenshtein distance.\n * Results are sorted by distance ascending then name ascending (deterministic).\n * Only names with distance <= {@link SUGGESTION_DISTANCE_CAP} are returned;\n * when no name is that close the caller falls back to listing the full set.\n */\nexport function nearestSuggestions(\n  requested: string,\n  registeredNames: readonly string[],\n): SuggestionCandidate[] {\n  // Defense in depth: the entry point already caps; this guards any direct\n  // caller of the helper from an unbounded Levenshtein pass (issue #3042).\n  if (requested.length > SUGGESTION_REQUEST_MAX_LEN) return [];\n  const candidates: SuggestionCandidate[] = [];\n  for (const name of registeredNames) {\n    const distance = levenshtein(requested.toLowerCase(), name.toLowerCase());\n    if (distance <= SUGGESTION_DISTANCE_CAP) {\n      candidates.push({ name, distance });\n    }\n  }\n  // Total comparator: distance asc, then name asc.\n  candidates.sort((a, b) => {\n    if (a.distance !== b.distance) return a.distance < b.distance ? -1 : 1;\n    return a.name < b.name ? -1 : a.name > b.name ? 1 : 0;\n  });\n  return candidates;\n}\n\n/**\n * Build a human-readable \"did you mean?\" suggestion string.\n * When no close match is found, returns a fallback listing.\n */\nfunction buildSuggestion(\n  requested: string,\n  registeredNames: readonly string[],\n): string {\n  const suggestions = nearestSuggestions(requested, registeredNames);\n  if (suggestions.length === 0) {\n    return `Registered tools: ${registeredNames.join(\", \")}`;\n  }\n  return `Did you mean ${suggestions.map((s) => s.name).join(\", \")}?`;\n}\n\n/**\n * Read a Zod type tag without asserting a shape.\n *\n * Zod keeps its discriminant at `_def.typeName`. Both hops are narrowed with\n * `in`/`typeof` rather than an inline cast, so a non-Zod object yields\n * `undefined` instead of a fabricated read.\n */\nfunction zodTypeName(schema: unknown): string | undefined {\n  // zod 4: schema internals live on `_zod.def.type` (v3 read `_def.typeName`).\n  if (!(schema instanceof Object) || !(\"_zod\" in schema)) return undefined;\n  // SAFETY: the guard above established `_zod` exists; its `.def` carries the\n  // discriminator string under `type`.\n  const def = (schema as { _zod?: { def?: { type?: unknown } } })._zod?.def;\n  // SAFETY: zod's `_zod.def.type` discriminator is always a string literal.\n  const discriminator = def?.type;\n  return discriminator === undefined ? undefined : String(discriminator);\n}\n\n/**\n * A zod schema node this module reflects over — any object the library\n * exposes as a schema (v4 marks them with `_zod`).\n */\n/** Structural marker: every zod schema carries `_zod`. */\ntype ZodSchemaLike = { _zod?: unknown };\n\n/**\n * A synthetic example value derived from a schema: a placeholder the SAME\n * schema accepts, so the error message can show a valid argument shape.\n */\ntype SchemaExample = string | number | boolean | null | readonly SchemaExample[] | { [key: string]: SchemaExample };\n\n/**\n * Reverse-engineer ONE synthetic example value from a Zod schema type.\n * Returns a deterministic placeholder intended to round-trip through parse().\n */\nfunction exampleFromSchema(schema: ZodSchemaLike): SchemaExample | undefined {\n  switch (zodTypeName(schema)) {\n    case \"string\":\n      return \"<string>\";\n    case \"number\":\n      return 42;\n    case \"boolean\":\n      return true;\n    case \"nullable\":\n      return null;\n    case \"array\":\n      return [];\n    case \"optional\":\n      // Optional fields are omitted from the example rather than sent as null.\n      return undefined;\n    case \"enum\": {\n      // v4 exposes accepted values as the public `.enum` record.\n      if (!(schema instanceof Object) || !(\"enum\" in schema)) return \"<value>\";\n      // SAFETY: the guard established `.enum`; zod types it as a value record.\n      const values = Object.values((schema as { enum: Record<string, string> }).enum);\n      return values.length > 0 ? values[0] : \"<value>\";\n    }\n    case \"object\": {\n      // v4 exposes `.shape` as a plain property on the object schema.\n      if (!(schema instanceof Object) || !(\"shape\" in schema)) return {};\n      // SAFETY: object schemas expose their field schemas keyed by name.\n      const fieldsByName = (schema as { shape: { [field: string]: ZodSchemaLike } }).shape;\n      if (!(fieldsByName instanceof Object)) return {};\n      const result: { [key: string]: SchemaExample } = {};\n      for (const field of Object.getOwnPropertyNames(fieldsByName)) {\n        if (!Object.hasOwn(fieldsByName, field)) continue;\n        const schemaNode = fieldsByName[field];\n        const value = exampleFromSchema(schemaNode);\n        if (value !== undefined) result[field] = value;\n      }\n      return result;\n    }\n    default:\n      return undefined;\n  }\n}\n/**\n * Build an enriched \"unknown tool\" error message.\n *\n * @param requested - the tool name the caller used\n * @param registeredNames - ALL registered tool names (including aliases)\n */\nexport function unknownToolError(\n  requested: string,\n  registeredNames: readonly string[],\n): string {\n  // Cap the request before the suggestion pass: a 128 KB name would otherwise\n  // pay O(n*m) per registered tool (issue #3042 review, P2). The cap matches\n  // the documented tool-name shape; an over-long request is rejected with a\n  // teaching message rather than a silent truncate.\n  if (requested.length > SUGGESTION_REQUEST_MAX_LEN) {\n    return `Unknown tool: name exceeds ${SUGGESTION_REQUEST_MAX_LEN} characters (got ${requested.length}).`;\n  }\n  const suggestion = buildSuggestion(requested, registeredNames);\n  return `Unknown tool: ${requested}. ${suggestion}`;\n}\n\n/**\n * Build an enriched \"invalid arguments\" error message.\n *\n * The example is generated from the schema (never hand-written, so it cannot\n * drift) and is shown ONLY when it round-trips through that same schema. It\n * carries schema-derived fields only: injecting the tool name would add an\n * unrecognized property and fail a `.strict()` object (#3035 review finding).\n *\n * @param tool - the tool name that received the invalid args\n * @param zodError - the ZodError from parse()\n * @param schema - the original Zod schema, used to generate the example\n */\nexport function invalidArgsError(\n  tool: string,\n  zodError: ZodError,\n  schema?: unknown,\n): string {\n  const issues = zodError.issues.map((issue) => {\n    const path = issue.path.length > 0 ? issue.path.join(\".\") : \"(root)\";\n    // `expected` exists only on the invalid_type / invalid_literal variants of\n    // ZodIssue, so it is read through a presence check rather than assumed.\n    const expected = \"expected\" in issue ? issue.expected : undefined;\n    return expected === undefined\n      ? `${path}: ${issue.message}`\n      : `${path}: ${issue.message} (expected ${String(expected)})`;\n  });\n  let message = `Invalid arguments for \"${tool}\": ${issues.join(\"; \")}`;\n  if (!schema) return message;\n\n  const example = exampleFromSchema(schema);\n  if (!example || typeof example !== \"object\" || Object.keys(example).length === 0) {\n    return message;\n  }\n\n  // Withhold an example that cannot parse against its own schema: a\n  // non-round-tripping example is misinformation, worse than none. Narrowed\n  // with `in`/`typeof` rather than an inline cast so the shape is checked.\n  let roundTrips = false;\n  if (typeof schema === \"object\" && \"safeParse\" in schema) {\n    const parser = schema.safeParse;\n    if (typeof parser === \"function\") {\n      try {\n        const parsed: unknown = parser.call(schema, example);\n        roundTrips =\n          typeof parsed === \"object\"\n          && parsed !== null\n          && \"success\" in parsed\n          && parsed.success === true;\n      } catch {\n        roundTrips = false;\n      }\n    }\n  }\n\n  return roundTrips ? `${message}. Example arguments: ${JSON.stringify(example)}` : message;\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-E33UJHY3.js → chunk-CN7Q3T2J.js}

@@ -1,12 +1,12 @@
 import {
   parseDeepRecallMaxSteps
-} from "./chunk-AJG2TAMR.js";
+} from "./chunk-IEEV27BC.js";
 import {
   deepRecallRequestSchema
-} from "./chunk-HWHNQVRV.js";
+} from "./chunk-YMJRLT7S.js";
 import {
   EngramAccessInputError
-} from "./chunk-LGEH473S.js";
+} from "./chunk-CJCTKL6Y.js";
 
 // src/deep-recall-http-glue.ts
 async function respondDeepRecall(req, res, respondJson, readJsonBody, service, scopeFor, abortSignal) {
@@ -40,4 +40,4 @@ async function respondDeepRecall(req, res, respondJson, readJsonBody, service, s
 export {
   respondDeepRecall
 };
-//# sourceMappingURL=chunk-E33UJHY3.js.map
+//# sourceMappingURL=chunk-CN7Q3T2J.js.map

package/dist/{chunk-YUTG35M4.js → chunk-CYCEROPR.js}

@@ -1,6 +1,6 @@
 import {
   withBriefingDeadline
-} from "./chunk-X2KO4FK5.js";
+} from "./chunk-FNFURZBZ.js";
 import {
   withBriefingFollowupTimeout
 } from "./chunk-GZFKCLRC.js";
@@ -10,7 +10,7 @@ import {
 } from "./chunk-EKUI7I2X.js";
 import {
   StorageManager
-} from "./chunk-WAD32CZG.js";
+} from "./chunk-CC4V7HNP.js";
 import {
   normalizeEntityName
 } from "./chunk-YXZG5TVN.js";
@@ -974,4 +974,4 @@ export {
   resolveBriefingSaveDir,
   briefingFilename
 };
-//# sourceMappingURL=chunk-YUTG35M4.js.map
+//# sourceMappingURL=chunk-CYCEROPR.js.map

package/dist/{chunk-TFLPDNQV.js → chunk-D5EV6Y2L.js}

@@ -1,12 +1,12 @@
 import {
   listNamespaces
-} from "./chunk-HPFVZPRH.js";
+} from "./chunk-2U4LMSEX.js";
 import {
   corpusScanWorker
 } from "./chunk-4LZ7SVKM.js";
 import {
   capabilityAllowsNamespace
-} from "./chunk-YO2JEX2Z.js";
+} from "./chunk-OGBQMY46.js";
 
 // src/corpus-watermark.ts
 import { createHash } from "crypto";
@@ -292,4 +292,4 @@ export {
   computeServiceCorpusWatermarks,
   computeServiceCorpusCensus
 };
-//# sourceMappingURL=chunk-TFLPDNQV.js.map
+//# sourceMappingURL=chunk-D5EV6Y2L.js.map

package/dist/{chunk-BFBS7OFQ.js → chunk-DC55RIEZ.js}

@@ -3,6 +3,9 @@ import {
   withGraphWriteLock,
   yieldForLockHeartbeat
 } from "./chunk-QGJSBU4R.js";
+import {
+  readEdgeConfidence
+} from "./chunk-2LSZVONP.js";
 import {
   emitGraphEvent
 } from "./chunk-DEUNUKTD.js";
@@ -14,9 +17,6 @@ import {
 import {
   GraphEdgeAppendError
 } from "./chunk-GKCXTSFF.js";
-import {
-  readEdgeConfidence
-} from "./chunk-2LSZVONP.js";
 import {
   isErrnoCode
 } from "./chunk-KNA3BXXL.js";
@@ -758,4 +758,4 @@ export {
   applyPageRankRefinement,
   applyLateralInhibition
 };
-//# sourceMappingURL=chunk-BFBS7OFQ.js.map
+//# sourceMappingURL=chunk-DC55RIEZ.js.map

package/dist/{chunk-B4ZU34JQ.js → chunk-DT7SNJH6.js}

@@ -7,10 +7,10 @@ import {
 import {
   listMemoryGovernanceRuns,
   readMemoryGovernanceRunArtifact
-} from "./chunk-GCAQ3VUJ.js";
+} from "./chunk-JM2YZKCQ.js";
 import {
   StorageManager
-} from "./chunk-WAD32CZG.js";
+} from "./chunk-CC4V7HNP.js";
 import {
   normalizeProjectionPreview,
   normalizeProjectionTags
@@ -1156,4 +1156,4 @@ export {
   verifyMemoryProjection,
   repairMemoryProjection
 };
-//# sourceMappingURL=chunk-B4ZU34JQ.js.map
+//# sourceMappingURL=chunk-DT7SNJH6.js.map

package/dist/{chunk-VLMBSGQF.js → chunk-DZ7DPDVW.js}

@@ -3,7 +3,7 @@ import {
   headerConnector,
   renderExtractionConversation,
   resolveSourceConnector
-} from "./chunk-QZBTIYKD.js";
+} from "./chunk-BLSHFIR6.js";
 import {
   normalizeReasoningTrace
 } from "./chunk-54V4BZWP.js";
@@ -29,10 +29,10 @@ import {
   buildSpanMaterializeTurns,
   stripUntrustedFactSpans,
   truncateLocalExtractionConversation
-} from "./chunk-FZVROZKC.js";
+} from "./chunk-XVZA6VXC.js";
 import {
   attachExtractionProvenance
-} from "./chunk-CIIHIAJ2.js";
+} from "./chunk-ROGO7FRA.js";
 import {
   containsExtractionPlaceholder,
   extractionAttributes,
@@ -85,7 +85,7 @@ import {
 } from "./chunk-QNUNAXBE.js";
 import {
   LocalLlmClient
-} from "./chunk-MSIRVXQ3.js";
+} from "./chunk-2G4TV2ML.js";
 import {
   normalizeProcedureSteps
 } from "./chunk-QDW3E4RD.js";
@@ -105,7 +105,7 @@ import {
 } from "./chunk-YBA52OKG.js";
 import {
   isMemoryCategory
-} from "./chunk-JRVMCZE3.js";
+} from "./chunk-QEYTRFR3.js";
 import {
   sanitizeMemoryContent
 } from "./chunk-5GKPFL3S.js";
@@ -928,7 +928,8 @@ var ExtractionEngine = class {
     const { conversation, renderedConversation } = renderExtractionConversation(boundedTurns, headerConnector(sourceConnector));
     const spanTurns = buildSpanMaterializeTurns(boundedTurns.map((turn) => turn.content));
     const groundingSource = boundedTurns.map((turn) => turn.content).join("\n\n");
-    const assertionSource = boundedTurns.filter((turn) => turn.extractionContextOnly !== true).map((turn) => turn.content).join("\n\n");
+    const assertionTurns = boundedTurns.filter((turn) => turn.extractionContextOnly !== true);
+    const assertionSource = assertionTurns.map((turn) => turn.content).join("\n\n");
     const roleAssertionSources = {
       profile: boundedTurns.filter((turn) => turn.role === "user" && turn.extractionContextOnly !== true).map((turn) => turn.content).join("\n\n"),
       identity: boundedTurns.filter((turn) => turn.role === "assistant" && turn.extractionContextOnly !== true).map((turn) => turn.content).join("\n\n")
@@ -962,7 +963,8 @@ var ExtractionEngine = class {
       messageTimestamp,
       sourceConnector,
       ambientCapture,
-      scopeClassificationEnabled: lifecycleCaps.extractionScopeClassification
+      scopeClassificationEnabled: lifecycleCaps.extractionScopeClassification,
+      turns: assertionTurns.map((turn) => turn.content)
     };
     const traceId = crypto.randomUUID();
     const emittedDirectStart = !!(this.shouldUseDirectClient || this.shouldUseLocalLlm);
@@ -2441,4 +2443,4 @@ export {
   shouldEnableLocalExtractionThinking,
   ExtractionEngine
 };
-//# sourceMappingURL=chunk-VLMBSGQF.js.map
+//# sourceMappingURL=chunk-DZ7DPDVW.js.map