@remnic/core 9.7.15 → 9.9.0

package/dist/{chunk-UDQUSU27.js → chunk-HNZKVLAN.js}

@@ -3,7 +3,7 @@ import {
   graphsDir,
   readEdgesStrict,
   withGraphWriteLock
-} from "./chunk-2S6QHZGJ.js";
+} from "./chunk-L2DPF4DF.js";
 import {
   DEFAULT_DECAY_FLOOR,
   DEFAULT_DECAY_PER_WINDOW,
@@ -203,4 +203,4 @@ export {
   discoverGraphNamespaceRoots,
   runGraphEdgeDecayMaintenanceAcrossNamespaces
 };
-//# sourceMappingURL=chunk-UDQUSU27.js.map
+//# sourceMappingURL=chunk-HNZKVLAN.js.map

package/dist/{chunk-5EZXHU36.js → chunk-HYQJQGD3.js}

@@ -9,7 +9,7 @@ import {
 } from "./chunk-FF4KLI5W.js";
 import {
   log
-} from "./chunk-37CTGERM.js";
+} from "./chunk-3WCASNQZ.js";
 
 // src/transcript.ts
 import { appendFile, mkdir, readdir, readFile, stat, unlink, writeFile } from "fs/promises";
@@ -938,4 +938,4 @@ export {
   utcDayRange,
   TranscriptManager
 };
-//# sourceMappingURL=chunk-5EZXHU36.js.map
+//# sourceMappingURL=chunk-HYQJQGD3.js.map

package/dist/{chunk-PLQE6MJA.js → chunk-IFH6LWTO.js}

@@ -1,13 +1,16 @@
 import {
   createSearchBackend
-} from "./chunk-G4CN3ZXL.js";
+} from "./chunk-FUTF72MJ.js";
 import {
   namespaceIdentityToken,
   normalizeNamespaceIdentity
 } from "./chunk-EGGE52UU.js";
+import {
+  ALL_CATEGORY_DIRS
+} from "./chunk-VS2IYZRU.js";
 import {
   resolveNamespaceCapabilities
-} from "./chunk-BFPETA3S.js";
+} from "./chunk-SCCO46KZ.js";
 
 // src/namespaces/search.ts
 import path from "path";
@@ -34,6 +37,17 @@ var NamespaceSearchRouter = class {
   async collectionForNamespace(namespace) {
     return (await this.backendRecordFor(namespace)).collection;
   }
+  /**
+   * Resolve the search backend for a namespace (#2019). Returns `unknown` so
+   * callers (e.g. the prioritized-embed path) duck-type for capability like
+   * `embedFiles` rather than depending on a concrete QMD shape. Reuses the
+   * cached backend record, so this never re-creates a backend. Returns `null`
+   * when the namespace backend is unavailable.
+   */
+  async backendForNamespace(namespace) {
+    const record = await this.backendRecordFor(namespace);
+    return record.available ? record.backend : null;
+  }
   async searchAcrossNamespaces(options) {
     const query = options.query.trim();
     if (!query) return [];
@@ -93,7 +107,15 @@ var NamespaceSearchRouter = class {
             );
             break;
         }
-        results = filterNamespaceSubtreeResults(record, results);
+        results = filterNamespaceSubtreeResults(record, results).map((result) => ({
+          ...result,
+          namespace,
+          // Resolve to an absolute path so the (namespace, path) identity is
+          // globally unique — same-relative-path hits from different namespaces
+          // stay distinct across every downstream consumer with no special
+          // handling. Display/citation surfaces relativize for portability (#2020).
+          path: resolveNamespaceResultPath(record.memoryDir, record.collection, result.path)
+        }));
         return { namespace, results };
       })
     );
@@ -158,6 +180,10 @@ var NamespaceSearchRouter = class {
       const diagnosticBackend = liveRecord?.backend ?? record.backend;
       const versionStatus = "getVersionStatus" in diagnosticBackend && typeof diagnosticBackend.getVersionStatus === "function" ? diagnosticBackend.getVersionStatus() : null;
       const daemonMode = daemonModeForBackend(diagnosticBackend);
+      const backendStatus = "status" in diagnosticBackend && typeof diagnosticBackend.status === "function" ? await Promise.race([
+        diagnosticBackend.status().catch(() => null),
+        new Promise((resolve) => setTimeout(() => resolve(null), 5e3).unref?.())
+      ]) : null;
       const collectionState = liveRecord?.collectionState === "missing" ? "missing" : record.collectionState;
       return {
         collection: record.collection,
@@ -170,7 +196,10 @@ var NamespaceSearchRouter = class {
         supported: versionStatus?.supported ?? null,
         upgradeAvailable: versionStatus?.upgradeAvailable ?? null,
         doctorAvailable: versionStatus?.capabilities?.doctor ?? null,
-        daemonMode
+        daemonMode,
+        pendingEmbeddings: backendStatus?.pendingEmbeddings ?? null,
+        oldestPendingAgeMs: backendStatus?.oldestPendingAgeMs ?? null,
+        embeddingBacklogThreshold: this.config.qmdEmbeddingBacklogThreshold
       };
     } finally {
       const dispose = record.backend.dispose;
@@ -384,11 +413,22 @@ function normalizeQmdResultPath(resultPath, collection) {
     }
   }
   const collectionPrefix = `${collection}/`;
-  if (value.startsWith(collectionPrefix)) {
+  if (value.startsWith(collectionPrefix) && !ALL_CATEGORY_DIRS.includes(collection)) {
     value = value.slice(collectionPrefix.length);
   }
   return value;
 }
+function resolveNamespaceResultPath(memoryDir, collection, resultPath) {
+  const normalized = normalizeQmdResultPath(resultPath, collection);
+  if (path.isAbsolute(normalized)) return normalized;
+  const root = path.resolve(memoryDir);
+  const resolved = path.resolve(root, normalized);
+  const relative = path.relative(root, resolved);
+  if (relative === "" || relative.startsWith("..") || path.isAbsolute(relative)) {
+    return resultPath;
+  }
+  return resolved;
+}
 function mergeNamespaceSearchResults(lists, maxResults) {
   const merged = /* @__PURE__ */ new Map();
   for (const { namespace, results } of lists) {
@@ -396,12 +436,13 @@ function mergeNamespaceSearchResults(lists, maxResults) {
       const key = `${namespace}\0${result.path || result.docid}`;
       const existing = merged.get(key);
       if (!existing) {
-        merged.set(key, result);
+        merged.set(key, { ...result, namespace });
         continue;
       }
       if (result.score > existing.score) {
         merged.set(key, {
           ...result,
+          namespace,
           snippet: existing.snippet || result.snippet || ""
         });
       }
@@ -412,6 +453,7 @@ function mergeNamespaceSearchResults(lists, maxResults) {
 
 export {
   namespaceCollectionName,
-  NamespaceSearchRouter
+  NamespaceSearchRouter,
+  normalizeQmdResultPath
 };
-//# sourceMappingURL=chunk-PLQE6MJA.js.map
+//# sourceMappingURL=chunk-IFH6LWTO.js.map

package/dist/chunk-IFH6LWTO.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/namespaces/search.ts"],"sourcesContent":["import { resolveNamespaceCapabilities } from \"../capabilities.js\";\nimport path from \"node:path\";\nimport type { PluginConfig, QmdSearchResult } from \"../types.js\";\nimport type {\n  SearchBackend,\n  SearchExecutionOptions,\n  SearchQueryOptions,\n} from \"../search/port.js\";\nimport { createSearchBackend } from \"../search/factory.js\";\nimport { namespaceIdentityToken, normalizeNamespaceIdentity } from \"./identity.js\";\nimport { ALL_CATEGORY_DIRS } from \"../utils/category-dir.js\";\n\nconst NESTED_NAMESPACE_FILTER_OVERFETCH_FACTOR = 4;\nconst NESTED_NAMESPACE_FILTER_OVERFETCH_MIN = 50;\n\nexport function namespaceCollectionName(\n  baseCollection: string,\n  namespace: string,\n  options?: {\n    defaultNamespace?: string;\n    useLegacyDefaultCollection?: boolean;\n  },\n): string {\n  const trimmed = normalizeNamespaceIdentity(namespace);\n  const defaultNamespace = normalizeNamespaceIdentity(options?.defaultNamespace ?? \"\") || \"default\";\n  if (\n    options?.useLegacyDefaultCollection === true &&\n    trimmed === defaultNamespace\n  ) {\n    return baseCollection;\n  }\n\n  return `${baseCollection}--${namespaceIdentityToken(trimmed || defaultNamespace)}`;\n}\n\ntype StorageRouterLike = {\n  storageFor(namespace: string): Promise<{ dir: string }>;\n};\n\ntype NamespaceBackendRecord = {\n  backend: SearchBackend;\n  collection: string;\n  memoryDir: string;\n  available: boolean;\n  collectionState: CollectionState;\n  filtersNestedNamespaces: boolean;\n};\n\nexport interface NamespaceUpdateResult {\n  backendCount: number;\n  eligibleNamespaces: string[];\n}\n\nexport type CollectionState = \"present\" | \"missing\" | \"unknown\" | \"skipped\";\n\nexport interface NamespaceSearchHealth {\n  collection: string;\n  memoryDir: string;\n  available: boolean;\n  collectionState: CollectionState;\n  debugStatus: string;\n  installedVersion: string | null;\n  supportedVersion: string | null;\n  supported: boolean | null;\n  upgradeAvailable: boolean | null;\n  doctorAvailable: boolean | null;\n  daemonMode: boolean | null;\n  pendingEmbeddings: number | null;\n  oldestPendingAgeMs: number | null;\n  embeddingBacklogThreshold: number;\n}\n\ntype NamespaceScopedSearchConfig = PluginConfig & {\n  hostEmbeddingProviderScope?: string;\n};\n\ntype BackendRecordOptions = {\n  autoCreateCollection: boolean;\n  abortAsUnavailable: boolean;\n  failOpenMissingGuardedCollection: boolean;\n};\n\nexport class NamespaceSearchRouter {\n  private readonly cache = new Map<string, Promise<NamespaceBackendRecord>>();\n\n  constructor(\n    private readonly config: PluginConfig,\n    private readonly storageRouter: StorageRouterLike,\n    private readonly createBackend: (config: PluginConfig) => SearchBackend = createSearchBackend,\n  ) {}\n\n  async collectionForNamespace(namespace: string): Promise<string> {\n    return (await this.backendRecordFor(namespace)).collection;\n  }\n\n  /**\n   * Resolve the search backend for a namespace (#2019). Returns `unknown` so\n   * callers (e.g. the prioritized-embed path) duck-type for capability like\n   * `embedFiles` rather than depending on a concrete QMD shape. Reuses the\n   * cached backend record, so this never re-creates a backend. Returns `null`\n   * when the namespace backend is unavailable.\n   */\n  async backendForNamespace(namespace: string): Promise<unknown> {\n    const record = await this.backendRecordFor(namespace);\n    return record.available ? record.backend : null;\n  }\n\n  async searchAcrossNamespaces(options: {\n    query: string;\n    namespaces: string[];\n    maxResults?: number;\n    mode?: \"search\" | \"hybrid\" | \"bm25\" | \"vector\";\n    searchOptions?: SearchQueryOptions;\n    execution?: SearchExecutionOptions;\n  }): Promise<QmdSearchResult[]> {\n    const query = options.query.trim();\n    if (!query) return [];\n    const maxResults = Math.max(0, Math.floor(options.maxResults ?? this.config.qmdMaxResults));\n    if (maxResults === 0) return [];\n\n    const method = options.mode ?? \"search\";\n    const namespaces = Array.from(new Set(options.namespaces.map((value) => value.trim()).filter(Boolean)));\n    if (namespaces.length === 0) return [];\n\n    const resultsByNamespace = await Promise.all(\n      namespaces.map(async (namespace) => {\n        const record = await this.backendRecordFor(namespace);\n        if (!record.available || record.collectionState === \"missing\") {\n          // A per-namespace backend that is unavailable (or missing its\n          // collection) must report like any other QMD skip (#1536): its\n          // empty contribution is otherwise indistinguishable from a true\n          // no-matches for that namespace (codex round-5 review on #1544).\n          try {\n            options.execution?.onDegradation?.({\n              backend: \"qmd\",\n              code: \"backend_unavailable\",\n              detail:\n                record.collectionState === \"missing\"\n                  ? `namespace collection missing: ${namespace}`\n                  : `namespace backend unavailable: ${namespace}`,\n            });\n          } catch {\n            // Observers must never break search.\n          }\n          return { namespace, results: [] as QmdSearchResult[] };\n        }\n        const backendLimit = backendSearchLimit(record, maxResults);\n        let results: QmdSearchResult[];\n        switch (method) {\n          case \"hybrid\":\n            results = await record.backend.hybridSearch(\n              query,\n              record.collection,\n              backendLimit,\n              options.execution,\n            );\n            break;\n          case \"bm25\":\n            results = await record.backend.bm25Search(\n              query,\n              record.collection,\n              backendLimit,\n              options.execution,\n            );\n            break;\n          case \"vector\":\n            results = await record.backend.vectorSearch(\n              query,\n              record.collection,\n              backendLimit,\n              options.execution,\n            );\n            break;\n          default:\n            results = await record.backend.search(\n              query,\n              record.collection,\n              backendLimit,\n              options.searchOptions,\n              options.execution,\n            );\n            break;\n        }\n        results = filterNamespaceSubtreeResults(record, results).map((result) => ({\n          ...result,\n          namespace,\n          // Resolve to an absolute path so the (namespace, path) identity is\n          // globally unique — same-relative-path hits from different namespaces\n          // stay distinct across every downstream consumer with no special\n          // handling. Display/citation surfaces relativize for portability (#2020).\n          path: resolveNamespaceResultPath(record.memoryDir, record.collection, result.path),\n        }));\n        return { namespace, results };\n      }),\n    );\n\n    return mergeNamespaceSearchResults(resultsByNamespace, maxResults);\n  }\n\n  /**\n   * Update all namespace backends.\n   * Returns the number of backends for which an update was attempted\n   * (i.e., available and collection present).  Callers can treat 0 as a\n   * signal that no backend was eligible — useful for success-verification in\n   * startup-sync when namespacesEnabled is true.\n   */\n  async updateNamespaces(\n    namespaces: string[],\n    execution?: SearchExecutionOptions,\n    options?: { strict?: boolean },\n  ): Promise<number> {\n    return (await this.updateNamespacesDetailed(namespaces, execution, options)).backendCount;\n  }\n\n  async updateNamespacesDetailed(\n    namespaces: string[],\n    execution?: SearchExecutionOptions,\n    options?: { strict?: boolean },\n  ): Promise<NamespaceUpdateResult> {\n    const unique = Array.from(new Set(namespaces.map((value) => value.trim()).filter(Boolean)));\n    const eligible = (await Promise.all(\n      unique.map(async (namespace) => {\n        const record = await this.backendRecordFor(namespace);\n        return record.available && record.collectionState !== \"missing\"\n          ? { namespace, record }\n          : null;\n      }),\n    )).filter((entry): entry is { namespace: string; record: NamespaceBackendRecord } => entry !== null);\n\n    const globalEntry = eligible.find(({ record }) => record.backend.updatesAllCollections?.() === true);\n    const scopedEntries = globalEntry\n      ? eligible.filter(({ record }) => record.backend.updatesAllCollections?.() !== true)\n      : eligible;\n\n    await Promise.all([\n      globalEntry\n        ? updateBackendRecord(globalEntry.record, execution, options)\n        : Promise.resolve(),\n      ...scopedEntries.map(({ record }) => updateBackendRecord(record, execution, options)),\n    ]);\n\n    return {\n      backendCount: (globalEntry ? 1 : 0) + scopedEntries.length,\n      eligibleNamespaces: eligible.map(({ namespace }) => namespace),\n    };\n  }\n\n  async embedNamespaces(namespaces: string[], options?: { strict?: boolean }): Promise<void> {\n    const unique = Array.from(new Set(namespaces.map((value) => value.trim()).filter(Boolean)));\n    await Promise.all(\n      unique.map(async (namespace) => {\n        const record = await this.backendRecordFor(namespace);\n        if (!record.available || record.collectionState === \"missing\") return;\n        await embedBackendRecord(record, options);\n      }),\n    );\n  }\n\n  async ensureNamespaceCollection(\n    namespace: string,\n    execution?: SearchExecutionOptions,\n  ): Promise<\"present\" | \"missing\" | \"unknown\" | \"skipped\"> {\n    const record = await this.backendRecordFor(namespace, execution);\n    return record.collectionState;\n  }\n\n  async healthForNamespace(\n    namespace: string,\n    execution?: SearchExecutionOptions,\n  ): Promise<NamespaceSearchHealth> {\n    const key = namespace.trim() || this.config.defaultNamespace;\n    const record = await this.createBackendRecordFor(\n      key,\n      execution,\n      {\n        autoCreateCollection: false,\n        abortAsUnavailable: true,\n        failOpenMissingGuardedCollection: false,\n      },\n    );\n    try {\n      const liveRecord = await this.liveCachedRecordForHealth(key, record, execution);\n      const diagnosticBackend = liveRecord?.backend ?? record.backend;\n      const versionStatus =\n        \"getVersionStatus\" in diagnosticBackend &&\n        typeof diagnosticBackend.getVersionStatus === \"function\"\n          ? diagnosticBackend.getVersionStatus()\n          : null;\n      const daemonMode = daemonModeForBackend(diagnosticBackend);\n      const backendStatus =\n        \"status\" in diagnosticBackend &&\n        typeof diagnosticBackend.status === \"function\"\n          ? await Promise.race([\n              diagnosticBackend.status().catch(() => null),\n              new Promise<null>((resolve) => setTimeout(() => resolve(null), 5_000).unref?.()),\n            ])\n          : null;\n      const collectionState =\n        liveRecord?.collectionState === \"missing\"\n          ? \"missing\"\n          : record.collectionState;\n\n      return {\n        collection: record.collection,\n        memoryDir: record.memoryDir,\n        available: liveRecord?.available ?? record.available,\n        collectionState,\n        debugStatus: diagnosticBackend.debugStatus(),\n        installedVersion: versionStatus?.installedVersion ?? null,\n        supportedVersion: versionStatus?.supportedVersion ?? null,\n        supported: versionStatus?.supported ?? null,\n        upgradeAvailable: versionStatus?.upgradeAvailable ?? null,\n        doctorAvailable: versionStatus?.capabilities?.doctor ?? null,\n        daemonMode,\n        pendingEmbeddings: backendStatus?.pendingEmbeddings ?? null,\n        oldestPendingAgeMs: backendStatus?.oldestPendingAgeMs ?? null,\n        embeddingBacklogThreshold: this.config.qmdEmbeddingBacklogThreshold,\n      };\n    } finally {\n      const dispose = (record.backend as { dispose?: () => void | Promise<void> }).dispose;\n      await dispose?.call(record.backend);\n    }\n  }\n\n  private async liveCachedRecordForHealth(\n    key: string,\n    disposableRecord: NamespaceBackendRecord,\n    execution?: SearchExecutionOptions,\n  ): Promise<NamespaceBackendRecord | null> {\n    const pending = this.cache.get(key);\n    if (!pending) return null;\n    const cachedRecord = await awaitWithAbort(pending, execution?.signal).catch(() => null);\n    if (!cachedRecord) return null;\n    if (cachedRecord.collection !== disposableRecord.collection) return null;\n    if (cachedRecord.memoryDir !== disposableRecord.memoryDir) return null;\n    return cachedRecord;\n  }\n\n  /** Clear cached backend records so the next access re-probes availability. */\n  clearCache(): void {\n    this.cache.clear();\n  }\n\n  /** Release any per-namespace backend handles held by cached records. */\n  async dispose(): Promise<void> {\n    const pendingRecords = Array.from(this.cache.values());\n    this.cache.clear();\n    const settled = await Promise.allSettled(pendingRecords);\n    await Promise.allSettled(\n      settled.flatMap((entry) => {\n        if (entry.status !== \"fulfilled\") return [];\n        const dispose = (entry.value.backend as { dispose?: () => void | Promise<void> }).dispose;\n        return dispose ? [dispose.call(entry.value.backend)] : [];\n      }),\n    );\n  }\n\n  private async backendRecordFor(\n    namespace: string,\n    execution?: SearchExecutionOptions,\n  ): Promise<NamespaceBackendRecord> {\n    const key = namespace.trim() || this.config.defaultNamespace;\n    const existing = this.cache.get(key);\n    if (existing) return await existing;\n\n    const pending = this.createBackendRecordFor(key, execution, {\n      autoCreateCollection: true,\n      abortAsUnavailable: false,\n      failOpenMissingGuardedCollection: true,\n    }).catch((error) => {\n      this.cache.delete(key);\n      throw error;\n    });\n\n    this.cache.set(key, pending);\n    return await pending;\n  }\n\n  private async createBackendRecordFor(\n    namespace: string,\n    execution: SearchExecutionOptions | undefined,\n    options: BackendRecordOptions,\n  ): Promise<NamespaceBackendRecord> {\n    const key = namespace.trim() || this.config.defaultNamespace;\n    const storage = await this.storageRouter.storageFor(key);\n    const useLegacyDefaultCollection =\n      key === this.config.defaultNamespace && storage.dir === this.config.memoryDir;\n    const filtersNestedNamespaces =\n      resolveNamespaceCapabilities(this.config).namespaces === true && useLegacyDefaultCollection;\n    const rootHostEmbeddingScope =\n      (this.config as NamespaceScopedSearchConfig).hostEmbeddingProviderScope ??\n      this.config.memoryDir;\n    const scopedConfig: NamespaceScopedSearchConfig = {\n      ...this.config,\n      memoryDir: storage.dir,\n      hostEmbeddingProviderScope: rootHostEmbeddingScope,\n      qmdCollection: namespaceCollectionName(this.config.qmdCollection, key, {\n        defaultNamespace: this.config.defaultNamespace,\n        useLegacyDefaultCollection,\n      }),\n    };\n\n    const backend = this.createBackend(scopedConfig);\n    try {\n      const availabilityProbe =\n        options.autoCreateCollection || typeof backend.checkAvailability !== \"function\"\n          ? backend.probe()\n          : backend.checkAvailability({ signal: execution?.signal });\n      const available = await awaitWithAbort(availabilityProbe, execution?.signal).catch((error) => {\n        if (error instanceof NamespaceSearchAbortError && !options.abortAsUnavailable) {\n          throw error;\n        }\n        return false;\n      });\n      const collectionState = available\n        ? await awaitWithAbort(\n          // The legacy default namespace at the flat root (`filtersNestedNamespaces`)\n          // shares its `memoryDir` with the `namespaces/` container, so its base\n          // collection is a \"broad root\" that also indexes nested-namespace files.\n          // We STILL auto-create it (issue #1929): the search side already targets\n          // this exact base collection and `filterNamespaceSubtreeResults` strips\n          // the nested `namespaces/` subtree out of its results, so index and\n          // search stay symmetric. Skipping creation left a configured default\n          // namespace (e.g. `geek`) with maintenance \"ran\" but no collection and 0\n          // recall results. `ensureCollection` is a no-op when the collection is\n          // already present, so legacy installs that pre-created the broad root are\n          // unaffected.\n          this.collectionStateForBackend(backend, storage.dir, scopedConfig.qmdCollection, {\n            autoCreate: options.autoCreateCollection,\n            failOpenMissingGuardedCollection: options.failOpenMissingGuardedCollection,\n            execution,\n          }),\n          execution?.signal,\n        ).catch((error) => {\n          if (error instanceof NamespaceSearchAbortError && !options.abortAsUnavailable) {\n            throw error;\n          }\n          return \"unknown\" as const;\n        })\n        : \"unknown\";\n      return {\n        backend,\n        collection: scopedConfig.qmdCollection,\n        memoryDir: storage.dir,\n        available,\n        collectionState,\n        filtersNestedNamespaces,\n      };\n    } catch (error) {\n      const dispose = (backend as { dispose?: () => void | Promise<void> }).dispose;\n      if (dispose) {\n        await Promise.resolve(dispose.call(backend)).catch(() => {});\n      }\n      throw error;\n    }\n  }\n\n  private async collectionStateForBackend(\n    backend: SearchBackend,\n    memoryDir: string,\n    collection: string,\n    options: {\n      autoCreate: boolean;\n      failOpenMissingGuardedCollection: boolean;\n      execution?: SearchExecutionOptions;\n    },\n  ): Promise<CollectionState> {\n    if (!options.autoCreate) {\n      if (!backend.checkCollection) return \"unknown\";\n      const collectionState = await backend\n        .checkCollection(collection, options.execution)\n        .catch(() => \"unknown\" as const);\n      return options.failOpenMissingGuardedCollection && collectionState === \"missing\"\n        ? \"unknown\"\n        : collectionState;\n    }\n    return await backend.ensureCollection(memoryDir, collection, options.execution).catch(() => \"unknown\" as const);\n  }\n}\n\nclass NamespaceSearchAbortError extends Error {\n  constructor() {\n    super(\"operation aborted\");\n  }\n}\n\nfunction awaitWithAbort<T>(operation: Promise<T>, signal?: AbortSignal): Promise<T> {\n  if (!signal) return operation;\n  if (signal.aborted) return Promise.reject(new NamespaceSearchAbortError());\n\n  return new Promise<T>((resolve, reject) => {\n    const onAbort = () => {\n      signal.removeEventListener(\"abort\", onAbort);\n      reject(new NamespaceSearchAbortError());\n    };\n    signal.addEventListener(\"abort\", onAbort, { once: true });\n    operation.then(resolve, reject).finally(() => {\n      signal.removeEventListener(\"abort\", onAbort);\n    });\n  });\n}\n\nfunction filterNamespaceSubtreeResults(\n  record: NamespaceBackendRecord,\n  results: QmdSearchResult[],\n): QmdSearchResult[] {\n  if (!record.filtersNestedNamespaces) return results;\n  return results.filter((result) =>\n    !pathIsInsideNamespaceSubtree(record.memoryDir, record.collection, result.path)\n  );\n}\n\nfunction backendSearchLimit(\n  record: NamespaceBackendRecord,\n  maxResults: number,\n): number {\n  if (!record.filtersNestedNamespaces) return maxResults;\n  return Math.max(\n    maxResults,\n    maxResults * NESTED_NAMESPACE_FILTER_OVERFETCH_FACTOR,\n    NESTED_NAMESPACE_FILTER_OVERFETCH_MIN,\n  );\n}\n\nasync function updateBackendRecord(\n  record: NamespaceBackendRecord,\n  execution?: SearchExecutionOptions,\n  options?: { strict?: boolean },\n): Promise<void> {\n  if (options?.strict === true) {\n    if (\n      record.backend.updatesAllCollections?.() === true &&\n      typeof record.backend.updateStrict === \"function\"\n    ) {\n      await record.backend.updateStrict(execution);\n      return;\n    }\n    if (typeof record.backend.updateCollectionStrict === \"function\") {\n      await record.backend.updateCollectionStrict(record.collection, execution);\n      return;\n    }\n  }\n  await record.backend.update(execution);\n}\n\nasync function embedBackendRecord(\n  record: NamespaceBackendRecord,\n  options?: { strict?: boolean },\n): Promise<void> {\n  if (options?.strict === true) {\n    if (typeof record.backend.embedCollectionStrict === \"function\") {\n      await record.backend.embedCollectionStrict(record.collection);\n      return;\n    }\n    if (typeof record.backend.embedStrict === \"function\") {\n      await record.backend.embedStrict();\n      return;\n    }\n  }\n  if (typeof record.backend.embedCollection === \"function\") {\n    await record.backend.embedCollection(record.collection);\n    return;\n  }\n  await record.backend.embed();\n}\n\nfunction daemonModeForBackend(backend: SearchBackend): boolean | null {\n  return \"isDaemonMode\" in backend && typeof backend.isDaemonMode === \"function\"\n    ? backend.isDaemonMode() === true\n    : null;\n}\n\nfunction pathIsInsideNamespaceSubtree(\n  memoryDir: string,\n  collection: string,\n  resultPath: string | undefined,\n): boolean {\n  if (!resultPath) return false;\n  const normalizedResultPath = normalizeQmdResultPath(resultPath, collection);\n  const memoryRoot = path.resolve(memoryDir);\n  const namespacesRoot = path.join(memoryRoot, \"namespaces\");\n  const candidate = path.isAbsolute(normalizedResultPath)\n    ? path.normalize(normalizedResultPath)\n    : path.resolve(memoryRoot, normalizedResultPath);\n  const relative = path.relative(namespacesRoot, candidate);\n  return relative === \"\" || (!relative.startsWith(\"..\") && !path.isAbsolute(relative));\n}\nexport function normalizeQmdResultPath(resultPath: string, collection: string): string {\n  let value = resultPath.trim();\n  if (value.startsWith(\"qmd://\")) {\n    try {\n      const parsed = new URL(value);\n      if (parsed.protocol === \"qmd:\" && parsed.hostname === collection) {\n        value = decodeURIComponent(parsed.pathname.replace(/^\\/+/, \"\"));\n      }\n    } catch {\n      const remainder = value.slice(\"qmd://\".length);\n      const slashIndex = remainder.indexOf(\"/\");\n      if (slashIndex !== -1) {\n        value = remainder.slice(slashIndex + 1);\n      }\n    }\n  }\n\n  // Only strip a genuine QMD collection prefix — never when the collection name\n  // collides with a memory category dir (e.g. qmdCollection == \"facts\"), or a\n  // bare \"facts/<id>.md\" hit would be corrupted to \"<id>.md\" and fail namespace\n  // reads/access tracking (#2020).\n  const collectionPrefix = `${collection}/`;\n  if (value.startsWith(collectionPrefix) && !ALL_CATEGORY_DIRS.includes(collection)) {\n    value = value.slice(collectionPrefix.length);\n  }\n  return value;\n}\nfunction resolveNamespaceResultPath(\n  memoryDir: string,\n  collection: string,\n  resultPath: string,\n): string {\n  const normalized = normalizeQmdResultPath(resultPath, collection);\n  if (path.isAbsolute(normalized)) return normalized;\n  const root = path.resolve(memoryDir);\n  const resolved = path.resolve(root, normalized);\n  const relative = path.relative(root, resolved);\n  if (relative === \"\" || relative.startsWith(\"..\") || path.isAbsolute(relative)) {\n    return resultPath;\n  }\n  return resolved;\n}\nfunction mergeNamespaceSearchResults(\n  lists: Array<{ namespace: string; results: QmdSearchResult[] }>,\n  maxResults: number,\n): QmdSearchResult[] {\n  const merged = new Map<string, QmdSearchResult>();\n\n  for (const { namespace, results } of lists) {\n    for (const result of results) {\n      const key = `${namespace}\\0${result.path || result.docid}`;\n      const existing = merged.get(key);\n      if (!existing) {\n        merged.set(key, { ...result, namespace });\n        continue;\n      }\n      if (result.score > existing.score) {\n        merged.set(key, {\n          ...result,\n          namespace,\n          snippet: existing.snippet || result.snippet || \"\",\n        });\n      }\n    }\n  }\n\n  return [...merged.values()]\n    .sort((a, b) => b.score - a.score)\n    .slice(0, maxResults);\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-RULE4VG5.js → chunk-ILGC6JH6.js}

@@ -14,6 +14,15 @@ var MEMORY_LIFECYCLE_EVENT_SORT_ORDER = {
   rejected: 9,
   archived: 10
 };
+var UNKNOWN_LIFECYCLE_EVENT_SORT_RANK = Number.MAX_SAFE_INTEGER;
+function lifecycleEventSortRank(eventType) {
+  return MEMORY_LIFECYCLE_EVENT_SORT_ORDER[eventType] ?? UNKNOWN_LIFECYCLE_EVENT_SORT_RANK;
+}
+function memoryLifecycleLedgerLockPath(ledgerPath) {
+  return `${ledgerPath}.lock`;
+}
+var MEMORY_LIFECYCLE_LEDGER_LOCK_STALE_MS = 3e4;
+var MEMORY_LIFECYCLE_LEDGER_APPEND_LOCK_MAX_WAIT_MS = MEMORY_LIFECYCLE_LEDGER_LOCK_STALE_MS * 2;
 function toMemoryPathRel(baseDir, filePath) {
   if (!baseDir) return filePath.split(path.sep).join("/");
   return path.relative(baseDir, filePath).split(path.sep).join("/");
@@ -74,17 +83,22 @@ function buildLifecycleEventsForMemory(memory) {
   }
   return events;
 }
+function compareMemoryLifecycleEvents(a, b) {
+  if (a.memoryId !== b.memoryId) return a.memoryId.localeCompare(b.memoryId);
+  if (a.timestamp !== b.timestamp) return a.timestamp.localeCompare(b.timestamp);
+  return lifecycleEventSortRank(a.eventType) - lifecycleEventSortRank(b.eventType);
+}
 function sortMemoryLifecycleEvents(events) {
-  return [...events].sort((a, b) => {
-    if (a.memoryId !== b.memoryId) return a.memoryId.localeCompare(b.memoryId);
-    if (a.timestamp !== b.timestamp) return a.timestamp.localeCompare(b.timestamp);
-    return MEMORY_LIFECYCLE_EVENT_SORT_ORDER[a.eventType] - MEMORY_LIFECYCLE_EVENT_SORT_ORDER[b.eventType];
-  });
+  return [...events].sort(compareMemoryLifecycleEvents);
 }
 
 export {
   MEMORY_LIFECYCLE_RULE_VERSION,
   MEMORY_LIFECYCLE_EVENT_SORT_ORDER,
+  lifecycleEventSortRank,
+  memoryLifecycleLedgerLockPath,
+  MEMORY_LIFECYCLE_LEDGER_LOCK_STALE_MS,
+  MEMORY_LIFECYCLE_LEDGER_APPEND_LOCK_MAX_WAIT_MS,
   toMemoryPathRel,
   isArchivedMemoryPath,
   inferMemoryStatus,
@@ -92,6 +106,7 @@ export {
   summarizeMemoryLifecycleState,
   makeRebuiltMemoryLifecycleEvent,
   buildLifecycleEventsForMemory,
+  compareMemoryLifecycleEvents,
   sortMemoryLifecycleEvents
 };
-//# sourceMappingURL=chunk-RULE4VG5.js.map
+//# sourceMappingURL=chunk-ILGC6JH6.js.map

package/dist/chunk-ILGC6JH6.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/memory-lifecycle-ledger-utils.ts"],"sourcesContent":["import path from \"node:path\";\nimport type {\n  MemoryFile,\n  MemoryLifecycleEvent,\n  MemoryLifecycleEventType,\n  MemoryLifecycleStateSummary,\n  MemoryFrontmatter,\n  MemoryStatus,\n} from \"./types.js\";\n\nexport const MEMORY_LIFECYCLE_RULE_VERSION = \"memory-lifecycle-ledger.v1\";\n\nexport const MEMORY_LIFECYCLE_EVENT_SORT_ORDER: Record<MemoryLifecycleEventType, number> = {\n  created: 0,\n  updated: 1,\n  promoted: 2,\n  explicit_capture_accepted: 3,\n  explicit_capture_queued: 4,\n  imported: 5,\n  merged: 6,\n  restored: 7,\n  superseded: 8,\n  rejected: 9,\n  archived: 10,\n};\n\n/**\n * Deterministic sort rank for a lifecycle event type. The ledger readers admit\n * any structurally valid row (permissive `eventType`, issue #1910), so an\n * unknown/typoed type must still sort deterministically: it ranks AFTER every\n * known type and keeps the comparator total. Without this fallback,\n * `map[unknown] - map[known]` is `NaN`, an invalid comparator result.\n */\nconst UNKNOWN_LIFECYCLE_EVENT_SORT_RANK = Number.MAX_SAFE_INTEGER;\n\nexport function lifecycleEventSortRank(eventType: string): number {\n  return (\n    MEMORY_LIFECYCLE_EVENT_SORT_ORDER[eventType as MemoryLifecycleEventType] ??\n    UNKNOWN_LIFECYCLE_EVENT_SORT_RANK\n  );\n}\n\n/**\n * Cross-process lock path guarding lifecycle-ledger mutations (issue #1910,\n * codex): `appendMemoryLifecycleEvents` and the compaction rewrite both hold\n * this lock so a lifecycle event appended during compaction's read->rewrite\n * window cannot be clobbered by the atomic rename that replaces the ledger.\n */\nexport function memoryLifecycleLedgerLockPath(ledgerPath: string): string {\n  return `${ledgerPath}.lock`;\n}\n\n/** Stale-break window for the lifecycle-ledger lock, shared by append + rewrite. */\nexport const MEMORY_LIFECYCLE_LEDGER_LOCK_STALE_MS = 30_000;\n\n/**\n * Acquisition budget for a lifecycle append waiting on the shared ledger lock\n * (issue #2033). Set to twice the stale-break window so a normal append waits\n * out an in-progress compaction rewrite instead of giving up at\n * withHeldFileLock's 5s default and dropping the event: a live compaction\n * releases within its own runtime, and a crashed holder's lock is stale-broken\n * at MEMORY_LIFECYCLE_LEDGER_LOCK_STALE_MS, so the append still acquires well\n * inside this budget rather than failing open.\n */\nexport const MEMORY_LIFECYCLE_LEDGER_APPEND_LOCK_MAX_WAIT_MS =\n  MEMORY_LIFECYCLE_LEDGER_LOCK_STALE_MS * 2;\n\nexport function toMemoryPathRel(baseDir: string, filePath: string): string {\n  if (!baseDir) return filePath.split(path.sep).join(\"/\");\n  return path.relative(baseDir, filePath).split(path.sep).join(\"/\");\n}\n\nexport function isArchivedMemoryPath(pathRel: string): boolean {\n  return pathRel === \"archive\" || pathRel.startsWith(\"archive/\");\n}\n\nexport function inferMemoryStatus(\n  frontmatter: MemoryFrontmatter,\n  pathRel: string,\n  fallbackStatus: MemoryStatus = \"active\",\n): MemoryStatus {\n  if (frontmatter.status && frontmatter.status !== \"active\") return frontmatter.status;\n  if (frontmatter.archivedAt) return \"archived\";\n  if (isArchivedMemoryPath(pathRel)) return \"archived\";\n  if (frontmatter.status) return frontmatter.status;\n  return fallbackStatus;\n}\n\nexport function isActiveMemoryStatus(status: MemoryStatus | string | undefined): boolean {\n  return status === undefined || status === \"active\";\n}\n\nexport function summarizeMemoryLifecycleState(memory: MemoryFile): MemoryLifecycleStateSummary {\n  return {\n    category: memory.frontmatter.category,\n    path: memory.path,\n    status: memory.frontmatter.status ?? \"active\",\n    lifecycleState: memory.frontmatter.lifecycleState,\n  };\n}\n\nexport function makeRebuiltMemoryLifecycleEvent(\n  memory: MemoryFile,\n  eventType: MemoryLifecycleEventType,\n  timestamp: string,\n): MemoryLifecycleEvent {\n  return {\n    eventId: `rebuild-${memory.frontmatter.id}-${eventType}-${timestamp}`,\n    memoryId: memory.frontmatter.id,\n    eventType,\n    timestamp,\n    actor: \"maintenance.rebuildMemoryLifecycleLedger\",\n    ruleVersion: MEMORY_LIFECYCLE_RULE_VERSION,\n    after: summarizeMemoryLifecycleState(memory),\n    relatedMemoryIds: [\n      ...(memory.frontmatter.supersededBy ? [memory.frontmatter.supersededBy] : []),\n      ...(memory.frontmatter.supersedes ? [memory.frontmatter.supersedes] : []),\n      ...((memory.frontmatter.lineage ?? []).filter(Boolean)),\n    ],\n  };\n}\n\nexport function buildLifecycleEventsForMemory(memory: MemoryFile): MemoryLifecycleEvent[] {\n  const events: MemoryLifecycleEvent[] = [];\n  const created = memory.frontmatter.created;\n  const updated = memory.frontmatter.updated;\n  const archivedAt = memory.frontmatter.archivedAt;\n  const supersededAt = memory.frontmatter.supersededAt;\n  const effectiveArchivedAt =\n    archivedAt ?? (memory.frontmatter.status === \"archived\" && updated ? updated : undefined);\n\n  events.push(makeRebuiltMemoryLifecycleEvent(memory, \"created\", created));\n  if (\n    updated &&\n    updated !== created &&\n    updated !== effectiveArchivedAt &&\n    updated !== supersededAt\n  ) {\n    events.push(makeRebuiltMemoryLifecycleEvent(memory, \"updated\", updated));\n  }\n  if (supersededAt) {\n    events.push(makeRebuiltMemoryLifecycleEvent(memory, \"superseded\", supersededAt));\n  }\n  if (effectiveArchivedAt) {\n    events.push(makeRebuiltMemoryLifecycleEvent(memory, \"archived\", effectiveArchivedAt));\n  }\n\n  return events;\n}\n\nexport function compareMemoryLifecycleEvents(\n  a: MemoryLifecycleEvent,\n  b: MemoryLifecycleEvent,\n): number {\n  if (a.memoryId !== b.memoryId) return a.memoryId.localeCompare(b.memoryId);\n  if (a.timestamp !== b.timestamp) return a.timestamp.localeCompare(b.timestamp);\n  return lifecycleEventSortRank(a.eventType) - lifecycleEventSortRank(b.eventType);\n}\n\nexport function sortMemoryLifecycleEvents(events: MemoryLifecycleEvent[]): MemoryLifecycleEvent[] {\n  return [...events].sort(compareMemoryLifecycleEvents);\n}\n"],"mappings":";AAAA,OAAO,UAAU;AAUV,IAAM,gCAAgC;AAEtC,IAAM,oCAA8E;AAAA,EACzF,SAAS;AAAA,EACT,SAAS;AAAA,EACT,UAAU;AAAA,EACV,2BAA2B;AAAA,EAC3B,yBAAyB;AAAA,EACzB,UAAU;AAAA,EACV,QAAQ;AAAA,EACR,UAAU;AAAA,EACV,YAAY;AAAA,EACZ,UAAU;AAAA,EACV,UAAU;AACZ;AASA,IAAM,oCAAoC,OAAO;AAE1C,SAAS,uBAAuB,WAA2B;AAChE,SACE,kCAAkC,SAAqC,KACvE;AAEJ;AAQO,SAAS,8BAA8B,YAA4B;AACxE,SAAO,GAAG,UAAU;AACtB;AAGO,IAAM,wCAAwC;AAW9C,IAAM,kDACX,wCAAwC;AAEnC,SAAS,gBAAgB,SAAiB,UAA0B;AACzE,MAAI,CAAC,QAAS,QAAO,SAAS,MAAM,KAAK,GAAG,EAAE,KAAK,GAAG;AACtD,SAAO,KAAK,SAAS,SAAS,QAAQ,EAAE,MAAM,KAAK,GAAG,EAAE,KAAK,GAAG;AAClE;AAEO,SAAS,qBAAqB,SAA0B;AAC7D,SAAO,YAAY,aAAa,QAAQ,WAAW,UAAU;AAC/D;AAEO,SAAS,kBACd,aACA,SACA,iBAA+B,UACjB;AACd,MAAI,YAAY,UAAU,YAAY,WAAW,SAAU,QAAO,YAAY;AAC9E,MAAI,YAAY,WAAY,QAAO;AACnC,MAAI,qBAAqB,OAAO,EAAG,QAAO;AAC1C,MAAI,YAAY,OAAQ,QAAO,YAAY;AAC3C,SAAO;AACT;AAEO,SAAS,qBAAqB,QAAoD;AACvF,SAAO,WAAW,UAAa,WAAW;AAC5C;AAEO,SAAS,8BAA8B,QAAiD;AAC7F,SAAO;AAAA,IACL,UAAU,OAAO,YAAY;AAAA,IAC7B,MAAM,OAAO;AAAA,IACb,QAAQ,OAAO,YAAY,UAAU;AAAA,IACrC,gBAAgB,OAAO,YAAY;AAAA,EACrC;AACF;AAEO,SAAS,gCACd,QACA,WACA,WACsB;AACtB,SAAO;AAAA,IACL,SAAS,WAAW,OAAO,YAAY,EAAE,IAAI,SAAS,IAAI,SAAS;AAAA,IACnE,UAAU,OAAO,YAAY;AAAA,IAC7B;AAAA,IACA;AAAA,IACA,OAAO;AAAA,IACP,aAAa;AAAA,IACb,OAAO,8BAA8B,MAAM;AAAA,IAC3C,kBAAkB;AAAA,MAChB,GAAI,OAAO,YAAY,eAAe,CAAC,OAAO,YAAY,YAAY,IAAI,CAAC;AAAA,MAC3E,GAAI,OAAO,YAAY,aAAa,CAAC,OAAO,YAAY,UAAU,IAAI,CAAC;AAAA,MACvE,IAAK,OAAO,YAAY,WAAW,CAAC,GAAG,OAAO,OAAO;AAAA,IACvD;AAAA,EACF;AACF;AAEO,SAAS,8BAA8B,QAA4C;AACxF,QAAM,SAAiC,CAAC;AACxC,QAAM,UAAU,OAAO,YAAY;AACnC,QAAM,UAAU,OAAO,YAAY;AACnC,QAAM,aAAa,OAAO,YAAY;AACtC,QAAM,eAAe,OAAO,YAAY;AACxC,QAAM,sBACJ,eAAe,OAAO,YAAY,WAAW,cAAc,UAAU,UAAU;AAEjF,SAAO,KAAK,gCAAgC,QAAQ,WAAW,OAAO,CAAC;AACvE,MACE,WACA,YAAY,WACZ,YAAY,uBACZ,YAAY,cACZ;AACA,WAAO,KAAK,gCAAgC,QAAQ,WAAW,OAAO,CAAC;AAAA,EACzE;AACA,MAAI,cAAc;AAChB,WAAO,KAAK,gCAAgC,QAAQ,cAAc,YAAY,CAAC;AAAA,EACjF;AACA,MAAI,qBAAqB;AACvB,WAAO,KAAK,gCAAgC,QAAQ,YAAY,mBAAmB,CAAC;AAAA,EACtF;AAEA,SAAO;AACT;AAEO,SAAS,6BACd,GACA,GACQ;AACR,MAAI,EAAE,aAAa,EAAE,SAAU,QAAO,EAAE,SAAS,cAAc,EAAE,QAAQ;AACzE,MAAI,EAAE,cAAc,EAAE,UAAW,QAAO,EAAE,UAAU,cAAc,EAAE,SAAS;AAC7E,SAAO,uBAAuB,EAAE,SAAS,IAAI,uBAAuB,EAAE,SAAS;AACjF;AAEO,SAAS,0BAA0B,QAAwD;AAChG,SAAO,CAAC,GAAG,MAAM,EAAE,KAAK,4BAA4B;AACtD;","names":[]}

package/dist/chunk-IUM3VSHI.js

@@ -0,0 +1,113 @@
+// src/qmd-status.ts
+function parseLeadingInt(s) {
+  let digits = "";
+  for (const ch of s) {
+    if (ch >= "0" && ch <= "9") digits += ch;
+    else if (ch === "," && digits.length > 0) continue;
+    else break;
+  }
+  return digits.length > 0 ? Number.parseInt(digits, 10) : null;
+}
+function parseLeadingDurationMs(s) {
+  let digits = "";
+  let i = 0;
+  for (; i < s.length; i++) {
+    if (s[i] >= "0" && s[i] <= "9") digits += s[i];
+    else break;
+  }
+  if (digits.length === 0) return null;
+  const val = Number.parseInt(digits, 10);
+  const unit = s.slice(i).trim();
+  if (unit === "ms") return val;
+  if (unit === "s") return val * 1e3;
+  if (unit === "m") return val * 6e4;
+  if (unit === "h") return val * 36e5;
+  return null;
+}
+function parseQmdStatusOutput(stdout) {
+  const raw = stdout;
+  let totalFiles = null;
+  let embeddedFiles = null;
+  let pendingEmbeddings = null;
+  let oldestPendingAgeMs = null;
+  for (const rawLine of stdout.split("\n")) {
+    const line = rawLine.trim().toLowerCase();
+    const colonIdx = line.indexOf(":");
+    if (colonIdx === -1) continue;
+    const key = line.slice(0, colonIdx).trim();
+    const value = line.slice(colonIdx + 1).trim();
+    if (key === "total" || key === "total files" || key === "total file") {
+      totalFiles = parseLeadingInt(value);
+    } else if (key === "vectors" || key === "embedded") {
+      embeddedFiles = parseLeadingInt(value);
+    } else if (key === "oldest pending") {
+      oldestPendingAgeMs = parseLeadingDurationMs(value);
+    } else if (key.startsWith("pending")) {
+      pendingEmbeddings = parseLeadingInt(value);
+    }
+  }
+  return { totalFiles, embeddedFiles, pendingEmbeddings, oldestPendingAgeMs, raw };
+}
+var EMPTY_QMD_STATUS = {
+  totalFiles: null,
+  embeddedFiles: null,
+  pendingEmbeddings: null,
+  oldestPendingAgeMs: null,
+  raw: ""
+};
+function formatBacklogLinesFromReport(report, threshold) {
+  if (!report) return [];
+  const lines = [];
+  if (report.pendingEmbeddings != null) {
+    lines.push(`  Pending embeddings: ${report.pendingEmbeddings}`);
+    if (threshold > 0 && report.pendingEmbeddings > threshold) {
+      lines.push(`  \u26A0 Embedding backlog exceeds threshold (${threshold}) \u2014 degraded`);
+    }
+  }
+  if (report.oldestPendingAgeMs != null) {
+    const ageMin = Math.round(report.oldestPendingAgeMs / 6e4);
+    lines.push(`  Oldest pending: ${ageMin}m`);
+  }
+  return lines;
+}
+async function renderQmdBacklogStatus(qmd, threshold) {
+  const backend = qmd;
+  if (!backend || typeof backend.status !== "function") return [];
+  try {
+    const report = await Promise.race([
+      backend.status(),
+      new Promise((resolve) => setTimeout(() => resolve(null), 5e3).unref?.())
+    ]);
+    if (!report) return [];
+    return formatBacklogLinesFromReport(report, threshold);
+  } catch {
+    return [];
+  }
+}
+async function fetchQmdStatus(runQmdCommand, collection, timeoutMs) {
+  try {
+    const { stdout } = await runQmdCommand(["status", "-c", collection], timeoutMs);
+    return parseQmdStatusOutput(stdout);
+  } catch (error) {
+    return { ...EMPTY_QMD_STATUS, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+async function embedQmdFiles(runQmdCommand, collection, _filePaths, timeoutMs, embedArgs) {
+  try {
+    await runQmdCommand(["update", "-c", collection], timeoutMs);
+    await runQmdCommand(embedArgs ?? ["embed", "-c", collection], timeoutMs);
+    return { ok: true };
+  } catch (error) {
+    return { ok: false, error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+export {
+  parseQmdStatusOutput,
+  EMPTY_QMD_STATUS,
+  formatBacklogLinesFromReport,
+  renderQmdBacklogStatus,
+  fetchQmdStatus,
+  embedQmdFiles
+};
+//# sourceMappingURL=chunk-IUM3VSHI.js.map

package/dist/chunk-IUM3VSHI.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/qmd-status.ts"],"sourcesContent":["/**\n * QMD status parsing and backlog reporting helpers.\n *\n * Extracted from qmd.ts to keep that module under its structural ceiling.\n * Issue #2019: expose embedding backlog metrics in health and CLI surfaces.\n */\n\nexport interface QmdStatusReport {\n  totalFiles: number | null;\n  embeddedFiles: number | null;\n  pendingEmbeddings: number | null;\n  /** Age in ms of the oldest file still pending embedding, or null if unavailable. */\n  oldestPendingAgeMs: number | null;\n  /** Raw text output from `qmd status` for debugging. */\n  raw: string;\n  /** Error message when the status command fails, if any. */\n  error?: string;\n}\n\n/** Minimal interface for backends that expose QMD status. */\nexport interface QmdStatusCapable {\n  status(): Promise<QmdStatusReport>;\n}\n\n/**\n * Parse `qmd status -c <collection>` text output into structured metrics.\n * Handles formats like:\n *   Total files: 200129\n *   Embedded: 189091 (94.5%)\n *   Pending embedding: 108186\n * Returns null fields for unparseable or missing lines.\n */\nfunction parseLeadingInt(s: string): number | null {\n  let digits = \"\";\n  for (const ch of s) {\n    if (ch >= \"0\" && ch <= \"9\") digits += ch;\n    else if (ch === \",\" && digits.length > 0) continue;\n    else break;\n  }\n  return digits.length > 0 ? Number.parseInt(digits, 10) : null;\n}\n\nfunction parseLeadingDurationMs(s: string): number | null {\n  let digits = \"\";\n  let i = 0;\n  for (; i < s.length; i++) {\n    if (s[i] >= \"0\" && s[i] <= \"9\") digits += s[i];\n    else break;\n  }\n  if (digits.length === 0) return null;\n  const val = Number.parseInt(digits, 10);\n  const unit = s.slice(i).trim();\n  if (unit === \"ms\") return val;\n  if (unit === \"s\") return val * 1000;\n  if (unit === \"m\") return val * 60_000;\n  if (unit === \"h\") return val * 3_600_000;\n  return null;\n}\n\nexport function parseQmdStatusOutput(stdout: string): QmdStatusReport {\n  const raw = stdout;\n  let totalFiles: number | null = null;\n  let embeddedFiles: number | null = null;\n  let pendingEmbeddings: number | null = null;\n  let oldestPendingAgeMs: number | null = null;\n\n  for (const rawLine of stdout.split(\"\\n\")) {\n    const line = rawLine.trim().toLowerCase();\n    const colonIdx = line.indexOf(\":\");\n    if (colonIdx === -1) continue;\n    const key = line.slice(0, colonIdx).trim();\n    const value = line.slice(colonIdx + 1).trim();\n\n    if (key === \"total\" || key === \"total files\" || key === \"total file\") {\n      totalFiles = parseLeadingInt(value);\n    } else if (key === \"vectors\" || key === \"embedded\") {\n      embeddedFiles = parseLeadingInt(value);\n    } else if (key === \"oldest pending\") {\n      oldestPendingAgeMs = parseLeadingDurationMs(value);\n    } else if (key.startsWith(\"pending\")) {\n      pendingEmbeddings = parseLeadingInt(value);\n    }\n  }\n\n  return { totalFiles, embeddedFiles, pendingEmbeddings, oldestPendingAgeMs, raw };\n}\n\n/** Empty status report returned when QMD is unavailable or the command fails. */\nexport const EMPTY_QMD_STATUS: QmdStatusReport = {\n  totalFiles: null,\n  embeddedFiles: null,\n  pendingEmbeddings: null,\n  oldestPendingAgeMs: null,\n  raw: \"\",\n};\n\n/**\n * Format backlog lines from a pre-resolved status report.\n * Returns display strings for CLI output; empty array when unavailable.\n */\nexport function formatBacklogLinesFromReport(\n  report: QmdStatusReport | null | undefined,\n  threshold: number,\n): string[] {\n  if (!report) return [];\n  const lines: string[] = [];\n\n  if (report.pendingEmbeddings != null) {\n    lines.push(`  Pending embeddings: ${report.pendingEmbeddings}`);\n    if (threshold > 0 && report.pendingEmbeddings > threshold) {\n      lines.push(`  ⚠ Embedding backlog exceeds threshold (${threshold}) — degraded`);\n    }\n  }\n\n  if (report.oldestPendingAgeMs != null) {\n    const ageMin = Math.round(report.oldestPendingAgeMs / 60_000);\n    lines.push(`  Oldest pending: ${ageMin}m`);\n  }\n\n  return lines;\n}\n\n/**\n * Fetch QMD status and format backlog lines for CLI output.\n * Returns empty array when the backend lacks status() or the call fails.\n */\nexport async function renderQmdBacklogStatus(\n  qmd: unknown,\n  threshold: number,\n): Promise<string[]> {\n  const backend = qmd as Partial<QmdStatusCapable> | null;\n  if (!backend || typeof backend.status !== \"function\") return [];\n  try {\n    const report = await Promise.race([\n      backend.status(),\n      new Promise<null>((resolve) => setTimeout(() => resolve(null), 5_000).unref?.()),\n    ]);\n    if (!report) return [];\n    return formatBacklogLinesFromReport(report, threshold);\n  } catch {\n    return [];\n  }\n}\n\nexport type QmdCommandRunner = (args: string[], timeoutMs: number) => Promise<{ stdout: string; stderr: string }>;\n\n/**\n * Fetch QMD collection status via the `qmd status` command. Returns an\n * unavailable report (with `error` set) when the command fails.\n */\nexport async function fetchQmdStatus(\n  runQmdCommand: QmdCommandRunner,\n  collection: string,\n  timeoutMs: number,\n): Promise<QmdStatusReport> {\n  try {\n    const { stdout } = await runQmdCommand([\"status\", \"-c\", collection], timeoutMs);\n    return parseQmdStatusOutput(stdout);\n  } catch (error) {\n    return { ...EMPTY_QMD_STATUS, error: error instanceof Error ? error.message : String(error) };\n  }\n}\n\n/**\n * Trigger a collection-level embed run via `qmd embed -c <collection>`.\n * The QMD CLI does not support per-file embed targeting; this triggers\n * embedding for all pending files in the collection. The prioritized-embed\n * module debounces and batches these triggers so fresh writes become\n * searchable within minutes without hammering the CLI on every write.\n * Returns `{ ok: false }` on failure so callers can reschedule without crashing.\n */\nexport async function embedQmdFiles(\n  runQmdCommand: QmdCommandRunner,\n  collection: string,\n  _filePaths: string[],\n  timeoutMs: number,\n  embedArgs?: string[],\n): Promise<{ ok: boolean; error?: string }> {\n  try {\n    await runQmdCommand([\"update\", \"-c\", collection], timeoutMs);\n    await runQmdCommand(embedArgs ?? [\"embed\", \"-c\", collection], timeoutMs);\n    return { ok: true };\n  } catch (error) {\n    return { ok: false, error: error instanceof Error ? error.message : String(error) };\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-TRWPCR6P.js → chunk-JECBQBEX.js}

@@ -5,10 +5,10 @@ import {
 } from "./chunk-OD4FM2U7.js";
 import {
   resolveCompressionCapabilities
-} from "./chunk-BFPETA3S.js";
+} from "./chunk-SCCO46KZ.js";
 import {
   log
-} from "./chunk-37CTGERM.js";
+} from "./chunk-3WCASNQZ.js";
 
 // src/orchestration/compression-guideline-coordinator.ts
 import { createHash } from "crypto";
@@ -283,4 +283,4 @@ export {
   CompressionGuidelineCoordinator,
   formatCompressionGuidelinesForRecall
 };
-//# sourceMappingURL=chunk-TRWPCR6P.js.map
+//# sourceMappingURL=chunk-JECBQBEX.js.map

package/dist/{chunk-E6CBU7XP.js → chunk-JYIFGGEM.js}

@@ -1,6 +1,6 @@
 import {
   readAllEdges
-} from "./chunk-2S6QHZGJ.js";
+} from "./chunk-L2DPF4DF.js";
 import {
   readEdgeConfidence
 } from "./chunk-2LSZVONP.js";
@@ -162,4 +162,4 @@ export {
   parseGraphSnapshotSince,
   buildGraphSnapshot
 };
-//# sourceMappingURL=chunk-E6CBU7XP.js.map
+//# sourceMappingURL=chunk-JYIFGGEM.js.map

package/dist/{chunk-VA4WSW54.js → chunk-JYIJNNN3.js}

@@ -4,13 +4,13 @@ import {
 } from "./chunk-AAD2ZS6P.js";
 import {
   gatewayTaskChainOptions
-} from "./chunk-UXKMMNJD.js";
+} from "./chunk-C23BYTJV.js";
 import {
   extractJsonCandidates
 } from "./chunk-RGMVMVMF.js";
 import {
   log
-} from "./chunk-37CTGERM.js";
+} from "./chunk-3WCASNQZ.js";
 
 // src/extraction-faithfulness.ts
 import { createHash } from "crypto";
@@ -685,4 +685,4 @@ export {
   serializeFaithfulnessFields,
   parseFaithfulnessField
 };
-//# sourceMappingURL=chunk-VA4WSW54.js.map
+//# sourceMappingURL=chunk-JYIJNNN3.js.map

package/dist/{chunk-L5HJQC36.js → chunk-K2TDK7GG.js}

@@ -3,13 +3,13 @@ import {
 } from "./chunk-QDW3E4RD.js";
 import {
   gatewayTaskChainOptions
-} from "./chunk-UXKMMNJD.js";
+} from "./chunk-C23BYTJV.js";
 import {
   extractJsonCandidates
 } from "./chunk-RGMVMVMF.js";
 import {
   log
-} from "./chunk-37CTGERM.js";
+} from "./chunk-3WCASNQZ.js";
 
 // src/extraction-judge.ts
 import { createHash } from "crypto";
@@ -486,4 +486,4 @@ export {
   createVerdictCache,
   createDeferCountMap
 };
-//# sourceMappingURL=chunk-L5HJQC36.js.map
+//# sourceMappingURL=chunk-K2TDK7GG.js.map

package/dist/{chunk-KDXVOFYY.js → chunk-KAVBJSBQ.js}

@@ -1,10 +1,10 @@
 import {
   StorageManager,
   normalizeEntityName
-} from "./chunk-K7LOWSLU.js";
+} from "./chunk-4BJQODZF.js";
 import {
   serializeMutations
-} from "./chunk-LTJAMRGI.js";
+} from "./chunk-WL5EBRDH.js";
 import {
   extractJsonCandidates
 } from "./chunk-RGMVMVMF.js";
@@ -14,7 +14,7 @@ import {
 } from "./chunk-JUC24CTX.js";
 import {
   log
-} from "./chunk-37CTGERM.js";
+} from "./chunk-3WCASNQZ.js";
 
 // src/briefing.ts
 import { readFile as readFile2 } from "fs/promises";
@@ -956,4 +956,4 @@ export {
   resolveBriefingSaveDir,
   briefingFilename
 };
-//# sourceMappingURL=chunk-KDXVOFYY.js.map
+//# sourceMappingURL=chunk-KAVBJSBQ.js.map

package/dist/{chunk-BS4SGLWV.js → chunk-KF5EUVKQ.js}

@@ -1,14 +1,16 @@
 import {
   assertFleetWideOperationAllowed,
   assertOperationAllowed,
+  capabilityAllowsOp,
   tokenCapabilityStore
-} from "./chunk-D7FOKIY5.js";
-import {
-  EngramAccessInputError
-} from "./chunk-LZOV7MX7.js";
+} from "./chunk-7AMFUATK.js";
 import {
   expandTildePath
 } from "./chunk-EYIEWJNI.js";
+import {
+  EngramAccessForbiddenError,
+  EngramAccessInputError
+} from "./chunk-2Z24E5W2.js";
 
 // src/access-boundary.ts
 import { z } from "zod";
@@ -44,6 +46,7 @@ var OPERATION_NAMES = [
   "set_coding_context",
   "recall_tier_explain",
   "recall_xray",
+  "namespace_writable",
   "wearables_status",
   "wearables_sync",
   "transcript_day",
@@ -245,7 +248,14 @@ function defineOperation(spec) {
       if (!parseResult.success) {
         throw new EngramAccessInputError(formatZodIssues(parseResult.error));
       }
-      assertOperationAllowed(tokenCapabilityStore.getStore(), spec.name);
+      if (spec.allowedByOps && spec.allowedByOps.length > 0) {
+        const store = tokenCapabilityStore.getStore();
+        if (!spec.allowedByOps.some((op) => capabilityAllowsOp(store, op))) {
+          throw new EngramAccessForbiddenError(`token is not permitted to call operation: ${spec.name}`);
+        }
+      } else {
+        assertOperationAllowed(tokenCapabilityStore.getStore(), spec.name);
+      }
       if (spec.fleetWide) {
         assertFleetWideOperationAllowed(tokenCapabilityStore.getStore());
       }
@@ -276,4 +286,4 @@ export {
   listRegisteredOperations,
   __resetRegistryForTest
 };
-//# sourceMappingURL=chunk-BS4SGLWV.js.map
+//# sourceMappingURL=chunk-KF5EUVKQ.js.map