@remnic/core 9.30.1 → 9.32.0

package/dist/chunk-ULARSG5Z.js.map

@@ -0,0 +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":"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","names":[]}

package/dist/{chunk-TH2LSRMG.js → chunk-UORKJ34C.js}

@@ -1,6 +1,6 @@
 import {
   StorageManager
-} from "./chunk-RGIWINDN.js";
+} from "./chunk-FHBITMRY.js";
 import {
   getCachedRuleMemories,
   setCachedRuleMemories
@@ -119,4 +119,4 @@ export {
   compareVerifiedSemanticRuleResults,
   searchVerifiedSemanticRules
 };
-//# sourceMappingURL=chunk-TH2LSRMG.js.map
+//# sourceMappingURL=chunk-UORKJ34C.js.map

package/dist/{chunk-4Z4XNEWZ.js → chunk-VCD4PSK2.js}

@@ -4,16 +4,14 @@ function respondLcmCompactionCapabilitiesHttp(response) {
   response.setHeader("content-type", "application/json; charset=utf-8");
   response.end(JSON.stringify({ lcmCompactionFlushBatch: true }, null, 2));
 }
-async function handleLcmCompactionFlushHttp({
+async function runLcmCompactionFlushHttp({
   body,
   service,
-  response,
   ensureWriteRateLimitAvailable,
   recordWriteRateLimitHit,
   resolveNamespace,
   defaultNamespace,
-  resolveRequestPrincipal,
-  respondJson
+  resolveRequestPrincipal
 }) {
   ensureWriteRateLimitAvailable();
   const requestedNamespaces = body.namespaces;
@@ -21,11 +19,12 @@ async function handleLcmCompactionFlushHttp({
     const result = await service.lcmCompactionFlush({
       sessionKey: body.sessionKey,
       namespace: resolveNamespace(body.namespace),
+      ...body.cwd !== void 0 ? { cwd: body.cwd } : {},
+      ...body.projectTag !== void 0 ? { projectTag: body.projectTag } : {},
       authenticatedPrincipal: resolveRequestPrincipal()
     });
     recordWriteRateLimitHit();
-    respondJson(response, 200, result);
-    return;
+    return result;
   }
   const resolutionOutcomes = await Promise.allSettled(
     requestedNamespaces.map(async (requestedNamespace) => {
@@ -50,6 +49,8 @@ async function handleLcmCompactionFlushHttp({
       ({ namespace }) => service.lcmCompactionFlush({
         sessionKey: body.sessionKey,
         namespace,
+        ...body.cwd !== void 0 ? { cwd: body.cwd } : {},
+        ...body.projectTag !== void 0 ? { projectTag: body.projectTag } : {},
         authenticatedPrincipal: resolveRequestPrincipal()
       })
     )
@@ -64,23 +65,66 @@ async function handleLcmCompactionFlushHttp({
   const results = resolutionOutcomes.map((outcome, index) => {
     const requestedNamespace = requestedNamespaces[index] ?? "";
     if (outcome.status === "rejected") {
-      return { status: "rejected", requestedNamespace };
+      return { status: "rejected", namespace: requestedNamespace };
     }
     const serviceOutcome = serviceOutcomesByEffectiveNamespace.get(outcome.value.effectiveNamespace);
-    return serviceOutcome?.status === "fulfilled" ? { status: "fulfilled", requestedNamespace, result: serviceOutcome.value } : { status: "rejected", requestedNamespace };
+    return serviceOutcome?.status === "fulfilled" ? { status: "fulfilled", namespace: requestedNamespace, result: serviceOutcome.value } : { status: "rejected", namespace: requestedNamespace };
   });
   recordWriteRateLimitHit();
-  respondJson(response, 200, {
+  return {
     enabled: results.every((result) => result.status === "fulfilled" && result.result.enabled !== false),
     flushed: results.every((result) => result.status === "fulfilled" && result.result.flushed !== false),
     sessionKey: body.sessionKey,
     namespaces: requestedNamespaces,
-    results: results.map(({ requestedNamespace, ...result }) => ({ ...result, namespace: requestedNamespace }))
+    results
+  };
+}
+async function handleLcmCompactionFlushHttp({
+  body,
+  service,
+  response,
+  ensureWriteRateLimitAvailable,
+  recordWriteRateLimitHit,
+  resolveNamespace,
+  defaultNamespace,
+  resolveRequestPrincipal,
+  respondJson
+}) {
+  const result = await runLcmCompactionFlushHttp({
+    body,
+    service,
+    ensureWriteRateLimitAvailable,
+    recordWriteRateLimitHit,
+    resolveNamespace,
+    defaultNamespace,
+    resolveRequestPrincipal
   });
+  respondJson(response, 200, result);
+}
+async function runLcmCompactionRecordHttp({
+  body,
+  service,
+  ensureWriteRateLimitAvailable,
+  recordWriteRateLimitHit,
+  resolveNamespace,
+  resolveRequestPrincipal
+}) {
+  ensureWriteRateLimitAvailable();
+  const response = await service.lcmCompactionRecord({
+    sessionKey: body.sessionKey,
+    namespace: resolveNamespace(body.namespace),
+    tokensBefore: body.tokensBefore,
+    tokensAfter: body.tokensAfter,
+    authenticatedPrincipal: resolveRequestPrincipal()
+  });
+  recordWriteRateLimitHit();
+  return response;
 }
 
 export {
   respondLcmCompactionCapabilitiesHttp,
-  handleLcmCompactionFlushHttp
+  runLcmCompactionFlushHttp,
+  handleLcmCompactionFlushHttp,
+  runLcmCompactionRecordHttp
 };
-//# sourceMappingURL=chunk-4Z4XNEWZ.js.map
+//# sourceMappingURL=chunk-VCD4PSK2.js.map

package/dist/chunk-VCD4PSK2.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/access-http-lcm-compaction.ts"],"sourcesContent":["import type { ServerResponse } from \"node:http\";\n\nimport type { LcmCompactionFlushRequest, LcmCompactionRecordRequest } from \"./access-schema.js\";\nimport type {\n  EngramAccessLcmCompactionFlushResponse,\n  EngramAccessLcmCompactionRecordResponse,\n  EngramAccessService,\n} from \"./access-service.js\";\n\ntype LcmCompactionService = Pick<EngramAccessService, \"lcmCompactionFlush\" | \"lcmCompactionRecord\">;\ntype JsonResponder = (res: ServerResponse, status: number, payload: unknown) => void;\n\nexport interface LcmCompactionFlushHttpOptions {\n  body: LcmCompactionFlushRequest;\n  service: LcmCompactionService;\n  response: ServerResponse;\n  ensureWriteRateLimitAvailable: () => void;\n  recordWriteRateLimitHit: () => void;\n  resolveNamespace: (namespace?: string) => string | undefined;\n  defaultNamespace?: string;\n  resolveRequestPrincipal: () => string | undefined;\n  respondJson: JsonResponder;\n}\n\nexport function respondLcmCompactionCapabilitiesHttp(response: ServerResponse): void {\n  response.statusCode = 200;\n  response.setHeader(\"content-type\", \"application/json; charset=utf-8\");\n  response.end(JSON.stringify({ lcmCompactionFlushBatch: true }, null, 2));\n}\n\nexport interface LcmCompactionFlushRunnerOptions {\n  body: LcmCompactionFlushRequest;\n  service: LcmCompactionService;\n  ensureWriteRateLimitAvailable: () => void;\n  recordWriteRateLimitHit: () => void;\n  resolveNamespace: (namespace?: string) => string | undefined;\n  defaultNamespace?: string;\n  resolveRequestPrincipal: () => string | undefined;\n}\n\ntype LcmCompactionFlushBatchResult =\n  | {\n      namespace: string;\n      status: \"fulfilled\";\n      result: EngramAccessLcmCompactionFlushResponse;\n    }\n  | { namespace: string; status: \"rejected\" };\n\ntype LcmCompactionFlushHttpResult =\n  | EngramAccessLcmCompactionFlushResponse\n  | {\n      enabled: boolean;\n      flushed: boolean;\n      sessionKey: string;\n      namespaces: string[];\n      results: LcmCompactionFlushBatchResult[];\n    };\n\nexport async function runLcmCompactionFlushHttp({\n  body,\n  service,\n  ensureWriteRateLimitAvailable,\n  recordWriteRateLimitHit,\n  resolveNamespace,\n  defaultNamespace,\n  resolveRequestPrincipal,\n}: LcmCompactionFlushRunnerOptions): Promise<LcmCompactionFlushHttpResult> {\n  ensureWriteRateLimitAvailable();\n  const requestedNamespaces = body.namespaces;\n  if (requestedNamespaces === undefined) {\n    const result = await service.lcmCompactionFlush({\n      sessionKey: body.sessionKey,\n      namespace: resolveNamespace(body.namespace),\n      ...(body.cwd !== undefined ? { cwd: body.cwd } : {}),\n      ...(body.projectTag !== undefined ? { projectTag: body.projectTag } : {}),\n      authenticatedPrincipal: resolveRequestPrincipal(),\n    });\n    recordWriteRateLimitHit();\n    return result;\n  }\n  const resolutionOutcomes = await Promise.allSettled(\n    requestedNamespaces.map(async (requestedNamespace) => {\n      const namespace = resolveNamespace(requestedNamespace);\n      return {\n        requestedNamespace,\n        namespace,\n        effectiveNamespace: namespace ?? defaultNamespace ?? \"\",\n      };\n    })\n  );\n  const uniqueResolvedNamespaces: Array<{\n    requestedNamespace: string;\n    namespace: string | undefined;\n    effectiveNamespace: string;\n  }> = [];\n  const queuedEffectiveNamespaces = new Set<string>();\n  for (const outcome of resolutionOutcomes) {\n    if (outcome.status === \"fulfilled\" && !queuedEffectiveNamespaces.has(outcome.value.effectiveNamespace)) {\n      queuedEffectiveNamespaces.add(outcome.value.effectiveNamespace);\n      uniqueResolvedNamespaces.push(outcome.value);\n    }\n  }\n  const serviceOutcomes = await Promise.allSettled(\n    uniqueResolvedNamespaces.map(({ namespace }) =>\n      service.lcmCompactionFlush({\n        sessionKey: body.sessionKey,\n        namespace,\n        ...(body.cwd !== undefined ? { cwd: body.cwd } : {}),\n        ...(body.projectTag !== undefined ? { projectTag: body.projectTag } : {}),\n        authenticatedPrincipal: resolveRequestPrincipal(),\n      })\n    )\n  );\n  const serviceOutcomesByEffectiveNamespace = new Map<\n    string,\n    PromiseSettledResult<EngramAccessLcmCompactionFlushResponse>\n  >();\n  for (const [index, resolved] of uniqueResolvedNamespaces.entries()) {\n    const serviceOutcome = serviceOutcomes[index];\n    if (serviceOutcome !== undefined) {\n      serviceOutcomesByEffectiveNamespace.set(resolved.effectiveNamespace, serviceOutcome);\n    }\n  }\n  const results = resolutionOutcomes.map((outcome, index): LcmCompactionFlushBatchResult => {\n    const requestedNamespace = requestedNamespaces[index] ?? \"\";\n    if (outcome.status === \"rejected\") {\n      return { status: \"rejected\", namespace: requestedNamespace };\n    }\n    const serviceOutcome = serviceOutcomesByEffectiveNamespace.get(outcome.value.effectiveNamespace);\n    return serviceOutcome?.status === \"fulfilled\"\n      ? { status: \"fulfilled\", namespace: requestedNamespace, result: serviceOutcome.value }\n      : { status: \"rejected\", namespace: requestedNamespace };\n  });\n  recordWriteRateLimitHit();\n  return {\n    enabled: results.every((result) => result.status === \"fulfilled\" && result.result.enabled !== false),\n    flushed: results.every((result) => result.status === \"fulfilled\" && result.result.flushed !== false),\n    sessionKey: body.sessionKey,\n    namespaces: requestedNamespaces,\n    results,\n  };\n}\nexport async function handleLcmCompactionFlushHttp({\n  body,\n  service,\n  response,\n  ensureWriteRateLimitAvailable,\n  recordWriteRateLimitHit,\n  resolveNamespace,\n  defaultNamespace,\n  resolveRequestPrincipal,\n  respondJson,\n}: LcmCompactionFlushHttpOptions): Promise<void> {\n  const result = await runLcmCompactionFlushHttp({\n    body,\n    service,\n    ensureWriteRateLimitAvailable,\n    recordWriteRateLimitHit,\n    resolveNamespace,\n    defaultNamespace,\n    resolveRequestPrincipal,\n  });\n  respondJson(response, 200, result);\n}\n\nexport interface LcmCompactionRecordHttpOptions {\n  body: LcmCompactionRecordRequest;\n  service: LcmCompactionService;\n  ensureWriteRateLimitAvailable: () => void;\n  recordWriteRateLimitHit: () => void;\n  resolveNamespace: (namespace?: string) => string | undefined;\n  resolveRequestPrincipal: () => string | undefined;\n}\n\nexport async function runLcmCompactionRecordHttp({\n  body,\n  service,\n  ensureWriteRateLimitAvailable,\n  recordWriteRateLimitHit,\n  resolveNamespace,\n  resolveRequestPrincipal,\n}: LcmCompactionRecordHttpOptions): Promise<EngramAccessLcmCompactionRecordResponse> {\n  ensureWriteRateLimitAvailable();\n  const response = await service.lcmCompactionRecord({\n    sessionKey: body.sessionKey,\n    namespace: resolveNamespace(body.namespace),\n    tokensBefore: body.tokensBefore,\n    tokensAfter: body.tokensAfter,\n    authenticatedPrincipal: resolveRequestPrincipal(),\n  });\n  recordWriteRateLimitHit();\n  return response;\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-K5GB36ME.js → chunk-VMZ56EE3.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-SOBJ6NEY.js";
 import {
   summarizeDisclosureTokens
-} from "./chunk-ACXPX4AG.js";
+} from "./chunk-OPBTPRGY.js";
 import {
   summarizeRetrievedMemoryProvenance
 } from "./chunk-I4WBNM3M.js";
@@ -587,4 +587,4 @@ export {
   renderRecallExplain,
   parseRecallExplainFormat
 };
-//# sourceMappingURL=chunk-K5GB36ME.js.map
+//# sourceMappingURL=chunk-VMZ56EE3.js.map

package/dist/{chunk-HUHX2OCX.js → chunk-VVDPPDDF.js}

@@ -23,4 +23,4 @@ export {
   confidenceTier,
   SPECULATIVE_TTL_DAYS
 };
-//# sourceMappingURL=chunk-HUHX2OCX.js.map
+//# sourceMappingURL=chunk-VVDPPDDF.js.map