@remnic/core 9.69.45 → 9.69.47

package/dist/{chunk-JMBTNVMW.js → chunk-FGRJJBFO.js}

@@ -11,7 +11,7 @@ import {
 } from "./chunk-NHLLKEKK.js";
 import {
   parseConfig
-} from "./chunk-W6YDAIVB.js";
+} from "./chunk-OSTXIFZW.js";
 import {
   resolveObjectiveStateStoreDir,
   validateObjectiveStateSnapshot
@@ -268,4 +268,4 @@ export {
   recordResumeBundle,
   getResumeBundleStatus
 };
-//# sourceMappingURL=chunk-JMBTNVMW.js.map
+//# sourceMappingURL=chunk-FGRJJBFO.js.map

package/dist/{chunk-F3TURDFG.js → chunk-FPB5LQWW.js}

@@ -18,6 +18,9 @@ var MCP_READ_ONLY_TOOL_SUFFIXES = {
   deep_recall: true,
   memory_expand: true,
   memory_traverse: true,
+  memory_ls: true,
+  memory_tree: true,
+  memory_find: true,
   standup: true,
   action_confidence: true,
   capsule_list: true,
@@ -65,4 +68,4 @@ var MCP_READ_ONLY_TOOL_SUFFIXES = {
 export {
   MCP_READ_ONLY_TOOL_SUFFIXES
 };
-//# sourceMappingURL=chunk-F3TURDFG.js.map
+//# sourceMappingURL=chunk-FPB5LQWW.js.map

package/dist/{chunk-F3TURDFG.js.map → chunk-FPB5LQWW.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/mcp-read-only-tools.ts"],"sourcesContent":["/**\n * Conservative allowlist of canonical MCP tool suffixes that are\n * unambiguously read-only. Tools in this set are tagged with\n * `annotations: { readOnlyHint: true }` so ChatGPT (and other MCP\n * clients that honor the hint) can skip per-call confirmation.\n *\n * The list is suffix-based so it covers both the `remnic.*` and\n * `engram.*` naming forms. Anything not on it stays unannotated:\n * uncertainty is resolved as \"might mutate\".\n *\n * Excluded by construction: anything that writes, runs a pipeline,\n * flushes, applies, records, imports, or destructively deletes.\n */\nexport const MCP_READ_ONLY_TOOL_SUFFIXES: Readonly<Record<string, true>> = {\n  recall: true,\n  recall_explain: true,\n  recall_tier_explain: true,\n  recall_xray: true,\n  who_knows: true,\n  promotion_candidates: true,\n  briefing: true,\n  wearables_status: true,\n  transcript_day: true,\n  transcript_search: true,\n  transcript_memories: true,\n  location_status: true,\n  location_day: true,\n  meetings_list: true,\n  meetings_get: true,\n  deep_recall: true,\n  memory_expand: true,\n  memory_traverse: true,\n  standup: true,\n  action_confidence: true,\n  capsule_list: true,\n  procedural_stats: true,\n  memory_get: true,\n  memory_timeline: true,\n  entity_get: true,\n  review_queue_list: true,\n  lcm_search: true,\n  continuity_incident_list: true,\n  identity_anchor_get: true,\n  memory_identity: true,\n  memory_search: true,\n  external_wiki_search: true,\n  memory_profile: true,\n  memory_entities_list: true,\n  memory_questions: true,\n  memory_last_recall: true,\n  memory_intent_debug: true,\n  memory_qmd_debug: true,\n  memory_graph_explain: true,\n  graph_snapshot: true,\n  review_list: true,\n  profiling_report: true,\n  peer_list: true,\n  peer_get: true,\n  peer_profile_get: true,\n  console_state: true,\n  dreams_status: true,\n  codegraph_list_projects: true,\n  codegraph_index_status: true,\n  codegraph_search_graph: true,\n  codegraph_trace_path: true,\n  codegraph_detect_changes: true,\n  codegraph_query_graph: true,\n  codegraph_get_schema: true,\n  codegraph_get_snippet: true,\n  codegraph_get_architecture: true,\n  codegraph_search_code: true,\n  support_passport_memory_preview: true,\n  support_passport_cards_list: true,\n  support_passport_grants_list: true,\n};\n"],"mappings":";AAaO,IAAM,8BAA8D;AAAA,EACzE,QAAQ;AAAA,EACR,gBAAgB;AAAA,EAChB,qBAAqB;AAAA,EACrB,aAAa;AAAA,EACb,WAAW;AAAA,EACX,sBAAsB;AAAA,EACtB,UAAU;AAAA,EACV,kBAAkB;AAAA,EAClB,gBAAgB;AAAA,EAChB,mBAAmB;AAAA,EACnB,qBAAqB;AAAA,EACrB,iBAAiB;AAAA,EACjB,cAAc;AAAA,EACd,eAAe;AAAA,EACf,cAAc;AAAA,EACd,aAAa;AAAA,EACb,eAAe;AAAA,EACf,iBAAiB;AAAA,EACjB,SAAS;AAAA,EACT,mBAAmB;AAAA,EACnB,cAAc;AAAA,EACd,kBAAkB;AAAA,EAClB,YAAY;AAAA,EACZ,iBAAiB;AAAA,EACjB,YAAY;AAAA,EACZ,mBAAmB;AAAA,EACnB,YAAY;AAAA,EACZ,0BAA0B;AAAA,EAC1B,qBAAqB;AAAA,EACrB,iBAAiB;AAAA,EACjB,eAAe;AAAA,EACf,sBAAsB;AAAA,EACtB,gBAAgB;AAAA,EAChB,sBAAsB;AAAA,EACtB,kBAAkB;AAAA,EAClB,oBAAoB;AAAA,EACpB,qBAAqB;AAAA,EACrB,kBAAkB;AAAA,EAClB,sBAAsB;AAAA,EACtB,gBAAgB;AAAA,EAChB,aAAa;AAAA,EACb,kBAAkB;AAAA,EAClB,WAAW;AAAA,EACX,UAAU;AAAA,EACV,kBAAkB;AAAA,EAClB,eAAe;AAAA,EACf,eAAe;AAAA,EACf,yBAAyB;AAAA,EACzB,wBAAwB;AAAA,EACxB,wBAAwB;AAAA,EACxB,sBAAsB;AAAA,EACtB,0BAA0B;AAAA,EAC1B,uBAAuB;AAAA,EACvB,sBAAsB;AAAA,EACtB,uBAAuB;AAAA,EACvB,4BAA4B;AAAA,EAC5B,uBAAuB;AAAA,EACvB,iCAAiC;AAAA,EACjC,6BAA6B;AAAA,EAC7B,8BAA8B;AAChC;","names":[]}
+{"version":3,"sources":["../src/mcp-read-only-tools.ts"],"sourcesContent":["/**\n * Conservative allowlist of canonical MCP tool suffixes that are\n * unambiguously read-only. Tools in this set are tagged with\n * `annotations: { readOnlyHint: true }` so ChatGPT (and other MCP\n * clients that honor the hint) can skip per-call confirmation.\n *\n * The list is suffix-based so it covers both the `remnic.*` and\n * `engram.*` naming forms. Anything not on it stays unannotated:\n * uncertainty is resolved as \"might mutate\".\n *\n * Excluded by construction: anything that writes, runs a pipeline,\n * flushes, applies, records, imports, or destructively deletes.\n */\nexport const MCP_READ_ONLY_TOOL_SUFFIXES: Readonly<Record<string, true>> = {\n  recall: true,\n  recall_explain: true,\n  recall_tier_explain: true,\n  recall_xray: true,\n  who_knows: true,\n  promotion_candidates: true,\n  briefing: true,\n  wearables_status: true,\n  transcript_day: true,\n  transcript_search: true,\n  transcript_memories: true,\n  location_status: true,\n  location_day: true,\n  meetings_list: true,\n  meetings_get: true,\n  deep_recall: true,\n  memory_expand: true,\n  memory_traverse: true,\n  memory_ls: true,\n  memory_tree: true,\n  memory_find: true,\n  standup: true,\n  action_confidence: true,\n  capsule_list: true,\n  procedural_stats: true,\n  memory_get: true,\n  memory_timeline: true,\n  entity_get: true,\n  review_queue_list: true,\n  lcm_search: true,\n  continuity_incident_list: true,\n  identity_anchor_get: true,\n  memory_identity: true,\n  memory_search: true,\n  external_wiki_search: true,\n  memory_profile: true,\n  memory_entities_list: true,\n  memory_questions: true,\n  memory_last_recall: true,\n  memory_intent_debug: true,\n  memory_qmd_debug: true,\n  memory_graph_explain: true,\n  graph_snapshot: true,\n  review_list: true,\n  profiling_report: true,\n  peer_list: true,\n  peer_get: true,\n  peer_profile_get: true,\n  console_state: true,\n  dreams_status: true,\n  codegraph_list_projects: true,\n  codegraph_index_status: true,\n  codegraph_search_graph: true,\n  codegraph_trace_path: true,\n  codegraph_detect_changes: true,\n  codegraph_query_graph: true,\n  codegraph_get_schema: true,\n  codegraph_get_snippet: true,\n  codegraph_get_architecture: true,\n  codegraph_search_code: true,\n  support_passport_memory_preview: true,\n  support_passport_cards_list: true,\n  support_passport_grants_list: true,\n};\n"],"mappings":";AAaO,IAAM,8BAA8D;AAAA,EACzE,QAAQ;AAAA,EACR,gBAAgB;AAAA,EAChB,qBAAqB;AAAA,EACrB,aAAa;AAAA,EACb,WAAW;AAAA,EACX,sBAAsB;AAAA,EACtB,UAAU;AAAA,EACV,kBAAkB;AAAA,EAClB,gBAAgB;AAAA,EAChB,mBAAmB;AAAA,EACnB,qBAAqB;AAAA,EACrB,iBAAiB;AAAA,EACjB,cAAc;AAAA,EACd,eAAe;AAAA,EACf,cAAc;AAAA,EACd,aAAa;AAAA,EACb,eAAe;AAAA,EACf,iBAAiB;AAAA,EACjB,WAAW;AAAA,EACX,aAAa;AAAA,EACb,aAAa;AAAA,EACb,SAAS;AAAA,EACT,mBAAmB;AAAA,EACnB,cAAc;AAAA,EACd,kBAAkB;AAAA,EAClB,YAAY;AAAA,EACZ,iBAAiB;AAAA,EACjB,YAAY;AAAA,EACZ,mBAAmB;AAAA,EACnB,YAAY;AAAA,EACZ,0BAA0B;AAAA,EAC1B,qBAAqB;AAAA,EACrB,iBAAiB;AAAA,EACjB,eAAe;AAAA,EACf,sBAAsB;AAAA,EACtB,gBAAgB;AAAA,EAChB,sBAAsB;AAAA,EACtB,kBAAkB;AAAA,EAClB,oBAAoB;AAAA,EACpB,qBAAqB;AAAA,EACrB,kBAAkB;AAAA,EAClB,sBAAsB;AAAA,EACtB,gBAAgB;AAAA,EAChB,aAAa;AAAA,EACb,kBAAkB;AAAA,EAClB,WAAW;AAAA,EACX,UAAU;AAAA,EACV,kBAAkB;AAAA,EAClB,eAAe;AAAA,EACf,eAAe;AAAA,EACf,yBAAyB;AAAA,EACzB,wBAAwB;AAAA,EACxB,wBAAwB;AAAA,EACxB,sBAAsB;AAAA,EACtB,0BAA0B;AAAA,EAC1B,uBAAuB;AAAA,EACvB,sBAAsB;AAAA,EACtB,uBAAuB;AAAA,EACvB,4BAA4B;AAAA,EAC5B,uBAAuB;AAAA,EACvB,iCAAiC;AAAA,EACjC,6BAA6B;AAAA,EAC7B,8BAA8B;AAChC;","names":[]}

package/dist/{chunk-OOBUWMPY.js → chunk-G2SJRFGP.js}

@@ -1,9 +1,9 @@
-import {
-  normalizeDreamsStatusWindowHours
-} from "./chunk-EQWEIIKQ.js";
 import {
   runGraphEdgeDecayMaintenanceAcrossNamespaces
 } from "./chunk-SCXURCVT.js";
+import {
+  normalizeDreamsStatusWindowHours
+} from "./chunk-EQWEIIKQ.js";
 import {
   executeResolution,
   isValidResolutionVerb,
@@ -29,13 +29,13 @@ import {
   defineOperation,
   parseNamespacePreflightWriteOp,
   resolveAuthorizedNamespaceWritablePreflight
-} from "./chunk-NKDQXDFL.js";
+} from "./chunk-AS4YKT75.js";
 import {
   parseSharedWriteOutputControls
 } from "./chunk-IFBSZGW3.js";
 import {
   validateBriefingFormat
-} from "./chunk-YHSEUZV5.js";
+} from "./chunk-QLCMOHRE.js";
 import {
   parseDeepRecallMaxSteps
 } from "./chunk-7RGX7BMF.js";
@@ -594,4 +594,4 @@ defineOperation({ name: "graph_events", description: "SSE graph events.", schema
 defineOperation({ name: "chat_message", description: "Chat message.", schema: strictSchema({ message: S.str, chatSessionId: S.str }), handler: async (_i, _ctx) => ({ result: { ok: true } }) });
 defineOperation({ name: "chat_events", description: "SSE chat events.", schema: strictSchema({}), handler: async (_i, _ctx) => ({ result: { stream: "sse" } }) });
 defineOperation({ name: "adapters_status", description: "Adapter registry metadata (issue #1850 round 5). Marker op: the HTTP transport builds the response from its own adapterRegistry, but the op still must be registered so it appears in listRegisteredOperations and enforceTokenOp can gate it for scoped tokens.", schema: strictSchema({}), handler: async (_i, _ctx) => ({ result: { ok: true } }) });
-//# sourceMappingURL=chunk-OOBUWMPY.js.map
+//# sourceMappingURL=chunk-G2SJRFGP.js.map

package/dist/{chunk-WGZHSQDV.js → chunk-G2XZFGYN.js}

@@ -1,6 +1,3 @@
-import {
-  ChatTransport
-} from "./chunk-JUXOTY6J.js";
 import {
   SingleFlightProbe,
   extractNonRecoverableBackendReason,
@@ -11,6 +8,9 @@ import {
   resolveUnavailableVerdict,
   waitForRetryBackoff
 } from "./chunk-QM2SPLKQ.js";
+import {
+  ChatTransport
+} from "./chunk-JUXOTY6J.js";
 import {
   estimateTokenCount
 } from "./chunk-TOTT6S2V.js";
@@ -1100,4 +1100,4 @@ var LocalLlmClient = class _LocalLlmClient {
 export {
   LocalLlmClient
 };
-//# sourceMappingURL=chunk-WGZHSQDV.js.map
+//# sourceMappingURL=chunk-G2XZFGYN.js.map

package/dist/{chunk-JPNUKKSL.js → chunk-GGROFIYX.js}

@@ -14,7 +14,7 @@ import {
 } from "./chunk-3UXOZBHV.js";
 import {
   StorageManager
-} from "./chunk-IAT5WFEU.js";
+} from "./chunk-MNG536IS.js";
 import {
   OKF_PROFILE_TYPE,
   okfTypeForMemory
@@ -272,4 +272,4 @@ export {
   exportOkfBundle,
   firstHeading
 };
-//# sourceMappingURL=chunk-JPNUKKSL.js.map
+//# sourceMappingURL=chunk-GGROFIYX.js.map

package/dist/chunk-GXJSLNYO.js

@@ -0,0 +1,74 @@
+import {
+  defineOperation
+} from "./chunk-AS4YKT75.js";
+import {
+  EngramAccessInputError
+} from "./chunk-2Z24E5W2.js";
+
+// src/memory-browse-operations.ts
+import { z } from "zod";
+function strictSchema(shape) {
+  return z.preprocess(
+    (data) => {
+      if (data !== null && typeof data === "object" && !Array.isArray(data)) {
+        return Object.fromEntries(Object.entries(data).filter(([, value]) => value !== null));
+      }
+      return data;
+    },
+    z.object(shape).passthrough()
+  );
+}
+function optStr(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function optInt(value) {
+  if (typeof value === "number") return value;
+  if (typeof value === "string" && Number.isFinite(Number(value))) return Number(value);
+  return void 0;
+}
+function reqStr(value, field) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new EngramAccessInputError(`${field} is required`);
+  }
+  return value;
+}
+var verbShape = {
+  namespace: z.string().optional()
+};
+function browseRequest(verb, input) {
+  return {
+    verb,
+    ...optStr(input.path) !== void 0 ? { path: optStr(input.path) } : {},
+    ...optInt(input.depth) !== void 0 ? { depth: optInt(input.depth) } : {},
+    ...optStr(input.pattern) !== void 0 ? { pattern: optStr(input.pattern) } : {},
+    namespace: optStr(input.namespace)
+  };
+}
+defineOperation({
+  name: "memory_ls",
+  description: "List the children of one store path in the caller's namespace: category dirs with counts, memory files with a one-line description.",
+  schema: strictSchema({ ...verbShape, path: z.string().optional() }),
+  handler: async (input, ctx) => ({
+    result: await ctx.service.memoryStoreBrowse({ ...browseRequest("ls", input), authenticatedPrincipal: ctx.authenticatedPrincipal })
+  })
+});
+defineOperation({
+  name: "memory_tree",
+  description: "Depth-limited tree of store paths under one directory, one-line descriptions, entry-capped.",
+  schema: strictSchema({ ...verbShape, path: z.string().optional(), depth: z.union([z.number(), z.string()]).optional() }),
+  handler: async (input, ctx) => ({
+    result: await ctx.service.memoryStoreBrowse({ ...browseRequest("tree", input), authenticatedPrincipal: ctx.authenticatedPrincipal })
+  })
+});
+defineOperation({
+  name: "memory_find",
+  description: "Deterministic name/path match (`*` glob or substring) over the caller's namespace store; semantic search stays memory_search.",
+  schema: strictSchema({ ...verbShape, pattern: z.string() }),
+  handler: async (input, ctx) => ({
+    result: await ctx.service.memoryStoreBrowse({
+      ...browseRequest("find", { ...input, pattern: reqStr(input.pattern, "pattern") }),
+      authenticatedPrincipal: ctx.authenticatedPrincipal
+    })
+  })
+});
+//# sourceMappingURL=chunk-GXJSLNYO.js.map

package/dist/chunk-GXJSLNYO.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/memory-browse-operations.ts"],"sourcesContent":["/**\n * Memory-store browse boundary operations (issue #2978).\n *\n * `memory_ls` / `memory_tree` / `memory_find` route MCP, HTTP, and CLI\n * dispatch through the shared validation + error-mapping layer\n * (access-boundary.ts) to the single `EngramAccessService.memoryStoreBrowse`\n * implementation. Sibling module so access-operations-batch.ts stays at its\n * ceiling seam (same layout as recall-navigation-operations.ts).\n */\n\nimport { z } from \"zod\";\n\nimport { defineOperation } from \"./access-boundary.js\";\nimport { EngramAccessInputError } from \"./access-errors.js\";\nimport type { BrowseVerb, MemoryStoreBrowseRequest } from \"./memory-browse.js\";\n\nfunction strictSchema<T extends z.ZodRawShape>(shape: T): z.ZodType<Record<string, unknown>> {\n  return z.preprocess(\n    (data) => {\n      if (data !== null && typeof data === \"object\" && !Array.isArray(data)) {\n        return Object.fromEntries(Object.entries(data as Record<string, unknown>).filter(([, value]) => value !== null));\n      }\n      return data;\n    },\n    z.object(shape).passthrough(),\n  ) as unknown as z.ZodType<Record<string, unknown>>;\n}\n\nfunction optStr(value: unknown): string | undefined {\n  return typeof value === \"string\" ? value : undefined;\n}\n\nfunction optInt(value: unknown): number | undefined {\n  if (typeof value === \"number\") return value;\n  if (typeof value === \"string\" && Number.isFinite(Number(value))) return Number(value);\n  return undefined;\n}\n\nfunction reqStr(value: unknown, field: string): string {\n  if (typeof value !== \"string\" || value.trim().length === 0) {\n    throw new EngramAccessInputError(`${field} is required`);\n  }\n  return value;\n}\n\nconst verbShape = {\n  namespace: z.string().optional(),\n} as const;\n\nfunction browseRequest(verb: BrowseVerb, input: Record<string, unknown>): MemoryStoreBrowseRequest {\n  return {\n    verb,\n    ...(optStr(input.path) !== undefined ? { path: optStr(input.path) } : {}),\n    ...(optInt(input.depth) !== undefined ? { depth: optInt(input.depth) } : {}),\n    ...(optStr(input.pattern) !== undefined ? { pattern: optStr(input.pattern) } : {}),\n    namespace: optStr(input.namespace),\n  };\n}\n\ndefineOperation({\n  name: \"memory_ls\",\n  description: \"List the children of one store path in the caller's namespace: category dirs with counts, memory files with a one-line description.\",\n  schema: strictSchema({ ...verbShape, path: z.string().optional() }),\n  handler: async (input, ctx) => ({\n    result: await ctx.service.memoryStoreBrowse({ ...browseRequest(\"ls\", input), authenticatedPrincipal: ctx.authenticatedPrincipal }),\n  }),\n});\n\ndefineOperation({\n  name: \"memory_tree\",\n  description: \"Depth-limited tree of store paths under one directory, one-line descriptions, entry-capped.\",\n  schema: strictSchema({ ...verbShape, path: z.string().optional(), depth: z.union([z.number(), z.string()]).optional() }),\n  handler: async (input, ctx) => ({\n    result: await ctx.service.memoryStoreBrowse({ ...browseRequest(\"tree\", input), authenticatedPrincipal: ctx.authenticatedPrincipal }),\n  }),\n});\n\ndefineOperation({\n  name: \"memory_find\",\n  description: \"Deterministic name/path match (`*` glob or substring) over the caller's namespace store; semantic search stays memory_search.\",\n  schema: strictSchema({ ...verbShape, pattern: z.string() }),\n  handler: async (input, ctx) => ({\n    result: await ctx.service.memoryStoreBrowse({\n      ...browseRequest(\"find\", { ...input, pattern: reqStr(input.pattern, \"pattern\") }),\n      authenticatedPrincipal: ctx.authenticatedPrincipal,\n    }),\n  }),\n});\n"],"mappings":";;;;;;;;AAUA,SAAS,SAAS;AAMlB,SAAS,aAAsC,OAA8C;AAC3F,SAAO,EAAE;AAAA,IACP,CAAC,SAAS;AACR,UAAI,SAAS,QAAQ,OAAO,SAAS,YAAY,CAAC,MAAM,QAAQ,IAAI,GAAG;AACrE,eAAO,OAAO,YAAY,OAAO,QAAQ,IAA+B,EAAE,OAAO,CAAC,CAAC,EAAE,KAAK,MAAM,UAAU,IAAI,CAAC;AAAA,MACjH;AACA,aAAO;AAAA,IACT;AAAA,IACA,EAAE,OAAO,KAAK,EAAE,YAAY;AAAA,EAC9B;AACF;AAEA,SAAS,OAAO,OAAoC;AAClD,SAAO,OAAO,UAAU,WAAW,QAAQ;AAC7C;AAEA,SAAS,OAAO,OAAoC;AAClD,MAAI,OAAO,UAAU,SAAU,QAAO;AACtC,MAAI,OAAO,UAAU,YAAY,OAAO,SAAS,OAAO,KAAK,CAAC,EAAG,QAAO,OAAO,KAAK;AACpF,SAAO;AACT;AAEA,SAAS,OAAO,OAAgB,OAAuB;AACrD,MAAI,OAAO,UAAU,YAAY,MAAM,KAAK,EAAE,WAAW,GAAG;AAC1D,UAAM,IAAI,uBAAuB,GAAG,KAAK,cAAc;AAAA,EACzD;AACA,SAAO;AACT;AAEA,IAAM,YAAY;AAAA,EAChB,WAAW,EAAE,OAAO,EAAE,SAAS;AACjC;AAEA,SAAS,cAAc,MAAkB,OAA0D;AACjG,SAAO;AAAA,IACL;AAAA,IACA,GAAI,OAAO,MAAM,IAAI,MAAM,SAAY,EAAE,MAAM,OAAO,MAAM,IAAI,EAAE,IAAI,CAAC;AAAA,IACvE,GAAI,OAAO,MAAM,KAAK,MAAM,SAAY,EAAE,OAAO,OAAO,MAAM,KAAK,EAAE,IAAI,CAAC;AAAA,IAC1E,GAAI,OAAO,MAAM,OAAO,MAAM,SAAY,EAAE,SAAS,OAAO,MAAM,OAAO,EAAE,IAAI,CAAC;AAAA,IAChF,WAAW,OAAO,MAAM,SAAS;AAAA,EACnC;AACF;AAEA,gBAAgB;AAAA,EACd,MAAM;AAAA,EACN,aAAa;AAAA,EACb,QAAQ,aAAa,EAAE,GAAG,WAAW,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,CAAC;AAAA,EAClE,SAAS,OAAO,OAAO,SAAS;AAAA,IAC9B,QAAQ,MAAM,IAAI,QAAQ,kBAAkB,EAAE,GAAG,cAAc,MAAM,KAAK,GAAG,wBAAwB,IAAI,uBAAuB,CAAC;AAAA,EACnI;AACF,CAAC;AAED,gBAAgB;AAAA,EACd,MAAM;AAAA,EACN,aAAa;AAAA,EACb,QAAQ,aAAa,EAAE,GAAG,WAAW,MAAM,EAAE,OAAO,EAAE,SAAS,GAAG,OAAO,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,EAAE,OAAO,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC;AAAA,EACvH,SAAS,OAAO,OAAO,SAAS;AAAA,IAC9B,QAAQ,MAAM,IAAI,QAAQ,kBAAkB,EAAE,GAAG,cAAc,QAAQ,KAAK,GAAG,wBAAwB,IAAI,uBAAuB,CAAC;AAAA,EACrI;AACF,CAAC;AAED,gBAAgB;AAAA,EACd,MAAM;AAAA,EACN,aAAa;AAAA,EACb,QAAQ,aAAa,EAAE,GAAG,WAAW,SAAS,EAAE,OAAO,EAAE,CAAC;AAAA,EAC1D,SAAS,OAAO,OAAO,SAAS;AAAA,IAC9B,QAAQ,MAAM,IAAI,QAAQ,kBAAkB;AAAA,MAC1C,GAAG,cAAc,QAAQ,EAAE,GAAG,OAAO,SAAS,OAAO,MAAM,SAAS,SAAS,EAAE,CAAC;AAAA,MAChF,wBAAwB,IAAI;AAAA,IAC9B,CAAC;AAAA,EACH;AACF,CAAC;","names":[]}

package/dist/{chunk-VA5QRTZX.js → chunk-HG74GEVY.js}

@@ -5,7 +5,7 @@ import {
 } from "./chunk-5JMAGU26.js";
 import {
   runPostConsolidationMaterialize
-} from "./chunk-MDYZCPNQ.js";
+} from "./chunk-WL3PGPGU.js";
 import {
   isSemanticConsolidationLlmOperator
 } from "./chunk-G7D6GZ5J.js";
@@ -220,4 +220,4 @@ export {
   buildExtensionsBlockForConsolidation,
   materializeAfterSemanticConsolidation
 };
-//# sourceMappingURL=chunk-VA5QRTZX.js.map
+//# sourceMappingURL=chunk-HG74GEVY.js.map

package/dist/chunk-HMDYSGY6.js

@@ -0,0 +1,54 @@
+import {
+  EngramAccessInputError
+} from "./chunk-2Z24E5W2.js";
+
+// src/memory-browse-http-glue.ts
+function optStr(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function optInt(value) {
+  if (value === void 0 || value === null || value === "") return void 0;
+  const parsed = typeof value === "string" ? Number(value) : value;
+  if (typeof parsed !== "number" || !Number.isInteger(parsed)) {
+    throw new EngramAccessInputError("depth must be an integer");
+  }
+  return parsed;
+}
+async function respondBrowse(req, res, respondJson, readJsonBody, service, scopeFor, verb) {
+  const body = await readJsonBody(req);
+  const scope = scopeFor(optStr(body.namespace));
+  const depth = verb === "tree" ? optInt(body.depth) : void 0;
+  const result = await service.memoryStoreBrowse({
+    verb,
+    ...optStr(body.path) !== void 0 ? { path: optStr(body.path) } : {},
+    ...depth !== void 0 ? { depth } : {},
+    ...verb === "find" && optStr(body.pattern) !== void 0 ? { pattern: optStr(body.pattern) } : {},
+    namespace: scope.namespace,
+    authenticatedPrincipal: scope.authenticatedPrincipal
+  });
+  const { rendered: _rendered, ...payload } = result;
+  respondJson(res, 200, payload);
+}
+async function maybeRespondMemoryBrowse(req, res, pathname, method, enforceTokenOp, respondJson, readJsonBody, service, scopeFor) {
+  if (method === "POST" && (pathname === "/engram/v1/memory/ls" || pathname === "/remnic/v1/memory/ls")) {
+    enforceTokenOp("memory_ls");
+    await respondBrowse(req, res, respondJson, readJsonBody, service, scopeFor, "ls");
+    return true;
+  }
+  if (method === "POST" && (pathname === "/engram/v1/memory/tree" || pathname === "/remnic/v1/memory/tree")) {
+    enforceTokenOp("memory_tree");
+    await respondBrowse(req, res, respondJson, readJsonBody, service, scopeFor, "tree");
+    return true;
+  }
+  if (method === "POST" && (pathname === "/engram/v1/memory/find" || pathname === "/remnic/v1/memory/find")) {
+    enforceTokenOp("memory_find");
+    await respondBrowse(req, res, respondJson, readJsonBody, service, scopeFor, "find");
+    return true;
+  }
+  return false;
+}
+
+export {
+  maybeRespondMemoryBrowse
+};
+//# sourceMappingURL=chunk-HMDYSGY6.js.map

package/dist/chunk-HMDYSGY6.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/memory-browse-http-glue.ts"],"sourcesContent":["/**\n * Memory-store browse HTTP glue (issue #2978) — route bodies live here so\n * access-http.ts stays at its structural ceiling (same seam as\n * recall-navigation-http-glue.ts).\n *\n * Each route carries its literal `enforceTokenOp(\"<op>\")` boundary-dispatch\n * marker so `access-surface-catalog.test.ts` can prove dispatch statically.\n * Input errors map to 400; everything else rethrows to the global 500\n * handler. Namespace resolution flows through the caller-supplied\n * `scopeFor` gate so a body-supplied namespace passes the SAME\n * effective-namespace allow-list as the query string (issue #1850 finding\n * 2), and `authenticatedPrincipal` reaches the service so authorization\n * derives from the presenting principal, never client-supplied input.\n */\n\nimport type { IncomingMessage, ServerResponse } from \"node:http\";\n\nimport { EngramAccessInputError } from \"./access-errors.js\";\nimport type { EngramAccessService } from \"./access-service.js\";\nimport type { BrowseVerb } from \"./memory-browse.js\";\n\ntype RespondJson = (res: ServerResponse, status: number, payload: unknown) => void;\ntype ReadJsonBody = (req: IncomingMessage) => Promise<unknown>;\n\ntype ScopeFor = (\n  bodyNamespace?: string,\n) => { namespace?: string; authenticatedPrincipal?: string };\n\nfunction optStr(value: unknown): string | undefined {\n  return typeof value === \"string\" ? value : undefined;\n}\n\nfunction optInt(value: unknown): number | undefined {\n  if (value === undefined || value === null || value === \"\") return undefined;\n  const parsed = typeof value === \"string\" ? Number(value) : value;\n  if (typeof parsed !== \"number\" || !Number.isInteger(parsed)) {\n    throw new EngramAccessInputError(\"depth must be an integer\");\n  }\n  return parsed;\n}\n\nasync function respondBrowse(\n  req: IncomingMessage,\n  res: ServerResponse,\n  respondJson: RespondJson,\n  readJsonBody: ReadJsonBody,\n  service: EngramAccessService,\n  scopeFor: ScopeFor,\n  verb: BrowseVerb,\n): Promise<void> {\n  const body = (await readJsonBody(req)) as Record<string, unknown>;\n  const scope = scopeFor(optStr(body.namespace));\n  const depth = verb === \"tree\" ? optInt(body.depth) : undefined;\n  const result = await service.memoryStoreBrowse({\n    verb,\n    ...(optStr(body.path) !== undefined ? { path: optStr(body.path) } : {}),\n    ...(depth !== undefined ? { depth } : {}),\n    ...(verb === \"find\" && optStr(body.pattern) !== undefined ? { pattern: optStr(body.pattern) } : {}),\n    namespace: scope.namespace,\n    authenticatedPrincipal: scope.authenticatedPrincipal,\n  });\n  const { rendered: _rendered, ...payload } = result;\n  respondJson(res, 200, payload);\n}\n\nexport async function maybeRespondMemoryBrowse(\n  req: IncomingMessage,\n  res: ServerResponse,\n  pathname: string,\n  method: string | undefined,\n  enforceTokenOp: (op: \"memory_ls\" | \"memory_tree\" | \"memory_find\") => void,\n  respondJson: RespondJson,\n  readJsonBody: ReadJsonBody,\n  service: EngramAccessService,\n  scopeFor: ScopeFor,\n): Promise<boolean> {\n  if (method === \"POST\" && (pathname === \"/engram/v1/memory/ls\" || pathname === \"/remnic/v1/memory/ls\")) {\n    enforceTokenOp(\"memory_ls\");\n    await respondBrowse(req, res, respondJson, readJsonBody, service, scopeFor, \"ls\");\n    return true;\n  }\n  if (method === \"POST\" && (pathname === \"/engram/v1/memory/tree\" || pathname === \"/remnic/v1/memory/tree\")) {\n    enforceTokenOp(\"memory_tree\");\n    await respondBrowse(req, res, respondJson, readJsonBody, service, scopeFor, \"tree\");\n    return true;\n  }\n  if (method === \"POST\" && (pathname === \"/engram/v1/memory/find\" || pathname === \"/remnic/v1/memory/find\")) {\n    enforceTokenOp(\"memory_find\");\n    await respondBrowse(req, res, respondJson, readJsonBody, service, scopeFor, \"find\");\n    return true;\n  }\n  return false;\n}\n"],"mappings":";;;;;AA4BA,SAAS,OAAO,OAAoC;AAClD,SAAO,OAAO,UAAU,WAAW,QAAQ;AAC7C;AAEA,SAAS,OAAO,OAAoC;AAClD,MAAI,UAAU,UAAa,UAAU,QAAQ,UAAU,GAAI,QAAO;AAClE,QAAM,SAAS,OAAO,UAAU,WAAW,OAAO,KAAK,IAAI;AAC3D,MAAI,OAAO,WAAW,YAAY,CAAC,OAAO,UAAU,MAAM,GAAG;AAC3D,UAAM,IAAI,uBAAuB,0BAA0B;AAAA,EAC7D;AACA,SAAO;AACT;AAEA,eAAe,cACb,KACA,KACA,aACA,cACA,SACA,UACA,MACe;AACf,QAAM,OAAQ,MAAM,aAAa,GAAG;AACpC,QAAM,QAAQ,SAAS,OAAO,KAAK,SAAS,CAAC;AAC7C,QAAM,QAAQ,SAAS,SAAS,OAAO,KAAK,KAAK,IAAI;AACrD,QAAM,SAAS,MAAM,QAAQ,kBAAkB;AAAA,IAC7C;AAAA,IACA,GAAI,OAAO,KAAK,IAAI,MAAM,SAAY,EAAE,MAAM,OAAO,KAAK,IAAI,EAAE,IAAI,CAAC;AAAA,IACrE,GAAI,UAAU,SAAY,EAAE,MAAM,IAAI,CAAC;AAAA,IACvC,GAAI,SAAS,UAAU,OAAO,KAAK,OAAO,MAAM,SAAY,EAAE,SAAS,OAAO,KAAK,OAAO,EAAE,IAAI,CAAC;AAAA,IACjG,WAAW,MAAM;AAAA,IACjB,wBAAwB,MAAM;AAAA,EAChC,CAAC;AACD,QAAM,EAAE,UAAU,WAAW,GAAG,QAAQ,IAAI;AAC5C,cAAY,KAAK,KAAK,OAAO;AAC/B;AAEA,eAAsB,yBACpB,KACA,KACA,UACA,QACA,gBACA,aACA,cACA,SACA,UACkB;AAClB,MAAI,WAAW,WAAW,aAAa,0BAA0B,aAAa,yBAAyB;AACrG,mBAAe,WAAW;AAC1B,UAAM,cAAc,KAAK,KAAK,aAAa,cAAc,SAAS,UAAU,IAAI;AAChF,WAAO;AAAA,EACT;AACA,MAAI,WAAW,WAAW,aAAa,4BAA4B,aAAa,2BAA2B;AACzG,mBAAe,aAAa;AAC5B,UAAM,cAAc,KAAK,KAAK,aAAa,cAAc,SAAS,UAAU,MAAM;AAClF,WAAO;AAAA,EACT;AACA,MAAI,WAAW,WAAW,aAAa,4BAA4B,aAAa,2BAA2B;AACzG,mBAAe,aAAa;AAC5B,UAAM,cAAc,KAAK,KAAK,aAAa,cAAc,SAAS,UAAU,MAAM;AAClF,WAAO;AAAA,EACT;AACA,SAAO;AACT;","names":[]}

package/dist/{chunk-WUUGE7QC.js → chunk-HS75MCQF.js}

@@ -1,12 +1,12 @@
-import {
-  rankDeepRecallFrontier
-} from "./chunk-HRATODNO.js";
 import {
   validateRefineRewrite
 } from "./chunk-WTWQA7BB.js";
 import {
   selectExpandNodeIds
 } from "./chunk-VZIAVM72.js";
+import {
+  rankDeepRecallFrontier
+} from "./chunk-HRATODNO.js";
 import {
   extractJsonCandidates,
   stripCodeFences
@@ -384,4 +384,4 @@ async function runBudgetedDeepRecall(deps, query) {
 export {
   runBudgetedDeepRecall
 };
-//# sourceMappingURL=chunk-WUUGE7QC.js.map
+//# sourceMappingURL=chunk-HS75MCQF.js.map

package/dist/{chunk-DO6R3LIE.js → chunk-I6IJDTRP.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-DBB5JPSL.js";
 import {
   isGenericRecallExcludedPath
-} from "./chunk-EC5SVM6H.js";
+} from "./chunk-DE4ZGH2N.js";
 import {
   shouldFilterSupersededFromRecall
 } from "./chunk-5WITETWU.js";
@@ -69,4 +69,4 @@ export {
   filterRecentScanMemoriesForStateView,
   indexStateViewAnnotatedResults
 };
-//# sourceMappingURL=chunk-DO6R3LIE.js.map
+//# sourceMappingURL=chunk-I6IJDTRP.js.map

package/dist/{chunk-T3F2HWIG.js → chunk-IO7K7GES.js}

@@ -1,6 +1,6 @@
 import {
   createSearchBackend
-} from "./chunk-C3YEB7CR.js";
+} from "./chunk-PA67GXYJ.js";
 import {
   namespaceIdentityToken,
   normalizeNamespaceIdentity
@@ -508,4 +508,4 @@ export {
   NamespaceSearchRouter,
   normalizeQmdResultPath
 };
-//# sourceMappingURL=chunk-T3F2HWIG.js.map
+//# sourceMappingURL=chunk-IO7K7GES.js.map

package/dist/{chunk-6II55MXS.js → chunk-JXLEQIJ7.js}

@@ -23,7 +23,7 @@ import {
 } from "./chunk-7ZNJN5WZ.js";
 import {
   compareEntityTimestamps
-} from "./chunk-IAT5WFEU.js";
+} from "./chunk-MNG536IS.js";
 import {
   normalizeEntityName
 } from "./chunk-YXZG5TVN.js";
@@ -918,4 +918,4 @@ export {
   entityIndexVersion,
   entityRecentTranscriptLookbackHours
 };
-//# sourceMappingURL=chunk-6II55MXS.js.map
+//# sourceMappingURL=chunk-JXLEQIJ7.js.map

package/dist/{chunk-4XTSKGLX.js → chunk-JYXLW22X.js}

@@ -1,6 +1,6 @@
 import {
   applyExtractionSourceGrounding
-} from "./chunk-PGAB2V53.js";
+} from "./chunk-SMBWBEE7.js";
 import {
   CONNECTOR_LABEL_MAX_LENGTH,
   knownConnectorIds
@@ -10,7 +10,7 @@ import {
 } from "./chunk-SGUDMW2K.js";
 import {
   deriveSourceConnector
-} from "./chunk-EUP4AXIW.js";
+} from "./chunk-B6VDWDFN.js";
 import {
   resolvePipelineProcessingCapabilities
 } from "./chunk-JUOZ62Y7.js";
@@ -112,4 +112,4 @@ export {
   renderExtractionConversation,
   applyGroundingWithConnector
 };
-//# sourceMappingURL=chunk-4XTSKGLX.js.map
+//# sourceMappingURL=chunk-JYXLW22X.js.map

package/dist/chunk-LI4APB6M.js

@@ -0,0 +1,218 @@
+import {
+  coerceBooleanLike,
+  coerceNumber
+} from "./chunk-PQVCH2AE.js";
+
+// src/standing-memory-block.ts
+var DEFAULT_RECALL_STANDING_BLOCK = false;
+var DEFAULT_STANDING_BLOCK_FRESH_DAYS = 14;
+var DEFAULT_STANDING_BLOCK_MAX_CHARS = 2048;
+var DEFAULT_STANDING_BLOCK_HOOK_CHARS = 96;
+var STANDING_BLOCK_HEADER = "## Standing Memory (Remnic)";
+var STANDING_BLOCK_INSTRUCTION = "Use this standing index for orientation. It changes only when the memory store changes.";
+var STANDING_BLOCK_TRIMMED_MARKER = "- ...(older lines trimmed)";
+function standingHookLedgerKey(description, hookMaxChars) {
+  return `${description}\0${hookMaxChars}`;
+}
+var ISO_DATE_RE = /\b\d{4}-\d{2}-\d{2}(?:[T ]\d{2}:\d{2})?/;
+var CLOCK_TIME_RE = /\b\d{1,2}:\d{2}(?::\d{2})?\b/;
+var RELATIVE_DATE_RE = /\b(?:today|tonight|tomorrow|yesterday|this\s+(?:morning|afternoon|evening|week|month|year))\b/i;
+var COUNTER_RE = /\b(?:count|total|entries|memories|items)\s*[:=]\s*\d+\b/i;
+function lintStandingBlockVolatility(text) {
+  const matches = [];
+  for (const [kind, re] of [
+    ["iso-date", ISO_DATE_RE],
+    ["clock-time", CLOCK_TIME_RE],
+    ["relative-date", RELATIVE_DATE_RE],
+    ["counter", COUNTER_RE]
+  ]) {
+    const hit = text.match(re);
+    if (hit) matches.push({ kind, token: hit[0] });
+  }
+  return matches;
+}
+var StandingBlockError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "StandingBlockError";
+  }
+};
+var StandingBlockVolatilityError = class extends StandingBlockError {
+  matches;
+  constructor(matches) {
+    super(
+      `standing memory block refused: volatile content busts the prefix cache (${matches.map((m) => `${m.kind}:${JSON.stringify(m.token)}`).join(", ")})`
+    );
+    this.name = "StandingBlockVolatilityError";
+    this.matches = matches;
+  }
+};
+var StandingBlockBudgetError = class extends StandingBlockError {
+  constructor(maxChars) {
+    super(
+      `standing memory block does not fit: pinned lines alone exceed maxChars=${maxChars}; raise standingBlockMaxChars or unpin entries`
+    );
+    this.name = "StandingBlockBudgetError";
+  }
+};
+function parseRecallStandingBlock(raw) {
+  return coerceBooleanLike(raw, "recallStandingBlock") === true;
+}
+function parseStandingBlockFreshDays(raw) {
+  if (raw === void 0 || raw === null) return DEFAULT_STANDING_BLOCK_FRESH_DAYS;
+  const n = coerceNumber(raw, "standingBlockFreshDays");
+  if (n === void 0 || !Number.isFinite(n) || n < 0) {
+    throw new Error(`Invalid standingBlockFreshDays: expected a number >= 0, got ${JSON.stringify(raw)}`);
+  }
+  return n;
+}
+function parseStandingBlockMaxChars(raw) {
+  if (raw === void 0 || raw === null) return DEFAULT_STANDING_BLOCK_MAX_CHARS;
+  const n = coerceNumber(raw, "standingBlockMaxChars");
+  if (n === void 0 || !Number.isFinite(n) || n < 1) {
+    throw new Error(`Invalid standingBlockMaxChars: expected an integer >= 1, got ${JSON.stringify(raw)}`);
+  }
+  return Math.floor(n);
+}
+function mechanicalHook(description, budget) {
+  if (description.length <= budget) return description;
+  const cut = description.slice(0, budget);
+  const lastSpace = cut.lastIndexOf(" ");
+  const base = lastSpace > Math.floor(budget * 0.6) ? cut.slice(0, lastSpace) : cut;
+  return `${base.replace(/[\s,;:]+$/, "")}...`;
+}
+var BAND_RANK = { pinned: 0, fresh: 1, compressed: 2 };
+function validateEntries(entries) {
+  if (!Array.isArray(entries)) {
+    throw new StandingBlockError("standing memory block entries must be an array");
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const validated = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (typeof entry !== "object" || entry === null) {
+      throw new StandingBlockError(`standing memory block entry must be an object, got ${JSON.stringify(entry)}`);
+    }
+    const id = typeof entry.id === "string" ? entry.id.trim() : "";
+    const description = typeof entry.description === "string" ? entry.description.trim() : "";
+    if (id.length === 0) {
+      throw new StandingBlockError("standing memory block entry requires a non-empty id");
+    }
+    if (description.length === 0) {
+      throw new StandingBlockError(`standing memory block entry ${id} requires a non-empty description`);
+    }
+    if (seen.has(id)) {
+      throw new StandingBlockError(`standing memory block entry ids must be unique; duplicate: ${id}`);
+    }
+    if (entry.lastChangedAt !== void 0 && Number.isNaN(Date.parse(entry.lastChangedAt))) {
+      throw new StandingBlockError(
+        `standing memory block entry ${id} has an unparseable lastChangedAt: ${JSON.stringify(entry.lastChangedAt)}`
+      );
+    }
+    seen.add(id);
+    validated.set(id, { ...entry, id, description });
+  }
+  return validated;
+}
+function buildStandingMemoryBlock(input) {
+  const freshDays = input.freshDays ?? DEFAULT_STANDING_BLOCK_FRESH_DAYS;
+  const maxChars = input.maxChars ?? DEFAULT_STANDING_BLOCK_MAX_CHARS;
+  const hookMaxChars = input.hookMaxChars ?? DEFAULT_STANDING_BLOCK_HOOK_CHARS;
+  if (!Number.isFinite(input.nowMs)) {
+    throw new StandingBlockError("standing memory block requires a finite nowMs");
+  }
+  if (!(freshDays >= 0) || !Number.isFinite(freshDays)) {
+    throw new StandingBlockError("standing memory block requires freshDays >= 0");
+  }
+  if (!(maxChars >= 1) || !Number.isFinite(maxChars)) {
+    throw new StandingBlockError("standing memory block requires maxChars >= 1");
+  }
+  if (!(hookMaxChars >= 1) || !Number.isFinite(hookMaxChars)) {
+    throw new StandingBlockError("standing memory block requires hookMaxChars >= 1");
+  }
+  const entries = validateEntries(input.entries);
+  const ledger = new Map(input.ledger ?? []);
+  if (entries.size === 0) {
+    return {
+      text: "",
+      lines: [],
+      ledger,
+      bandCounts: { pinned: 0, fresh: 0, compressed: 0, dropped: 0 }
+    };
+  }
+  const freshCutoff = input.nowMs - freshDays * 864e5;
+  const layered = [];
+  for (const entry of entries.values()) {
+    let band;
+    if (entry.pinned === true) {
+      band = "pinned";
+    } else if (typeof entry.lastChangedAt === "string" && Date.parse(entry.lastChangedAt) >= freshCutoff && Date.parse(entry.lastChangedAt) <= input.nowMs) {
+      band = "fresh";
+    } else {
+      band = "compressed";
+    }
+    if (band !== "compressed") {
+      layered.push({ id: entry.id, band, line: `- ${entry.description}` });
+      continue;
+    }
+    const key = standingHookLedgerKey(entry.description, hookMaxChars);
+    const cached = ledger.get(key);
+    const hook = cached ?? mechanicalHook(entry.description, hookMaxChars);
+    if (cached === void 0) ledger.set(key, hook);
+    layered.push({ id: entry.id, band, line: `- ${hook}` });
+  }
+  layered.sort(
+    (a, b) => BAND_RANK[a.band] - BAND_RANK[b.band] || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0)
+  );
+  const render = (keep2, withMarker) => {
+    const body = layered.slice(0, keep2).map((item) => item.line);
+    if (withMarker) body.push(STANDING_BLOCK_TRIMMED_MARKER);
+    const lines = [STANDING_BLOCK_HEADER, "", ...body, "", STANDING_BLOCK_INSTRUCTION];
+    return { text: lines.join("\n"), lines };
+  };
+  const pinnedCount = layered.filter((item) => item.band === "pinned").length;
+  let keep = layered.length;
+  let rendered = render(keep, false);
+  while (rendered.text.length > maxChars && keep > pinnedCount) {
+    keep -= 1;
+    rendered = render(keep, true);
+  }
+  if (rendered.text.length > maxChars) {
+    throw new StandingBlockBudgetError(maxChars);
+  }
+  const volatility = lintStandingBlockVolatility(rendered.text);
+  if (volatility.length > 0) {
+    throw new StandingBlockVolatilityError(volatility);
+  }
+  const kept = layered.slice(0, keep);
+  return {
+    text: rendered.text,
+    lines: rendered.lines,
+    ledger,
+    bandCounts: {
+      pinned: kept.filter((item) => item.band === "pinned").length,
+      fresh: kept.filter((item) => item.band === "fresh").length,
+      compressed: kept.filter((item) => item.band === "compressed").length,
+      dropped: layered.length - keep
+    }
+  };
+}
+
+export {
+  DEFAULT_RECALL_STANDING_BLOCK,
+  DEFAULT_STANDING_BLOCK_FRESH_DAYS,
+  DEFAULT_STANDING_BLOCK_MAX_CHARS,
+  DEFAULT_STANDING_BLOCK_HOOK_CHARS,
+  STANDING_BLOCK_HEADER,
+  STANDING_BLOCK_INSTRUCTION,
+  STANDING_BLOCK_TRIMMED_MARKER,
+  standingHookLedgerKey,
+  lintStandingBlockVolatility,
+  StandingBlockError,
+  StandingBlockVolatilityError,
+  StandingBlockBudgetError,
+  parseRecallStandingBlock,
+  parseStandingBlockFreshDays,
+  parseStandingBlockMaxChars,
+  buildStandingMemoryBlock
+};
+//# sourceMappingURL=chunk-LI4APB6M.js.map

package/dist/chunk-LI4APB6M.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/standing-memory-block.ts"],"sourcesContent":["/**\n * Prefix-cache-stable standing memory block (issue #2971, foundation slice).\n *\n * A standing block is a compact, byte-stable index over pinned/high-value\n * memories that a host injects as the FIRST part of the system prompt, so\n * the LLM prefix cache survives across turns. Measured motivation\n * (distill-kura, local OpenAI-compatible server): an identical 4k-token\n * prefix reprices at 0.14 s vs 0.68 s cold, and one changed word at the\n * front costs the whole cache. So the block contains no clock, no date,\n * and no counter — and the builder REFUSES, at build time, any block that\n * carries one instead of discovering slow turns weeks later.\n *\n * Determinism rules (byte-identical between rebuilds):\n *  - line order is band rank, then id codepoint order — never wall clock,\n *    never insertion order, never locale collation;\n *  - `nowMs` classifies bands but never renders into the text;\n *  - the trimmed-tail marker is a constant string (no count of dropped\n *    lines, which would itself be a counter).\n *\n * Host contract for the full feature (later wiring slices):\n *  - rebuild only when the underlying store changes (store version), not\n *    per turn and not on a timer — band edges must not drift mid-session;\n *  - inject the standing block BEFORE per-turn dynamic recall and any\n *    ticking content (persona with a clock), see docs/config-reference.md;\n *  - selection of which memories qualify (pinned/high-value) happens\n *    before this builder — it only layers and renders what it is given;\n *  - on build failure (volatility, budget) skip injection and log — the\n *    dynamic recall surface must not go blank.\n *\n * Pure: no I/O, inputs never mutated, the returned ledger is a fresh Map.\n */\nimport { coerceBooleanLike, coerceNumber } from \"./connectors/coerce.js\";\n\nexport const DEFAULT_RECALL_STANDING_BLOCK = false;\nexport const DEFAULT_STANDING_BLOCK_FRESH_DAYS = 14;\nexport const DEFAULT_STANDING_BLOCK_MAX_CHARS = 2048;\n/** ~24-token recognition hook at the repo's 4-chars-per-token Latin headroom. */\nexport const DEFAULT_STANDING_BLOCK_HOOK_CHARS = 96;\n\nexport const STANDING_BLOCK_HEADER = \"## Standing Memory (Remnic)\";\nexport const STANDING_BLOCK_INSTRUCTION =\n  \"Use this standing index for orientation. It changes only when the memory store changes.\";\nexport const STANDING_BLOCK_TRIMMED_MARKER = \"- ...(older lines trimmed)\";\n\nexport type StandingBand = \"pinned\" | \"fresh\" | \"compressed\";\n\nexport interface StandingMemoryEntry {\n  /** Stable document id. Total order within a band is id codepoint order. */\n  id: string;\n  /** The one-line description to stand in the index. */\n  description: string;\n  /** Pinned entries render in full, first band, never trimmed away. */\n  pinned?: boolean;\n  /** ISO timestamp of the last content change; drives the fresh band. */\n  lastChangedAt?: string;\n}\n\n/** Cache of compressed hooks keyed on `${description}\\u0000${hookMaxChars}`. */\nexport type StandingHookLedger = ReadonlyMap<string, string>;\n\nexport function standingHookLedgerKey(description: string, hookMaxChars: number): string {\n  return `${description}\\u0000${hookMaxChars}`;\n}\n\nexport interface StandingBlockBandCounts {\n  pinned: number;\n  fresh: number;\n  compressed: number;\n  dropped: number;\n}\n\nexport interface StandingMemoryBlock {\n  /** Full block text (header + lines + instruction). Empty string for no entries. */\n  text: string;\n  /** Lines without a trailing newline; empty for no entries. */\n  lines: string[];\n  /** Ledger including hooks generated this build. Fresh Map; input never mutated. */\n  ledger: StandingHookLedger;\n  bandCounts: StandingBlockBandCounts;\n}\n\nexport type StandingVolatilityKind = \"iso-date\" | \"clock-time\" | \"relative-date\" | \"counter\";\n\nexport interface StandingVolatilityMatch {\n  kind: StandingVolatilityKind;\n  token: string;\n}\n\nconst ISO_DATE_RE = /\\b\\d{4}-\\d{2}-\\d{2}(?:[T ]\\d{2}:\\d{2})?/;\nconst CLOCK_TIME_RE = /\\b\\d{1,2}:\\d{2}(?::\\d{2})?\\b/;\nconst RELATIVE_DATE_RE =\n  /\\b(?:today|tonight|tomorrow|yesterday|this\\s+(?:morning|afternoon|evening|week|month|year))\\b/i;\nconst COUNTER_RE = /\\b(?:count|total|entries|memories|items)\\s*[:=]\\s*\\d+\\b/i;\n\n/**\n * Build-time volatility lint. Returns every cache-busting token class found:\n * ISO dates/datetimes, clock times, relative date words, and index counters.\n * Refusal is the designed behavior (a memory surface skips the block and\n * logs) — a silently repricing prefix is the failure this catches.\n */\nexport function lintStandingBlockVolatility(text: string): StandingVolatilityMatch[] {\n  const matches: StandingVolatilityMatch[] = [];\n  for (const [kind, re] of [\n    [\"iso-date\", ISO_DATE_RE],\n    [\"clock-time\", CLOCK_TIME_RE],\n    [\"relative-date\", RELATIVE_DATE_RE],\n    [\"counter\", COUNTER_RE],\n  ] as const) {\n    const hit = text.match(re);\n    if (hit) matches.push({ kind, token: hit[0] });\n  }\n  return matches;\n}\n\nexport class StandingBlockError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"StandingBlockError\";\n  }\n}\n\nexport class StandingBlockVolatilityError extends StandingBlockError {\n  readonly matches: readonly StandingVolatilityMatch[];\n  constructor(matches: readonly StandingVolatilityMatch[]) {\n    super(\n      `standing memory block refused: volatile content busts the prefix cache (${matches\n        .map((m) => `${m.kind}:${JSON.stringify(m.token)}`)\n        .join(\", \")})`,\n    );\n    this.name = \"StandingBlockVolatilityError\";\n    this.matches = matches;\n  }\n}\n\nexport class StandingBlockBudgetError extends StandingBlockError {\n  constructor(maxChars: number) {\n    super(\n      `standing memory block does not fit: pinned lines alone exceed maxChars=${maxChars}; raise standingBlockMaxChars or unpin entries`,\n    );\n    this.name = \"StandingBlockBudgetError\";\n  }\n}\n\nexport function parseRecallStandingBlock(raw: unknown): boolean {\n  return coerceBooleanLike(raw, \"recallStandingBlock\") === true;\n}\n\nexport function parseStandingBlockFreshDays(raw: unknown): number {\n  if (raw === undefined || raw === null) return DEFAULT_STANDING_BLOCK_FRESH_DAYS;\n  const n = coerceNumber(raw, \"standingBlockFreshDays\");\n  if (n === undefined || !Number.isFinite(n) || n < 0) {\n    throw new Error(`Invalid standingBlockFreshDays: expected a number >= 0, got ${JSON.stringify(raw)}`);\n  }\n  return n;\n}\n\nexport function parseStandingBlockMaxChars(raw: unknown): number {\n  if (raw === undefined || raw === null) return DEFAULT_STANDING_BLOCK_MAX_CHARS;\n  const n = coerceNumber(raw, \"standingBlockMaxChars\");\n  if (n === undefined || !Number.isFinite(n) || n < 1) {\n    throw new Error(`Invalid standingBlockMaxChars: expected an integer >= 1, got ${JSON.stringify(raw)}`);\n  }\n  return Math.floor(n);\n}\n\n/**\n * Mechanical hook: deterministic first-cut of the description to the char\n * budget at a word boundary. This is also the fallback when no model is\n * reachable for compression — the standing surface never goes blank because\n * a model is down. Model-generated hooks arrive pre-seeded in the ledger.\n */\nfunction mechanicalHook(description: string, budget: number): string {\n  if (description.length <= budget) return description;\n  const cut = description.slice(0, budget);\n  const lastSpace = cut.lastIndexOf(\" \");\n  const base = lastSpace > Math.floor(budget * 0.6) ? cut.slice(0, lastSpace) : cut;\n  return `${base.replace(/[\\s,;:]+$/, \"\")}...`;\n}\n\ninterface LayeredEntry {\n  id: string;\n  band: StandingBand;\n  line: string;\n}\n\nconst BAND_RANK: Record<StandingBand, number> = { pinned: 0, fresh: 1, compressed: 2 };\n\nfunction validateEntries(entries: readonly StandingMemoryEntry[]): Map<string, StandingMemoryEntry> {\n  if (!Array.isArray(entries)) {\n    throw new StandingBlockError(\"standing memory block entries must be an array\");\n  }\n  const seen = new Set<string>();\n  const validated = new Map<string, StandingMemoryEntry>();\n  for (const entry of entries) {\n    if (typeof entry !== \"object\" || entry === null) {\n      throw new StandingBlockError(`standing memory block entry must be an object, got ${JSON.stringify(entry)}`);\n    }\n    const id = typeof entry.id === \"string\" ? entry.id.trim() : \"\";\n    const description = typeof entry.description === \"string\" ? entry.description.trim() : \"\";\n    if (id.length === 0) {\n      throw new StandingBlockError(\"standing memory block entry requires a non-empty id\");\n    }\n    if (description.length === 0) {\n      throw new StandingBlockError(`standing memory block entry ${id} requires a non-empty description`);\n    }\n    if (seen.has(id)) {\n      throw new StandingBlockError(`standing memory block entry ids must be unique; duplicate: ${id}`);\n    }\n    if (entry.lastChangedAt !== undefined && Number.isNaN(Date.parse(entry.lastChangedAt))) {\n      throw new StandingBlockError(\n        `standing memory block entry ${id} has an unparseable lastChangedAt: ${JSON.stringify(entry.lastChangedAt)}`,\n      );\n    }\n    seen.add(id);\n    validated.set(id, { ...entry, id, description });\n  }\n  return validated;\n}\n\nexport interface StandingMemoryBlockInput {\n  entries: readonly StandingMemoryEntry[];\n  /**\n   * Evaluation instant for the fresh band. Hosts must key rebuilds on the\n   * store version, not on this clock, or band edges drift per turn.\n   */\n  nowMs: number;\n  freshDays?: number;\n  maxChars?: number;\n  hookMaxChars?: number;\n  ledger?: StandingHookLedger;\n}\n\nexport function buildStandingMemoryBlock(input: StandingMemoryBlockInput): StandingMemoryBlock {\n  const freshDays = input.freshDays ?? DEFAULT_STANDING_BLOCK_FRESH_DAYS;\n  const maxChars = input.maxChars ?? DEFAULT_STANDING_BLOCK_MAX_CHARS;\n  const hookMaxChars = input.hookMaxChars ?? DEFAULT_STANDING_BLOCK_HOOK_CHARS;\n  if (!Number.isFinite(input.nowMs)) {\n    throw new StandingBlockError(\"standing memory block requires a finite nowMs\");\n  }\n  if (!(freshDays >= 0) || !Number.isFinite(freshDays)) {\n    throw new StandingBlockError(\"standing memory block requires freshDays >= 0\");\n  }\n  if (!(maxChars >= 1) || !Number.isFinite(maxChars)) {\n    throw new StandingBlockError(\"standing memory block requires maxChars >= 1\");\n  }\n  if (!(hookMaxChars >= 1) || !Number.isFinite(hookMaxChars)) {\n    throw new StandingBlockError(\"standing memory block requires hookMaxChars >= 1\");\n  }\n\n  const entries = validateEntries(input.entries);\n  const ledger = new Map(input.ledger ?? []);\n  if (entries.size === 0) {\n    return {\n      text: \"\",\n      lines: [],\n      ledger,\n      bandCounts: { pinned: 0, fresh: 0, compressed: 0, dropped: 0 },\n    };\n  }\n\n  const freshCutoff = input.nowMs - freshDays * 86_400_000;\n  const layered: LayeredEntry[] = [];\n  for (const entry of entries.values()) {\n    let band: StandingBand;\n    if (entry.pinned === true) {\n      band = \"pinned\";\n    } else if (\n      typeof entry.lastChangedAt === \"string\" &&\n      Date.parse(entry.lastChangedAt) >= freshCutoff &&\n      Date.parse(entry.lastChangedAt) <= input.nowMs\n    ) {\n      band = \"fresh\";\n    } else {\n      band = \"compressed\";\n    }\n    if (band !== \"compressed\") {\n      layered.push({ id: entry.id, band, line: `- ${entry.description}` });\n      continue;\n    }\n    const key = standingHookLedgerKey(entry.description, hookMaxChars);\n    const cached = ledger.get(key);\n    const hook = cached ?? mechanicalHook(entry.description, hookMaxChars);\n    if (cached === undefined) ledger.set(key, hook);\n    layered.push({ id: entry.id, band, line: `- ${hook}` });\n  }\n\n  // Band rank, then id codepoint order. Never localeCompare: collation is\n  // ICU-dependent and this text must be byte-identical across rebuilds.\n  layered.sort(\n    (a, b) =>\n      BAND_RANK[a.band] - BAND_RANK[b.band] || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0),\n  );\n\n  const render = (keep: number, withMarker: boolean): { text: string; lines: string[] } => {\n    const body = layered.slice(0, keep).map((item) => item.line);\n    if (withMarker) body.push(STANDING_BLOCK_TRIMMED_MARKER);\n    const lines = [STANDING_BLOCK_HEADER, \"\", ...body, \"\", STANDING_BLOCK_INSTRUCTION];\n    return { text: lines.join(\"\\n\"), lines };\n  };\n\n  const pinnedCount = layered.filter((item) => item.band === \"pinned\").length;\n  let keep = layered.length;\n  let rendered = render(keep, false);\n  // Mechanical trim: drop from the tail. The sort puts compressed lines\n  // last, so oldest-band hooks go first and pinned lines are never reached.\n  while (rendered.text.length > maxChars && keep > pinnedCount) {\n    keep -= 1;\n    rendered = render(keep, true);\n  }\n  if (rendered.text.length > maxChars) {\n    throw new StandingBlockBudgetError(maxChars);\n  }\n\n  const volatility = lintStandingBlockVolatility(rendered.text);\n  if (volatility.length > 0) {\n    throw new StandingBlockVolatilityError(volatility);\n  }\n\n  const kept = layered.slice(0, keep);\n  return {\n    text: rendered.text,\n    lines: rendered.lines,\n    ledger,\n    bandCounts: {\n      pinned: kept.filter((item) => item.band === \"pinned\").length,\n      fresh: kept.filter((item) => item.band === \"fresh\").length,\n      compressed: kept.filter((item) => item.band === \"compressed\").length,\n      dropped: layered.length - keep,\n    },\n  };\n}\n"],"mappings":"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","names":["keep"]}