@remnic/core 9.57.4 → 9.57.6

package/src/routing/engine.test.ts

@@ -0,0 +1,30 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { isSafeRouteNamespace, validateRouteTarget } from "./engine.js";
+
+test("isSafeRouteNamespace accepts Unicode letters and NFC-normalizes before validation", () => {
+  assert.equal(isSafeRouteNamespace("项目"), true);
+  assert.equal(isSafeRouteNamespace("Cafe\u0301"), true);
+  assert.equal(isSafeRouteNamespace("a1._-"), true);
+  assert.equal(isSafeRouteNamespace("a".repeat(64)), true);
+  assert.equal(isSafeRouteNamespace("a".repeat(65)), false);
+  assert.equal(isSafeRouteNamespace("界".repeat(42)), true);
+  assert.equal(isSafeRouteNamespace("界".repeat(43)), false);
+
+  const target = validateRouteTarget({ namespace: "Cafe\u0301" }, { allowedNamespaces: ["Café"] });
+  assert.deepEqual(target, {
+    ok: true,
+    target: { namespace: "Café" },
+  });
+  assert.equal(
+    validateRouteTarget({ namespace: "Café" }, { allowedNamespaces: [" Café "] }).ok,
+    true,
+  );
+});
+
+test("isSafeRouteNamespace rejects traversal, controls, bidi overrides, and edge whitespace", () => {
+  for (const unsafe of ["../escape", "a/b", "a\\b", "a\u0000b", "a\u202Eb", " name", "name ", ".."]) {
+    assert.equal(isSafeRouteNamespace(unsafe), false, JSON.stringify(unsafe));
+  }
+});

package/src/routing/engine.ts

@@ -1,3 +1,4 @@
+import { namespaceIdentityToken } from "../namespaces/identity.js";
 import type { MemoryCategory } from "../types.js";
 
 export type RoutePatternType = "regex" | "keyword";
@@ -43,9 +44,11 @@ const DEFAULT_CATEGORIES: readonly MemoryCategory[] = [
 ] as const;
 
 function normalizeNamespace(namespace: string): string {
-  return namespace.trim();
+  return namespace.normalize("NFC");
 }
 
+const SAFE_ROUTE_NAMESPACE_CHARS = /^[\p{L}\p{M}\p{N}._-]+$/u;
+
 export function isLikelyUnsafeRegex(pattern: string): boolean {
   const value = pattern.trim();
   if (value.length === 0) return true;
@@ -65,11 +68,17 @@ export function isLikelyUnsafeRegex(pattern: string): boolean {
 
 export function isSafeRouteNamespace(namespace: string): boolean {
   const value = normalizeNamespace(namespace);
+  // The route limit is 64 Unicode code points. On-disk identity tokens may
+  // exceed 64 characters because namespaceIdentityToken hex-encodes UTF-8.
+  // A route can use at most 64 code points, but the reversible on-disk token
+  // must also fit one filesystem component (255 characters).
   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);
 }
 
 export function validateRouteTarget(target: RouteTarget | null | undefined, options?: RoutingEngineOptions): {
@@ -83,7 +92,7 @@ export function validateRouteTarget(target: RouteTarget | null | undefined, opti
 
   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))
+    ? new Set(options.allowedNamespaces.map((v) => normalizeNamespace(v.trim())).filter((v) => v.length > 0))
     : null;
 
   const normalized: RouteTarget = {};

package/src/scopes/scope-plan.ts

@@ -41,7 +41,9 @@ import {
 } from "../namespaces/principal.js";
 import {
   namespaceIdentityFromToken,
+  namespaceIdentityLegacyToken,
   namespaceIdentityToken,
+  normalizeNamespaceIdentity,
 } from "../namespaces/identity.js";
 import path from "node:path";
 import {
@@ -359,7 +361,7 @@ export function getConfiguredNamespaces(config: PluginConfig): string[] {
         config.sharedNamespace,
         ...config.namespacePolicies.map((policy) => policy.name),
       ]
-        .map((value) => value.trim())
+        .map((value) => normalizeNamespaceIdentity(value))
         .filter(Boolean),
     ),
   );
@@ -430,7 +432,11 @@ export function resolveNamespaceFromStorageDir(
     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;

package/src/semantic-chunking.ts

@@ -6,7 +6,13 @@
  * natural topic boundaries, producing more coherent chunks.
  */
 
-import { chunkContent, type Chunk, type ChunkResult } from "./chunking.js";
+import {
+  chunkContent,
+  joinSentences,
+  splitSentences,
+  type Chunk,
+  type ChunkResult,
+} from "./chunking.js";
 
 // ---------------------------------------------------------------------------
 // Configuration
@@ -177,50 +183,6 @@ export function findLocalMinima(
 }
 
 // ---------------------------------------------------------------------------
-// Sentence tokenizer
-// ---------------------------------------------------------------------------
-
-/**
- * Split text into sentences at punctuation boundaries.
- * Preserves punctuation with the preceding sentence.
- */
-function splitSentences(text: string): string[] {
-  // Linear character scan instead of a regex. Every regex form of this split is
-  // either polynomial (CodeQL js/polynomial-redos) or — once bounded/anchored to
-  // satisfy CodeQL — mishandles long runs or interior punctuation (a global
-  // match drops a skipped prefix; a sticky match stops at the first non-boundary
-  // `.`, e.g. "v1.2.3" / "example.com", returning the whole document as one
-  // sentence and bypassing chunking). The scan is O(n), drops nothing, and
-  // handles interior punctuation correctly; normal prose splits identically to
-  // the previous /[^.!?]*[.!?]+(?:\s+|$)/g form.
-  const sentences: string[] = [];
-  let start = 0;
-  for (let i = 0; i < text.length; i++) {
-    const ch = text[i];
-    if (ch !== "." && ch !== "!" && ch !== "?") continue;
-    let end = i;
-    while (end + 1 < text.length) {
-      const n = text[end + 1];
-      if (n !== "." && n !== "!" && n !== "?") break;
-      end++;
-    }
-    const after = text[end + 1];
-    // A real boundary only if the terminator run ends the string or is followed
-    // by whitespace. Interior punctuation (no following whitespace) is left in
-    // place and the scan continues.
-    if (after === undefined || /\s/.test(after)) {
-      const sentence = text.slice(start, end + 1).trim();
-      if (sentence.length > 0) sentences.push(sentence);
-      start = end + 1;
-    }
-    i = end;
-  }
-  if (start < text.length) {
-    const remaining = text.slice(start).trim();
-    if (remaining.length > 0) sentences.push(remaining);
-  }
-  return sentences;
-}
 
 // ---------------------------------------------------------------------------
 // Token estimation
@@ -316,7 +278,7 @@ function mergeShortSegments(
 
   for (let i = 0; i < segments.length; i++) {
     buffer = [...buffer, ...segments[i]];
-    const tokenCount = estimateTokens(buffer.join(" "));
+    const tokenCount = estimateTokens(joinSentences(buffer));
 
     if (tokenCount >= minTokens || i === segments.length - 1) {
       merged.push(buffer);
@@ -344,7 +306,7 @@ function splitLongSegment(
   maxTokens: number,
   targetTokens: number,
 ): SemanticChunk[] {
-  const text = segment.join(" ");
+  const text = joinSentences(segment);
   // Cap targetTokens to maxTokens so recursive splitting never produces
   // segments larger than the configured maximum (Finding 2, PR #420).
   const cappedTarget = Math.min(targetTokens, maxTokens);
@@ -511,7 +473,7 @@ export async function semanticChunkContent(
 
   for (let segIdx = 0; segIdx < segments.length; segIdx++) {
     const segment = segments[segIdx];
-    const segText = segment.join(" ");
+    const segText = joinSentences(segment);
     const segTokens = estimateTokens(segText);
 
     if (segTokens > cfg.maxTokens) {

package/src/storage-contract/namespace-routing.test.ts

@@ -19,7 +19,7 @@ import path from "node:path";
 import test from "node:test";
 
 import { makeStorage, makeNamespaceRouter, resetStaticCaches } from "./harness.js";
-import { resolveNamespaceStorageRoot } from "../namespaces/storage.js";
+import { NamespaceStorageRouter, resolveNamespaceStorageRoot } from "../namespaces/storage.js";
 import { namespaceIdentityToken } from "../namespaces/identity.js";
 import { getCachedMemories } from "../memory-cache.js";
 
@@ -158,3 +158,20 @@ test("namespace-routing: hotMemoriesCacheEnabled=false propagates to namespace c
     await cleanup();
   }
 });
+
+test("namespace-routing: CJK namespace round-trips through storage", async () => {
+  const { router, memoryDir, config, cleanup } = await makeNamespaceRouter();
+  try {
+    const namespace = "项目";
+    const token = namespaceIdentityToken(namespace);
+    const writer = await router.storageFor(namespace);
+    const written = await writer.writeMemory("fact", "CJK namespace fact");
+    assert.equal(writer.dir, path.join(memoryDir, "namespaces", token));
+
+    const reader = await new NamespaceStorageRouter(config).storageFor(namespace);
+    assert.equal(reader.dir, writer.dir);
+    assert.equal((await reader.getMemoryById(written.id))?.content, "CJK namespace fact");
+  } finally {
+    await cleanup();
+  }
+});

package/dist/chunk-CMRUIKVA.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/namespaces/scope-profiles.ts"],"sourcesContent":["import { resolveNamespaceCapabilities } from \"../capabilities.js\";\nimport { createHash } from \"node:crypto\";\n\nimport { combineNamespaces, type CodingNamespaceOverlay } from \"../coding/coding-namespace.js\";\nimport { stableHash } from \"../coding/git-context.js\";\nimport { isSafeRouteNamespace } from \"../routing/engine.js\";\nimport type {\n  CodingContext,\n  PluginConfig,\n  ScopeProfileConfig,\n  ScopeProfileLayerId,\n  ScopeProfilePromotionTarget,\n  ScopeTeamConfig,\n} from \"../types.js\";\nimport { canReadNamespace, canWriteNamespace, defaultNamespaceForPrincipal } from \"./principal.js\";\n\ntype ScopeProfileCodingOverlay = Pick<CodingNamespaceOverlay, \"namespace\" | \"readFallbacks\">;\n\nexport interface ScopeProfileLayerResolution {\n  id: ScopeProfileLayerId;\n  kind: \"user-project\" | \"team-project\" | \"user-global\" | \"server-shared\";\n  namespace?: string;\n  readable: boolean;\n  writable: boolean;\n  promotable: boolean;\n  reason: string;\n}\n\nexport interface ScopeProfilePromotionResolution {\n  target: ScopeProfilePromotionTarget;\n  namespace?: string;\n  authorized: boolean;\n  reason: string;\n}\n\nexport interface ResolvedScopeProfilePlan {\n  profileId: string;\n  profile: ScopeProfileConfig;\n  baseNamespace: string;\n  writeLayer: ScopeProfileLayerId;\n  writeNamespace: string;\n  readNamespaces: string[];\n  layers: ScopeProfileLayerResolution[];\n  promotionTargets: ScopeProfilePromotionResolution[];\n  warnings: string[];\n}\n\nexport interface ResolveScopeProfilePlanOptions {\n  config: PluginConfig;\n  principal?: string;\n  codingContext?: CodingContext | null;\n  codingOverlay?: ScopeProfileCodingOverlay | null;\n}\n\nfunction activeScopeProfile(config: PluginConfig): { profileId: string; profile: ScopeProfileConfig } | null {\n  const profileId = config.defaultScopeProfile;\n  if (!profileId) return null;\n  const profile = (config.scopeProfiles ?? {})[profileId];\n  return profile ? { profileId, profile } : null;\n}\n\nfunction principalListed(list: string[], principal: string | undefined): boolean {\n  if (!principal) return false;\n  return list.includes(principal) || list.includes(\"*\");\n}\n\nfunction derivedScopeProfileSelfNamespace(principal: string | undefined, config: PluginConfig): string | null {\n  if (!principal || principal === config.defaultNamespace || principal === config.sharedNamespace) return null;\n  if (isSafeRouteNamespace(principal)) return principal;\n  return \"principal-\" + createHash(\"sha256\").update(principal).digest(\"hex\").slice(0, 54);\n}\n\nfunction scopeProfileSelfNamespace(principal: string | undefined, config: PluginConfig): string {\n  const existing = defaultNamespaceForPrincipal(principal, config);\n  if (existing !== config.defaultNamespace) return existing;\n  return derivedScopeProfileSelfNamespace(principal, config) ?? existing;\n}\n\nfunction hasExplicitNamespacePolicy(namespace: string, config: PluginConfig): boolean {\n  return (config.namespacePolicies ?? []).some((policy) => policy.name === namespace);\n}\n\nfunction isScopeProfileImplicitSelfNamespace(\n  principal: string | undefined,\n  namespace: string,\n  config: PluginConfig,\n): boolean {\n  const derived = derivedScopeProfileSelfNamespace(principal, config);\n  return Boolean(\n    derived &&\n      namespace === derived &&\n      namespace !== config.defaultNamespace &&\n      namespace !== config.sharedNamespace &&\n      isSafeRouteNamespace(namespace) &&\n      !hasExplicitNamespacePolicy(namespace, config),\n  );\n}\n\nfunction canReadScopeProfileNamespace(\n  principal: string | undefined,\n  namespace: string,\n  config: PluginConfig,\n): boolean {\n  return isScopeProfileImplicitSelfNamespace(principal, namespace, config) || canReadNamespace(principal, namespace, config);\n}\n\nfunction canWriteScopeProfileNamespace(\n  principal: string | undefined,\n  namespace: string,\n  config: PluginConfig,\n): boolean {\n  return isScopeProfileImplicitSelfNamespace(principal, namespace, config) || canWriteNamespace(principal, namespace, config);\n}\n\nfunction resolveTeam(\n  config: PluginConfig,\n  profile: ScopeProfileConfig,\n  principal: string | undefined,\n): { teamId: string; team: ScopeTeamConfig } | null {\n  const configuredTeamId = profile.teamProject?.teamId;\n  if (configuredTeamId) {\n    const configured = (config.teams ?? {})[configuredTeamId];\n    return configured ? { teamId: configuredTeamId, team: configured } : null;\n  }\n  const readableTeams = Object.entries(config.teams ?? {}).filter(([, team]) =>\n    principalListed(team.principals, principal) || principalListed(team.read, principal),\n  );\n  const needsWritableTeam = profile.writeDefault === \"teamProject\" || profile.readOrder.includes(\"teamProject\");\n  if (needsWritableTeam) {\n    const writableTeam = readableTeams.find(([, team]) => principalListed(team.write, principal));\n    if (writableTeam) return { teamId: writableTeam[0], team: writableTeam[1] };\n  }\n  const needsPromotableTeam =\n    profile.promotionTargets.includes(\"teamProject\") || profile.autoPromote.targets.includes(\"teamProject\");\n  if (needsPromotableTeam) {\n    const promotableTeam = readableTeams.find(\n      ([, team]) => principalListed(team.promote, principal) || principalListed(team.write, principal),\n    );\n    if (promotableTeam) return { teamId: promotableTeam[0], team: promotableTeam[1] };\n  }\n  const firstReadableTeam = readableTeams[0];\n  return firstReadableTeam\n    ? { teamId: firstReadableTeam[0], team: firstReadableTeam[1] }\n    : null;\n}\n\nfunction renderTeamProjectNamespace(params: {\n  template: string;\n  teamId: string;\n  principal: string | undefined;\n  codingContext: CodingContext;\n  codingOverlay: ScopeProfileCodingOverlay;\n}): { namespace: string; unknownPlaceholders: string[] } {\n  const replacements: Record<string, string> = {\n    teamId: params.teamId,\n    principal: params.principal ?? \"anonymous\",\n    projectId: params.codingContext.projectId,\n    projectHash: stableHash(params.codingContext.projectId),\n    projectNamespace: params.codingOverlay.namespace,\n  };\n  const unknownPlaceholders: string[] = [];\n  const namespace = params.template.replace(/\\{([A-Za-z][A-Za-z0-9]*)\\}/g, (match, key: string) => {\n    const replacement = replacements[key];\n    if (replacement !== undefined) return replacement;\n    if (!unknownPlaceholders.includes(key)) unknownPlaceholders.push(key);\n    return match;\n  });\n  return { namespace, unknownPlaceholders };\n}\n\nfunction resolveLayer(params: {\n  id: ScopeProfileLayerId;\n  config: PluginConfig;\n  profile: ScopeProfileConfig;\n  principal: string | undefined;\n  baseNamespace: string;\n  codingContext: CodingContext | null | undefined;\n  codingOverlay: ScopeProfileCodingOverlay | null | undefined;\n}): ScopeProfileLayerResolution {\n  const { id, config, profile, principal, baseNamespace, codingContext, codingOverlay } = params;\n  if (id === \"userGlobal\") {\n    return {\n      id,\n      kind: \"user-global\",\n      namespace: baseNamespace,\n      readable: canReadScopeProfileNamespace(principal, baseNamespace, config),\n      writable: canWriteScopeProfileNamespace(principal, baseNamespace, config),\n      promotable: canWriteScopeProfileNamespace(principal, baseNamespace, config),\n      reason: \"principal self/global namespace\",\n    };\n  }\n  if (id === \"serverShared\") {\n    return {\n      id,\n      kind: \"server-shared\",\n      namespace: config.sharedNamespace,\n      readable: canReadNamespace(principal, config.sharedNamespace, config),\n      writable: canWriteNamespace(principal, config.sharedNamespace, config),\n      promotable: canWriteNamespace(principal, config.sharedNamespace, config),\n      reason: \"configured shared namespace\",\n    };\n  }\n  if (id === \"userProject\") {\n    if (!codingContext || !codingOverlay) {\n      return {\n        id,\n        kind: \"user-project\",\n        readable: false,\n        writable: false,\n        promotable: false,\n        reason: \"missing project context\",\n      };\n    }\n    const namespace = combineNamespaces(baseNamespace, codingOverlay.namespace);\n    const explicitProjectPolicy = hasExplicitNamespacePolicy(namespace, config);\n    const baseReadable = canReadScopeProfileNamespace(principal, baseNamespace, config);\n    const baseWritable = canWriteScopeProfileNamespace(principal, baseNamespace, config);\n    const projectReadable = explicitProjectPolicy\n      ? canReadNamespace(principal, namespace, config)\n      : baseReadable;\n    const projectWritable = explicitProjectPolicy\n      ? canWriteNamespace(principal, namespace, config)\n      : baseWritable;\n    return {\n      id,\n      kind: \"user-project\",\n      namespace,\n      readable: projectReadable,\n      writable: projectWritable,\n      promotable: projectWritable,\n      reason: explicitProjectPolicy\n        ? \"explicit user-project namespace policy\"\n        : baseReadable || baseWritable\n          ? \"principal project namespace derived from coding context\"\n          : \"principal base namespace is not authorized\",\n    };\n  }\n  const team = resolveTeam(config, profile, principal);\n  if (!team) {\n    return {\n      id,\n      kind: \"team-project\",\n      readable: false,\n      writable: false,\n      promotable: false,\n      reason: \"no authorized team mapping\",\n    };\n  }\n  if (!codingContext || !codingOverlay) {\n    return {\n      id,\n      kind: \"team-project\",\n      readable: false,\n      writable: false,\n      promotable: false,\n      reason: \"missing project context\",\n    };\n  }\n  const template =\n    profile.teamProject?.namespaceTemplate ??\n    team.team.projectNamespaceTemplate ??\n    \"team-{teamId}-project-{projectHash}\";\n  const renderedNamespace = renderTeamProjectNamespace({\n    template,\n    teamId: team.teamId,\n    principal,\n    codingContext,\n    codingOverlay,\n  });\n  const namespace = renderedNamespace.namespace.trim();\n  if (renderedNamespace.unknownPlaceholders.length > 0) {\n    return {\n      id,\n      kind: \"team-project\",\n      namespace,\n      readable: false,\n      writable: false,\n      promotable: false,\n      reason: `unknown team-project namespace template placeholder(s): ${renderedNamespace.unknownPlaceholders.join(\", \")}`,\n    };\n  }\n  if (!namespace || !isSafeRouteNamespace(namespace)) {\n    return {\n      id,\n      kind: \"team-project\",\n      namespace,\n      readable: false,\n      writable: false,\n      promotable: false,\n      reason: \"team-project namespace template resolved to an unsafe namespace\",\n    };\n  }\n  const teamReadable = principalListed(team.team.read, principal) || principalListed(team.team.principals, principal);\n  const teamWritable = principalListed(team.team.write, principal);\n  const teamPromotable = principalListed(team.team.promote, principal) || principalListed(team.team.write, principal);\n  const userProjectSuffix = `-${codingOverlay.namespace}`;\n  const userProjectBase = namespace.endsWith(userProjectSuffix)\n    ? namespace.slice(0, -userProjectSuffix.length)\n    : \"\";\n  const dynamicUserProjectCollision =\n    userProjectBase.length > 0 &&\n    (userProjectBase === config.defaultNamespace ||\n      userProjectBase === config.sharedNamespace ||\n      (config.namespacePolicies ?? []).some((policy) => policy.name === userProjectBase));\n  const protectedNamespace =\n    namespace === config.defaultNamespace ||\n    namespace === config.sharedNamespace ||\n    dynamicUserProjectCollision ||\n    (config.namespacePolicies ?? []).some((policy) => policy.name === namespace);\n  const policyReadable = !protectedNamespace || canReadNamespace(principal, namespace, config);\n  const policyWritable = !protectedNamespace || canWriteNamespace(principal, namespace, config);\n  const policyBlocked = protectedNamespace && (!policyReadable || !policyWritable);\n  return {\n    id,\n    kind: \"team-project\",\n    namespace,\n    readable: teamReadable && policyReadable,\n    writable: teamWritable && policyWritable,\n    promotable: teamPromotable && policyWritable,\n    reason: policyBlocked\n      ? \"team-project namespace collides with a protected namespace policy\"\n      : \"trusted team-project namespace derived from team and project config\",\n  };\n}\n\nexport function resolveScopeProfilePlan(\n  options: ResolveScopeProfilePlanOptions,\n): ResolvedScopeProfilePlan | null {\n  const active = activeScopeProfile(options.config);\n  if (!active || !resolveNamespaceCapabilities(options.config).namespaces) return null;\n\n  const baseNamespace = scopeProfileSelfNamespace(options.principal, options.config);\n  const layerIds = Array.from(\n    new Set<ScopeProfileLayerId>([\n      ...active.profile.readOrder,\n      active.profile.writeDefault,\n      \"userGlobal\",\n      ...active.profile.promotionTargets.filter((target): target is ScopeProfileLayerId =>\n        [\"userProject\", \"teamProject\", \"userGlobal\", \"serverShared\"].includes(target),\n      ),\n    ]),\n  );\n  const layerMap = new Map<ScopeProfileLayerId, ScopeProfileLayerResolution>();\n  for (const id of layerIds) {\n    layerMap.set(\n      id,\n      resolveLayer({\n        id,\n        config: options.config,\n        profile: active.profile,\n        principal: options.principal,\n        baseNamespace,\n        codingContext: options.codingContext,\n        codingOverlay: options.codingOverlay,\n      }),\n    );\n  }\n\n  const readNamespaces: string[] = [];\n  for (const id of active.profile.readOrder) {\n    const layer = layerMap.get(id);\n    if (layer?.readable && layer.namespace && !readNamespaces.includes(layer.namespace)) {\n      readNamespaces.push(layer.namespace);\n    }\n  }\n\n  const preferredWriteLayer = layerMap.get(active.profile.writeDefault);\n  const readableWriteLayers = active.profile.readOrder\n    .map((id) => layerMap.get(id))\n    .filter(\n      (layer): layer is ScopeProfileLayerResolution =>\n        Boolean(layer?.writable && layer.namespace && readNamespaces.includes(layer.namespace)),\n    );\n  const fallbackWriteLayer =\n    preferredWriteLayer?.writable &&\n    preferredWriteLayer.namespace &&\n    readNamespaces.includes(preferredWriteLayer.namespace)\n      ? preferredWriteLayer\n      : readableWriteLayers[0];\n  const warnings: string[] = [];\n  if (!fallbackWriteLayer?.namespace) {\n    warnings.push(`scope profile ${active.profileId} has no writable layer inside the profile read stack; writes disabled`);\n  } else if (fallbackWriteLayer.id !== active.profile.writeDefault) {\n    warnings.push(\n      `scope profile ${active.profileId} writeDefault ${active.profile.writeDefault} unavailable: ${preferredWriteLayer?.reason ?? \"not resolved\"}`,\n    );\n  }\n\n  const promotionTargets = active.profile.promotionTargets.map((target) => {\n    const layer = layerMap.get(target as ScopeProfileLayerId);\n    if (!layer) {\n      return {\n        target,\n        authorized: false,\n        reason: \"promotion target did not resolve to a profile layer\",\n      };\n    }\n    return {\n      target,\n      namespace: layer.namespace,\n      authorized: layer.promotable && Boolean(layer.namespace),\n      reason: layer.reason,\n    };\n  });\n\n  return {\n    profileId: active.profileId,\n    profile: active.profile,\n    baseNamespace,\n    writeLayer: fallbackWriteLayer?.id ?? active.profile.writeDefault,\n    writeNamespace: fallbackWriteLayer?.namespace ?? \"\",\n    readNamespaces,\n    layers: [...layerMap.values()],\n    promotionTargets,\n    warnings,\n  };\n}\n\nexport function expandScopeProfileReadNamespaces(options: {\n  profilePlan: ResolvedScopeProfilePlan;\n  principalSelfNamespace: string;\n  config: PluginConfig;\n  principal?: string;\n  codingOverlay?: ScopeProfileCodingOverlay | null;\n  legacyRecallNamespaces?: string[];\n}): string[] {\n  if (options.profilePlan.readNamespaces.length === 0) {\n    return [];\n  }\n  const out = [...options.profilePlan.readNamespaces];\n  const add = (namespace: string | undefined): void => {\n    if (namespace && !out.includes(namespace)) out.push(namespace);\n  };\n  const userProjectReadable =\n    options.profilePlan.profile.readOrder.includes(\"userProject\") &&\n    options.profilePlan.layers.some(\n      (layer) => layer.id === \"userProject\" && layer.readable && layer.namespace,\n    );\n  const userGlobalReadable =\n    options.profilePlan.profile.readOrder.includes(\"userGlobal\") &&\n    options.profilePlan.layers.some(\n      (layer) => layer.id === \"userGlobal\" && layer.readable && layer.namespace,\n    );\n  if (userProjectReadable) {\n    for (const fallback of options.codingOverlay?.readFallbacks ?? []) {\n      if (fallback === \"\" && !userGlobalReadable) continue;\n      const fallbackNamespace = combineNamespaces(options.principalSelfNamespace, fallback);\n      if (\n        !hasExplicitNamespacePolicy(fallbackNamespace, options.config) ||\n        canReadScopeProfileNamespace(options.principal, fallbackNamespace, options.config)\n      ) {\n        add(fallbackNamespace);\n      }\n    }\n  }\n  return out;\n}\n"],"mappings":"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","names":["namespace"]}

package/dist/chunk-EGGE52UU.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/namespaces/identity.ts"],"sourcesContent":["export function normalizeNamespaceIdentity(namespace: string | null | undefined): string {\n  return namespace?.trim() ?? \"\";\n}\n\nexport function namespaceIdentityToken(namespace: string): string {\n  const normalized = normalizeNamespaceIdentity(namespace);\n  const bytes = new TextEncoder().encode(normalized);\n  const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, \"0\")).join(\"\");\n  return `ns-${hex || \"default\"}`;\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  return namespaceIdentityToken(decoded).toLowerCase() === token.toLowerCase()\n    ? decoded\n    : null;\n}\n"],"mappings":";AAAO,SAAS,2BAA2B,WAA8C;AACvF,SAAO,WAAW,KAAK,KAAK;AAC9B;AAEO,SAAS,uBAAuB,WAA2B;AAChE,QAAM,aAAa,2BAA2B,SAAS;AACvD,QAAM,QAAQ,IAAI,YAAY,EAAE,OAAO,UAAU;AACjD,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,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,SAAO,uBAAuB,OAAO,EAAE,YAAY,MAAM,MAAM,YAAY,IACvE,UACA;AACN;","names":[]}

package/dist/chunk-IGWVMA4Y.js.map

@@ -1 +0,0 @@
-{"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\";\n\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 policy = config.namespacePolicies.find((p) => p.name === namespace);\n  if (!policy) return namespace === config.defaultNamespace || namespace === config.sharedNamespace;\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 policy = config.namespacePolicies.find((p) => p.name === namespace);\n  if (!policy) return namespace === 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 policy = config.namespacePolicies.find((p) => p.name === namespace);\n  if (!policy) return namespace === 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 exists = config.namespacePolicies.some((p) => p.name === principal);\n  return exists ? principal : 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-JFPZEWY3.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/namespaces/storage.ts"],"sourcesContent":["import { resolveNamespaceCapabilities, resolveRecallAuxiliaryCapabilities } from \"../capabilities.js\";\nimport path from \"node:path\";\nimport { access, lstat, readdir } from \"node:fs/promises\";\nimport { isSafeRouteNamespace } from \"../routing/engine.js\";\nimport { StorageManager } from \"../storage.js\";\nimport { keyring, secureStoreDir } from \"../secure-store/index.js\";\nimport type { PluginConfig } from \"../types.js\";\nimport { ALL_CATEGORY_DIRS } from \"../utils/category-dir.js\";\nimport { namespaceIdentityToken, normalizeNamespaceIdentity } from \"./identity.js\";\nimport type { NamespaceCatalog } from \"./catalog.js\";\nimport { MutationSerializer } from \"../utils/serialize-mutations.js\";\n\nasync function exists(p: string): Promise<boolean> {\n  try {\n    await access(p);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\nasync function hasStoredEntries(p: string): Promise<boolean> {\n  try {\n    const entry = await lstat(p);\n    if (entry.isSymbolicLink()) return true;\n    if (!entry.isDirectory()) return true;\n    const children = await readdir(p, { withFileTypes: true });\n    for (const child of children) {\n      const childPath = path.join(p, child.name);\n      if (child.isSymbolicLink() || child.isFile()) return true;\n      if (child.isDirectory() && (await hasStoredEntries(childPath))) return true;\n    }\n    return false;\n  } catch {\n    return false;\n  }\n}\n\n// Build a per-namespace directory under `<memoryDir>/namespaces` and assert the\n// resolved path stays inside that base. Namespace identifiers can originate from\n// operator config (config.defaultNamespace) and request-derived routing, so this\n// containment check prevents directory traversal (CodeQL js/path-injection).\n// For safe segments this returns exactly `path.join(base, segment)`, so there is\n// no behavioral change for valid namespaces.\nfunction resolveNamespaceDir(memoryDir: string, segment: string): string {\n  // Mirror isSafeRouteNamespace's separator/parent-ref rejection (without its\n  // 64-char cap, so identity tokens still pass). Rejecting separators and \"..\"\n  // up front keeps the value a single contained child of <memoryDir>/namespaces.\n  if (\n    segment.length === 0 ||\n    segment.includes(\"/\") ||\n    segment.includes(\"\\\\\") ||\n    segment.includes(\"..\") ||\n    path.isAbsolute(segment)\n  ) {\n    throw new Error(`unsafe namespace path segment: ${segment}`);\n  }\n  return path.join(memoryDir, \"namespaces\", segment);\n}\n\nconst LEGACY_NAMESPACE_CONTENT_CHILDREN = [\n  ...ALL_CATEGORY_DIRS,\n  \"entities\",\n  \"artifacts\",\n  \"identity\",\n  \"config\",\n  \"summaries\",\n  \"profile.md\",\n] as const;\n\nconst LEGACY_NAMESPACE_RUNTIME_CHILDREN = [\"state\"] as const;\n\nasync function hasAnyLegacyData(\n  rootDir: string,\n  options: { includeRuntimeState?: boolean } = {},\n): Promise<boolean> {\n  const children = options.includeRuntimeState === true\n    ? [...LEGACY_NAMESPACE_CONTENT_CHILDREN, ...LEGACY_NAMESPACE_RUNTIME_CHILDREN]\n    : LEGACY_NAMESPACE_CONTENT_CHILDREN;\n  for (const child of children) {\n    if (await hasStoredEntries(path.join(rootDir, child))) return true;\n  }\n  return false;\n}\n\nasync function hasAnyNamespaceStorageMarker(\n  rootDir: string,\n  options: { includeRuntimeState?: boolean } = {},\n): Promise<boolean> {\n  const children = options.includeRuntimeState === true\n    ? [...LEGACY_NAMESPACE_CONTENT_CHILDREN, ...LEGACY_NAMESPACE_RUNTIME_CHILDREN]\n    : LEGACY_NAMESPACE_CONTENT_CHILDREN;\n  for (const child of children) {\n    if (await exists(path.join(rootDir, child))) return true;\n  }\n  return false;\n}\n\n/**\n * Storage routing for namespaces.\n *\n * Compatibility note:\n * - When namespaces are enabled, existing raw namespace roots are preserved.\n *   New namespace roots use tokenized names under `memoryDir/namespaces/<token>`.\n * - The default namespace continues to use the legacy `memoryDir` root unless the caller\n *   has created `memoryDir/namespaces/<defaultNamespace>` (in which case we use that).\n *\n * This avoids surprising \"lost memories\" when an install flips namespaces on without\n * migrating existing data.\n */\n/**\n * Optional hooks for the storage router. `onResolve` fires whenever a namespace's\n * storage is resolved/created, so a downstream consumer (e.g. the namespace\n * catalog, issue #1499) can register the namespace. The hook MUST NOT throw into\n * the router; the router invokes it defensively and a hook failure never affects\n * storage resolution.\n *\n * The hook MAY return (or resolve to) a boolean indicating whether the\n * registration actually PERSISTED (round 6, codex P2 — NEFoX). When it resolves\n * to `false` (a dropped/no-op registration), the router does NOT mark the\n * (namespace, storageDir) pair as notified, so the next resolve RETRIES it\n * instead of suppressing it forever. A `void`/`undefined` result is treated as\n * success (legacy hooks).\n */\nexport interface NamespaceStorageRouterHooks {\n  onResolve?: (\n    namespace: string,\n    storageDir: string,\n  ) => void | boolean | Promise<void | boolean>;\n}\n\n/**\n * Resolve the runtime storage root for the configured DEFAULT namespace.\n *\n * Shared between the live router (`NamespaceStorageRouter.defaultNamespaceRoot`)\n * and the rebuildable catalog (`NamespaceCatalog.rebuildFromDisk`) so the two\n * can never diverge (CLAUDE.md rule #22/#42 — read & write paths resolve through\n * the same logic). The contract is: while legacy memory data still lives\n * directly under `memoryDir`, the default root stays `memoryDir`; only once the\n * legacy root is empty and a `namespaces/<default|token>` dir holds data does\n * the default migrate into that tokenized/legacy-named dir.\n */\nexport async function resolveDefaultNamespaceRoot(config: PluginConfig): Promise<string> {\n  if (!resolveNamespaceCapabilities(config).namespaces) {\n    return config.memoryDir;\n  }\n\n  // Build the legacy default root from the NORMALIZED (trimmed) name so a\n  // whitespace-padded `defaultNamespace` still finds the live `namespaces/default`\n  // root (NIabe). `storageFor()` classifies the trimmed value as the default, and\n  // the on-disk legacy dir is created under the trimmed name; using the raw spaced\n  // name here would look for `namespaces/<spaced>` and miss the real root, falling\n  // back to memoryDir/tokenized. `namespaceIdentityToken` already normalizes\n  // internally, so the tokenized path is unaffected.\n  const defaultIdentity = normalizeNamespaceIdentity(config.defaultNamespace);\n  const legacyNsDir = resolveNamespaceDir(config.memoryDir, defaultIdentity);\n  const tokenizedNsDir = resolveNamespaceDir(\n    config.memoryDir,\n    namespaceIdentityToken(config.defaultNamespace),\n  );\n  const tokenizedHasData =\n    (await exists(tokenizedNsDir)) &&\n    (await hasAnyNamespaceStorageMarker(tokenizedNsDir, { includeRuntimeState: true }));\n  const nsDir = tokenizedHasData\n    ? tokenizedNsDir\n    : (await exists(legacyNsDir))\n      ? legacyNsDir\n      : tokenizedNsDir;\n  return (await exists(nsDir)) && !(await hasAnyLegacyData(config.memoryDir))\n    ? nsDir\n    : config.memoryDir;\n}\n\n/**\n * Resolve the runtime storage root for ANY namespace exactly as the live router\n * would (`NamespaceStorageRouter.namespaceRoot`). Shared so the rebuildable\n * catalog records the SAME on-disk root the router routes to — a recall/read\n * touch must not guess `namespaces/<token>` when the router actually serves a\n * legacy raw-name dir or a migrated default root (CLAUDE.md rule #22/#42; round\n * 4, cursor Medium). The default namespace delegates to `resolveDefaultNamespaceRoot`;\n * every other namespace prefers the tokenized root when it has a storage marker,\n * else a legacy raw-name dir when present, else the tokenized root.\n */\nexport async function resolveNamespaceStorageRoot(\n  config: PluginConfig,\n  namespace: string,\n): Promise<string> {\n  if (!resolveNamespaceCapabilities(config).namespaces) return config.memoryDir;\n  // Compare on NORMALIZED identity so a whitespace-padded configured default name\n  // still routes to the default root rather than a tokenized non-default dir\n  // (NH-FH). The catalog keys records by the same normalized identity.\n  if (normalizeNamespaceIdentity(namespace) === normalizeNamespaceIdentity(config.defaultNamespace)) {\n    return resolveDefaultNamespaceRoot(config);\n  }\n  const legacyRoot = resolveNamespaceDir(config.memoryDir, namespace);\n  const tokenizedRoot = resolveNamespaceDir(config.memoryDir, namespaceIdentityToken(namespace));\n  if (\n    (await exists(tokenizedRoot)) &&\n    (await hasAnyNamespaceStorageMarker(tokenizedRoot, { includeRuntimeState: true }))\n  ) {\n    return tokenizedRoot;\n  }\n  return (await exists(legacyRoot)) ? legacyRoot : tokenizedRoot;\n}\n\nexport class NamespaceStorageRouter {\n  private readonly cache = new Map<string, StorageManager>();\n  private defaultNsRootResolved: string | null = null;\n  // Dedup the resolve hook (round 6, cursor Medium — NCNL2). Recall/extraction\n  // call `storageFor` repeatedly; firing `onResolve` (→ catalog loadCompacted +\n  // append) on every cache hit grows `namespaces.jsonl` without bound between\n  // rebuilds. We fire the hook only when the (namespace, storageDir) pair is new\n  // or its dir changed, so a steady-state cache hit is a no-op for the catalog.\n  private readonly notifiedResolved = new Map<string, string>();\n  // Instance-scoped serializer for the resolve hook (issue #1524 adoption).\n  // Replaces the bespoke `inFlightResolved` marker-then-clear pattern: the\n  // serializer's per-key chain strictly orders concurrent notifications for the\n  // SAME namespace, and the task re-checks `notifiedResolved` once it runs, so a\n  // burst of cache hits before the first hook settles collapses to a single\n  // hook invocation (the once-per-namespace intent). Recovery is preserved —\n  // one rejected hook never poisons subsequent notifications for that key.\n  private readonly resolveSerializer = new MutationSerializer();\n  // (namespace, storageDir) pairs whose resolve hook is currently pending. Set SYNCHRONOUSLY in\n  // notifyResolved (before queueing) so a burst of concurrent storageFor()\n  // cache hits collapses onto the one in-flight hook instead of each enqueuing\n  // its own task. Cleared when the queued hook settles. Without this, a dropped\n  // hook (returns false on a rebuild-lock timeout) leaves notifiedResolved\n  // unset, so every queued sibling task would re-run the hook — N serial lock\n  // waits (cursor Medium 06f58a7c, codex P2).\n  private readonly inFlightResolveHooks = new Set<string>();\n  // Tracks every in-flight resolve-hook promise so callers can deterministically\n  // await the fire-and-forget registrations that `storageFor()` kicks off (see\n  // `whenResolveHooksSettled`). Entries are removed as each hook settles, so the\n  // set holds at most one promise per concurrently-resolving namespace.\n  private readonly pendingResolveHooks = new Set<Promise<unknown>>();\n  // Pending post-write catalog touch promises (#1522). Like pendingResolveHooks,\n  // lets tests await fire-and-forget write touches deterministically.\n  private readonly pendingWriteTouches = new Set<Promise<unknown>>();\n\n  // Normalized (trimmed) default namespace identity (NH-FH). `storageFor`\n  // normalizes its input, so default-namespace branches must compare against the\n  // normalized config default too — otherwise a whitespace-padded configured\n  // default name routes the default namespace to a tokenized non-default root.\n  private readonly defaultNamespaceIdentity: string;\n\n  /** #2019: hook fired when a new namespace storage is created via storageFor. */\n  onStorageCreated?: (storage: StorageManager, namespace: string) => void;\n\n  constructor(\n    private readonly config: PluginConfig,\n    private readonly hooks: NamespaceStorageRouterHooks = {},\n    /** Catalog reference for post-write/read touches (issue #1522 chokepoint). */\n    private readonly catalog?: NamespaceCatalog,\n  ) {\n    this.defaultNamespaceIdentity = normalizeNamespaceIdentity(config.defaultNamespace);\n  }\n\n  private async defaultNamespaceRoot(): Promise<string> {\n    this.defaultNsRootResolved = await resolveDefaultNamespaceRoot(this.config);\n    return this.defaultNsRootResolved;\n  }\n\n  private async namespaceRoot(namespace: string): Promise<string> {\n    // NOTE: only used after defaultNamespaceRoot() resolution.\n    if (!resolveNamespaceCapabilities(this.config).namespaces) return this.config.memoryDir;\n    if (normalizeNamespaceIdentity(namespace) === this.defaultNamespaceIdentity) {\n      return this.defaultNsRootResolved ?? this.config.memoryDir;\n    }\n    return resolveNamespaceStorageRoot(this.config, namespace);\n  }\n\n  async storageFor(namespace: string): Promise<StorageManager> {\n    const ns = normalizeNamespaceIdentity(namespace || this.config.defaultNamespace);\n    if (ns !== this.defaultNamespaceIdentity && !isSafeRouteNamespace(ns)) {\n      throw new Error(`unsafe namespace: ${ns}`);\n    }\n    // Even when the default namespace is exempt from the check above, every\n    // on-disk path is built through resolveNamespaceDir(), which rejects\n    // traversal segments — so an unsafe configured default still cannot escape\n    // <memoryDir>/namespaces (CodeQL js/path-injection).\n\n    let root: string;\n    if (ns === this.defaultNamespaceIdentity) {\n      root = await this.defaultNamespaceRoot();\n      const cached = this.cache.get(ns);\n      if (cached && cached.dir === root) {\n        await this.applySecureStoreConfig(cached);\n        this.notifyResolved(ns, root);\n        return cached;\n      }\n    } else {\n      const cached = this.cache.get(ns);\n      root = await this.namespaceRoot(ns);\n      if (cached && cached.dir === root) {\n        await this.applySecureStoreConfig(cached);\n        this.notifyResolved(ns, root);\n        return cached;\n      }\n    }\n\n    // Pass the hot-memories cache gate explicitly (issue #1902, Codex P2): a\n    // per-namespace child root is never registered in the per-dir default map,\n    // so without this it would fall back to the process-wide default and ignore\n    // THIS daemon's hotMemoriesCacheEnabled config. Threading it from config\n    // keeps every namespace storage aligned with its owning orchestrator.\n    const sm = new StorageManager(\n      root,\n      this.config.entitySchemas,\n      this.config.hotMemoriesCacheEnabled,\n    );\n    // Register this child root's gate AND TTL in the per-dir maps (issue #1902,\n    // Codex P2). The constructor override above fixes the child's own gate, but\n    // its TTL is resolved via the per-dir map (hotCacheTtlMs); an unregistered\n    // child root would fall back to the last process-wide TTL and could inherit\n    // another daemon's value. Registering keyed by root keeps both per-dir.\n    StorageManager.setHotMemoriesCacheDefault(\n      root,\n      this.config.hotMemoriesCacheEnabled,\n      this.config.hotMemoriesCacheTtlMs,\n    );\n    const { scopedCacheInvalidationEnabled } = this.config;\n    StorageManager.setScopedCacheInvalidationDefault(root, scopedCacheInvalidationEnabled);\n    // Propagate the inline-attribution template so that router-created storages\n    // (used by extraction and shared-promotion paths) strip citations consistently,\n    // matching the behaviour of the primary this.storage instance in the orchestrator.\n    sm.citationTemplate = this.config.inlineSourceAttributionFormat;\n    // #1522: install the post-write catalog touch at the chokepoint — every\n    // successful write on this StorageManager records the namespace touch.\n    this.bindCatalogWriteHook(sm, ns);\n    // #1579: apply the tombstone non-resurrection config so every namespace\n    // storage enforces the invariant at its own writeMemory chokepoint.\n    this.applyTombstonesConfig(sm, ns);\n    // #2033: install the secure-store context on router-created stores. The\n    // orchestrator keys ONLY its primary default-namespace storage; without\n    // this, a store resolved through the router reads isSecureStoreUnlocked()\n    // === false even after the operator unlocked the keyring, so secure-store\n    // recovery paths (e.g. the CLI lifecycle-ledger rebuild) refuse an encrypted\n    // ledger they could actually rewrite, and namespace writes could silently\n    // fall back to plaintext. Mirror the orchestrator's setup exactly.\n    await this.applySecureStoreConfig(sm);\n    this.cache.set(ns, sm);\n    // #2019: let the orchestrator wire write-triggered prioritized embedding on\n    // every router-created namespace storage, not just the primary default store.\n    this.onStorageCreated?.(sm, ns);\n    this.notifyResolved(ns, root);\n    return sm;\n  }\n\n  /**\n   * Fire the resolve hook defensively. A hook failure (e.g. a catalog write\n   * error) MUST NOT crash storage resolution — see CLAUDE.md gotcha #13.\n   *\n   * Issue #1524 adoption: hook invocations for the SAME namespace are now\n   * strictly ordered through the shared `MutationSerializer` rather than the\n   * bespoke `inFlightResolved` marker-then-clear pattern. The serializer\n   * guarantees one in-flight hook per namespace; a concurrent burst of\n   * `storageFor()` cache hits collapses to a single hook invocation because\n   * each queued task re-checks `notifiedResolved` before invoking the hook. A\n   * dropped (`false`) or rejected hook leaves `notifiedResolved` unset so the\n   * next `storageFor()` retries — the serializer recovers from the rejection,\n   * so a failed hook never poisons later notifications.\n   */\n  private notifyResolved(namespace: string, storageDir: string): void {\n    const hook = this.hooks.onResolve;\n    if (!hook) return;\n    // Permanent dedup: skip once we've SUCCESSFULLY notified this exact\n    // (namespace, storageDir). A changed dir (rare: migration/realignment)\n    // still re-fires once. The mark is set ONLY AFTER the hook succeeds, so a\n    // dropped registration (e.g. rebuild-lock timeout) is RETRIED on the next\n    // cache hit instead of being suppressed forever (round 6, cursor Medium —\n    // ND3EJ).\n    if (this.notifiedResolved.get(namespace) === storageDir) return;\n    // In-flight dedup (cursor Medium 06f58a7c, codex P2): if a hook for THIS\n    // namespace is already pending, collapse this call onto it instead of\n    // enqueueing another task. The serializer strictly orders queued tasks, but\n    // ordering alone is not enough — when the first hook returns `false`\n    // (dropped touch, e.g. rebuild-lock timeout), `notifiedResolved` stays\n    // unset, so each queued sibling task would pass its re-check and re-run the\n    // hook. With the real catalog hook each retry can spend the full lock wait,\n    // so N cache hits during a rebuild leave N serial background lock attempts.\n    // Collapsing here means at most ONE hook runs per in-flight registration;\n    // its result (set `notifiedResolved` on success, leave unset on drop)\n    // decides whether a LATER `storageFor()` retries — collapsing loses\n    // nothing because the drop is already retried on the next cache hit.\n    // Keyed by the composite (namespace, storageDir) so a CHANGED dir\n    // (migration/realignment) for the same namespace still gets its own hook —\n    // it is NOT collapsed onto the old dir's pending registration (cursor\n    // Medium, codex P2).\n    const inFlightKey = namespace + \"\\u0000\" + storageDir;\n    if (this.inFlightResolveHooks.has(inFlightKey)) return;\n    this.inFlightResolveHooks.add(inFlightKey);\n    // Queue through the serializer. Concurrent calls for the same namespace\n    // strictly order here; the 2nd call's task runs only after the 1st's hook\n    // settles, by which point `notifiedResolved` is either set (no-op) or still\n    // unset (retry). The returned promise is tracked for\n    // `whenResolveHooksSettled()`. Rejections from the task body are caught so\n    // they never reach the caller (best-effort hook contract); the serializer's\n    // recovered tail still lets subsequent notifications run.\n    const task = async (): Promise<void> => {\n      // Re-check after queueing: a prior task in this same chain may have just\n      // marked the pair as notified.\n      if (this.notifiedResolved.get(namespace) === storageDir) return;\n      try {\n        // Hook may be sync or async; Promise.resolve normalizes both. A result\n        // of `false` means the registration was dropped/no-op (e.g. rebuild-lock\n        // timeout) — leave notifiedResolved UNSET so the next storageFor retries\n        // (round 6, codex P2 — NEFoX). `void`/`undefined` is success for legacy\n        // hooks. A rejection leaves notifiedResolved unset for the same reason.\n        const persisted = await Promise.resolve(hook(namespace, storageDir));\n        if (persisted !== false) {\n          this.notifiedResolved.set(namespace, storageDir);\n        }\n      } catch {\n        // Best-effort: a hook failure MUST NOT crash storage resolution. Leave\n        // notifiedResolved unset so a later storageFor retries the registration.\n      }\n    };\n    const queued = this.resolveSerializer.serialize(namespace, task);\n    this.pendingResolveHooks.add(queued);\n    // Clear the in-flight marker when the hook settles so a subsequent\n    // storageFor() can retry after a drop, or short-circuit via notifiedResolved\n    // after a success.\n    const cleanup = (): void => {\n      this.inFlightResolveHooks.delete(inFlightKey);\n      this.pendingResolveHooks.delete(queued);\n    };\n    void queued.then(cleanup, cleanup);\n  }\n\n  /**\n   * Install the post-write catalog touch hook on an externally-constructed\n   * StorageManager (issue #1522). Used by the orchestrator for the legacy\n   * default-namespace storage (`this.storage`) that bypasses the router.\n   */\n  bindCatalogWriteHook(sm: StorageManager, namespace: string): void {\n    // Issue #1903: pure state-file writes only touch the catalog when explicitly\n    // opted in. Router-created storages (storageFor) and the legacy default\n    // storage both flow through here, so this is the single wiring point.\n    sm.touchStateWrites = this.config.namespacesCatalogTouchStateWrites === true;\n    sm.onCatalogWrite = () => this.touchCatalogWrite(namespace, sm.dir);\n  }\n\n  /**\n   * Install the tombstone config on an externally-constructed StorageManager\n   * (issue #1579). Mirrors `bindCatalogWriteHook` — used for the legacy\n   * default-namespace storage that bypasses the router. Router-created\n   * storages are wired inline in `storageFor()` via `applyTombstonesConfig`.\n   */\n  bindTombstonesConfig(\n    sm: StorageManager,\n    namespace: string,\n    config: { enabled: boolean; semanticMatch: boolean; semanticThreshold: number },\n  ): void {\n    this.tombstonesGlobalConfig = { ...config };\n    sm.setTombstonesConfig({ ...config, namespace });\n  }\n\n  private tombstonesGlobalConfig: {\n    enabled: boolean;\n    semanticMatch: boolean;\n    semanticThreshold: number;\n  } = { enabled: false, semanticMatch: false, semanticThreshold: 0.9 };\n\n  /**\n   * Apply the tombstone config to a router-created StorageManager. Called\n   * inline in `storageFor()` so every namespace storage enforces the\n   * non-resurrection invariant, namespace-scoped (rule 42).\n   */\n  private applyTombstonesConfig(sm: StorageManager, namespace: string): void {\n    sm.setTombstonesConfig({ ...this.tombstonesGlobalConfig, namespace });\n  }\n\n  /**\n   * Install the at-rest secure-store context on a router-created StorageManager\n   * (#2033). Mirrors the orchestrator's primary-storage setup: mark the store\n   * required so a locked store throws instead of silently writing plaintext, and\n   * install the master key when the process-local keyring already holds it (the\n   * operator unlocked). The secure store is one key per memory ROOT (single\n   * header + per-file path-bound AAD), so every namespace store keys off the\n   * root keyring id — exactly the id the orchestrator and `secure-store unlock`\n   * register under. No-op when secure-store is disabled.\n   */\n  private async applySecureStoreConfig(sm: StorageManager): Promise<void> {\n    if (!resolveRecallAuxiliaryCapabilities(this.config).secureStore) return;\n    sm.setSecureStoreRequired(true);\n    const existingKey = keyring.getKey(secureStoreDir(this.config.memoryDir));\n    if (existingKey) {\n      await sm.setSecureStoreKeyAndWait(existingKey, this.config.secureStoreEncryptOnWrite);\n    }\n  }\n\n  /**\n   * Post-write catalog touch (issue #1522 chokepoint). Called by every\n   * StorageManager's post-write hook AFTER a successful write. Best-effort\n   * and failure-tolerant — a catalog error MUST NOT affect the primary write\n   * (gotcha #13, rule #40). Fire-and-forget by design.\n   */\n  private touchCatalogWrite(namespace: string, storageDir: string): void {\n    if (!this.catalog) return;\n    const touch = this.catalog\n      .markWrite(namespace, { discoveredBy: \"write\", storageDir })\n      .catch(() => undefined);\n    this.pendingWriteTouches.add(touch);\n    void touch.then(\n      () => { this.pendingWriteTouches.delete(touch); },\n      () => { this.pendingWriteTouches.delete(touch); },\n    );\n  }\n\n  /**\n   * Record a namespace read in the catalog (issue #1522 chokepoint move).\n   * Best-effort and failure-tolerant. Used by recall paths so the read touch\n   * lives in the storage layer, not at the caller.\n   */\n  recordRead(namespace: string, storageDir?: string): void {\n    if (!this.catalog) return;\n    const ns = normalizeNamespaceIdentity(namespace || this.config.defaultNamespace);\n    void this.catalog\n      .markRead(ns, { discoveredBy: \"read\", storageDir })\n      .catch(() => undefined);\n  }\n  /**\n   * Record a namespace write touch in the catalog (issue #1522). Best-effort\n   * and failure-tolerant. Used by consolidation/cleanup passes that may mutate\n   * the store via delete-only paths (e.g. entity-file merges, TTL cleanup) so\n   * the namespace's lastWriteAt stays fresh even when no explicit write went\n   * through the storage chokepoint. This is NOT a substitute for the chokepoint\n   * — it's a belt-and-suspenders for paths the chokepoint doesn't cover.\n   */\n  recordWrite(namespace: string, storageDir?: string): void {\n    if (!this.catalog) return;\n    const ns = normalizeNamespaceIdentity(namespace || this.config.defaultNamespace);\n    const touch = this.catalog\n      .markWrite(ns, { discoveredBy: \"write\", storageDir })\n      .catch(() => undefined);\n    this.pendingWriteTouches.add(touch);\n    void touch.then(\n      () => { this.pendingWriteTouches.delete(touch); },\n      () => { this.pendingWriteTouches.delete(touch); },\n    );\n  }\n\n  /**\n   * Resolve once every in-flight post-write catalog touch has settled (#1522).\n   * Mirrors `whenResolveHooksSettled()`: the StorageManager's post-write hook\n   * fires the catalog touch fire-and-forget, so tests asserting lastWriteAt\n   * moved should await this instead of racing a timer.\n   */\n  async whenWriteTouchesSettled(): Promise<void> {\n    // Flush any coalesced (buffered) touches first so their appends join the\n    // pending set below — otherwise this could resolve while a buffered touch's\n    // lastWriteAt is still unwritten on disk (#1903, Cursor). No-op when\n    // coalescing is disabled (window 0) or the catalog is inert.\n    await this.catalog?.flushPendingTouches().catch(() => undefined);\n    while (this.pendingWriteTouches.size > 0) {\n      await Promise.allSettled([...this.pendingWriteTouches]);\n    }\n  }\n\n  /**\n   * Resolve once every in-flight `onResolve` registration has settled.\n   *\n   * `storageFor()` fires the resolve hook fire-and-forget, so its catalog side\n   * effect (e.g. `registerResolved(...)`) is not observable the moment\n   * `storageFor()` returns. Callers that must act on that side effect — notably\n   * tests asserting the catalog was updated — should await this instead of\n   * racing a timer. Resolves immediately when no hook is registered or nothing\n   * is in flight. The loop re-checks because a settling hook could, in\n   * principle, trigger a follow-on resolution.\n   */\n  async whenResolveHooksSettled(): Promise<void> {\n    while (this.pendingResolveHooks.size > 0) {\n      await Promise.allSettled([...this.pendingResolveHooks]);\n    }\n  }\n\n  /**\n   * #2019: iterate the currently cached router storages with their namespace so\n   * callers can wire hooks on stores resolved before the hook was installed.\n   */\n  forEachCachedStorage(fn: (storage: StorageManager, namespace: string) => void): void {\n    for (const [namespace, storage] of this.cache) fn(storage, namespace);\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-P4BC54KI.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/semantic-chunking.ts"],"sourcesContent":["/**\n * Semantic Chunking with Smoothing-Based Topic Boundaries (Issue #368)\n *\n * An optional alternative to the recursive chunker in chunking.ts.\n * Uses sentence embeddings + cosine similarity + smoothing to detect\n * natural topic boundaries, producing more coherent chunks.\n */\n\nimport { chunkContent, type Chunk, type ChunkResult } from \"./chunking.js\";\n\n// ---------------------------------------------------------------------------\n// Configuration\n// ---------------------------------------------------------------------------\n\nexport interface SemanticChunkingConfig {\n  /** Target tokens per chunk. Default: 200. */\n  targetTokens: number;\n  /** Minimum tokens for a segment before merging with neighbor. Default: 100. */\n  minTokens: number;\n  /** Maximum tokens for a segment before recursive splitting. Default: 400. */\n  maxTokens: number;\n  /** Window size for the moving-average smoothing filter. Default: 3. */\n  smoothingWindowSize: number;\n  /** How many standard deviations below the mean constitutes a boundary. Default: 1.0. */\n  boundaryThresholdStdDevs: number;\n  /** Batch size for embedding requests. Default: 32. */\n  embeddingBatchSize: number;\n  /** Fall back to recursive chunking when embeddings are unavailable. Default: true. */\n  fallbackToRecursive: boolean;\n}\n\nexport const DEFAULT_SEMANTIC_CHUNKING_CONFIG: SemanticChunkingConfig = {\n  targetTokens: 200,\n  minTokens: 100,\n  maxTokens: 400,\n  smoothingWindowSize: 3,\n  boundaryThresholdStdDevs: 1.0,\n  embeddingBatchSize: 32,\n  fallbackToRecursive: true,\n};\n\n// ---------------------------------------------------------------------------\n// Result types\n// ---------------------------------------------------------------------------\n\nexport interface SemanticChunk extends Chunk {\n  /** Optional topic hint derived from position. */\n  topicLabel?: string;\n  /** Cosine similarity score at the trailing boundary of this chunk. */\n  boundaryScore: number;\n}\n\nexport interface SemanticChunkResult {\n  /** Whether content was split into multiple chunks. */\n  chunked: boolean;\n  /** The chunks produced. */\n  chunks: SemanticChunk[];\n  /** Sentence indices where topic splits occurred. */\n  boundaries: number[];\n  /** Which algorithm produced the result. */\n  method: \"semantic\" | \"recursive-fallback\";\n}\n\n// ---------------------------------------------------------------------------\n// Embedding function signature\n// ---------------------------------------------------------------------------\n\n/** Caller-provided function that embeds an array of texts, returning vectors. */\nexport type EmbedFn = (texts: string[]) => Promise<number[][]>;\n\n// ---------------------------------------------------------------------------\n// Math utilities (exported for testing)\n// ---------------------------------------------------------------------------\n\n/**\n * Cosine similarity between two vectors.\n * Returns a value in [-1, 1]. Identical direction = 1, orthogonal = 0.\n *\n * NOTE: This duplicates cosineSimilarity in recall-mmr.ts and embedding-fallback.ts.\n * Consider extracting to a shared math utility in a future refactor.\n */\nexport function cosineSimilarity(a: number[], b: number[]): number {\n  if (a.length !== b.length) {\n    throw new Error(\n      `cosineSimilarity: vector length mismatch (${a.length} vs ${b.length})`,\n    );\n  }\n  if (a.length === 0) return 0;\n\n  let dot = 0;\n  let magA = 0;\n  let magB = 0;\n  for (let i = 0; i < a.length; i++) {\n    dot += a[i] * b[i];\n    magA += a[i] * a[i];\n    magB += b[i] * b[i];\n  }\n\n  const denom = Math.sqrt(magA) * Math.sqrt(magB);\n  if (denom === 0) return 0;\n  return dot / denom;\n}\n\n/**\n * Arithmetic mean of a numeric series.\n */\nexport function mean(series: number[]): number {\n  if (series.length === 0) return 0;\n  let sum = 0;\n  for (const v of series) sum += v;\n  return sum / series.length;\n}\n\n/**\n * Population standard deviation of a numeric series.\n */\nexport function stddev(series: number[]): number {\n  if (series.length === 0) return 0;\n  const m = mean(series);\n  let sumSq = 0;\n  for (const v of series) {\n    const d = v - m;\n    sumSq += d * d;\n  }\n  return Math.sqrt(sumSq / series.length);\n}\n\n/**\n * Simple moving average over a 1D series.\n * The window is centered: for window size W, each output[i] averages\n * series[i - floor(W/2) .. i + floor(W/2)], clamped to bounds.\n *\n * Even window sizes are rounded up to the next odd value so the window\n * is symmetric around the center point (Finding 4, PR #420).\n */\nexport function movingAverage(series: number[], windowSize: number): number[] {\n  if (series.length === 0) return [];\n  if (windowSize < 1) windowSize = 1;\n  // Round even values up to the next odd so the window is symmetric.\n  if (windowSize % 2 === 0) windowSize = windowSize + 1;\n\n  const halfW = Math.floor(windowSize / 2);\n  const result: number[] = new Array(series.length);\n\n  for (let i = 0; i < series.length; i++) {\n    const lo = Math.max(0, i - halfW);\n    const hi = Math.min(series.length - 1, i + halfW);\n    let sum = 0;\n    for (let j = lo; j <= hi; j++) sum += series[j];\n    result[i] = sum / (hi - lo + 1);\n  }\n  return result;\n}\n\n/**\n * Find indices in the series that are local minima AND below the threshold.\n * A local minimum is a point lower than both its immediate neighbors\n * (or lower-or-equal at series boundaries).\n */\nexport function findLocalMinima(\n  series: number[],\n  threshold: number,\n): number[] {\n  if (series.length <= 2) return [];\n\n  const minima: number[] = [];\n  for (let i = 1; i < series.length - 1; i++) {\n    if (\n      series[i] < series[i - 1] &&\n      series[i] < series[i + 1] &&\n      series[i] < threshold\n    ) {\n      minima.push(i);\n    }\n  }\n  return minima;\n}\n\n// ---------------------------------------------------------------------------\n// Sentence tokenizer\n// ---------------------------------------------------------------------------\n\n/**\n * Split text into sentences at punctuation boundaries.\n * Preserves punctuation with the preceding sentence.\n */\nfunction splitSentences(text: string): string[] {\n  // Linear character scan instead of a regex. Every regex form of this split is\n  // either polynomial (CodeQL js/polynomial-redos) or — once bounded/anchored to\n  // satisfy CodeQL — mishandles long runs or interior punctuation (a global\n  // match drops a skipped prefix; a sticky match stops at the first non-boundary\n  // `.`, e.g. \"v1.2.3\" / \"example.com\", returning the whole document as one\n  // sentence and bypassing chunking). The scan is O(n), drops nothing, and\n  // handles interior punctuation correctly; normal prose splits identically to\n  // the previous /[^.!?]*[.!?]+(?:\\s+|$)/g form.\n  const sentences: string[] = [];\n  let start = 0;\n  for (let i = 0; i < text.length; i++) {\n    const ch = text[i];\n    if (ch !== \".\" && ch !== \"!\" && ch !== \"?\") continue;\n    let end = i;\n    while (end + 1 < text.length) {\n      const n = text[end + 1];\n      if (n !== \".\" && n !== \"!\" && n !== \"?\") break;\n      end++;\n    }\n    const after = text[end + 1];\n    // A real boundary only if the terminator run ends the string or is followed\n    // by whitespace. Interior punctuation (no following whitespace) is left in\n    // place and the scan continues.\n    if (after === undefined || /\\s/.test(after)) {\n      const sentence = text.slice(start, end + 1).trim();\n      if (sentence.length > 0) sentences.push(sentence);\n      start = end + 1;\n    }\n    i = end;\n  }\n  if (start < text.length) {\n    const remaining = text.slice(start).trim();\n    if (remaining.length > 0) sentences.push(remaining);\n  }\n  return sentences;\n}\n\n// ---------------------------------------------------------------------------\n// Token estimation\n// ---------------------------------------------------------------------------\n\n/** Rough token estimate: ~4 chars per token for English. */\nfunction estimateTokens(text: string): number {\n  return Math.ceil(text.length / 4);\n}\n\n// ---------------------------------------------------------------------------\n// Core semantic chunking\n// ---------------------------------------------------------------------------\n\n/**\n * Batch-embed sentences using the provided embed function.\n * Respects the configured batch size.\n */\nasync function batchEmbed(\n  sentences: string[],\n  embedFn: EmbedFn,\n  batchSize: number,\n): Promise<number[][]> {\n  const allEmbeddings: number[][] = [];\n\n  for (let i = 0; i < sentences.length; i += batchSize) {\n    const batch = sentences.slice(i, i + batchSize);\n    const batchResult = await embedFn(batch);\n    for (const vec of batchResult) {\n      allEmbeddings.push(vec);\n    }\n  }\n\n  return allEmbeddings;\n}\n\nfunction findEmbeddingDimensionMismatch(\n  embeddings: number[][],\n): { expected: number; actual: number; index: number } | null {\n  if (embeddings.length <= 1) return null;\n  const expected = embeddings[0].length;\n  for (let i = 1; i < embeddings.length; i++) {\n    const actual = embeddings[i].length;\n    if (actual !== expected) {\n      return { expected, actual, index: i };\n    }\n  }\n  return null;\n}\n\n/**\n * Build segments from boundary indices.\n * boundaries are sentence indices at which splits occur (i.e., the split\n * happens AFTER the boundary index sentence).\n */\nfunction buildSegments(\n  sentences: string[],\n  boundaries: number[],\n): string[][] {\n  const sorted = [...boundaries].sort((a, b) => a - b);\n  const segments: string[][] = [];\n  let start = 0;\n\n  for (const b of sorted) {\n    // Split after sentence at index b: segment is [start .. b]\n    const splitPoint = b + 1;\n    if (splitPoint > start && splitPoint <= sentences.length) {\n      segments.push(sentences.slice(start, splitPoint));\n      start = splitPoint;\n    }\n  }\n\n  // Remaining sentences\n  if (start < sentences.length) {\n    segments.push(sentences.slice(start));\n  }\n\n  return segments;\n}\n\n/**\n * Merge short segments (below minTokens) with their neighbor.\n * Prefers merging forward; falls back to merging backward.\n */\nfunction mergeShortSegments(\n  segments: string[][],\n  minTokens: number,\n): string[][] {\n  if (segments.length <= 1) return segments;\n\n  const merged: string[][] = [];\n  let buffer: string[] = [];\n\n  for (let i = 0; i < segments.length; i++) {\n    buffer = [...buffer, ...segments[i]];\n    const tokenCount = estimateTokens(buffer.join(\" \"));\n\n    if (tokenCount >= minTokens || i === segments.length - 1) {\n      merged.push(buffer);\n      buffer = [];\n    }\n  }\n\n  // If the last merge left a dangling buffer, attach it to the last segment\n  if (buffer.length > 0) {\n    if (merged.length > 0) {\n      merged[merged.length - 1] = [...merged[merged.length - 1], ...buffer];\n    } else {\n      merged.push(buffer);\n    }\n  }\n\n  return merged;\n}\n\n/**\n * Split an oversized segment using recursive chunking.\n */\nfunction splitLongSegment(\n  segment: string[],\n  maxTokens: number,\n  targetTokens: number,\n): SemanticChunk[] {\n  const text = segment.join(\" \");\n  // Cap targetTokens to maxTokens so recursive splitting never produces\n  // segments larger than the configured maximum (Finding 2, PR #420).\n  const cappedTarget = Math.min(targetTokens, maxTokens);\n  const result: ChunkResult = chunkContent(text, {\n    targetTokens: cappedTarget,\n    minTokens: Math.min(cappedTarget, maxTokens),\n    overlapSentences: 0,\n  });\n\n  return result.chunks.map((c) => ({\n    content: c.content,\n    index: c.index,\n    tokenCount: c.tokenCount,\n    boundaryScore: 0,\n  }));\n}\n\n/**\n * Semantic chunking with smoothing-based topic boundary detection.\n *\n * @param content   - Full text to chunk.\n * @param embedFn   - Async function that embeds an array of texts.\n * @param config    - Optional partial config overrides.\n * @returns SemanticChunkResult\n */\nexport async function semanticChunkContent(\n  content: string,\n  embedFn: EmbedFn,\n  config?: Partial<SemanticChunkingConfig>,\n): Promise<SemanticChunkResult> {\n  const cfg: SemanticChunkingConfig = {\n    ...DEFAULT_SEMANTIC_CHUNKING_CONFIG,\n    ...config,\n  };\n\n  // Guard against non-positive batch size which would cause an infinite loop\n  const batchSize = Math.max(1, cfg.embeddingBatchSize);\n\n  // --- Empty / trivially short input ---\n  if (!content || content.trim().length === 0) {\n    return {\n      chunked: false,\n      chunks: [],\n      boundaries: [],\n      method: \"semantic\",\n    };\n  }\n\n  const sentences = splitSentences(content);\n\n  if (sentences.length <= 1) {\n    const tokenCount = estimateTokens(content);\n    return {\n      chunked: false,\n      chunks: [\n        {\n          content: content.trim(),\n          index: 0,\n          tokenCount,\n          boundaryScore: 1,\n        },\n      ],\n      boundaries: [],\n      method: \"semantic\",\n    };\n  }\n\n  // If total tokens is short enough, return as single chunk\n  const totalTokens = estimateTokens(content);\n  if (totalTokens <= cfg.minTokens) {\n    return {\n      chunked: false,\n      chunks: [\n        {\n          content: content.trim(),\n          index: 0,\n          tokenCount: totalTokens,\n          boundaryScore: 1,\n        },\n      ],\n      boundaries: [],\n      method: \"semantic\",\n    };\n  }\n\n  // --- Attempt embedding ---\n  let embeddings: number[][];\n  try {\n    embeddings = await batchEmbed(sentences, embedFn, batchSize);\n  } catch {\n    // Embedding failed — fall back if configured\n    if (cfg.fallbackToRecursive) {\n      return buildRecursiveFallback(content, cfg);\n    }\n    throw new Error(\n      \"Semantic chunking failed: embedding function threw and fallbackToRecursive is disabled\",\n    );\n  }\n\n  if (embeddings.length !== sentences.length) {\n    if (cfg.fallbackToRecursive) {\n      return buildRecursiveFallback(content, cfg);\n    }\n    throw new Error(\n      `Semantic chunking failed: expected ${sentences.length} embeddings but received ${embeddings.length}`,\n    );\n  }\n\n  const dimensionMismatch = findEmbeddingDimensionMismatch(embeddings);\n  if (dimensionMismatch) {\n    if (cfg.fallbackToRecursive) {\n      return buildRecursiveFallback(content, cfg);\n    }\n    throw new Error(\n      `Semantic chunking failed: embedding vectors have mismatched dimensions ` +\n        `(${dimensionMismatch.expected} vs ${dimensionMismatch.actual} at index ${dimensionMismatch.index})`,\n    );\n  }\n\n  // --- Compute pairwise cosine similarity ---\n  const similarities: number[] = [];\n  for (let i = 0; i < sentences.length - 1; i++) {\n    similarities.push(cosineSimilarity(embeddings[i], embeddings[i + 1]));\n  }\n\n  // If only one pair (2 sentences), nothing to smooth or split meaningfully.\n  // However, if the combined content exceeds maxTokens, apply recursive splitting.\n  if (similarities.length <= 1) {\n    if (totalTokens > cfg.maxTokens) {\n      return buildRecursiveFallback(content, cfg);\n    }\n    return {\n      chunked: false,\n      chunks: [\n        {\n          content: content.trim(),\n          index: 0,\n          tokenCount: totalTokens,\n          boundaryScore: similarities.length === 1 ? similarities[0] : 1,\n        },\n      ],\n      boundaries: [],\n      method: \"semantic\",\n    };\n  }\n\n  // --- Smooth the similarity series ---\n  const smoothed = movingAverage(similarities, cfg.smoothingWindowSize);\n\n  // --- Detect boundaries: local minima below (mean - k * stddev) ---\n  const m = mean(smoothed);\n  const s = stddev(smoothed);\n  const threshold = m - cfg.boundaryThresholdStdDevs * s;\n  const rawBoundaries = findLocalMinima(smoothed, threshold);\n\n  // --- Build segments, merge short, split long ---\n  let segments = buildSegments(sentences, rawBoundaries);\n  segments = mergeShortSegments(segments, cfg.minTokens);\n\n  // --- Convert segments to chunks, splitting oversized ones ---\n  const chunks: SemanticChunk[] = [];\n  const finalBoundaries: number[] = [];\n  let sentenceOffset = 0;\n\n  for (let segIdx = 0; segIdx < segments.length; segIdx++) {\n    const segment = segments[segIdx];\n    const segText = segment.join(\" \");\n    const segTokens = estimateTokens(segText);\n\n    if (segTokens > cfg.maxTokens) {\n      // Recursive split for oversized segment\n      const subChunks = splitLongSegment(segment, cfg.maxTokens, cfg.targetTokens);\n      for (const sc of subChunks) {\n        chunks.push({\n          ...sc,\n          index: chunks.length,\n        });\n      }\n    } else {\n      // Compute boundary score: the similarity at the trailing edge\n      const trailingSentenceIdx = sentenceOffset + segment.length - 1;\n      let bScore = 1;\n      if (\n        trailingSentenceIdx < similarities.length &&\n        segIdx < segments.length - 1\n      ) {\n        bScore = smoothed[trailingSentenceIdx] ?? similarities[trailingSentenceIdx] ?? 1;\n      }\n\n      chunks.push({\n        content: segText,\n        index: chunks.length,\n        tokenCount: segTokens,\n        boundaryScore: bScore,\n      });\n    }\n\n    // Record boundaries (all but the last segment produce a boundary)\n    if (segIdx < segments.length - 1) {\n      finalBoundaries.push(sentenceOffset + segment.length - 1);\n    }\n    sentenceOffset += segment.length;\n  }\n\n  return {\n    chunked: chunks.length > 1,\n    chunks,\n    boundaries: finalBoundaries,\n    method: \"semantic\",\n  };\n}\n\n// ---------------------------------------------------------------------------\n// Recursive fallback helper\n// ---------------------------------------------------------------------------\n\nfunction buildRecursiveFallback(\n  content: string,\n  cfg: SemanticChunkingConfig,\n): SemanticChunkResult {\n  // Cap targetTokens to maxTokens so the recursive fallback path honours the\n  // same constraint as splitLongSegment (PR #439 post-merge cursor[bot] finding).\n  const cappedTarget = Math.min(cfg.targetTokens, cfg.maxTokens);\n  const result: ChunkResult = chunkContent(content, {\n    targetTokens: cappedTarget,\n    minTokens: Math.min(cfg.minTokens, cappedTarget),\n    overlapSentences: 0,\n  });\n\n  return {\n    chunked: result.chunked,\n    chunks: result.chunks.map((c) => ({\n      ...c,\n      boundaryScore: 0,\n    })),\n    boundaries: [],\n    method: \"recursive-fallback\",\n  };\n}\n"],"mappings":"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","names":[]}