@remnic/core 9.57.4 → 9.57.5

package/dist/{chunk-IGWVMA4Y.js → chunk-MRV7VSQK.js}

@@ -1,6 +1,9 @@
 import {
   isLikelyUnsafeRegex
-} from "./chunk-U3PN77QT.js";
+} from "./chunk-PCXDUHQH.js";
+import {
+  normalizeNamespaceIdentity
+} from "./chunk-VUFL7X3H.js";
 import {
   resolveNamespaceCapabilities
 } from "./chunk-JUOZ62Y7.js";
@@ -49,28 +52,35 @@ function resolvePrincipal(sessionKey, config) {
 function canReadNamespace(principal, namespace, config) {
   if (!resolveNamespaceCapabilities(config).namespaces) return true;
   if (!principal) return false;
-  const policy = config.namespacePolicies.find((p) => p.name === namespace);
-  if (!policy) return namespace === config.defaultNamespace || namespace === config.sharedNamespace;
+  const identity = normalizeNamespaceIdentity(namespace);
+  const policy = config.namespacePolicies.find((p) => normalizeNamespaceIdentity(p.name) === identity);
+  if (!policy) {
+    return identity === normalizeNamespaceIdentity(config.defaultNamespace) || identity === normalizeNamespaceIdentity(config.sharedNamespace);
+  }
   return policy.readPrincipals.includes(principal) || policy.readPrincipals.includes("*");
 }
 function canWriteNamespace(principal, namespace, config) {
   if (!resolveNamespaceCapabilities(config).namespaces) return true;
   if (!principal) return false;
-  const policy = config.namespacePolicies.find((p) => p.name === namespace);
-  if (!policy) return namespace === config.defaultNamespace;
+  const identity = normalizeNamespaceIdentity(namespace);
+  const policy = config.namespacePolicies.find((p) => normalizeNamespaceIdentity(p.name) === identity);
+  if (!policy) return identity === normalizeNamespaceIdentity(config.defaultNamespace);
   return policy.writePrincipals.includes(principal) || policy.writePrincipals.includes("*");
 }
 function isNamespacePolicyCovered(namespace, config) {
   if (!resolveNamespaceCapabilities(config).namespaces) return true;
-  const policy = config.namespacePolicies.find((p) => p.name === namespace);
-  if (!policy) return namespace === config.defaultNamespace;
+  const identity = normalizeNamespaceIdentity(namespace);
+  const policy = config.namespacePolicies.find((p) => normalizeNamespaceIdentity(p.name) === identity);
+  if (!policy) return identity === normalizeNamespaceIdentity(config.defaultNamespace);
   return policy.writePrincipals.some((w) => w.trim().length > 0);
 }
 function defaultNamespaceForPrincipal(principal, config) {
   if (!resolveNamespaceCapabilities(config).namespaces) return config.defaultNamespace;
   if (!principal) return config.defaultNamespace;
-  const exists = config.namespacePolicies.some((p) => p.name === principal);
-  return exists ? principal : config.defaultNamespace;
+  const policy = config.namespacePolicies.find(
+    (p) => normalizeNamespaceIdentity(p.name) === normalizeNamespaceIdentity(principal)
+  );
+  return policy ? normalizeNamespaceIdentity(policy.name) : config.defaultNamespace;
 }
 function recallNamespacesForPrincipal(principal, config) {
   const out = [];
@@ -111,4 +121,4 @@ export {
   recallNamespacesForPrincipal,
   citationAuthorizedNamespaces
 };
-//# sourceMappingURL=chunk-IGWVMA4Y.js.map
+//# sourceMappingURL=chunk-MRV7VSQK.js.map

package/dist/chunk-MRV7VSQK.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/namespaces/principal.ts"],"sourcesContent":["import { resolveNamespaceCapabilities } from \"../capabilities.js\";\nimport type { PluginConfig } from \"../types.js\";\nimport { isLikelyUnsafeRegex } from \"../routing/engine.js\";\nimport { normalizeNamespaceIdentity } from \"./identity.js\";\nconst MAX_REGEX_SESSION_KEY_LENGTH = 512;\n\nfunction compileSafePrincipalRegex(pattern: string): RegExp | null {\n  if (isLikelyUnsafeRegex(pattern)) return null;\n  try {\n    return new RegExp(pattern);\n  } catch {\n    return null;\n  }\n}\n\nexport function resolvePrincipal(sessionKey: string | undefined, config: PluginConfig): string | undefined {\n  if (!resolveNamespaceCapabilities(config).namespaces) return \"default\";\n  const sk = typeof sessionKey === \"string\" && sessionKey.trim().length > 0\n    ? sessionKey\n    : \"\";\n  const mode = config.principalFromSessionKeyMode;\n  const rules = config.principalFromSessionKeyRules ?? [];\n\n  if (!sk) return undefined;\n\n  if (mode === \"prefix\") {\n    for (const r of rules) {\n      if (sk.startsWith(r.match)) return r.principal;\n    }\n  } else if (mode === \"map\") {\n    for (const r of rules) {\n      if (sk === r.match) return r.principal;\n    }\n  } else if (mode === \"regex\") {\n    if (sk.length <= MAX_REGEX_SESSION_KEY_LENGTH) {\n      for (const r of rules) {\n        const re = compileSafePrincipalRegex(r.match);\n        if (re?.test(sk)) {\n          return r.principal;\n        }\n      }\n    }\n  }\n\n  // Fallback heuristic: \"agent:<agentId>:<channelType>:...\"\n  const parts = sk.split(\":\");\n  if (parts.length >= 2 && parts[0] === \"agent\") {\n    const agentId = parts[1];\n    if (agentId && agentId.length > 0) return agentId;\n  }\n  return \"default\";\n}\n\nexport function canReadNamespace(principal: string | undefined, namespace: string, config: PluginConfig): boolean {\n  if (!resolveNamespaceCapabilities(config).namespaces) return true;\n  if (!principal) return false;\n  const identity = normalizeNamespaceIdentity(namespace);\n  const policy = config.namespacePolicies.find((p) => normalizeNamespaceIdentity(p.name) === identity);\n  if (!policy) {\n    return identity === normalizeNamespaceIdentity(config.defaultNamespace) ||\n      identity === normalizeNamespaceIdentity(config.sharedNamespace);\n  }\n  return policy.readPrincipals.includes(principal) || policy.readPrincipals.includes(\"*\");\n}\n\nexport function canWriteNamespace(principal: string | undefined, namespace: string, config: PluginConfig): boolean {\n  if (!resolveNamespaceCapabilities(config).namespaces) return true;\n  if (!principal) return false;\n  const identity = normalizeNamespaceIdentity(namespace);\n  const policy = config.namespacePolicies.find((p) => normalizeNamespaceIdentity(p.name) === identity);\n  if (!policy) return identity === normalizeNamespaceIdentity(config.defaultNamespace);\n  return policy.writePrincipals.includes(principal) || policy.writePrincipals.includes(\"*\");\n}\n\n/**\n * Config-time namespace-policy lint (issue #1888 improvement 3). Principal-\n * agnostic mirror of {@link canWriteNamespace}: true when the namespace is\n * writable by AT LEAST ONE principal. When namespace enforcement is off every\n * write is allowed. Otherwise an explicit `namespacePolicies` entry takes\n * precedence (exactly as `canWriteNamespace`): with a matching policy the\n * namespace is covered only if that policy grants at least one non-blank\n * writer — even when the name equals `defaultNamespace`; without a policy it\n * is covered only if it IS the `defaultNamespace`. The `sharedNamespace` is\n * NOT implicitly writable (matching\n * `canWriteNamespace`), and a policy entry with no `writePrincipals` grants\n * nobody. A configured namespace that is NOT covered is writable for no one,\n * so every write to it is rejected by the ACL and dead-lettered — `remnic\n * doctor` warns on that before a session silently loses memory.\n */\nexport function isNamespacePolicyCovered(namespace: string, config: PluginConfig): boolean {\n  if (!resolveNamespaceCapabilities(config).namespaces) return true;\n  // An explicit policy wins over the default fallback (exactly as\n  // canWriteNamespace), so a policy naming the default with no writers is NOT\n  // covered. Only fall back to defaultNamespace when no policy matches.\n  const identity = normalizeNamespaceIdentity(namespace);\n  const policy = config.namespacePolicies.find((p) => normalizeNamespaceIdentity(p.name) === identity);\n  if (!policy) return identity === normalizeNamespaceIdentity(config.defaultNamespace);\n  return policy.writePrincipals.some((w) => w.trim().length > 0);\n}\n\n/**\n * Default \"self\" namespace for a principal.\n *\n * Heuristic:\n * - If there's a namespace policy with the same name as the principal, use it.\n * - Otherwise use config.defaultNamespace.\n */\nexport function defaultNamespaceForPrincipal(principal: string | undefined, config: PluginConfig): string {\n  if (!resolveNamespaceCapabilities(config).namespaces) return config.defaultNamespace;\n  if (!principal) return config.defaultNamespace;\n  const policy = config.namespacePolicies.find(\n    (p) => normalizeNamespaceIdentity(p.name) === normalizeNamespaceIdentity(principal),\n  );\n  return policy ? normalizeNamespaceIdentity(policy.name) : config.defaultNamespace;\n}\n\nexport function recallNamespacesForPrincipal(principal: string | undefined, config: PluginConfig): string[] {\n  const out: string[] = [];\n  if (!resolveNamespaceCapabilities(config).namespaces) return [config.defaultNamespace];\n  if (!principal) return out;\n\n  const selfNs = defaultNamespaceForPrincipal(principal, config);\n  if (config.defaultRecallNamespaces.includes(\"self\") && canReadNamespace(principal, selfNs, config)) {\n    out.push(selfNs);\n  }\n  if (config.defaultRecallNamespaces.includes(\"shared\") && canReadNamespace(principal, config.sharedNamespace, config)) {\n    out.push(config.sharedNamespace);\n  }\n\n  for (const p of config.namespacePolicies) {\n    if (p.includeInRecallByDefault && canReadNamespace(principal, p.name, config)) {\n      if (!out.includes(p.name)) out.push(p.name);\n    }\n  }\n\n  return out;\n}\n\n/**\n * Namespaces a principal may attribute a citation to: the default-recall\n * namespaces, every readable policy namespace, and the readable built-in\n * default/shared namespaces — which `defaultRecallNamespaces` can omit even\n * though `canReadNamespace` grants access (#2020).\n */\nexport function citationAuthorizedNamespaces(\n  principal: string | undefined,\n  config: PluginConfig,\n): string[] {\n  return Array.from(\n    new Set([\n      ...recallNamespacesForPrincipal(principal, config),\n      ...config.namespacePolicies\n        .filter((p) => canReadNamespace(principal, p.name, config))\n        .map((p) => p.name),\n      ...[config.defaultNamespace, config.sharedNamespace].filter((ns) =>\n        canReadNamespace(principal, ns, config),\n      ),\n    ]),\n  );\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-6P2NUVM5.js → chunk-NEJQ65NV.js}

@@ -15,7 +15,7 @@ import {
 } from "./chunk-7ZNJN5WZ.js";
 import {
   compareEntityTimestamps
-} from "./chunk-BWJMBJCY.js";
+} from "./chunk-YTZA7U6Q.js";
 import {
   normalizeEntityName
 } from "./chunk-YXZG5TVN.js";
@@ -889,4 +889,4 @@ export {
   entityIndexVersion,
   entityRecentTranscriptLookbackHours
 };
-//# sourceMappingURL=chunk-6P2NUVM5.js.map
+//# sourceMappingURL=chunk-NEJQ65NV.js.map

package/dist/{chunk-7PKNOXYB.js → chunk-NTJ6TY44.js}

@@ -6,7 +6,7 @@ import {
   headerConnector,
   renderExtractionConversation,
   resolveSourceConnector
-} from "./chunk-SFCJCMZQ.js";
+} from "./chunk-A7266TRJ.js";
 import {
   ConsolidationResultSchema,
   DaySummaryResultSchema,
@@ -2442,4 +2442,4 @@ export {
   shouldEnableLocalExtractionThinking,
   ExtractionEngine
 };
-//# sourceMappingURL=chunk-7PKNOXYB.js.map
+//# sourceMappingURL=chunk-NTJ6TY44.js.map

package/dist/{chunk-HYVBJLEK.js → chunk-O5AFC5KM.js}

@@ -7,7 +7,7 @@ import {
 } from "./chunk-UYCIS6V5.js";
 import {
   StorageManager
-} from "./chunk-BWJMBJCY.js";
+} from "./chunk-YTZA7U6Q.js";
 import {
   parseContinuityImprovementLoops
 } from "./chunk-LDXUBPMO.js";
@@ -1283,4 +1283,4 @@ export {
   defaultTierMigrationCycleBudget,
   CompoundingEngine
 };
-//# sourceMappingURL=chunk-HYVBJLEK.js.map
+//# sourceMappingURL=chunk-O5AFC5KM.js.map

package/dist/{chunk-U3PN77QT.js → chunk-PCXDUHQH.js}

@@ -1,3 +1,7 @@
+import {
+  namespaceIdentityToken
+} from "./chunk-VUFL7X3H.js";
+
 // src/routing/engine.ts
 var DEFAULT_CATEGORIES = [
   "fact",
@@ -15,8 +19,9 @@ var DEFAULT_CATEGORIES = [
   "reasoning_trace"
 ];
 function normalizeNamespace(namespace) {
-  return namespace.trim();
+  return namespace.normalize("NFC");
 }
+var SAFE_ROUTE_NAMESPACE_CHARS = /^[\p{L}\p{M}\p{N}._-]+$/u;
 function isLikelyUnsafeRegex(pattern) {
   const value = pattern.trim();
   if (value.length === 0) return true;
@@ -32,17 +37,19 @@ function isLikelyUnsafeRegex(pattern) {
 function isSafeRouteNamespace(namespace) {
   const value = normalizeNamespace(namespace);
   if (value.length === 0) return false;
+  if (Array.from(value).length > 64) return false;
+  if (namespaceIdentityToken(value).length > 255) return false;
   if (value === ".") return false;
   if (value.includes("/") || value.includes("\\")) return false;
   if (value.includes("..")) return false;
-  return /^[A-Za-z0-9._-]{1,64}$/.test(value);
+  return SAFE_ROUTE_NAMESPACE_CHARS.test(value);
 }
 function validateRouteTarget(target, options) {
   if (!target || typeof target !== "object") {
     return { ok: false, error: "target must be an object" };
   }
   const allowedCategories = new Set(options?.allowedCategories ?? DEFAULT_CATEGORIES);
-  const allowedNamespaces = options?.allowedNamespaces ? new Set(options.allowedNamespaces.map((v) => v.trim()).filter((v) => v.length > 0)) : null;
+  const allowedNamespaces = options?.allowedNamespaces ? new Set(options.allowedNamespaces.map((v) => normalizeNamespace(v.trim())).filter((v) => v.length > 0)) : null;
   const normalized = {};
   if (typeof target.category === "string") {
     if (!allowedCategories.has(target.category)) {
@@ -110,4 +117,4 @@ export {
   doesRuleMatch,
   selectRouteRule
 };
-//# sourceMappingURL=chunk-U3PN77QT.js.map
+//# sourceMappingURL=chunk-PCXDUHQH.js.map

package/dist/chunk-PCXDUHQH.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/routing/engine.ts"],"sourcesContent":["import { namespaceIdentityToken } from \"../namespaces/identity.js\";\nimport type { MemoryCategory } from \"../types.js\";\n\nexport type RoutePatternType = \"regex\" | \"keyword\";\n\nexport interface RouteTarget {\n  category?: MemoryCategory;\n  namespace?: string;\n}\n\nexport interface RouteRule {\n  id: string;\n  patternType: RoutePatternType;\n  pattern: string;\n  priority: number;\n  target: RouteTarget;\n  enabled?: boolean;\n}\n\nexport interface RoutingEngineOptions {\n  allowedNamespaces?: string[];\n  allowedCategories?: MemoryCategory[];\n}\n\nexport interface RouteSelection {\n  rule: RouteRule;\n  target: RouteTarget;\n}\n\nconst DEFAULT_CATEGORIES: readonly MemoryCategory[] = [\n  \"fact\",\n  \"preference\",\n  \"correction\",\n  \"entity\",\n  \"decision\",\n  \"relationship\",\n  \"principle\",\n  \"commitment\",\n  \"moment\",\n  \"skill\",\n  \"rule\",\n  \"procedure\",\n  \"reasoning_trace\",\n] as const;\n\nfunction normalizeNamespace(namespace: string): string {\n  return namespace.normalize(\"NFC\");\n}\n\nconst SAFE_ROUTE_NAMESPACE_CHARS = /^[\\p{L}\\p{M}\\p{N}._-]+$/u;\n\nexport function isLikelyUnsafeRegex(pattern: string): boolean {\n  const value = pattern.trim();\n  if (value.length === 0) return true;\n  if (value.length > 120) return true;\n  if (/\\\\[1-9]/.test(value)) return true; // backreferences\n  if (/\\(\\?<?[=!]/.test(value)) return true; // lookaround assertions\n  if (/\\((?:[^()\\\\]|\\\\.)*[+*](?:[^()\\\\]|\\\\.)*\\)[+*{]/.test(value)) return true; // nested quantifiers\n  // Conservative fail-closed guardrail: grouped/alternation regexes are user-configurable and can be expensive.\n  if (/(^|[^\\\\])[()|]/.test(value)) return true;\n  // Multiple quantifiers in one user pattern are high risk for catastrophic backtracking on non-matches.\n  const quantifierCount =\n    (value.match(/(^|[^\\\\])[*+?]/g)?.length ?? 0) +\n    (value.match(/(^|[^\\\\])\\{/g)?.length ?? 0);\n  if (quantifierCount > 1) return true;\n  return false;\n}\n\nexport function isSafeRouteNamespace(namespace: string): boolean {\n  const value = normalizeNamespace(namespace);\n  // The route limit is 64 Unicode code points. On-disk identity tokens may\n  // exceed 64 characters because namespaceIdentityToken hex-encodes UTF-8.\n  // A route can use at most 64 code points, but the reversible on-disk token\n  // must also fit one filesystem component (255 characters).\n  if (value.length === 0) return false;\n  if (Array.from(value).length > 64) return false;\n  if (namespaceIdentityToken(value).length > 255) return false;\n  if (value === \".\") return false;\n  if (value.includes(\"/\") || value.includes(\"\\\\\")) return false;\n  if (value.includes(\"..\")) return false;\n  return SAFE_ROUTE_NAMESPACE_CHARS.test(value);\n}\n\nexport function validateRouteTarget(target: RouteTarget | null | undefined, options?: RoutingEngineOptions): {\n  ok: boolean;\n  error?: string;\n  target?: RouteTarget;\n} {\n  if (!target || typeof target !== \"object\") {\n    return { ok: false, error: \"target must be an object\" };\n  }\n\n  const allowedCategories = new Set(options?.allowedCategories ?? DEFAULT_CATEGORIES);\n  const allowedNamespaces = options?.allowedNamespaces\n    ? new Set(options.allowedNamespaces.map((v) => normalizeNamespace(v.trim())).filter((v) => v.length > 0))\n    : null;\n\n  const normalized: RouteTarget = {};\n\n  if (typeof target.category === \"string\") {\n    if (!allowedCategories.has(target.category)) {\n      return { ok: false, error: `invalid category: ${target.category}` };\n    }\n    normalized.category = target.category;\n  }\n\n  if (typeof target.namespace === \"string\") {\n    const namespace = normalizeNamespace(target.namespace);\n    if (!isSafeRouteNamespace(namespace)) {\n      return { ok: false, error: `invalid namespace: ${target.namespace}` };\n    }\n    if (allowedNamespaces && !allowedNamespaces.has(namespace)) {\n      return { ok: false, error: `namespace not allowed: ${namespace}` };\n    }\n    normalized.namespace = namespace;\n  }\n\n  if (!normalized.category && !normalized.namespace) {\n    return { ok: false, error: \"target must include category or namespace\" };\n  }\n\n  return { ok: true, target: normalized };\n}\n\nexport function doesRuleMatch(rule: RouteRule, text: string): boolean {\n  if (!rule || typeof rule !== \"object\") return false;\n  if (rule.enabled === false) return false;\n  if (typeof rule.pattern !== \"string\") return false;\n  const pattern = rule.pattern.trim();\n  if (pattern.length === 0) return false;\n\n  if (rule.patternType === \"keyword\") {\n    return text.toLowerCase().includes(pattern.toLowerCase());\n  }\n  if (rule.patternType !== \"regex\") {\n    return false;\n  }\n\n  if (isLikelyUnsafeRegex(pattern)) {\n    return false;\n  }\n\n  try {\n    return new RegExp(pattern, \"i\").test(text);\n  } catch {\n    return false;\n  }\n}\n\nexport function selectRouteRule(text: string, rules: RouteRule[], options?: RoutingEngineOptions): RouteSelection | null {\n  const ranked = rules\n    .map((rule, index) => ({ rule, index }))\n    .sort((a, b) => {\n      if (b.rule.priority !== a.rule.priority) return b.rule.priority - a.rule.priority;\n      return a.index - b.index;\n    });\n\n  for (const entry of ranked) {\n    if (!doesRuleMatch(entry.rule, text)) continue;\n\n    const validation = validateRouteTarget(entry.rule.target, options);\n    if (!validation.ok || !validation.target) continue;\n\n    return {\n      rule: entry.rule,\n      target: validation.target,\n    };\n  }\n\n  return null;\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-N655QIA2.js → chunk-PEDYKCJI.js}

@@ -13,10 +13,10 @@ import {
 } from "./chunk-2AD5SXO4.js";
 import {
   ExtractionDeadlineError
-} from "./chunk-UTDMY476.js";
+} from "./chunk-4UUF2EX3.js";
 import {
   resolvePrincipal
-} from "./chunk-IGWVMA4Y.js";
+} from "./chunk-MRV7VSQK.js";
 import {
   resolvePresentationCapabilities
 } from "./chunk-JUOZ62Y7.js";
@@ -792,4 +792,4 @@ var SmartBuffer = class {
 export {
   SmartBuffer
 };
-//# sourceMappingURL=chunk-N655QIA2.js.map
+//# sourceMappingURL=chunk-PEDYKCJI.js.map

package/dist/{chunk-TVKWT2CY.js → chunk-Q57GOHLF.js}

@@ -1,18 +1,20 @@
 import {
   expandScopeProfileReadNamespaces,
   resolveScopeProfilePlan
-} from "./chunk-CMRUIKVA.js";
-import {
-  namespaceIdentityFromToken,
-  namespaceIdentityToken
-} from "./chunk-EGGE52UU.js";
+} from "./chunk-KCT36JAW.js";
 import {
   canReadNamespace,
   canWriteNamespace,
   defaultNamespaceForPrincipal,
   recallNamespacesForPrincipal,
   resolvePrincipal
-} from "./chunk-IGWVMA4Y.js";
+} from "./chunk-MRV7VSQK.js";
+import {
+  namespaceIdentityFromToken,
+  namespaceIdentityLegacyToken,
+  namespaceIdentityToken,
+  normalizeNamespaceIdentity
+} from "./chunk-VUFL7X3H.js";
 import {
   resolveNamespaceCapabilities
 } from "./chunk-JUOZ62Y7.js";
@@ -104,7 +106,7 @@ function getConfiguredNamespaces(config) {
         config.defaultNamespace,
         config.sharedNamespace,
         ...config.namespacePolicies.map((policy) => policy.name)
-      ].map((value) => value.trim()).filter(Boolean)
+      ].map((value) => normalizeNamespaceIdentity(value)).filter(Boolean)
     )
   );
 }
@@ -131,7 +133,7 @@ function resolveNamespaceFromStorageDir(storageDir, options) {
     if (hintedNamespace) return hintedNamespace;
   }
   const decoded = namespaceIdentityFromToken(dirName);
-  if (decoded && namespaceIdentityToken(decoded) === dirName) {
+  if (decoded && (namespaceIdentityToken(decoded) === dirName || namespaceIdentityLegacyToken(decoded.normalize("NFD")) === dirName)) {
     return decoded;
   }
   return dirName;
@@ -202,4 +204,4 @@ export {
   resolveWritableNamespaceValue,
   resolveScopedWritableNamespaceValue
 };
-//# sourceMappingURL=chunk-TVKWT2CY.js.map
+//# sourceMappingURL=chunk-Q57GOHLF.js.map

package/dist/{chunk-TVKWT2CY.js.map → chunk-Q57GOHLF.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/scopes/scope-plan.ts"],"sourcesContent":["/**\n * ScopePlan resolver (issue #1521).\n *\n * A single pure function that resolves every namespace-bearing read/write path\n * to one {@link ScopePlan} value object. Consumers (recall tiers, QMD router,\n * LCM reads, maintenance) never call the ad-hoc resolution helpers directly —\n * they receive a resolved plan and read its fields.\n *\n * The resolver DELEGATES to the existing helpers (`resolvePrincipal`,\n * `recallNamespacesForPrincipal`, `resolveCodingNamespaceOverlay`,\n * `resolveScopeProfilePlan`, `expandScopeProfileReadNamespaces`,\n * `combineNamespaces`, `lcmReadSessionIdsForNamespaces`) — no logic rewrite.\n * The ad-hoc inline resolution that previously lived in the orchestrator's\n * `recallInternal` and `enqueueDirectAnswerObservation` paths is replaced by a\n * single call to {@link resolveScopePlan}, eliminating the duplicated\n * namespace-set construction that produced the largest share of #1519's review\n * threads (scope-profile recall paths missing `readFallbacks` appends).\n *\n * Migration tranches (issue #1521 step 4):\n *  - recall tiers (this PR): the two orchestrator recall entry points consume\n *    the plan instead of building `recallNamespaces`/`observationNamespaces`\n *    inline;\n *  - QMD router calls, LCM reads, maintenance: follow-up PRs.\n *\n * CLAUDE.md rules honoured (pitfalls from the issue):\n *  - rule 42: read/write resolve through the same layer; the coding overlay is\n *    COMBINED with the principal base via `combineNamespaces`;\n *  - rule 39: feature gates identical across every path the plan feeds;\n *  - rule 22/48: LCM keys derived through `lcmSessionKeyForNamespace` (via\n *    `lcmReadSessionIdsForNamespaces`), never hardcoded `:`-joins; unscoped LCM\n *    search stays suppressed when `namespacesEnabled`.\n */\n\nimport { resolveNamespaceCapabilities } from \"../capabilities.js\";\nimport {\n  canReadNamespace,\n  canWriteNamespace,\n  defaultNamespaceForPrincipal,\n  recallNamespacesForPrincipal,\n  resolvePrincipal,\n} from \"../namespaces/principal.js\";\nimport {\n  namespaceIdentityFromToken,\n  namespaceIdentityToken,\n} from \"../namespaces/identity.js\";\nimport path from \"node:path\";\nimport {\n  capabilityAllowsOp,\n  isNamespaceAllowed,\n  resolveEffectiveNamespace,\n  type TokenCapabilities,\n} from \"../access-token-capabilities.js\";\nimport type { ResolvedScopeProfilePlan } from \"../namespaces/scope-profiles.js\";\nimport {\n  expandScopeProfileReadNamespaces,\n  resolveScopeProfilePlan,\n} from \"../namespaces/scope-profiles.js\";\nimport {\n  combineNamespaces,\n  lcmReadSessionIdsForNamespaces,\n  resolveCodingNamespaceOverlay,\n  type CodingNamespaceOverlay,\n} from \"../coding/coding-namespace.js\";\nimport type { CodingContext, PluginConfig } from \"../types.js\";\n\n/**\n * A resolved scope plan: every namespace-bearing field a read or write path\n * needs, produced by ONE call to {@link resolveScopePlan}.\n *\n * Consumers read these fields directly — they never re-resolve namespaces.\n */\nexport interface ScopePlan {\n  /**\n   * Resolved principal under which the operation runs. `undefined` only when\n   * `namespacesEnabled` is false (collapses to `\"default\"`) or no session key\n   * was supplied in single-user mode.\n   */\n  readonly principal: string | undefined;\n\n  /**\n   * Explicit namespace override, trimmed, when the caller supplied one AND it\n   * is readable by the principal. `undefined` when no override was given or the\n   * override is not readable (the plan falls through to the coding/scope-profile\n   * resolution in that case, mirroring the pre-existing observe-path behavior).\n   */\n  readonly namespaceOverride: string | undefined;\n\n  /**\n   * Resolved base (self) namespace — the effective namespace absent an explicit\n   * override. This is the principal-self namespace, optionally substituted by a\n   * scope-profile write layer or a coding overlay.\n   *\n   * Callers that persisted this as the `selfNamespace` / response namespace\n   * read it here.\n   */\n  readonly baseNamespace: string;\n\n  /**\n   * Ordered, deduped read-namespace set. Includes the coding overlay fallbacks\n   * (branch → project → root) combined with the principal base exactly once, so\n   * the #1519 miss (scope-profile path omitted `readFallbacks` appends) cannot\n   * recur — the fallback appends live in ONE place.\n   */\n  readonly readNamespaces: string[];\n\n  /**\n   * Coding overlay fallback namespaces combined with the principal base (rule\n   * 42). Empty when no coding overlay applies. These are the SAME entries\n   * appended into {@link readNamespaces} for the coding-overlay branch,\n   * surfaced separately so consumers that need just the fallback set (e.g.\n   * LCM read-key derivation) can read them without re-deriving.\n   */\n  readonly readFallbacks: string[];\n\n  /**\n   * LCM read namespace set. May differ from {@link readNamespaces} for\n   * read-authorization reasons: when the principal self base is NOT in the\n   * readable recall set, the overlay LCM keys collapse to the default store\n   * (rule 42 read/write parity; rule 48 least-privilege) even though\n   * {@link readNamespaces} still searches the overlay for QMD/file recall.\n   */\n  readonly lcmReadNamespaces: string[];\n\n  /**\n   * LCM read `session_id` set, encoded via\n   * `lcmReadSessionIdsForNamespaces` (which delegates to\n   * `lcmSessionKeyForNamespace`). Ordered and deduped; the primary overlay key\n   * is first. Single-user / no-overlay recall collapses to `[sessionKey]` —\n   * byte-for-byte the pre-#1495 behavior.\n   *\n   * Empty (`[]`) when a scope-profile plan is active and no `sessionKey` was\n   * supplied (mirrors the pre-existing guard).\n   */\n  readonly lcmReadSessionIds: ReadonlyArray<string | undefined>;\n\n  /**\n   * Resolved coding overlay, or `null` when none applies (no coding context,\n   * `codingMode.projectScope` false, `namespacesEnabled` false, or an explicit\n   * readable namespace override is set).\n   */\n  readonly codingOverlay: { readonly namespace: string; readonly readFallbacks: readonly string[] } | null;\n\n  /**\n   * Resolved scope-profile plan, or `null` when no scope profile is active.\n   * Consumers that branched on \"profile vs. non-profile\" read this directly.\n   */\n  readonly scopeProfilePlan: ResolvedScopeProfilePlan | null;\n}\n\n/**\n * Options for {@link resolveScopePlan}.\n */\nexport interface ResolveScopePlanOptions {\n  /** Plugin config (namespace policies, coding mode, default namespace, …). */\n  readonly config: PluginConfig;\n  /** Session key (may derive the principal and/or coding context). */\n  readonly sessionKey?: string;\n  /**\n   * Explicit namespace override (raw — the resolver trims it). When supplied\n   * AND readable by the resolved principal, it wins over every other layer.\n   */\n  readonly namespace?: string;\n  /**\n   * Authenticated principal override. Access surfaces that already resolved\n   * identity at the transport layer pass it here so namespace ACL decisions\n   * use the same identity the surface authorized.\n   */\n  readonly principalOverride?: string;\n  /**\n   * Coding context for the session. Callers that track this on the orchestrator\n   * pass `getCodingContextForSession(sessionKey)` here; the resolver never\n   * reaches back into orchestrator state.\n   */\n  readonly codingContext?: CodingContext | null;\n  /**\n   * Whether namespace routing is enabled. Callers that have already read the\n   * namespaces-enabled flag pass it here so the resolver does NOT re-read it\n   * (keeps the scattered-read ratchet from growing, #1523).\n   */\n  readonly namespacesEnabled: boolean;\n}\n\n/**\n * Resolve a {@link ScopePlan} from the inputs by delegating to the existing\n * namespace-resolution helpers. Pure — no side effects, no orchestrator state.\n *\n * The caller is responsible for authorization checks that should THROW (e.g.\n * `namespacesEnabled && !principal`, or an unreadable explicit override in the\n * recall path). The resolver computes the plan; enforcement stays at the call\n * site so error semantics are unchanged.\n */\nexport function resolveScopePlan(options: ResolveScopePlanOptions): ScopePlan {\n  const { config, sessionKey } = options;\n\n  const namespaceOverride = options.namespace?.trim() || undefined;\n\n  const principal =\n    typeof options.principalOverride === \"string\" && options.principalOverride.length > 0\n      ? options.principalOverride\n      : resolvePrincipal(sessionKey, config);\n\n  // A namespace override gates the overlay/scope-profile layers. When it is\n  // readable it wins; when it is NOT readable the plan falls through to the\n  // coding/scope-profile/legacy branches (mirrors the observe-path behavior\n  // where an unreadable override does not throw but simply does not suppress\n  // the overlay). The recall path validates readability and throws BEFORE\n  // calling the resolver, so a reachable override is always readable there.\n  const namespaceOverrideReadable =\n    namespaceOverride !== undefined && canReadNamespace(principal, namespaceOverride, config);\n\n  const readableRecallNamespaces = recallNamespacesForPrincipal(principal, config);\n\n  // The orchestrator's `applyCodingRecallOverlay` gates on `namespacesEnabled`\n  // (returning null when disabled), so the resolver must too — otherwise\n  // single-store mode would produce apparent route separation with no actual\n  // storage isolation (false-isolation trap, rule 39). The caller passes the\n  // pre-read flag so the resolver does not add a scattered `config.*Enabled`\n  // read (ratchet, #1523).\n  const namespacesEnabled = options.namespacesEnabled;\n  const codingOverlay: CodingNamespaceOverlay | null =\n    namespaceOverrideReadable || !namespacesEnabled\n      ? null\n      : resolveCodingNamespaceOverlay(\n          options.codingContext ?? null,\n          config.codingMode,\n          config.defaultNamespace,\n        );\n\n  const principalSelfNamespace = defaultNamespaceForPrincipal(principal, config);\n  const codingSelfNamespace = codingOverlay\n    ? combineNamespaces(principalSelfNamespace, codingOverlay.namespace)\n    : null;\n\n  const scopeProfilePlan = namespaceOverrideReadable\n    ? null\n    : resolveScopeProfilePlan({\n        config,\n        principal,\n        codingContext: options.codingContext ?? null,\n        codingOverlay,\n      });\n\n  const profileEffectiveNamespace =\n    scopeProfilePlan?.writeNamespace || scopeProfilePlan?.readNamespaces[0];\n\n  const baseNamespace = namespaceOverrideReadable\n    ? namespaceOverride!\n    : profileEffectiveNamespace ?? codingSelfNamespace ?? principalSelfNamespace;\n\n  // ── Read namespace set ────────────────────────────────────────────────────\n  let readNamespaces: string[];\n  if (namespaceOverrideReadable) {\n    readNamespaces = [namespaceOverride!];\n  } else if (scopeProfilePlan) {\n    readNamespaces = expandScopeProfileReadNamespaces({\n      profilePlan: scopeProfilePlan,\n      principalSelfNamespace: scopeProfilePlan.baseNamespace,\n      config,\n      principal,\n      codingOverlay,\n      legacyRecallNamespaces: readableRecallNamespaces,\n    });\n  } else if (codingOverlay && codingSelfNamespace) {\n    // Substitute the principal's self namespace with the coding-scoped one, and\n    // append any read fallbacks (branch → project, rule 42) combined with the\n    // principal base so principal isolation is preserved on fallback entries.\n    const mapped = readableRecallNamespaces.map((ns) =>\n      ns === principalSelfNamespace ? codingSelfNamespace : ns,\n    );\n    const fallbackNs = codingOverlay.readFallbacks.map((fallback) =>\n      combineNamespaces(principalSelfNamespace, fallback),\n    );\n    readNamespaces = Array.from(new Set<string>([...mapped, ...fallbackNs]));\n  } else {\n    readNamespaces = readableRecallNamespaces;\n  }\n\n  const readFallbacks = codingOverlay\n    ? codingOverlay.readFallbacks.map((fb) => combineNamespaces(principalSelfNamespace, fb))\n    : [];\n\n  // ── LCM read namespace set ────────────────────────────────────────────────\n  // The LCM overlay keys are `<principal>-project-*` sub-namespaces authorized\n  // transitively by the principal SELF base. Include them ONLY when that base\n  // is in the readable recall set (rule 42 / 48). When it is NOT readable, the\n  // overlay rows are unauthorized for this reader, so the LCM read collapses to\n  // the default store — exactly what QMD/file recall surfaces for such a\n  // principal.\n  const codingOverlaySelfReadable =\n    codingOverlay !== null &&\n    (scopeProfilePlan\n      ? scopeProfilePlan.layers.some((layer) => layer.id === \"userProject\" && layer.readable)\n      : readableRecallNamespaces.includes(principalSelfNamespace));\n\n  let lcmReadNamespaces: string[];\n  if (namespaceOverrideReadable) {\n    lcmReadNamespaces = [namespaceOverride!];\n  } else if (scopeProfilePlan) {\n    // Scope profiles define a layered read stack; LCM-backed evidence uses the\n    // same namespace set as QMD/file recall so team/global/shared observations\n    // are not silently skipped.\n    lcmReadNamespaces = readNamespaces;\n  } else if (codingOverlay && codingSelfNamespace && codingOverlaySelfReadable) {\n    const fallbackNs = codingOverlay.readFallbacks.map((fallback) =>\n      combineNamespaces(principalSelfNamespace, fallback),\n    );\n    lcmReadNamespaces = [codingSelfNamespace, ...fallbackNs];\n  } else {\n    // No overlay, OR overlay present but self base unreadable → collapse to the\n    // default store (raw sessionKey). No `<principal>-project-*` overlay key is\n    // searched.\n    lcmReadNamespaces = [config.defaultNamespace];\n  }\n\n  const lcmReadSessionIds =\n    scopeProfilePlan && !sessionKey\n      ? []\n      : lcmReadSessionIdsForNamespaces(lcmReadNamespaces, sessionKey, config.defaultNamespace);\n\n  return {\n    principal,\n    namespaceOverride: namespaceOverrideReadable ? namespaceOverride : undefined,\n    baseNamespace,\n    readNamespaces,\n    readFallbacks,\n    lcmReadNamespaces,\n    lcmReadSessionIds,\n    codingOverlay: codingOverlay\n      ? { namespace: codingOverlay.namespace, readFallbacks: codingOverlay.readFallbacks }\n      : null,\n    scopeProfilePlan,\n  };\n}\n\n// ────────────────────────────────────────────────────────────────────────────\n// Centralized namespace-resolution helpers (issue #1521 step 3–4)\n//\n// The three functions below consolidate the ad-hoc namespace-resolution logic\n// that was previously scattered across orchestrator.ts (namespaceFromStorageDir,\n// configuredNamespaces) and access-service.ts (resolveWritableNamespace). By\n// living in THIS module they are excluded from the adHocNamespaceResolutions\n// ratchet, and every consumer reaches them through a single well-known import\n// instead of reimplementing the derivation inline (#1519's failure mode).\n// ────────────────────────────────────────────────────────────────────────────\n\n/**\n * The configured namespace set: default + shared + every namespace-policy\n * name, trimmed and de-duplicated. Pure — reads only from `config`.\n *\n * Replaces the `configuredNamespaces()` private method that lived on both\n * `Orchestrator` and the maintenance namespace-planner (two copies of the\n * same logic).\n */\nexport function getConfiguredNamespaces(config: PluginConfig): string[] {\n  return Array.from(\n    new Set(\n      [\n        config.defaultNamespace,\n        config.sharedNamespace,\n        ...config.namespacePolicies.map((policy) => policy.name),\n      ]\n        .map((value) => value.trim())\n        .filter(Boolean),\n    ),\n  );\n}\n\n/**\n * Options for {@link resolveNamespaceFromStorageDir}.\n */\nexport interface ResolveNamespaceFromStorageDirOptions {\n  /** Plugin config (memoryDir, defaultNamespace, namespacesEnabled, …). */\n  readonly config: PluginConfig;\n  /**\n   * Pre-computed configured-namespace set (from {@link getConfiguredNamespaces}).\n   * Passed by the caller so this function does not re-derive it on every call.\n   */\n  readonly configuredNamespaces: readonly string[];\n  /**\n   * Catalog-owned dir→namespace hints (best-effort union of configured +\n   * catalog-discovered). May be `undefined` when no catalog hints are loaded.\n   */\n  readonly hints?: ReadonlyMap<string, ReadonlySet<string>> | undefined;\n  /**\n   * Lazy catalog-hint loader. Called ONLY after the early returns (disabled,\n   * memory root, no namespace segment, configured namespace) — matching the\n   * original lazy behavior so an eager load does not mark hints as loaded\n   * before the catalog file exists (codex P2).\n   */\n  readonly loadHints?: () => void;\n}\n\n/**\n * Derive the namespace a storage directory belongs to.\n *\n * Pure (no orchestrator state): the caller passes `config`, the configured set,\n * and any catalog hints. The logic is byte-identical to the private\n * `namespaceFromStorageDir` method that previously lived on `Orchestrator`\n * (including the token round-trip guard from codex round 6).\n */\nexport function resolveNamespaceFromStorageDir(\n  storageDir: string,\n  options: ResolveNamespaceFromStorageDirOptions,\n): string {\n  const { config } = options;\n  if (!resolveNamespaceCapabilities(config).namespaces) return config.defaultNamespace;\n  const resolvedStorageDir = path.resolve(storageDir);\n  const resolvedMemoryDir = path.resolve(config.memoryDir);\n  if (resolvedStorageDir === resolvedMemoryDir) return config.defaultNamespace;\n  const m = resolvedStorageDir.match(/[\\\\/]namespaces[\\\\/]([^\\\\/]+)$/);\n  if (!m?.[1]) return config.defaultNamespace;\n  const dirName = m[1];\n  // Token-shaped raw names (codex P2 — NBsFz): a dir name might be a tokenized\n  // identity OR a literal raw namespace name that merely LOOKS like a token.\n  // A dir name that is itself a KNOWN namespace is preserved BEFORE decoding.\n  if (options.configuredNamespaces.includes(dirName)) {\n    return dirName;\n  }\n  // Load catalog hints ONLY after the early returns (codex P2: an eager load\n  // before the catalog file exists would mark hints as loaded and skip later\n  // catalog-derived rows).\n  options.loadHints?.();\n  const hints = options.hints;\n  const hintedNamespaces = hints?.get(resolvedStorageDir);\n  if (hintedNamespaces?.has(dirName)) {\n    return dirName;\n  }\n  if (hintedNamespaces?.size === 1) {\n    const [hintedNamespace] = hintedNamespaces;\n    if (hintedNamespace) return hintedNamespace;\n  }\n  const decoded = namespaceIdentityFromToken(dirName);\n  if (decoded && namespaceIdentityToken(decoded) === dirName) {\n    return decoded;\n  }\n  return dirName;\n}\n\n/**\n * Result of resolving a writable namespace: either the authorized namespace\n * or a structured rejection. The caller decides how to surface the rejection\n * (e.g. as an `EngramAccessInputError` in the access-service layer), keeping\n * this module free of transport-specific error types.\n */\nexport type WritableNamespaceResult =\n  | { readonly ok: true; readonly namespace: string }\n  | { readonly ok: false; readonly reason: \"unsupported\" | \"not_writable\"; readonly namespace: string };\n\n/**\n * Resolve and authorize a writable namespace.\n *\n * Combines the three steps that `AccessService.resolveWritableNamespace`\n * performed inline: (1) resolve the namespace value (trim → default fallback →\n * validate against `namespacesEnabled`), (2) resolve the principal, (3) check\n * `canWriteNamespace`. Returns a structured result so this module stays free of\n * `EngramAccessInputError` (avoiding a circular dependency on access-service.ts).\n *\n * The caller throws `EngramAccessInputError` when `ok === false` — the access-\n * service wrapper does this in one place.\n */\nexport function resolveWritableNamespaceValue(\n  namespace: string | undefined,\n  sessionKey: string | undefined,\n  authenticatedPrincipal: string | undefined,\n  config: PluginConfig,\n): WritableNamespaceResult {\n  const requested = namespace?.trim();\n  let resolved: string;\n  if (!requested) {\n    resolved = config.defaultNamespace;\n  } else if (\n    !resolveNamespaceCapabilities(config).namespaces &&\n    requested !== config.defaultNamespace\n  ) {\n    return { ok: false, reason: \"unsupported\", namespace: requested };\n  } else {\n    resolved = requested;\n  }\n\n  const trusted = authenticatedPrincipal?.trim();\n  const principal =\n    typeof trusted === \"string\" && trusted.length > 0\n      ? trusted\n      : resolvePrincipal(sessionKey, config);\n\n  if (!canWriteNamespace(principal, resolved, config)) {\n    return { ok: false, reason: \"not_writable\", namespace: resolved };\n  }\n  return { ok: true, namespace: resolved };\n}\n\n/**\n * Inputs already derived by the access-service's read-only coding-context\n * resolver. Keeping context discovery outside this pure function lets writes\n * and preflight checks apply identical namespace and ACL rules.\n */\nexport interface ScopedWritableNamespaceInput {\n  readonly namespace?: string;\n  readonly sessionKey?: string;\n  readonly authenticatedPrincipal?: string;\n  readonly principal: string | undefined;\n  readonly codingOverlay: CodingNamespaceOverlay | null;\n  readonly scopeProfile: ResolvedScopeProfilePlan | null;\n  readonly config: PluginConfig;\n}\n\n/**\n * Resolve the namespace an explicit write or implicit coding-scoped write\n * would use. The caller supplies the same derived coding inputs for the real\n * write and the read-only preflight.\n */\nexport function resolveScopedWritableNamespaceValue(\n  input: ScopedWritableNamespaceInput,\n): WritableNamespaceResult {\n  const requested = input.namespace?.trim();\n  if (requested) {\n    return resolveWritableNamespaceValue(\n      requested,\n      input.sessionKey,\n      input.authenticatedPrincipal,\n      input.config,\n    );\n  }\n  if (input.scopeProfile) {\n    const selectedLayer = input.scopeProfile.layers.find(\n      (layer) => layer.id === input.scopeProfile?.writeLayer,\n    );\n    const writeNamespaceReadable =\n      input.scopeProfile.writeNamespace.length > 0 &&\n      input.scopeProfile.readNamespaces.includes(input.scopeProfile.writeNamespace);\n    if (!selectedLayer?.writable || !writeNamespaceReadable) {\n      return {\n        ok: false,\n        reason: \"not_writable\",\n        namespace: input.scopeProfile.writeNamespace,\n      };\n    }\n    return { ok: true, namespace: input.scopeProfile.writeNamespace };\n  }\n  if (!input.codingOverlay) {\n    return resolveWritableNamespaceValue(\n      undefined,\n      input.sessionKey,\n      input.authenticatedPrincipal,\n      input.config,\n    );\n  }\n  const baseNamespace = defaultNamespaceForPrincipal(input.principal, input.config);\n  if (!canWriteNamespace(input.principal, baseNamespace, input.config)) {\n    return { ok: false, reason: \"not_writable\", namespace: baseNamespace };\n  }\n  return {\n    ok: true,\n    namespace: combineNamespaces(baseNamespace, input.codingOverlay.namespace),\n  };\n}\n\n/**\n * Namespace preflight (issue #1888 part 3): would a write to `namespace` by a\n * caller carrying `caps` succeed? Combines the token's write-op scope, its\n * namespace allow-list, and policy writability so one call answers the real\n * question. A token that cannot actually write (no `observe`/`memory_store` in\n * its ops allow-list) or is asking about a namespace outside its allow-list\n * gets a definitive `not_writable` — revealing nothing about the namespace's\n * policy beyond what the token's own scope already implies, and never throwing\n * a hard authorization error the caller cannot distinguish from a transport\n * fault. (Unrestricted tokens pass both scope checks unchanged.)\n */\nexport function resolveNamespacePreflight(\n  caps: TokenCapabilities | undefined | null,\n  namespace: string | undefined,\n  sessionKey: string | undefined,\n  authenticatedPrincipal: string | undefined,\n  config: PluginConfig,\n  writeOp: string,\n): WritableNamespaceResult {\n  const notWritable = (): WritableNamespaceResult => ({\n    ok: false,\n    reason: \"not_writable\",\n    namespace: resolveEffectiveNamespace(namespace, config.defaultNamespace) ?? namespace ?? \"\",\n  });\n  // The token must be able to perform the write op the caller's ENABLED write\n  // path actually uses (`observe` for automatic turn capture — the silent\n  // #1888 data-loss path — or `memory_store` for an explicit-only install).\n  // A token that cannot perform that op would drop the write, so an otherwise\n  // policy-writable namespace is still reported not_writable rather than a\n  // false ok:true that promises a write the token cannot make.\n  if (!capabilityAllowsOp(caps, writeOp)) {\n    return notWritable();\n  }\n  if (!isNamespaceAllowed(caps, namespace, config.defaultNamespace)) {\n    return notWritable();\n  }\n  return resolveWritableNamespaceValue(namespace, sessionKey, authenticatedPrincipal, config);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AA6CA,OAAO,UAAU;AAkJV,SAAS,iBAAiB,SAA6C;AAC5E,QAAM,EAAE,QAAQ,WAAW,IAAI;AAE/B,QAAM,oBAAoB,QAAQ,WAAW,KAAK,KAAK;AAEvD,QAAM,YACJ,OAAO,QAAQ,sBAAsB,YAAY,QAAQ,kBAAkB,SAAS,IAChF,QAAQ,oBACR,iBAAiB,YAAY,MAAM;AAQzC,QAAM,4BACJ,sBAAsB,UAAa,iBAAiB,WAAW,mBAAmB,MAAM;AAE1F,QAAM,2BAA2B,6BAA6B,WAAW,MAAM;AAQ/E,QAAM,oBAAoB,QAAQ;AAClC,QAAM,gBACJ,6BAA6B,CAAC,oBAC1B,OACA;AAAA,IACE,QAAQ,iBAAiB;AAAA,IACzB,OAAO;AAAA,IACP,OAAO;AAAA,EACT;AAEN,QAAM,yBAAyB,6BAA6B,WAAW,MAAM;AAC7E,QAAM,sBAAsB,gBACxB,kBAAkB,wBAAwB,cAAc,SAAS,IACjE;AAEJ,QAAM,mBAAmB,4BACrB,OACA,wBAAwB;AAAA,IACtB;AAAA,IACA;AAAA,IACA,eAAe,QAAQ,iBAAiB;AAAA,IACxC;AAAA,EACF,CAAC;AAEL,QAAM,4BACJ,kBAAkB,kBAAkB,kBAAkB,eAAe,CAAC;AAExE,QAAM,gBAAgB,4BAClB,oBACA,6BAA6B,uBAAuB;AAGxD,MAAI;AACJ,MAAI,2BAA2B;AAC7B,qBAAiB,CAAC,iBAAkB;AAAA,EACtC,WAAW,kBAAkB;AAC3B,qBAAiB,iCAAiC;AAAA,MAChD,aAAa;AAAA,MACb,wBAAwB,iBAAiB;AAAA,MACzC;AAAA,MACA;AAAA,MACA;AAAA,MACA,wBAAwB;AAAA,IAC1B,CAAC;AAAA,EACH,WAAW,iBAAiB,qBAAqB;AAI/C,UAAM,SAAS,yBAAyB;AAAA,MAAI,CAAC,OAC3C,OAAO,yBAAyB,sBAAsB;AAAA,IACxD;AACA,UAAM,aAAa,cAAc,cAAc;AAAA,MAAI,CAAC,aAClD,kBAAkB,wBAAwB,QAAQ;AAAA,IACpD;AACA,qBAAiB,MAAM,KAAK,oBAAI,IAAY,CAAC,GAAG,QAAQ,GAAG,UAAU,CAAC,CAAC;AAAA,EACzE,OAAO;AACL,qBAAiB;AAAA,EACnB;AAEA,QAAM,gBAAgB,gBAClB,cAAc,cAAc,IAAI,CAAC,OAAO,kBAAkB,wBAAwB,EAAE,CAAC,IACrF,CAAC;AASL,QAAM,4BACJ,kBAAkB,SACjB,mBACG,iBAAiB,OAAO,KAAK,CAAC,UAAU,MAAM,OAAO,iBAAiB,MAAM,QAAQ,IACpF,yBAAyB,SAAS,sBAAsB;AAE9D,MAAI;AACJ,MAAI,2BAA2B;AAC7B,wBAAoB,CAAC,iBAAkB;AAAA,EACzC,WAAW,kBAAkB;AAI3B,wBAAoB;AAAA,EACtB,WAAW,iBAAiB,uBAAuB,2BAA2B;AAC5E,UAAM,aAAa,cAAc,cAAc;AAAA,MAAI,CAAC,aAClD,kBAAkB,wBAAwB,QAAQ;AAAA,IACpD;AACA,wBAAoB,CAAC,qBAAqB,GAAG,UAAU;AAAA,EACzD,OAAO;AAIL,wBAAoB,CAAC,OAAO,gBAAgB;AAAA,EAC9C;AAEA,QAAM,oBACJ,oBAAoB,CAAC,aACjB,CAAC,IACD,+BAA+B,mBAAmB,YAAY,OAAO,gBAAgB;AAE3F,SAAO;AAAA,IACL;AAAA,IACA,mBAAmB,4BAA4B,oBAAoB;AAAA,IACnE;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,eAAe,gBACX,EAAE,WAAW,cAAc,WAAW,eAAe,cAAc,cAAc,IACjF;AAAA,IACJ;AAAA,EACF;AACF;AAqBO,SAAS,wBAAwB,QAAgC;AACtE,SAAO,MAAM;AAAA,IACX,IAAI;AAAA,MACF;AAAA,QACE,OAAO;AAAA,QACP,OAAO;AAAA,QACP,GAAG,OAAO,kBAAkB,IAAI,CAAC,WAAW,OAAO,IAAI;AAAA,MACzD,EACG,IAAI,CAAC,UAAU,MAAM,KAAK,CAAC,EAC3B,OAAO,OAAO;AAAA,IACnB;AAAA,EACF;AACF;AAmCO,SAAS,+BACd,YACA,SACQ;AACR,QAAM,EAAE,OAAO,IAAI;AACnB,MAAI,CAAC,6BAA6B,MAAM,EAAE,WAAY,QAAO,OAAO;AACpE,QAAM,qBAAqB,KAAK,QAAQ,UAAU;AAClD,QAAM,oBAAoB,KAAK,QAAQ,OAAO,SAAS;AACvD,MAAI,uBAAuB,kBAAmB,QAAO,OAAO;AAC5D,QAAM,IAAI,mBAAmB,MAAM,gCAAgC;AACnE,MAAI,CAAC,IAAI,CAAC,EAAG,QAAO,OAAO;AAC3B,QAAM,UAAU,EAAE,CAAC;AAInB,MAAI,QAAQ,qBAAqB,SAAS,OAAO,GAAG;AAClD,WAAO;AAAA,EACT;AAIA,UAAQ,YAAY;AACpB,QAAM,QAAQ,QAAQ;AACtB,QAAM,mBAAmB,OAAO,IAAI,kBAAkB;AACtD,MAAI,kBAAkB,IAAI,OAAO,GAAG;AAClC,WAAO;AAAA,EACT;AACA,MAAI,kBAAkB,SAAS,GAAG;AAChC,UAAM,CAAC,eAAe,IAAI;AAC1B,QAAI,gBAAiB,QAAO;AAAA,EAC9B;AACA,QAAM,UAAU,2BAA2B,OAAO;AAClD,MAAI,WAAW,uBAAuB,OAAO,MAAM,SAAS;AAC1D,WAAO;AAAA,EACT;AACA,SAAO;AACT;AAwBO,SAAS,8BACd,WACA,YACA,wBACA,QACyB;AACzB,QAAM,YAAY,WAAW,KAAK;AAClC,MAAI;AACJ,MAAI,CAAC,WAAW;AACd,eAAW,OAAO;AAAA,EACpB,WACE,CAAC,6BAA6B,MAAM,EAAE,cACtC,cAAc,OAAO,kBACrB;AACA,WAAO,EAAE,IAAI,OAAO,QAAQ,eAAe,WAAW,UAAU;AAAA,EAClE,OAAO;AACL,eAAW;AAAA,EACb;AAEA,QAAM,UAAU,wBAAwB,KAAK;AAC7C,QAAM,YACJ,OAAO,YAAY,YAAY,QAAQ,SAAS,IAC5C,UACA,iBAAiB,YAAY,MAAM;AAEzC,MAAI,CAAC,kBAAkB,WAAW,UAAU,MAAM,GAAG;AACnD,WAAO,EAAE,IAAI,OAAO,QAAQ,gBAAgB,WAAW,SAAS;AAAA,EAClE;AACA,SAAO,EAAE,IAAI,MAAM,WAAW,SAAS;AACzC;AAsBO,SAAS,oCACd,OACyB;AACzB,QAAM,YAAY,MAAM,WAAW,KAAK;AACxC,MAAI,WAAW;AACb,WAAO;AAAA,MACL;AAAA,MACA,MAAM;AAAA,MACN,MAAM;AAAA,MACN,MAAM;AAAA,IACR;AAAA,EACF;AACA,MAAI,MAAM,cAAc;AACtB,UAAM,gBAAgB,MAAM,aAAa,OAAO;AAAA,MAC9C,CAAC,UAAU,MAAM,OAAO,MAAM,cAAc;AAAA,IAC9C;AACA,UAAM,yBACJ,MAAM,aAAa,eAAe,SAAS,KAC3C,MAAM,aAAa,eAAe,SAAS,MAAM,aAAa,cAAc;AAC9E,QAAI,CAAC,eAAe,YAAY,CAAC,wBAAwB;AACvD,aAAO;AAAA,QACL,IAAI;AAAA,QACJ,QAAQ;AAAA,QACR,WAAW,MAAM,aAAa;AAAA,MAChC;AAAA,IACF;AACA,WAAO,EAAE,IAAI,MAAM,WAAW,MAAM,aAAa,eAAe;AAAA,EAClE;AACA,MAAI,CAAC,MAAM,eAAe;AACxB,WAAO;AAAA,MACL;AAAA,MACA,MAAM;AAAA,MACN,MAAM;AAAA,MACN,MAAM;AAAA,IACR;AAAA,EACF;AACA,QAAM,gBAAgB,6BAA6B,MAAM,WAAW,MAAM,MAAM;AAChF,MAAI,CAAC,kBAAkB,MAAM,WAAW,eAAe,MAAM,MAAM,GAAG;AACpE,WAAO,EAAE,IAAI,OAAO,QAAQ,gBAAgB,WAAW,cAAc;AAAA,EACvE;AACA,SAAO;AAAA,IACL,IAAI;AAAA,IACJ,WAAW,kBAAkB,eAAe,MAAM,cAAc,SAAS;AAAA,EAC3E;AACF;","names":[]}
+{"version":3,"sources":["../src/scopes/scope-plan.ts"],"sourcesContent":["/**\n * ScopePlan resolver (issue #1521).\n *\n * A single pure function that resolves every namespace-bearing read/write path\n * to one {@link ScopePlan} value object. Consumers (recall tiers, QMD router,\n * LCM reads, maintenance) never call the ad-hoc resolution helpers directly —\n * they receive a resolved plan and read its fields.\n *\n * The resolver DELEGATES to the existing helpers (`resolvePrincipal`,\n * `recallNamespacesForPrincipal`, `resolveCodingNamespaceOverlay`,\n * `resolveScopeProfilePlan`, `expandScopeProfileReadNamespaces`,\n * `combineNamespaces`, `lcmReadSessionIdsForNamespaces`) — no logic rewrite.\n * The ad-hoc inline resolution that previously lived in the orchestrator's\n * `recallInternal` and `enqueueDirectAnswerObservation` paths is replaced by a\n * single call to {@link resolveScopePlan}, eliminating the duplicated\n * namespace-set construction that produced the largest share of #1519's review\n * threads (scope-profile recall paths missing `readFallbacks` appends).\n *\n * Migration tranches (issue #1521 step 4):\n *  - recall tiers (this PR): the two orchestrator recall entry points consume\n *    the plan instead of building `recallNamespaces`/`observationNamespaces`\n *    inline;\n *  - QMD router calls, LCM reads, maintenance: follow-up PRs.\n *\n * CLAUDE.md rules honoured (pitfalls from the issue):\n *  - rule 42: read/write resolve through the same layer; the coding overlay is\n *    COMBINED with the principal base via `combineNamespaces`;\n *  - rule 39: feature gates identical across every path the plan feeds;\n *  - rule 22/48: LCM keys derived through `lcmSessionKeyForNamespace` (via\n *    `lcmReadSessionIdsForNamespaces`), never hardcoded `:`-joins; unscoped LCM\n *    search stays suppressed when `namespacesEnabled`.\n */\n\nimport { resolveNamespaceCapabilities } from \"../capabilities.js\";\nimport {\n  canReadNamespace,\n  canWriteNamespace,\n  defaultNamespaceForPrincipal,\n  recallNamespacesForPrincipal,\n  resolvePrincipal,\n} from \"../namespaces/principal.js\";\nimport {\n  namespaceIdentityFromToken,\n  namespaceIdentityLegacyToken,\n  namespaceIdentityToken,\n  normalizeNamespaceIdentity,\n} from \"../namespaces/identity.js\";\nimport path from \"node:path\";\nimport {\n  capabilityAllowsOp,\n  isNamespaceAllowed,\n  resolveEffectiveNamespace,\n  type TokenCapabilities,\n} from \"../access-token-capabilities.js\";\nimport type { ResolvedScopeProfilePlan } from \"../namespaces/scope-profiles.js\";\nimport {\n  expandScopeProfileReadNamespaces,\n  resolveScopeProfilePlan,\n} from \"../namespaces/scope-profiles.js\";\nimport {\n  combineNamespaces,\n  lcmReadSessionIdsForNamespaces,\n  resolveCodingNamespaceOverlay,\n  type CodingNamespaceOverlay,\n} from \"../coding/coding-namespace.js\";\nimport type { CodingContext, PluginConfig } from \"../types.js\";\n\n/**\n * A resolved scope plan: every namespace-bearing field a read or write path\n * needs, produced by ONE call to {@link resolveScopePlan}.\n *\n * Consumers read these fields directly — they never re-resolve namespaces.\n */\nexport interface ScopePlan {\n  /**\n   * Resolved principal under which the operation runs. `undefined` only when\n   * `namespacesEnabled` is false (collapses to `\"default\"`) or no session key\n   * was supplied in single-user mode.\n   */\n  readonly principal: string | undefined;\n\n  /**\n   * Explicit namespace override, trimmed, when the caller supplied one AND it\n   * is readable by the principal. `undefined` when no override was given or the\n   * override is not readable (the plan falls through to the coding/scope-profile\n   * resolution in that case, mirroring the pre-existing observe-path behavior).\n   */\n  readonly namespaceOverride: string | undefined;\n\n  /**\n   * Resolved base (self) namespace — the effective namespace absent an explicit\n   * override. This is the principal-self namespace, optionally substituted by a\n   * scope-profile write layer or a coding overlay.\n   *\n   * Callers that persisted this as the `selfNamespace` / response namespace\n   * read it here.\n   */\n  readonly baseNamespace: string;\n\n  /**\n   * Ordered, deduped read-namespace set. Includes the coding overlay fallbacks\n   * (branch → project → root) combined with the principal base exactly once, so\n   * the #1519 miss (scope-profile path omitted `readFallbacks` appends) cannot\n   * recur — the fallback appends live in ONE place.\n   */\n  readonly readNamespaces: string[];\n\n  /**\n   * Coding overlay fallback namespaces combined with the principal base (rule\n   * 42). Empty when no coding overlay applies. These are the SAME entries\n   * appended into {@link readNamespaces} for the coding-overlay branch,\n   * surfaced separately so consumers that need just the fallback set (e.g.\n   * LCM read-key derivation) can read them without re-deriving.\n   */\n  readonly readFallbacks: string[];\n\n  /**\n   * LCM read namespace set. May differ from {@link readNamespaces} for\n   * read-authorization reasons: when the principal self base is NOT in the\n   * readable recall set, the overlay LCM keys collapse to the default store\n   * (rule 42 read/write parity; rule 48 least-privilege) even though\n   * {@link readNamespaces} still searches the overlay for QMD/file recall.\n   */\n  readonly lcmReadNamespaces: string[];\n\n  /**\n   * LCM read `session_id` set, encoded via\n   * `lcmReadSessionIdsForNamespaces` (which delegates to\n   * `lcmSessionKeyForNamespace`). Ordered and deduped; the primary overlay key\n   * is first. Single-user / no-overlay recall collapses to `[sessionKey]` —\n   * byte-for-byte the pre-#1495 behavior.\n   *\n   * Empty (`[]`) when a scope-profile plan is active and no `sessionKey` was\n   * supplied (mirrors the pre-existing guard).\n   */\n  readonly lcmReadSessionIds: ReadonlyArray<string | undefined>;\n\n  /**\n   * Resolved coding overlay, or `null` when none applies (no coding context,\n   * `codingMode.projectScope` false, `namespacesEnabled` false, or an explicit\n   * readable namespace override is set).\n   */\n  readonly codingOverlay: { readonly namespace: string; readonly readFallbacks: readonly string[] } | null;\n\n  /**\n   * Resolved scope-profile plan, or `null` when no scope profile is active.\n   * Consumers that branched on \"profile vs. non-profile\" read this directly.\n   */\n  readonly scopeProfilePlan: ResolvedScopeProfilePlan | null;\n}\n\n/**\n * Options for {@link resolveScopePlan}.\n */\nexport interface ResolveScopePlanOptions {\n  /** Plugin config (namespace policies, coding mode, default namespace, …). */\n  readonly config: PluginConfig;\n  /** Session key (may derive the principal and/or coding context). */\n  readonly sessionKey?: string;\n  /**\n   * Explicit namespace override (raw — the resolver trims it). When supplied\n   * AND readable by the resolved principal, it wins over every other layer.\n   */\n  readonly namespace?: string;\n  /**\n   * Authenticated principal override. Access surfaces that already resolved\n   * identity at the transport layer pass it here so namespace ACL decisions\n   * use the same identity the surface authorized.\n   */\n  readonly principalOverride?: string;\n  /**\n   * Coding context for the session. Callers that track this on the orchestrator\n   * pass `getCodingContextForSession(sessionKey)` here; the resolver never\n   * reaches back into orchestrator state.\n   */\n  readonly codingContext?: CodingContext | null;\n  /**\n   * Whether namespace routing is enabled. Callers that have already read the\n   * namespaces-enabled flag pass it here so the resolver does NOT re-read it\n   * (keeps the scattered-read ratchet from growing, #1523).\n   */\n  readonly namespacesEnabled: boolean;\n}\n\n/**\n * Resolve a {@link ScopePlan} from the inputs by delegating to the existing\n * namespace-resolution helpers. Pure — no side effects, no orchestrator state.\n *\n * The caller is responsible for authorization checks that should THROW (e.g.\n * `namespacesEnabled && !principal`, or an unreadable explicit override in the\n * recall path). The resolver computes the plan; enforcement stays at the call\n * site so error semantics are unchanged.\n */\nexport function resolveScopePlan(options: ResolveScopePlanOptions): ScopePlan {\n  const { config, sessionKey } = options;\n\n  const namespaceOverride = options.namespace?.trim() || undefined;\n\n  const principal =\n    typeof options.principalOverride === \"string\" && options.principalOverride.length > 0\n      ? options.principalOverride\n      : resolvePrincipal(sessionKey, config);\n\n  // A namespace override gates the overlay/scope-profile layers. When it is\n  // readable it wins; when it is NOT readable the plan falls through to the\n  // coding/scope-profile/legacy branches (mirrors the observe-path behavior\n  // where an unreadable override does not throw but simply does not suppress\n  // the overlay). The recall path validates readability and throws BEFORE\n  // calling the resolver, so a reachable override is always readable there.\n  const namespaceOverrideReadable =\n    namespaceOverride !== undefined && canReadNamespace(principal, namespaceOverride, config);\n\n  const readableRecallNamespaces = recallNamespacesForPrincipal(principal, config);\n\n  // The orchestrator's `applyCodingRecallOverlay` gates on `namespacesEnabled`\n  // (returning null when disabled), so the resolver must too — otherwise\n  // single-store mode would produce apparent route separation with no actual\n  // storage isolation (false-isolation trap, rule 39). The caller passes the\n  // pre-read flag so the resolver does not add a scattered `config.*Enabled`\n  // read (ratchet, #1523).\n  const namespacesEnabled = options.namespacesEnabled;\n  const codingOverlay: CodingNamespaceOverlay | null =\n    namespaceOverrideReadable || !namespacesEnabled\n      ? null\n      : resolveCodingNamespaceOverlay(\n          options.codingContext ?? null,\n          config.codingMode,\n          config.defaultNamespace,\n        );\n\n  const principalSelfNamespace = defaultNamespaceForPrincipal(principal, config);\n  const codingSelfNamespace = codingOverlay\n    ? combineNamespaces(principalSelfNamespace, codingOverlay.namespace)\n    : null;\n\n  const scopeProfilePlan = namespaceOverrideReadable\n    ? null\n    : resolveScopeProfilePlan({\n        config,\n        principal,\n        codingContext: options.codingContext ?? null,\n        codingOverlay,\n      });\n\n  const profileEffectiveNamespace =\n    scopeProfilePlan?.writeNamespace || scopeProfilePlan?.readNamespaces[0];\n\n  const baseNamespace = namespaceOverrideReadable\n    ? namespaceOverride!\n    : profileEffectiveNamespace ?? codingSelfNamespace ?? principalSelfNamespace;\n\n  // ── Read namespace set ────────────────────────────────────────────────────\n  let readNamespaces: string[];\n  if (namespaceOverrideReadable) {\n    readNamespaces = [namespaceOverride!];\n  } else if (scopeProfilePlan) {\n    readNamespaces = expandScopeProfileReadNamespaces({\n      profilePlan: scopeProfilePlan,\n      principalSelfNamespace: scopeProfilePlan.baseNamespace,\n      config,\n      principal,\n      codingOverlay,\n      legacyRecallNamespaces: readableRecallNamespaces,\n    });\n  } else if (codingOverlay && codingSelfNamespace) {\n    // Substitute the principal's self namespace with the coding-scoped one, and\n    // append any read fallbacks (branch → project, rule 42) combined with the\n    // principal base so principal isolation is preserved on fallback entries.\n    const mapped = readableRecallNamespaces.map((ns) =>\n      ns === principalSelfNamespace ? codingSelfNamespace : ns,\n    );\n    const fallbackNs = codingOverlay.readFallbacks.map((fallback) =>\n      combineNamespaces(principalSelfNamespace, fallback),\n    );\n    readNamespaces = Array.from(new Set<string>([...mapped, ...fallbackNs]));\n  } else {\n    readNamespaces = readableRecallNamespaces;\n  }\n\n  const readFallbacks = codingOverlay\n    ? codingOverlay.readFallbacks.map((fb) => combineNamespaces(principalSelfNamespace, fb))\n    : [];\n\n  // ── LCM read namespace set ────────────────────────────────────────────────\n  // The LCM overlay keys are `<principal>-project-*` sub-namespaces authorized\n  // transitively by the principal SELF base. Include them ONLY when that base\n  // is in the readable recall set (rule 42 / 48). When it is NOT readable, the\n  // overlay rows are unauthorized for this reader, so the LCM read collapses to\n  // the default store — exactly what QMD/file recall surfaces for such a\n  // principal.\n  const codingOverlaySelfReadable =\n    codingOverlay !== null &&\n    (scopeProfilePlan\n      ? scopeProfilePlan.layers.some((layer) => layer.id === \"userProject\" && layer.readable)\n      : readableRecallNamespaces.includes(principalSelfNamespace));\n\n  let lcmReadNamespaces: string[];\n  if (namespaceOverrideReadable) {\n    lcmReadNamespaces = [namespaceOverride!];\n  } else if (scopeProfilePlan) {\n    // Scope profiles define a layered read stack; LCM-backed evidence uses the\n    // same namespace set as QMD/file recall so team/global/shared observations\n    // are not silently skipped.\n    lcmReadNamespaces = readNamespaces;\n  } else if (codingOverlay && codingSelfNamespace && codingOverlaySelfReadable) {\n    const fallbackNs = codingOverlay.readFallbacks.map((fallback) =>\n      combineNamespaces(principalSelfNamespace, fallback),\n    );\n    lcmReadNamespaces = [codingSelfNamespace, ...fallbackNs];\n  } else {\n    // No overlay, OR overlay present but self base unreadable → collapse to the\n    // default store (raw sessionKey). No `<principal>-project-*` overlay key is\n    // searched.\n    lcmReadNamespaces = [config.defaultNamespace];\n  }\n\n  const lcmReadSessionIds =\n    scopeProfilePlan && !sessionKey\n      ? []\n      : lcmReadSessionIdsForNamespaces(lcmReadNamespaces, sessionKey, config.defaultNamespace);\n\n  return {\n    principal,\n    namespaceOverride: namespaceOverrideReadable ? namespaceOverride : undefined,\n    baseNamespace,\n    readNamespaces,\n    readFallbacks,\n    lcmReadNamespaces,\n    lcmReadSessionIds,\n    codingOverlay: codingOverlay\n      ? { namespace: codingOverlay.namespace, readFallbacks: codingOverlay.readFallbacks }\n      : null,\n    scopeProfilePlan,\n  };\n}\n\n// ────────────────────────────────────────────────────────────────────────────\n// Centralized namespace-resolution helpers (issue #1521 step 3–4)\n//\n// The three functions below consolidate the ad-hoc namespace-resolution logic\n// that was previously scattered across orchestrator.ts (namespaceFromStorageDir,\n// configuredNamespaces) and access-service.ts (resolveWritableNamespace). By\n// living in THIS module they are excluded from the adHocNamespaceResolutions\n// ratchet, and every consumer reaches them through a single well-known import\n// instead of reimplementing the derivation inline (#1519's failure mode).\n// ────────────────────────────────────────────────────────────────────────────\n\n/**\n * The configured namespace set: default + shared + every namespace-policy\n * name, trimmed and de-duplicated. Pure — reads only from `config`.\n *\n * Replaces the `configuredNamespaces()` private method that lived on both\n * `Orchestrator` and the maintenance namespace-planner (two copies of the\n * same logic).\n */\nexport function getConfiguredNamespaces(config: PluginConfig): string[] {\n  return Array.from(\n    new Set(\n      [\n        config.defaultNamespace,\n        config.sharedNamespace,\n        ...config.namespacePolicies.map((policy) => policy.name),\n      ]\n        .map((value) => normalizeNamespaceIdentity(value))\n        .filter(Boolean),\n    ),\n  );\n}\n\n/**\n * Options for {@link resolveNamespaceFromStorageDir}.\n */\nexport interface ResolveNamespaceFromStorageDirOptions {\n  /** Plugin config (memoryDir, defaultNamespace, namespacesEnabled, …). */\n  readonly config: PluginConfig;\n  /**\n   * Pre-computed configured-namespace set (from {@link getConfiguredNamespaces}).\n   * Passed by the caller so this function does not re-derive it on every call.\n   */\n  readonly configuredNamespaces: readonly string[];\n  /**\n   * Catalog-owned dir→namespace hints (best-effort union of configured +\n   * catalog-discovered). May be `undefined` when no catalog hints are loaded.\n   */\n  readonly hints?: ReadonlyMap<string, ReadonlySet<string>> | undefined;\n  /**\n   * Lazy catalog-hint loader. Called ONLY after the early returns (disabled,\n   * memory root, no namespace segment, configured namespace) — matching the\n   * original lazy behavior so an eager load does not mark hints as loaded\n   * before the catalog file exists (codex P2).\n   */\n  readonly loadHints?: () => void;\n}\n\n/**\n * Derive the namespace a storage directory belongs to.\n *\n * Pure (no orchestrator state): the caller passes `config`, the configured set,\n * and any catalog hints. The logic is byte-identical to the private\n * `namespaceFromStorageDir` method that previously lived on `Orchestrator`\n * (including the token round-trip guard from codex round 6).\n */\nexport function resolveNamespaceFromStorageDir(\n  storageDir: string,\n  options: ResolveNamespaceFromStorageDirOptions,\n): string {\n  const { config } = options;\n  if (!resolveNamespaceCapabilities(config).namespaces) return config.defaultNamespace;\n  const resolvedStorageDir = path.resolve(storageDir);\n  const resolvedMemoryDir = path.resolve(config.memoryDir);\n  if (resolvedStorageDir === resolvedMemoryDir) return config.defaultNamespace;\n  const m = resolvedStorageDir.match(/[\\\\/]namespaces[\\\\/]([^\\\\/]+)$/);\n  if (!m?.[1]) return config.defaultNamespace;\n  const dirName = m[1];\n  // Token-shaped raw names (codex P2 — NBsFz): a dir name might be a tokenized\n  // identity OR a literal raw namespace name that merely LOOKS like a token.\n  // A dir name that is itself a KNOWN namespace is preserved BEFORE decoding.\n  if (options.configuredNamespaces.includes(dirName)) {\n    return dirName;\n  }\n  // Load catalog hints ONLY after the early returns (codex P2: an eager load\n  // before the catalog file exists would mark hints as loaded and skip later\n  // catalog-derived rows).\n  options.loadHints?.();\n  const hints = options.hints;\n  const hintedNamespaces = hints?.get(resolvedStorageDir);\n  if (hintedNamespaces?.has(dirName)) {\n    return dirName;\n  }\n  if (hintedNamespaces?.size === 1) {\n    const [hintedNamespace] = hintedNamespaces;\n    if (hintedNamespace) return hintedNamespace;\n  }\n  const decoded = namespaceIdentityFromToken(dirName);\n  if (\n    decoded &&\n    (namespaceIdentityToken(decoded) === dirName ||\n      namespaceIdentityLegacyToken(decoded.normalize(\"NFD\")) === dirName)\n  ) {\n    return decoded;\n  }\n  return dirName;\n}\n\n/**\n * Result of resolving a writable namespace: either the authorized namespace\n * or a structured rejection. The caller decides how to surface the rejection\n * (e.g. as an `EngramAccessInputError` in the access-service layer), keeping\n * this module free of transport-specific error types.\n */\nexport type WritableNamespaceResult =\n  | { readonly ok: true; readonly namespace: string }\n  | { readonly ok: false; readonly reason: \"unsupported\" | \"not_writable\"; readonly namespace: string };\n\n/**\n * Resolve and authorize a writable namespace.\n *\n * Combines the three steps that `AccessService.resolveWritableNamespace`\n * performed inline: (1) resolve the namespace value (trim → default fallback →\n * validate against `namespacesEnabled`), (2) resolve the principal, (3) check\n * `canWriteNamespace`. Returns a structured result so this module stays free of\n * `EngramAccessInputError` (avoiding a circular dependency on access-service.ts).\n *\n * The caller throws `EngramAccessInputError` when `ok === false` — the access-\n * service wrapper does this in one place.\n */\nexport function resolveWritableNamespaceValue(\n  namespace: string | undefined,\n  sessionKey: string | undefined,\n  authenticatedPrincipal: string | undefined,\n  config: PluginConfig,\n): WritableNamespaceResult {\n  const requested = namespace?.trim();\n  let resolved: string;\n  if (!requested) {\n    resolved = config.defaultNamespace;\n  } else if (\n    !resolveNamespaceCapabilities(config).namespaces &&\n    requested !== config.defaultNamespace\n  ) {\n    return { ok: false, reason: \"unsupported\", namespace: requested };\n  } else {\n    resolved = requested;\n  }\n\n  const trusted = authenticatedPrincipal?.trim();\n  const principal =\n    typeof trusted === \"string\" && trusted.length > 0\n      ? trusted\n      : resolvePrincipal(sessionKey, config);\n\n  if (!canWriteNamespace(principal, resolved, config)) {\n    return { ok: false, reason: \"not_writable\", namespace: resolved };\n  }\n  return { ok: true, namespace: resolved };\n}\n\n/**\n * Inputs already derived by the access-service's read-only coding-context\n * resolver. Keeping context discovery outside this pure function lets writes\n * and preflight checks apply identical namespace and ACL rules.\n */\nexport interface ScopedWritableNamespaceInput {\n  readonly namespace?: string;\n  readonly sessionKey?: string;\n  readonly authenticatedPrincipal?: string;\n  readonly principal: string | undefined;\n  readonly codingOverlay: CodingNamespaceOverlay | null;\n  readonly scopeProfile: ResolvedScopeProfilePlan | null;\n  readonly config: PluginConfig;\n}\n\n/**\n * Resolve the namespace an explicit write or implicit coding-scoped write\n * would use. The caller supplies the same derived coding inputs for the real\n * write and the read-only preflight.\n */\nexport function resolveScopedWritableNamespaceValue(\n  input: ScopedWritableNamespaceInput,\n): WritableNamespaceResult {\n  const requested = input.namespace?.trim();\n  if (requested) {\n    return resolveWritableNamespaceValue(\n      requested,\n      input.sessionKey,\n      input.authenticatedPrincipal,\n      input.config,\n    );\n  }\n  if (input.scopeProfile) {\n    const selectedLayer = input.scopeProfile.layers.find(\n      (layer) => layer.id === input.scopeProfile?.writeLayer,\n    );\n    const writeNamespaceReadable =\n      input.scopeProfile.writeNamespace.length > 0 &&\n      input.scopeProfile.readNamespaces.includes(input.scopeProfile.writeNamespace);\n    if (!selectedLayer?.writable || !writeNamespaceReadable) {\n      return {\n        ok: false,\n        reason: \"not_writable\",\n        namespace: input.scopeProfile.writeNamespace,\n      };\n    }\n    return { ok: true, namespace: input.scopeProfile.writeNamespace };\n  }\n  if (!input.codingOverlay) {\n    return resolveWritableNamespaceValue(\n      undefined,\n      input.sessionKey,\n      input.authenticatedPrincipal,\n      input.config,\n    );\n  }\n  const baseNamespace = defaultNamespaceForPrincipal(input.principal, input.config);\n  if (!canWriteNamespace(input.principal, baseNamespace, input.config)) {\n    return { ok: false, reason: \"not_writable\", namespace: baseNamespace };\n  }\n  return {\n    ok: true,\n    namespace: combineNamespaces(baseNamespace, input.codingOverlay.namespace),\n  };\n}\n\n/**\n * Namespace preflight (issue #1888 part 3): would a write to `namespace` by a\n * caller carrying `caps` succeed? Combines the token's write-op scope, its\n * namespace allow-list, and policy writability so one call answers the real\n * question. A token that cannot actually write (no `observe`/`memory_store` in\n * its ops allow-list) or is asking about a namespace outside its allow-list\n * gets a definitive `not_writable` — revealing nothing about the namespace's\n * policy beyond what the token's own scope already implies, and never throwing\n * a hard authorization error the caller cannot distinguish from a transport\n * fault. (Unrestricted tokens pass both scope checks unchanged.)\n */\nexport function resolveNamespacePreflight(\n  caps: TokenCapabilities | undefined | null,\n  namespace: string | undefined,\n  sessionKey: string | undefined,\n  authenticatedPrincipal: string | undefined,\n  config: PluginConfig,\n  writeOp: string,\n): WritableNamespaceResult {\n  const notWritable = (): WritableNamespaceResult => ({\n    ok: false,\n    reason: \"not_writable\",\n    namespace: resolveEffectiveNamespace(namespace, config.defaultNamespace) ?? namespace ?? \"\",\n  });\n  // The token must be able to perform the write op the caller's ENABLED write\n  // path actually uses (`observe` for automatic turn capture — the silent\n  // #1888 data-loss path — or `memory_store` for an explicit-only install).\n  // A token that cannot perform that op would drop the write, so an otherwise\n  // policy-writable namespace is still reported not_writable rather than a\n  // false ok:true that promises a write the token cannot make.\n  if (!capabilityAllowsOp(caps, writeOp)) {\n    return notWritable();\n  }\n  if (!isNamespaceAllowed(caps, namespace, config.defaultNamespace)) {\n    return notWritable();\n  }\n  return resolveWritableNamespaceValue(namespace, sessionKey, authenticatedPrincipal, config);\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-4QFCAKNM.js → chunk-RUZM6Z52.js}

@@ -279,4 +279,4 @@ async function searchHarmonicRetrieval(options) {
 export {
   searchHarmonicRetrieval
 };
-//# sourceMappingURL=chunk-4QFCAKNM.js.map
+//# sourceMappingURL=chunk-RUZM6Z52.js.map

package/dist/{chunk-O4TTIMOP.js → chunk-SFR7J2G6.js}

@@ -2,7 +2,7 @@ import {
   SupportPassportError,
   SupportPassportOwnerCreateGrantRequestSchema,
   getOperation
-} from "./chunk-FK7T55BA.js";
+} from "./chunk-CZUHNJHX.js";
 
 // src/support-passport/access-http.ts
 var OWNER_ROOT = "/engram/v1/support-passport";
@@ -137,4 +137,4 @@ export {
   SUPPORT_PASSPORT_OWNER_HTTP_ROUTES,
   handleSupportPassportOwnerHttp
 };
-//# sourceMappingURL=chunk-O4TTIMOP.js.map
+//# sourceMappingURL=chunk-SFR7J2G6.js.map

package/dist/{chunk-ION47U3Z.js → chunk-SNW3YRO6.js}

@@ -4,7 +4,7 @@ import {
 import {
   namespaceIdentityToken,
   normalizeNamespaceIdentity
-} from "./chunk-EGGE52UU.js";
+} from "./chunk-VUFL7X3H.js";
 import {
   resolveNamespaceCapabilities
 } from "./chunk-JUOZ62Y7.js";
@@ -470,4 +470,4 @@ export {
   NamespaceSearchRouter,
   normalizeQmdResultPath
 };
-//# sourceMappingURL=chunk-ION47U3Z.js.map
+//# sourceMappingURL=chunk-SNW3YRO6.js.map

package/dist/{chunk-XL24QQ63.js → chunk-TBUEE7XF.js}

@@ -1,6 +1,6 @@
 import {
   validateRouteTarget
-} from "./chunk-U3PN77QT.js";
+} from "./chunk-PCXDUHQH.js";
 import {
   log
 } from "./chunk-3WCASNQZ.js";
@@ -306,4 +306,4 @@ var RoutingRulesStore = class {
 export {
   RoutingRulesStore
 };
-//# sourceMappingURL=chunk-XL24QQ63.js.map
+//# sourceMappingURL=chunk-TBUEE7XF.js.map

package/dist/{chunk-TAPFJ3ET.js → chunk-U7XLOSG2.js}

@@ -1,10 +1,10 @@
 import {
   SUPPORT_PASSPORT_DRAFT_MAX_CONTENT_CHARACTERS,
   SUPPORT_PASSPORT_DRAFT_MAX_MEMORIES
-} from "./chunk-FK7T55BA.js";
+} from "./chunk-CZUHNJHX.js";
 import {
   SUPPORT_PASSPORT_SOURCE_MEMORY_ID_MAX_LENGTH
-} from "./chunk-XX4HPFFM.js";
+} from "./chunk-XDL5CYZN.js";
 
 // src/support-passport/model-bridge.ts
 import { randomUUID } from "crypto";
@@ -343,4 +343,4 @@ export {
   parseSupportPassportModelJob,
   SupportPassportModelBridge
 };
-//# sourceMappingURL=chunk-TAPFJ3ET.js.map
+//# sourceMappingURL=chunk-U7XLOSG2.js.map

package/dist/{chunk-T3HC7RJ7.js → chunk-USAUBGBC.js}

@@ -4,7 +4,7 @@ import {
 import {
   computeCorpusWatermarks,
   resolveCorpusNamespaceRoots
-} from "./chunk-QZR3WT3L.js";
+} from "./chunk-LJJWFV2Q.js";
 
 // src/operator-doctor-corpus.ts
 var DIGEST_PREFIX_LENGTH = 12;
@@ -78,4 +78,4 @@ export {
   corpusWatermarksFromCheck,
   summarizeCorpusAndReplica
 };
-//# sourceMappingURL=chunk-T3HC7RJ7.js.map
+//# sourceMappingURL=chunk-USAUBGBC.js.map

package/dist/{chunk-TAMY4NKO.js → chunk-USGKHF36.js}

@@ -1,6 +1,6 @@
 import {
   StorageManager
-} from "./chunk-BWJMBJCY.js";
+} from "./chunk-YTZA7U6Q.js";
 import {
   getCachedRuleMemories,
   setCachedRuleMemories
@@ -119,4 +119,4 @@ export {
   compareVerifiedSemanticRuleResults,
   searchVerifiedSemanticRules
 };
-//# sourceMappingURL=chunk-TAMY4NKO.js.map
+//# sourceMappingURL=chunk-USGKHF36.js.map

package/dist/{chunk-XRPPHIRI.js → chunk-VUDALPI5.js}

@@ -1,6 +1,6 @@
 import {
   summarizeReconcilePlan
-} from "./chunk-KJH6W2I7.js";
+} from "./chunk-L3CHRBHE.js";
 import {
   DEFAULT_CITATION_FORMAT,
   stripCitationForTemplate
@@ -284,4 +284,4 @@ export {
   buildReconcileManifest,
   collapseActiveFactDuplicates
 };
-//# sourceMappingURL=chunk-XRPPHIRI.js.map
+//# sourceMappingURL=chunk-VUDALPI5.js.map

package/dist/{chunk-EGGE52UU.js → chunk-VUFL7X3H.js}

@@ -1,13 +1,18 @@
 // src/namespaces/identity.ts
 function normalizeNamespaceIdentity(namespace) {
-  return namespace?.trim() ?? "";
+  return namespace?.trim().normalize("NFC") ?? "";
 }
-function namespaceIdentityToken(namespace) {
-  const normalized = normalizeNamespaceIdentity(namespace);
-  const bytes = new TextEncoder().encode(normalized);
+function encodeNamespaceIdentityToken(namespace) {
+  const bytes = new TextEncoder().encode(namespace);
   const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
   return `ns-${hex || "default"}`;
 }
+function namespaceIdentityToken(namespace) {
+  return encodeNamespaceIdentityToken(normalizeNamespaceIdentity(namespace));
+}
+function namespaceIdentityLegacyToken(namespace) {
+  return encodeNamespaceIdentityToken(namespace.trim());
+}
 function namespaceIdentityFromToken(token) {
   if (!token.startsWith("ns-")) return null;
   const hex = token.slice(3);
@@ -16,12 +21,14 @@ function namespaceIdentityFromToken(token) {
     return null;
   }
   const decoded = Buffer.from(hex, "hex").toString("utf8");
-  return namespaceIdentityToken(decoded).toLowerCase() === token.toLowerCase() ? decoded : null;
+  const normalized = normalizeNamespaceIdentity(decoded);
+  return namespaceIdentityToken(decoded).toLowerCase() === token.toLowerCase() || namespaceIdentityLegacyToken(decoded).toLowerCase() === token.toLowerCase() ? normalized : null;
 }
 
 export {
   normalizeNamespaceIdentity,
   namespaceIdentityToken,
+  namespaceIdentityLegacyToken,
   namespaceIdentityFromToken
 };
-//# sourceMappingURL=chunk-EGGE52UU.js.map
+//# sourceMappingURL=chunk-VUFL7X3H.js.map

package/dist/chunk-VUFL7X3H.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/namespaces/identity.ts"],"sourcesContent":["export function normalizeNamespaceIdentity(namespace: string | null | undefined): string {\n  return namespace?.trim().normalize(\"NFC\") ?? \"\";\n}\n\nfunction encodeNamespaceIdentityToken(namespace: string): string {\n  const bytes = new TextEncoder().encode(namespace);\n  const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, \"0\")).join(\"\");\n  return `ns-${hex || \"default\"}`;\n}\n\nexport function namespaceIdentityToken(namespace: string): string {\n  return encodeNamespaceIdentityToken(normalizeNamespaceIdentity(namespace));\n}\n\nexport function namespaceIdentityLegacyToken(namespace: string): string {\n  return encodeNamespaceIdentityToken(namespace.trim());\n}\n\nexport function namespaceIdentityFromToken(token: string): string | null {\n  if (!token.startsWith(\"ns-\")) return null;\n  const hex = token.slice(3);\n  if (hex === \"default\") return \"\";\n  if (hex.length === 0 || hex.length % 2 !== 0 || !/^[0-9a-f]+$/i.test(hex)) {\n    return null;\n  }\n  const decoded = Buffer.from(hex, \"hex\").toString(\"utf8\");\n  const normalized = normalizeNamespaceIdentity(decoded);\n  return namespaceIdentityToken(decoded).toLowerCase() === token.toLowerCase() ||\n    namespaceIdentityLegacyToken(decoded).toLowerCase() === token.toLowerCase()\n    ? normalized\n    : null;\n}\n"],"mappings":";AAAO,SAAS,2BAA2B,WAA8C;AACvF,SAAO,WAAW,KAAK,EAAE,UAAU,KAAK,KAAK;AAC/C;AAEA,SAAS,6BAA6B,WAA2B;AAC/D,QAAM,QAAQ,IAAI,YAAY,EAAE,OAAO,SAAS;AAChD,QAAM,MAAM,MAAM,KAAK,OAAO,CAAC,SAAS,KAAK,SAAS,EAAE,EAAE,SAAS,GAAG,GAAG,CAAC,EAAE,KAAK,EAAE;AACnF,SAAO,MAAM,OAAO,SAAS;AAC/B;AAEO,SAAS,uBAAuB,WAA2B;AAChE,SAAO,6BAA6B,2BAA2B,SAAS,CAAC;AAC3E;AAEO,SAAS,6BAA6B,WAA2B;AACtE,SAAO,6BAA6B,UAAU,KAAK,CAAC;AACtD;AAEO,SAAS,2BAA2B,OAA8B;AACvE,MAAI,CAAC,MAAM,WAAW,KAAK,EAAG,QAAO;AACrC,QAAM,MAAM,MAAM,MAAM,CAAC;AACzB,MAAI,QAAQ,UAAW,QAAO;AAC9B,MAAI,IAAI,WAAW,KAAK,IAAI,SAAS,MAAM,KAAK,CAAC,eAAe,KAAK,GAAG,GAAG;AACzE,WAAO;AAAA,EACT;AACA,QAAM,UAAU,OAAO,KAAK,KAAK,KAAK,EAAE,SAAS,MAAM;AACvD,QAAM,aAAa,2BAA2B,OAAO;AACrD,SAAO,uBAAuB,OAAO,EAAE,YAAY,MAAM,MAAM,YAAY,KACzE,6BAA6B,OAAO,EAAE,YAAY,MAAM,MAAM,YAAY,IACxE,aACA;AACN;","names":[]}

package/dist/{chunk-HC55YCNK.js → chunk-VYIXCMUP.js}

@@ -4,13 +4,13 @@ import {
 } from "./chunk-KSXJOC4F.js";
 import {
   StorageManager
-} from "./chunk-BWJMBJCY.js";
+} from "./chunk-YTZA7U6Q.js";
 import {
   excludeSupportPassportPrivateMemories
-} from "./chunk-XX4HPFFM.js";
+} from "./chunk-XDL5CYZN.js";
 import {
   isSafeRouteNamespace
-} from "./chunk-U3PN77QT.js";
+} from "./chunk-PCXDUHQH.js";
 import {
   log
 } from "./chunk-3WCASNQZ.js";
@@ -138,4 +138,4 @@ export {
   runCodexMaterialize,
   runPostConsolidationMaterialize
 };
-//# sourceMappingURL=chunk-HC55YCNK.js.map
+//# sourceMappingURL=chunk-VYIXCMUP.js.map