@remnic/core 10.0.14 → 10.0.15

package/dist/{chunk-Y4NKEXQT.js → chunk-5ATSXCAG.js}

@@ -7,10 +7,10 @@ import {
 import {
   listMemoryGovernanceRuns,
   readMemoryGovernanceRunArtifact
-} from "./chunk-P5NQN4JE.js";
+} from "./chunk-C6JMGAMO.js";
 import {
   StorageManager
-} from "./chunk-PAZ35RJ4.js";
+} from "./chunk-4SCZZ3U7.js";
 import {
   normalizeProjectionPreview,
   normalizeProjectionTags
@@ -1156,4 +1156,4 @@ export {
   verifyMemoryProjection,
   repairMemoryProjection
 };
-//# sourceMappingURL=chunk-Y4NKEXQT.js.map
+//# sourceMappingURL=chunk-5ATSXCAG.js.map

package/dist/{chunk-JDZFIR2S.js → chunk-5KGYTX5O.js}

@@ -1,6 +1,6 @@
 import {
   parseFrontmatter
-} from "./chunk-PAZ35RJ4.js";
+} from "./chunk-4SCZZ3U7.js";
 import {
   activityDigestPath,
   isValidActivityDate
@@ -199,4 +199,4 @@ export {
   buildStandup,
   standupHelp
 };
-//# sourceMappingURL=chunk-JDZFIR2S.js.map
+//# sourceMappingURL=chunk-5KGYTX5O.js.map

package/dist/{chunk-NW2E4CI2.js → chunk-5SMR542T.js}

@@ -2,7 +2,7 @@ import {
   OFFLINE_SYNC_SNAPSHOT_FORMAT,
   filterOfflineSyncDeletionRevisions,
   iterateOfflineSyncSnapshotFileRecords
-} from "./chunk-63B2IZYE.js";
+} from "./chunk-23ZQPP2G.js";
 import {
   computeOmittedEmbeddingGenerationPaths,
   embeddingGenerationMembership
@@ -61,4 +61,4 @@ async function buildEmbeddingAwareSnapshotStream(options) {
 export {
   buildEmbeddingAwareSnapshotStream
 };
-//# sourceMappingURL=chunk-NW2E4CI2.js.map
+//# sourceMappingURL=chunk-5SMR542T.js.map

package/dist/{chunk-S7LWX2PQ.js → chunk-655FVTCD.js}

@@ -1,6 +1,6 @@
 import {
   scanMemoryDir
-} from "./chunk-4O6WRBGE.js";
+} from "./chunk-KJXP6RUG.js";
 import {
   isSearchAborted,
   throwIfSearchAborted
@@ -508,4 +508,4 @@ function isMissingVectorProviderColumnError(err) {
 export {
   LanceDbBackend
 };
-//# sourceMappingURL=chunk-S7LWX2PQ.js.map
+//# sourceMappingURL=chunk-655FVTCD.js.map

package/dist/{chunk-ZSH2NRDV.js → chunk-6WGMZQGG.js}

@@ -1,6 +1,6 @@
 import {
   getOperation
-} from "./chunk-ZV65I6ME.js";
+} from "./chunk-XLBFX63V.js";
 import {
   EngramAccessInputError
 } from "./chunk-3MUKQQ7A.js";
@@ -21,4 +21,4 @@ async function respondBriefingHttp(options) {
 export {
   respondBriefingHttp
 };
-//# sourceMappingURL=chunk-ZSH2NRDV.js.map
+//# sourceMappingURL=chunk-6WGMZQGG.js.map

package/dist/{chunk-W47S5TIH.js → chunk-7VQ6AI7H.js}

@@ -34,7 +34,7 @@ import {
 } from "./chunk-NVKO5YKP.js";
 import {
   compareEntityTimestamps
-} from "./chunk-PAZ35RJ4.js";
+} from "./chunk-4SCZZ3U7.js";
 import {
   normalizeEntityName
 } from "./chunk-YXZG5TVN.js";
@@ -927,4 +927,4 @@ export {
   entityIndexVersion,
   entityRecentTranscriptLookbackHours
 };
-//# sourceMappingURL=chunk-W47S5TIH.js.map
+//# sourceMappingURL=chunk-7VQ6AI7H.js.map

package/dist/{chunk-G7NYVKD6.js → chunk-B2NXOVZN.js}

@@ -15,7 +15,7 @@ import {
 import {
   listJsonFiles,
   readJsonFile
-} from "./chunk-B6O2YLUR.js";
+} from "./chunk-2Z5DIDQD.js";
 
 // src/work-product-ledger.ts
 import path from "path";
@@ -182,4 +182,4 @@ export {
   searchWorkProductLedgerEntries,
   getWorkProductLedgerStatus
 };
-//# sourceMappingURL=chunk-G7NYVKD6.js.map
+//# sourceMappingURL=chunk-B2NXOVZN.js.map

package/dist/{chunk-N7KYEVLK.js → chunk-BK2BVLZW.js}

@@ -14,7 +14,7 @@ import {
 } from "./chunk-3UXOZBHV.js";
 import {
   StorageManager
-} from "./chunk-PAZ35RJ4.js";
+} from "./chunk-4SCZZ3U7.js";
 import {
   OKF_PROFILE_TYPE,
   okfTypeForMemory
@@ -272,4 +272,4 @@ export {
   exportOkfBundle,
   firstHeading
 };
-//# sourceMappingURL=chunk-N7KYEVLK.js.map
+//# sourceMappingURL=chunk-BK2BVLZW.js.map

package/dist/{chunk-QJ622LTI.js → chunk-BQOGQULP.js}

@@ -2,19 +2,28 @@ import {
   isTemporalQuery,
   recencyWindowBoundsFromPrompt
 } from "./chunk-ZOKZIR5K.js";
+import {
+  isShapedUnnamedEntityRecord
+} from "./chunk-PPUNC7UX.js";
 import {
   normalizeRecallTokens
 } from "./chunk-YCVB7X56.js";
 import {
   isAbortError
 } from "./chunk-BTTPKDIL.js";
+import {
+  isMacOsReplicationJunkBasename
+} from "./chunk-QUIRIG2P.js";
+import {
+  isEncryptedFile
+} from "./chunk-MAAL6OZV.js";
 import {
   log
 } from "./chunk-3WCASNQZ.js";
 
 // src/retrieval-agents.ts
+import { lstat, readFile, readdir, realpath, stat } from "fs/promises";
 import path from "path";
-import { lstat, readdir, readFile, realpath, stat } from "fs/promises";
 var PARALLEL_AGENT_WEIGHTS = {
   direct: 1,
   // entity-first: high precision
@@ -75,9 +84,9 @@ async function runDirectAgent(query, memoryDir, maxResults = 10, namespaceFromPa
     }
     const queryTokens = tokenize(query);
     if (queryTokens.length === 0) return [];
-    const results = [];
+    const scored = [];
     for (const entry of entries) {
-      if (!entry.endsWith(".md")) continue;
+      if (isMacOsReplicationJunkBasename(entry) || !entry.endsWith(".md")) continue;
       const nameWithoutExt = entry.slice(0, -3);
       const entityTokens = nameWithoutExt.split("-").filter((t) => t.length >= 2).map((t) => t.toLowerCase());
       const score = overlapScore(queryTokens, entityTokens);
@@ -85,14 +94,27 @@ async function runDirectAgent(query, memoryDir, maxResults = 10, namespaceFromPa
       const fullPath = path.join(entitiesDir, entry);
       const safePath = await resolveContainedRegularFile(memoryDir, fullPath, canonicalRoot);
       if (!safePath) continue;
+      scored.push({ nameWithoutExt, safePath, score });
+    }
+    scored.sort((a, b) => b.score - a.score);
+    const results = [];
+    for (const hit of scored) {
+      if (results.length >= maxResults) break;
+      let bytes;
+      try {
+        bytes = await readFile(hit.safePath);
+      } catch {
+        continue;
+      }
+      if (!isEncryptedFile(bytes) && isShapedUnnamedEntityRecord(bytes.toString("utf8"))) continue;
       results.push(
         namespaceRelativeResult(
           {
-            docid: nameWithoutExt,
-            path: safePath,
+            docid: hit.nameWithoutExt,
+            path: hit.safePath,
             snippet: "",
             // populated by augmentWithDirectAndTemporal after merge
-            score,
+            score: hit.score,
             transport: "scoped_prefilter",
             agentSource: "direct"
           },
@@ -101,7 +123,7 @@ async function runDirectAgent(query, memoryDir, maxResults = 10, namespaceFromPa
         )
       );
     }
-    return results.sort((a, b) => b.score - a.score).slice(0, maxResults);
+    return results;
   } catch (err) {
     log.debug(`DirectFactAgent error: ${err}`);
     return [];
@@ -430,4 +452,4 @@ export {
   augmentWithDirectAndTemporal,
   parallelRetrieval
 };
-//# sourceMappingURL=chunk-QJ622LTI.js.map
+//# sourceMappingURL=chunk-BQOGQULP.js.map

package/dist/chunk-BQOGQULP.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/retrieval-agents.ts"],"sourcesContent":["/**\n * Parallel Specialized Retrieval (v9.1 — ASMR-inspired)\n *\n * Replaces single-pass hybrid search with three parallel specialized agents:\n *\n *   1. DirectFactAgent  — entity-first lookup via entity filename index (<5ms)\n *   2. ContextualAgent  — existing hybridSearch (same cost as current single-pass)\n *   3. TemporalAgent    — temporal index prefilter + recency scoring (<10ms)\n *\n * All agents run via Promise.all(), so total latency = max(agents), not sum.\n * No new LLM inference is introduced — agents reuse existing search primitives.\n *\n * Graceful degradation: any agent error/timeout does not block the others.\n *\n * References:\n *   - Supermemory ASMR: https://blog.supermemory.ai/...\n *   - Spec: docs/ideas/parallel-specialized-retrieval.md\n */\n\nimport { lstat, readFile, readdir, realpath, stat } from \"node:fs/promises\";\nimport path from \"node:path\";\nimport { isAbortError } from \"./abort-error.js\";\nimport { log } from \"./logger.js\";\nimport type { QmdClient } from \"./qmd.js\";\nimport { normalizeRecallTokens } from \"./recall-tokenization.js\";\nimport { isEncryptedFile } from \"./secure-store/secure-fs.js\";\nimport { isTemporalQuery, recencyWindowBoundsFromPrompt } from \"./temporal-index.js\";\nimport type { QmdSearchResult } from \"./types.js\";\nimport { isMacOsReplicationJunkBasename } from \"./utils/macos-replication-junk.js\";\nimport { isShapedUnnamedEntityRecord } from \"./utils/malformed-entity-record.js\";\n\n\n// ─── Types ───────────────────────────────────────────────────────────────────\n\nexport type SearchAgentSource = \"direct\" | \"contextual\" | \"temporal\";\n\nexport interface ParallelSearchResult extends QmdSearchResult {\n  /** Which retrieval agent produced this result. */\n  agentSource: SearchAgentSource;\n}\n\n/** Source-based weights applied during merge. Higher = higher confidence/precision. */\nexport const PARALLEL_AGENT_WEIGHTS: Record<SearchAgentSource, number> = {\n  direct: 1.0, // entity-first: high precision\n  temporal: 0.85, // recency-boosted: relevant but broader\n  contextual: 0.7, // semantic: broadest, lower precision\n};\n\n// ─── Query classification ────────────────────────────────────────────────────\n\n/**\n * Decide whether a given agent should run for this query.\n * Agent 1 (direct) is the only one that may be skipped — when the query\n * contains no proper-noun-like tokens, entity lookups will return nothing.\n * Agents 2 (contextual) and 3 (temporal) always run.\n */\nexport function shouldRunAgent(\n  agent: SearchAgentSource,\n  query: string,\n  knownEntityCount: number,\n): boolean {\n  switch (agent) {\n    case \"direct\":\n      // Skip only if the query has no letter/number tokens. `\\w` and `\\b` are\n      // ASCII-only, so CJK entity names would never start the direct agent.\n      return knownEntityCount > 0 || /[\\p{L}\\p{N}]{2,}/u.test(query);\n    case \"temporal\":\n      // Only run temporal agent when the query actually asks about a time window.\n      // Running it for every query injects recency bias into semantic searches.\n      return isTemporalQuery(query);\n    case \"contextual\":\n      return true;\n    default:\n      return true;\n  }\n}\n\n// ─── Helpers ─────────────────────────────────────────────────────────────────\n\nfunction tokenize(value: string): string[] {\n  return normalizeRecallTokens(value).filter((t) => t.length >= 2);\n}\n\nfunction overlapScore(queryTokens: string[], candidateTokens: string[]): number {\n  if (queryTokens.length === 0 || candidateTokens.length === 0) return 0;\n  const candidateSet = new Set(candidateTokens);\n  const hits = queryTokens.filter((t) => candidateSet.has(t)).length;\n  return hits / Math.max(queryTokens.length, candidateTokens.length);\n}\n\nasync function resolveContainedRegularFile(\n  memoryDir: string,\n  candidatePath: string,\n  canonicalRoot?: string,\n): Promise<string | null> {\n  try {\n    const root = canonicalRoot ?? await realpath(memoryDir);\n    const absolute = path.isAbsolute(candidatePath)\n      ? path.resolve(candidatePath)\n      : path.resolve(memoryDir, candidatePath);\n    const entryStat = await lstat(absolute);\n    if (entryStat.isSymbolicLink()) return null;\n    const fileStat = await stat(absolute);\n    if (!fileStat.isFile()) return null;\n    const canonical = await realpath(absolute);\n    if (canonical !== root && !canonical.startsWith(root + path.sep)) return null;\n    return absolute;\n  } catch {\n    return null;\n  }\n}\n\n// ─── Agent 1: Direct Facts ───────────────────────────────────────────────────\n\n/**\n * Direct Facts Agent — entity-first retrieval.\n *\n * Reads entity filenames from the entities directory and scores them by\n * keyword overlap with the query. Returns matching entity file paths as\n * QmdSearchResult[]. Zero LLM inference; pure file I/O.\n *\n * Cost: readdir on entities/ + filename scoring. Typically <5ms.\n * Scored hits are read, up to the result cap, so a malformed record is not returned.\n *\n */\n// Agents scan one namespace storage dir and return absolute paths. Contextual\n// fanout hits are also absolute (globally-unique identity), so we keep the\n// agent path absolute and only stamp the owning namespace here — that carries\n// the namespace through merge/tracking without re-deriving it (#2020). No-op\n// without a resolver.\nfunction namespaceRelativeResult(\n  result: ParallelSearchResult,\n  _memoryDir: string,\n  namespaceFromPath?: (p: string) => string,\n): ParallelSearchResult {\n  if (!namespaceFromPath || !result.path || result.namespace) return result;\n  return { ...result, namespace: namespaceFromPath(result.path) };\n}\n\nexport async function runDirectAgent(\n  query: string,\n  memoryDir: string,\n  maxResults = 10,\n  namespaceFromPath?: (p: string) => string,\n): Promise<ParallelSearchResult[]> {\n  try {\n    const canonicalRoot = await realpath(memoryDir);\n    const entitiesDir = path.join(memoryDir, \"entities\");\n    let entries: string[];\n    try {\n      entries = await readdir(entitiesDir);\n    } catch {\n      return []; // entities dir missing or unreadable — not an error\n    }\n\n    const queryTokens = tokenize(query);\n    if (queryTokens.length === 0) return [];\n\n    const scored: Array<{ nameWithoutExt: string; safePath: string; score: number }> = [];\n    for (const entry of entries) {\n      if (isMacOsReplicationJunkBasename(entry) || !entry.endsWith(\".md\")) continue;\n\n      // Filename tokens: split on hyphens (normalizeEntityName uses hyphens)\n      const nameWithoutExt = entry.slice(0, -3);\n      const entityTokens = nameWithoutExt.split(\"-\").filter((t) => t.length >= 2).map((t) => t.toLowerCase());\n\n      const score = overlapScore(queryTokens, entityTokens);\n      if (score <= 0) continue;\n\n      const fullPath = path.join(entitiesDir, entry);\n      const safePath = await resolveContainedRegularFile(memoryDir, fullPath, canonicalRoot);\n      if (!safePath) continue;\n      scored.push({ nameWithoutExt, safePath, score });\n    }\n\n    scored.sort((a, b) => b.score - a.score);\n    const results: ParallelSearchResult[] = [];\n    for (const hit of scored) {\n      if (results.length >= maxResults) break;\n      let bytes: Buffer;\n      try {\n        bytes = await readFile(hit.safePath);\n      } catch {\n        continue;\n      }\n      // Ciphertext has no heading. The secure resolver decrypts after this\n      // candidate is kept; this scan does not look up a key.\n      if (!isEncryptedFile(bytes) && isShapedUnnamedEntityRecord(bytes.toString(\"utf8\"))) continue;\n      results.push(\n        namespaceRelativeResult(\n          {\n            docid: hit.nameWithoutExt,\n            path: hit.safePath,\n            snippet: \"\", // populated by augmentWithDirectAndTemporal after merge\n            score: hit.score,\n            transport: \"scoped_prefilter\",\n            agentSource: \"direct\",\n          },\n          memoryDir,\n          namespaceFromPath,\n        ),\n      );\n    }\n\n    return results;\n  } catch (err) {\n    log.debug(`DirectFactAgent error: ${err}`);\n    return [];\n  }\n}\n\n// ─── Agent 3: Temporal ───────────────────────────────────────────────────────\n\n/**\n * Temporal Agent — recency-focused retrieval.\n *\n * Uses the temporal index (index_time.json) to find memories from the\n * recent time window derived from the query (default: last 7 days).\n * Combines recency decay with query-filename token overlap so results stay\n * relevant to the query content, not just recency. Zero LLM inference; File I/O + math.\n *\n * Cost: read index_time.json + date range scan. Typically <10ms.\n */\nexport async function runTemporalAgent(\n  query: string,\n  memoryDir: string,\n  maxResults = 20,\n  /** Optional candidate set from query-aware prefilter. Applied BEFORE the top-K cap so\n   * in-scope entries are not displaced by newer out-of-scope entries. */\n  candidatePaths?: Set<string> | null,\n  namespaceFromPath?: (p: string) => string,\n): Promise<ParallelSearchResult[]> {\n  try {\n    const canonicalRoot = await realpath(memoryDir);\n    // Read index_time.json once — used for both date-range filtering and recency scoring.\n    let dateIndex: Record<string, string[]> = {};\n    try {\n      const indexPath = path.join(memoryDir, \"state\", \"index_time.json\");\n      const raw = await readFile(indexPath, \"utf-8\");\n      const parsed = JSON.parse(raw) as { dates?: Record<string, string[]> };\n      dateIndex = parsed.dates ?? {};\n    } catch {\n      return []; // Index missing or unreadable — nothing to return\n    }\n\n    // Derive both window edges from the same function so fromDate/toDate always use\n    // consistent pattern-matching and priority ordering.\n    const { fromDate, toDate } = recencyWindowBoundsFromPrompt(query);\n\n    // Build path → date map, filtering to the recency window in one pass.\n    // Apply candidatePaths here (before scoring + top-K) so in-scope entries are\n    // not displaced by newer out-of-scope entries at the slice boundary.\n    const pathToDate = new Map<string, string>();\n    for (const [date, datePaths] of Object.entries(dateIndex)) {\n      // toDate is an exclusive upper bound (the first day NOT included in the window).\n      // e.g. \"3 days ago\" → fromDate=\"2026-03-12\", toDate=\"2026-03-13\" → only includes 2026-03-12.\n      if (date >= fromDate && date < toDate) {\n        for (const p of datePaths) {\n          // Skip paths excluded by the query-aware prefilter scope\n          if (candidatePaths && !candidatePaths.has(p)) continue;\n          if (!pathToDate.has(p)) pathToDate.set(p, date);\n        }\n      }\n    }\n\n    if (pathToDate.size === 0) return [];\n\n    const todayMs = Date.now();\n\n    // Extract non-temporal topic tokens for tag-based relevance boost.\n    // Purely temporal words (dates, relative time) and common stopwords are stripped\n    // so the signal reflects the subject the user is asking about (e.g. \"auth\" in\n    // \"what changed in auth last week\"), not the time window itself.\n    const TEMPORAL_STOPWORDS = new Set([\n      \"today\", \"yesterday\", \"this\", \"last\", \"week\", \"month\", \"year\",\n      \"morning\", \"night\", \"now\", \"earlier\", \"since\", \"after\", \"before\",\n      \"ago\", \"hours\", \"days\", \"weeks\", \"months\",\n      \"january\", \"february\", \"march\", \"april\", \"may\", \"june\",\n      \"july\", \"august\", \"september\", \"october\", \"november\", \"december\",\n      \"monday\", \"tuesday\", \"wednesday\", \"thursday\", \"friday\", \"saturday\", \"sunday\",\n      \"what\", \"when\", \"where\", \"who\", \"why\", \"how\", \"the\", \"a\", \"an\",\n      \"and\", \"or\", \"in\", \"on\", \"at\", \"to\", \"of\", \"for\", \"with\", \"by\",\n      \"from\", \"changed\", \"happened\", \"was\", \"were\", \"is\", \"are\", \"did\",\n      \"about\", \"that\", \"have\", \"had\", \"has\", \"been\", \"any\", \"all\",\n    ]);\n    const topicTokens = tokenize(query).filter((t) => !TEMPORAL_STOPWORDS.has(t));\n\n    // Load tag index for topical scoring, in parallel with existence checks.\n    // Fail-open: if the tag index is unavailable, topicBoost = 0 and scores\n    // degrade gracefully to recency-only ordering (existing behaviour).\n    const entries = [...pathToDate.entries()];\n    const tagIndexPromise: Promise<Map<string, string[]>> = topicTokens.length > 0\n      ? readFile(path.join(memoryDir, \"state\", \"index_tags.json\"), \"utf-8\")\n          .then((raw) => {\n            const parsed = JSON.parse(raw) as { tags?: Record<string, { paths?: string[] } | string[]> };\n            const result = new Map<string, string[]>();\n            for (const [tag, node] of Object.entries(parsed.tags ?? {})) {\n              const tagPaths = Array.isArray(node) ? node : (node.paths ?? []);\n              for (const tp of tagPaths) {\n                const existing = result.get(tp);\n                if (existing) existing.push(tag);\n                else result.set(tp, [tag]);\n              }\n            }\n            return result;\n          })\n          .catch(() => new Map<string, string[]>())\n      : Promise.resolve(new Map<string, string[]>());\n\n    // Parallel: existence checks + tag index read.\n    const [safePathResults, pathToTags] = await Promise.all([\n      Promise.all(entries.map(([p]) => resolveContainedRegularFile(memoryDir, p, canonicalRoot))),\n      tagIndexPromise,\n    ]);\n\n    const results: ParallelSearchResult[] = [];\n\n    for (let i = 0; i < entries.length; i++) {\n      const [p, dateStr] = entries[i];\n      const safePath = safePathResults[i];\n      if (!safePath) continue; // skip stale or out-of-root index entry\n      const ageMs = todayMs - new Date(dateStr).getTime();\n      const ageDays = ageMs / 86_400_000;\n      // Exponential recency decay with half-life of ~30 days.\n      // score ≈ 1.0 at day 0, ≈ 0.79 at 7 days, ≈ 0.36 at 30 days, ≈ 0.13 at 60 days.\n      const recencyScore = Math.exp(-ageDays / 30);\n\n      // Topical boost: fraction of non-temporal query tokens matched by this file's tags.\n      // Adds up to +30% on recency score for a perfect tag match; zero when query is\n      // purely temporal (no topic tokens) or the tag index doesn't cover the file.\n      let topicBoost = 0;\n      if (topicTokens.length > 0) {\n        const tags = pathToTags.get(p) ?? pathToTags.get(safePath);\n        if (tags && tags.length > 0) {\n          const tagSet = new Set(tags.flatMap((t) => tokenize(t)));\n          const hits = topicTokens.filter((t) => tagSet.has(t)).length;\n          topicBoost = hits / topicTokens.length;\n        }\n      }\n      const score = recencyScore * (1 + topicBoost * 0.3);\n\n      const baseName = path.basename(safePath, \".md\");\n\n      results.push(\n        namespaceRelativeResult(\n          {\n            docid: baseName,\n            path: safePath,\n            snippet: \"\", // populated by augmentWithDirectAndTemporal after merge\n            score,\n            transport: \"scoped_prefilter\",\n            agentSource: \"temporal\",\n          },\n          memoryDir,\n          namespaceFromPath,\n        ),\n      );\n    }\n\n    return results\n      .sort((a, b) => b.score - a.score)\n      .slice(0, maxResults);\n  } catch (err) {\n    log.debug(`TemporalAgent error: ${err}`);\n    return [];\n  }\n}\n\n// ─── Agent 2: Contextual ─────────────────────────────────────────────────────\n\n/**\n * Contextual Agent — broad semantic/hybrid search.\n *\n * Delegates to the existing hybridSearch (BM25 + vector). Same cost as the\n * current single-pass retrieval — this agent introduces no additional LLM calls.\n */\nexport async function runContextualAgent(\n  query: string,\n  qmd: QmdClient,\n  collection: string | undefined,\n  maxResults: number,\n  signal?: AbortSignal,\n): Promise<ParallelSearchResult[]> {\n  try {\n    const results = await qmd.hybridSearch(\n      query,\n      collection,\n      maxResults,\n      signal ? { signal } : undefined,\n    );\n    return results.map((r: QmdSearchResult) => ({ ...r, agentSource: \"contextual\" as const }));\n  } catch (err) {\n    if (isAbortError(err)) throw err;\n    log.debug(`ContextualAgent error: ${err}`);\n    return [];\n  }\n}\n\n// ─── Merge helper ─────────────────────────────────────────────────────────────\n\n/**\n * Merge results from multiple agents into a single deduplicated, weighted list.\n * Deduplicates by (namespace, path). Contextual results carry a `namespace`\n * (from the namespace-fanout search); direct/temporal results do not. When a\n * `resolveNamespace` resolver is supplied, the missing namespace is derived from\n * the result path the same canonical way the contextual side derives it\n * (`result.namespace ?? resolveNamespace(result.path)`), so a direct/temporal hit\n * and a contextual hit for the same (namespace, path) collapse to ONE merge key\n * instead of being injected and access-counted twice. Preserves snippets: if a\n * higher-scoring result lacks a snippet, the existing snippet from a lower-scoring\n * source is retained.\n */\nfunction mergeAgentResults(\n  allResults: ParallelSearchResult[],\n  weights: Record<SearchAgentSource, number>,\n  maxResults: number,\n  resolveNamespace?: (path: string) => string,\n): QmdSearchResult[] {\n  const merged = new Map<string, QmdSearchResult>();\n  for (const result of allResults) {\n    const namespace =\n      result.namespace ?? (resolveNamespace && result.path ? resolveNamespace(result.path) : undefined);\n    const key = `${namespace ?? \"\"}\\0${result.path || result.docid}`;\n    const weightedScore = result.score * weights[result.agentSource];\n    const existing = merged.get(key);\n    if (!existing || weightedScore > existing.score) {\n      merged.set(key, {\n        docid: result.docid,\n        path: result.path,\n        namespace,\n        // Preserve any snippet from the existing entry when the new one has none\n        snippet: result.snippet || existing?.snippet || \"\",\n        score: weightedScore,\n        transport: \"hybrid\",\n      });\n    }\n  }\n  return [...merged.values()]\n    .sort((a, b) => b.score - a.score)\n    .slice(0, maxResults);\n}\n\n/**\n * For merged results that have an empty snippet, attempt to read the first\n * 200 characters of the file as a fallback preview. Bounded to MAX_SNIPPET_READS\n * to cap I/O when many specialized-agent results are present.\n */\nconst SNIPPET_PREVIEW_CHARS = 200;\nconst MAX_SNIPPET_READS = 8;\n\n/** Strip YAML frontmatter (---...---) and return the document body. */\nfunction stripFrontmatter(raw: string): string {\n  if (!raw.startsWith(\"---\")) return raw;\n  const end = raw.indexOf(\"\\n---\", 3);\n  if (end === -1) return raw;\n  // Skip the closing \"---\" line and any leading blank lines\n  return raw.slice(end + 4).replace(/^\\n+/, \"\");\n}\n\nasync function populateEmptySnippets(results: QmdSearchResult[], memoryDir?: string): Promise<QmdSearchResult[]> {\n  const needsSnippet = results.filter((r) => !r.snippet && r.path);\n  if (needsSnippet.length === 0) return results;\n  const canonicalRoot = memoryDir ? await realpath(memoryDir).catch(() => null) : null;\n\n  const toRead = needsSnippet.slice(0, MAX_SNIPPET_READS);\n  const snippetMap = new Map<string, string>();\n\n  await Promise.all(\n    toRead.map(async (r) => {\n      try {\n        const safePath = canonicalRoot && r.path\n          ? await resolveContainedRegularFile(memoryDir!, r.path, canonicalRoot)\n          : null;\n        if (!safePath) return;\n        const raw = await readFile(safePath, \"utf-8\");\n        // Memory files start with YAML frontmatter — skip it so the snippet\n        // contains actual memory content, not metadata fields.\n        const body = stripFrontmatter(raw);\n        const preview = body.slice(0, SNIPPET_PREVIEW_CHARS).replace(/\\s+/g, \" \").trim();\n        if (preview) snippetMap.set(r.path, preview);\n      } catch {\n        // File unreadable — leave snippet empty\n      }\n    }),\n  );\n\n  if (snippetMap.size === 0) return results;\n  return results.map((r) => (r.path && snippetMap.has(r.path) ? { ...r, snippet: snippetMap.get(r.path)! } : r));\n}\n\n/**\n * Merge pre-computed direct and temporal agent results with contextual results.\n *\n * This is the merge half of augmentWithDirectAndTemporal. Expose it separately so\n * callers that started agents concurrently with the contextual search (for true\n * parallel latency) can merge after all three complete, without re-running agents.\n *\n * Handles the same cases as augmentWithDirectAndTemporal:\n * - Returns contextual unchanged (no reweighting) when both agents return nothing\n * - Applies maxResults cap in all paths\n * - Populates snippets for results discovered only by specialized agents\n */\nexport async function mergeWithAgentResults(\n  contextualResults: QmdSearchResult[],\n  directResults: ParallelSearchResult[],\n  temporalResults: ParallelSearchResult[],\n  weights: Record<SearchAgentSource, number>,\n  maxResults: number,\n  memoryDir?: string,\n  /** Optional namespace resolver. Direct/temporal results lack a namespace under\n   * namespace fanout; deriving it from the path lets them collapse onto the same\n   * merge key as the contextual result for the same (namespace, path). */\n  resolveNamespace?: (path: string) => string,\n): Promise<QmdSearchResult[]> {\n  if (directResults.length === 0 && temporalResults.length === 0) {\n    return contextualResults.slice(0, maxResults);\n  }\n\n  const contextualTagged: ParallelSearchResult[] = contextualResults.map((r) => ({\n    ...r,\n    agentSource: \"contextual\" as const,\n  }));\n\n  const merged = mergeAgentResults(\n    [...contextualTagged, ...directResults, ...temporalResults],\n    weights,\n    maxResults,\n    resolveNamespace,\n  );\n  return populateEmptySnippets(merged, memoryDir);\n}\n\n// ─── Augmentation helper (used by tests; orchestrator uses inline logic) ─────\n//\n// NOTE: This function passes the same `memoryDir` to both direct and temporal\n// agents. The orchestrator's inline implementation differs: it passes a\n// namespace-specific storage dir to runDirectAgent and the shared root to\n// runTemporalAgent. augmentWithDirectAndTemporal is intentionally simpler\n// (single-dir assumption) and is exercised by unit tests where both agents\n// operate on the same temporary directory.\n\n/**\n * Augment a set of contextual (hybridSearch) results with direct and temporal\n * agent results, returning a merged, deduplicated list.\n *\n * **Test helper** — production recall uses the inline orchestrator path which\n * passes namespace-specific directories to each agent. This function uses a\n * simplified single-directory contract suitable for unit tests.\n *\n * Direct and temporal agents run in parallel, then all three are merged with\n * configurable weights.\n *\n * Contextual weight is always applied to `contextualResults` so scoring is\n * consistent regardless of whether direct/temporal agents return anything.\n *\n * Snippets: snippets from contextual results are preserved during merge. For\n * results discovered only by direct/temporal agents (no contextual match),\n * the first ~200 chars of the file are read as a fallback preview so downstream\n * formatters and rerankers have content to work with, not just a path.\n */\nexport async function augmentWithDirectAndTemporal(\n  query: string,\n  memoryDir: string,\n  contextualResults: QmdSearchResult[],\n  weights: Record<SearchAgentSource, number>,\n  maxPerAgent: number,\n  maxResults: number,\n  /** Optional candidate set from query-aware prefilter (time/tag scoped). Agents' results are\n   * filtered to this set when provided so recall stays within the operator-specified scope. */\n  candidatePaths?: Set<string> | null,\n  /** Optional namespace resolver so direct/temporal results collapse onto the same\n   * (namespace, path) merge key as their contextual counterpart. */\n  resolveNamespace?: (path: string) => string,\n): Promise<QmdSearchResult[]> {\n  // maxPerAgent=0 is a hard disable: skip agents entirely and return contextual unchanged\n  if (maxPerAgent === 0) return contextualResults;\n\n  const knownEntityCount = (query.match(/\\b[A-Z][a-z]{1,}/g) ?? []).length;\n  const runDirect = shouldRunAgent(\"direct\", query, knownEntityCount);\n  const runTemporal = shouldRunAgent(\"temporal\", query, knownEntityCount);\n\n  const startMs = Date.now();\n  const [directResults, temporalResults] = await Promise.all([\n    runDirect\n      ? runDirectAgent(query, memoryDir, maxPerAgent).catch((err) => {\n        log.debug(`augmentWithDirectAndTemporal: DirectAgent failed — ${err}`);\n        return [] as ParallelSearchResult[];\n      })\n      : Promise.resolve([] as ParallelSearchResult[]),\n    runTemporal\n      // Pass candidatePaths so scope-filtering happens before the top-K cap inside runTemporalAgent,\n      // preventing out-of-scope newer entries from displacing in-scope ones at the slice boundary.\n      ? runTemporalAgent(query, memoryDir, maxPerAgent, candidatePaths).catch((err) => {\n        log.debug(`augmentWithDirectAndTemporal: TemporalAgent failed — ${err}`);\n        return [] as ParallelSearchResult[];\n      })\n      : Promise.resolve([] as ParallelSearchResult[]),\n  ]);\n  const durationMs = Date.now() - startMs;\n\n  // Direct agent results (entities/) intentionally bypass candidatePaths.\n  //\n  // Why: candidatePaths is built from temporal + tag indexes, which never include\n  // entity files (entities/*.md). Applying the filter here would silently drop ALL\n  // direct-agent results for any scoped query, making the direct agent a no-op.\n  // Entity files are identified by filename matching (query tokens vs. entity name),\n  // so they are already query-scoped independently of the time/tag prefilter.\n  // Temporal results are scoped inside runTemporalAgent() before the top-K cap.\n  const scopedDirect = directResults;\n\n  // Tag contextual results with their source so they can participate in weighted merge.\n  // We do NOT cap contextual here: contextualResults comes from fetchQmdMemoryResultsWithArtifactTopUp\n  // which intentionally over-fetches so downstream phases (graph expansion, lifecycle filtering,\n  // reranking) can drop candidates. Capping before the merge would remove that headroom.\n  const contextualTagged: ParallelSearchResult[] = contextualResults.map((r) => ({\n    ...r,\n    agentSource: \"contextual\" as const,\n  }));\n\n  log.debug(\n    `augmentWithDirectAndTemporal: direct=${scopedDirect.length} temporal=${temporalResults.length} contextual=${contextualTagged.length} agentMs=${durationMs}ms`,\n  );\n\n  // If no specialized agents contributed anything (e.g. fresh setup without entities/ or temporal\n  // index), skip reweighting entirely — applying the contextual weight penalty with zero benefit\n  // would silently reduce every result score by ~30% compared to the non-augmented path.\n  if (scopedDirect.length === 0 && temporalResults.length === 0) {\n    return (contextualResults as QmdSearchResult[]).slice(0, maxResults);\n  }\n\n  // Merge all three; contextual first so its snippets are preserved when a higher-scoring\n  // direct/temporal result overrides the same path (see mergeAgentResults snippet logic).\n  // Note: maxPerAgent=0 is handled by the early-return guard above; we never reach here with 0.\n  const merged = mergeAgentResults(\n    [...contextualTagged, ...scopedDirect, ...temporalResults],\n    weights,\n    maxResults,\n    resolveNamespace,\n  );\n\n  // Populate snippets for results discovered only by direct/temporal (no contextual preview)\n  return populateEmptySnippets(merged, memoryDir);\n}\n\n// ─── Orchestrator ─────────────────────────────────────────────────────────────\n\nexport interface ParallelRetrievalOptions {\n  collection?: string;\n  maxResults?: number;\n  signal?: AbortSignal;\n  /** If true, skip the contextual agent (hybridSearch is already running externally). */\n  skipContextual?: boolean;\n  /** Max results per agent (capped before merge). */\n  maxResultsPerAgent?: number;\n  /** Override default agent weights. Falls back to PARALLEL_AGENT_WEIGHTS when absent. */\n  agentWeights?: Record<SearchAgentSource, number>;\n  /** Optional namespace resolver so direct/temporal results collapse onto the same\n   * (namespace, path) merge key as the contextual result for the same path. */\n  resolveNamespace?: (path: string) => string;\n}\n\n/**\n * Run parallel specialized retrieval agents and merge results.\n *\n * When `skipContextual` is true, only the direct and temporal agents run.\n * This is the intended usage inside the orchestrator, where hybridSearch\n * already runs as the primary search — we augment with the cheap extra agents.\n *\n * Total latency = max(agent_latencies), not sum.\n * Agent errors are isolated — others still return results.\n */\nexport async function parallelRetrieval(\n  query: string,\n  qmd: QmdClient,\n  memoryDir: string,\n  options: ParallelRetrievalOptions = {},\n): Promise<QmdSearchResult[]> {\n  const maxResults = options.maxResults ?? 20;\n  const maxPerAgent = options.maxResultsPerAgent ?? maxResults;\n  const startMs = Date.now();\n\n  // Rough entity detection: count proper-noun-like tokens in query\n  const knownEntityCount = (query.match(/\\b[A-Z][a-z]{1,}/g) ?? []).length;\n\n  const runDirect = shouldRunAgent(\"direct\", query, knownEntityCount);\n  const runTemporal = shouldRunAgent(\"temporal\", query, knownEntityCount);\n  const runContextual = !options.skipContextual && shouldRunAgent(\"contextual\", query, knownEntityCount);\n\n  const [directResults, temporalResults, contextualResults] = await Promise.all([\n    runDirect\n      ? runDirectAgent(query, memoryDir, maxPerAgent).catch((err) => {\n        log.debug(`parallelRetrieval: DirectAgent failed — ${err}`);\n        return [] as ParallelSearchResult[];\n      })\n      : Promise.resolve([] as ParallelSearchResult[]),\n    runTemporal\n      ? runTemporalAgent(query, memoryDir, maxPerAgent).catch((err) => {\n        log.debug(`parallelRetrieval: TemporalAgent failed — ${err}`);\n        return [] as ParallelSearchResult[];\n      })\n      : Promise.resolve([] as ParallelSearchResult[]),\n    runContextual\n      ? runContextualAgent(query, qmd, options.collection, maxPerAgent, options.signal).catch((err) => {\n        if (isAbortError(err)) throw err;\n        log.debug(`parallelRetrieval: ContextualAgent failed — ${err}`);\n        return [] as ParallelSearchResult[];\n      })\n      : Promise.resolve([] as ParallelSearchResult[]),\n  ]);\n\n  const durationMs = Date.now() - startMs;\n  log.debug(\n    `parallelRetrieval: direct=${directResults.length} temporal=${temporalResults.length} contextual=${contextualResults.length} durationMs=${durationMs}ms`,\n  );\n\n  // Contextual results go first so their snippets are preserved when a higher-scoring\n  // direct/temporal result overrides the same path in mergeAgentResults.\n  const merged = mergeAgentResults(\n    [...contextualResults, ...directResults, ...temporalResults],\n    options.agentWeights ?? PARALLEL_AGENT_WEIGHTS,\n    maxResults,\n    options.resolveNamespace,\n  );\n  return populateEmptySnippets(merged, memoryDir);\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-S2I7DL5Q.js → chunk-C2RW36YR.js}

@@ -15,7 +15,7 @@ import {
 import {
   listJsonFiles,
   readJsonFile
-} from "./chunk-B6O2YLUR.js";
+} from "./chunk-2Z5DIDQD.js";
 
 // src/causal-trajectory.ts
 import path from "path";
@@ -400,4 +400,4 @@ export {
   getCausalTrajectoryStoreStatus,
   searchCausalTrajectories
 };
-//# sourceMappingURL=chunk-S2I7DL5Q.js.map
+//# sourceMappingURL=chunk-C2RW36YR.js.map

package/dist/{chunk-P5NQN4JE.js → chunk-C6JMGAMO.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-TBBDFYXW.js";
 import {
   StorageManager
-} from "./chunk-PAZ35RJ4.js";
+} from "./chunk-4SCZZ3U7.js";
 import {
   bumpMemoryCorpusVersionForDir
 } from "./chunk-M5GVCJSJ.js";
@@ -16,6 +16,9 @@ import {
 import {
   assertPathInsideRoot
 } from "./chunk-C7HJ3NEI.js";
+import {
+  isMacOsReplicationJunkBasename
+} from "./chunk-QUIRIG2P.js";
 import {
   RECALL_FALLBACK_DIRS
 } from "./chunk-VS2IYZRU.js";
@@ -193,6 +196,7 @@ async function listMarkdownFiles(root, containmentRoot) {
       const entries = await readdir(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isSymbolicLink()) continue;
+        if (isMacOsReplicationJunkBasename(entry.name)) continue;
         const fullPath = path.join(dir, entry.name);
         if (entry.isDirectory()) {
           await walk(fullPath);
@@ -765,4 +769,4 @@ export {
   listMemoryGovernanceRuns,
   readMemoryGovernanceRunArtifact
 };
-//# sourceMappingURL=chunk-P5NQN4JE.js.map
+//# sourceMappingURL=chunk-C6JMGAMO.js.map

package/dist/chunk-C6JMGAMO.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/maintenance/memory-governance.ts"],"sourcesContent":["import path from \"node:path\";\nimport { lstat, mkdir, readFile, readdir, realpath, rm, writeFile } from \"node:fs/promises\";\nimport { StorageManager } from \"../storage.js\";\nimport { decideLifecycleTransition } from \"../lifecycle.js\";\nimport type { MemoryFile, MemoryStatus } from \"../types.js\";\nimport { RECALL_FALLBACK_DIRS } from \"../utils/category-dir.js\";\nimport { bumpMemoryCorpusVersionForDir } from \"../memory-corpus-version.js\";\nimport { assertPathInsideRoot } from \"../utils/path-containment.js\";\nimport { isMacOsReplicationJunkBasename } from \"../utils/macos-replication-junk.js\";\nimport { requestEntityCanonicalIdReconcile } from \"../storage/entity-canonical-id-references.js\";\nimport { excludeSupportPassportPrivateMemories } from \"../support-passport/card-projection.js\";\n\nexport type MemoryGovernanceMode = \"shadow\" | \"apply\";\nexport type MemoryGovernanceReasonCode =\n  | \"exact_duplicate\"\n  | \"semantic_duplicate_candidate\"\n  | \"disputed_memory\"\n  | \"speculative_low_confidence\"\n  | \"archive_candidate\"\n  | \"explicit_capture_review\"\n  | \"malformed_import\";\n\nexport interface MemoryGovernanceReviewQueueEntry {\n  entryId: string;\n  memoryId: string;\n  path: string;\n  reasonCode: MemoryGovernanceReasonCode;\n  severity: \"low\" | \"medium\" | \"high\";\n  suggestedAction: \"set_status\" | \"archive\";\n  suggestedStatus?: Extract<MemoryStatus, \"pending_review\" | \"quarantined\" | \"rejected\">;\n  relatedMemoryIds: string[];\n}\n\nexport interface MemoryGovernanceAppliedAction {\n  action: \"set_status\" | \"archive\";\n  memoryId: string;\n  reasonCode: MemoryGovernanceReviewQueueEntry[\"reasonCode\"];\n  beforeStatus: MemoryStatus;\n  afterStatus?: MemoryStatus;\n  originalPath: string;\n  currentPath: string;\n}\n\ninterface MemoryGovernanceRestoreEntry {\n  action: MemoryGovernanceAppliedAction[\"action\"];\n  memoryId: string;\n  reasonCode: MemoryGovernanceReviewQueueEntry[\"reasonCode\"];\n  originalPath: string;\n  currentPath: string;\n  beforeRaw: string;\n  expectedCurrentRaw?: string;\n  applied: boolean;\n}\n\nexport interface MemoryGovernanceRestoreManifest {\n  runId: string;\n  createdAt: string;\n  entries: MemoryGovernanceRestoreEntry[];\n}\n\nexport interface MemoryGovernanceSummary {\n  schemaVersion: 1;\n  runId: string;\n  traceId: string;\n  mode: MemoryGovernanceMode;\n  createdAt: string;\n  scannedMemories: number;\n  reviewQueueCount: number;\n  proposedActionCount: number;\n  appliedActionCount: number;\n  ruleVersion: string;\n}\n\nexport interface MemoryGovernanceMetrics {\n  reviewReasons: Record<MemoryGovernanceReasonCode, number>;\n  proposedStatuses: Record<string, number>;\n  keptMemoryCount: number;\n  qualityScore: MemoryGovernanceQualityScore;\n}\n\nexport interface MemoryGovernanceQualityScore {\n  score: number;\n  maxScore: 100;\n  grade: \"excellent\" | \"good\" | \"fair\" | \"poor\";\n  deductions: Array<{\n    reasonCode: MemoryGovernanceReasonCode;\n    count: number;\n    pointsLost: number;\n  }>;\n}\n\nexport interface MemoryGovernanceTransitionReport {\n  proposed: Record<string, MemoryGovernanceAppliedAction[]>;\n  applied: Record<string, MemoryGovernanceAppliedAction[]>;\n}\n\nexport interface MemoryGovernanceManifest {\n  schemaVersion: 1;\n  runId: string;\n  traceId: string;\n  mode: MemoryGovernanceMode;\n  createdAt: string;\n  ruleVersion: string;\n  artifacts: Record<string, string>;\n}\n\nexport interface MemoryGovernanceRunResult {\n  runId: string;\n  traceId: string;\n  mode: MemoryGovernanceMode;\n  summary: MemoryGovernanceSummary;\n  summaryPath: string;\n  reviewQueuePath: string;\n  qualityScorePath: string;\n  transitionReportPath: string;\n  reportPath: string;\n  keptMemoriesPath: string;\n  appliedActionsPath: string;\n  metricsPath: string;\n  manifestPath: string;\n  restorePath?: string;\n  reviewQueue: MemoryGovernanceReviewQueueEntry[];\n  proposedActions: MemoryGovernanceAppliedAction[];\n  appliedActions: MemoryGovernanceAppliedAction[];\n}\n\nexport interface RestoreMemoryGovernanceRunResult {\n  runId: string;\n  restoredActions: number;\n  restorePath: string;\n}\n\nexport interface RunMemoryGovernanceOptions {\n  memoryDir: string;\n  mode: MemoryGovernanceMode;\n  now?: Date;\n  maxMemories?: number;\n  batchSize?: number;\n  recentDays?: number;\n}\n\nexport interface RestoreMemoryGovernanceRunOptions {\n  memoryDir: string;\n  runId: string;\n  now?: Date;\n}\n\nexport const RULE_VERSION = \"memory-governance.v2\";\nconst SEMANTIC_DUPLICATE_MIN_TOKENS = 6;\nconst SEMANTIC_DUPLICATE_MIN_JACCARD = 0.66;\nconst QUALITY_SCORE_WEIGHTS: Record<MemoryGovernanceReasonCode, number> = {\n  exact_duplicate: 6,\n  semantic_duplicate_candidate: 4,\n  disputed_memory: 15,\n  speculative_low_confidence: 8,\n  archive_candidate: 2,\n  explicit_capture_review: 5,\n  malformed_import: 12,\n};\n\nfunction governanceRunsDir(memoryDir: string): string {\n  return path.join(memoryDir, \"state\", \"memory-governance\", \"runs\");\n}\n\nfunction governanceRunDir(memoryDir: string, runId: string): string {\n  return path.join(governanceRunsDir(memoryDir), runId);\n}\n\nfunction governanceRestorePath(memoryDir: string, runId: string): string {\n  return path.join(governanceRunDir(memoryDir, runId), \"restore.json\");\n}\n\nfunction buildRunId(now: Date): string {\n  return `gov-${now.toISOString().replace(/[:.]/g, \"-\")}`;\n}\n\nfunction plannedArchivePath(memoryDir: string, originalPath: string, now: Date): string {\n  return path.join(\n    memoryDir,\n    \"archive\",\n    now.toISOString().slice(0, 10),\n    path.basename(originalPath),\n  );\n}\n\nfunction normalizeContent(content: string): string {\n  return content.trim().replace(/\\s+/g, \" \").toLowerCase();\n}\n\nfunction statusOf(memory: MemoryFile): MemoryStatus {\n  return memory.frontmatter.status ?? \"active\";\n}\n\nfunction parseIsoMs(value?: string): number | null {\n  if (!value) return null;\n  const ms = Date.parse(value);\n  return Number.isFinite(ms) ? ms : null;\n}\n\nfunction daysSince(value: string | undefined, now: Date): number {\n  const ts = parseIsoMs(value);\n  if (ts === null) return 365;\n  return Math.max(0, (now.getTime() - ts) / 86_400_000);\n}\n\nfunction compareCanonicalPreference(left: MemoryFile, right: MemoryFile): number {\n  if (left.frontmatter.confidence !== right.frontmatter.confidence) {\n    return (right.frontmatter.confidence ?? 0) - (left.frontmatter.confidence ?? 0);\n  }\n  return left.frontmatter.created.localeCompare(right.frontmatter.created);\n}\n\nfunction proposedStatusPriority(status: MemoryStatus): number {\n  switch (status) {\n    case \"quarantined\":\n      return 4;\n    case \"rejected\":\n      return 3;\n    case \"archived\":\n      return 2;\n    case \"pending_review\":\n      return 1;\n    default:\n      return 0;\n  }\n}\n\nfunction proposedActionPriority(action: MemoryGovernanceAppliedAction): number {\n  if (action.action === \"archive\") {\n    return proposedStatusPriority(\"archived\");\n  }\n  return proposedStatusPriority(action.afterStatus ?? \"active\");\n}\n\nfunction tokenizeSemanticContent(content: string): string[] {\n  return Array.from(\n    new Set(\n      normalizeContent(content)\n        .replaceAll(/[^\\p{L}\\p{N}]+/gu, \" \")\n        .split(\" \")\n        .filter((token) => token.length >= 4),\n    ),\n  );\n}\n\nfunction jaccardSimilarity(left: string[], right: string[]): number {\n  if (left.length === 0 || right.length === 0) return 0;\n  const leftSet = new Set(left);\n  const rightSet = new Set(right);\n  let intersection = 0;\n  for (const token of leftSet) {\n    if (rightSet.has(token)) intersection += 1;\n  }\n  const union = new Set([...leftSet, ...rightSet]).size;\n  return union > 0 ? intersection / union : 0;\n}\n\nfunction sameSemanticDuplicateScope(left: MemoryFile, right: MemoryFile): boolean {\n  if (left.frontmatter.category !== right.frontmatter.category) return false;\n  const leftEntityRef = left.frontmatter.entityRef?.trim();\n  const rightEntityRef = right.frontmatter.entityRef?.trim();\n  if (leftEntityRef && rightEntityRef && leftEntityRef !== rightEntityRef) return false;\n  return true;\n}\n\nfunction buildSemanticDuplicateEntries(activeMemories: MemoryFile[]): MemoryGovernanceReviewQueueEntry[] {\n  const reviewQueue: MemoryGovernanceReviewQueueEntry[] = [];\n  const ordered = [...activeMemories].sort(compareCanonicalPreference);\n  const tokensByMemoryId = new Map(\n    ordered.map((memory) => [memory.frontmatter.id, tokenizeSemanticContent(memory.content)] as const),\n  );\n  const claimed = new Set<string>();\n\n  for (let candidateIndex = 1; candidateIndex < ordered.length; candidateIndex += 1) {\n    const candidate = ordered[candidateIndex];\n    if (claimed.has(candidate.frontmatter.id)) continue;\n    const candidateTokens = tokensByMemoryId.get(candidate.frontmatter.id) ?? [];\n    if (candidateTokens.length < SEMANTIC_DUPLICATE_MIN_TOKENS) continue;\n    const candidateNormalized = normalizeContent(candidate.content);\n\n    for (let canonicalIndex = 0; canonicalIndex < candidateIndex; canonicalIndex += 1) {\n      const canonical = ordered[canonicalIndex];\n      if (!sameSemanticDuplicateScope(canonical, candidate)) continue;\n      const canonicalNormalized = normalizeContent(canonical.content);\n      if (canonicalNormalized === candidateNormalized) continue;\n      const canonicalTokens = tokensByMemoryId.get(canonical.frontmatter.id) ?? [];\n      if (canonicalTokens.length < SEMANTIC_DUPLICATE_MIN_TOKENS) continue;\n\n      const shorter = Math.min(candidateTokens.length, canonicalTokens.length);\n      const longer = Math.max(candidateTokens.length, canonicalTokens.length);\n      if (shorter / longer < 0.6) continue;\n      if (jaccardSimilarity(candidateTokens, canonicalTokens) < SEMANTIC_DUPLICATE_MIN_JACCARD) continue;\n\n      reviewQueue.push({\n        entryId: `review:${candidate.frontmatter.id}:semantic_duplicate_candidate`,\n        memoryId: candidate.frontmatter.id,\n        path: candidate.path,\n        reasonCode: \"semantic_duplicate_candidate\",\n        severity: \"medium\",\n        suggestedAction: \"set_status\",\n        suggestedStatus: \"pending_review\",\n        relatedMemoryIds: [canonical.frontmatter.id],\n      });\n      claimed.add(candidate.frontmatter.id);\n      break;\n    }\n  }\n\n  return reviewQueue;\n}\n\nfunction buildExplicitCaptureReviewEntries(\n  memories: MemoryFile[],\n  lifecycleEvents: Array<{\n    memoryId: string;\n    eventType: string;\n    reasonCode?: string;\n  }>,\n): MemoryGovernanceReviewQueueEntry[] {\n  const explicitQueuedIds = new Set(\n    lifecycleEvents\n      .filter((event) => event.eventType === \"explicit_capture_queued\")\n      .map((event) => event.memoryId),\n  );\n\n  return memories\n    .filter((memory) => {\n      if (statusOf(memory) !== \"pending_review\") return false;\n      const tags = memory.frontmatter.tags ?? [];\n      if (tags.includes(\"queued-review\")) return true;\n      if (explicitQueuedIds.has(memory.frontmatter.id)) return true;\n      return memory.frontmatter.source === \"explicit-review\" || memory.frontmatter.source === \"explicit-inline-review\";\n    })\n    .map((memory) => ({\n      entryId: `review:${memory.frontmatter.id}:explicit_capture_review`,\n      memoryId: memory.frontmatter.id,\n      path: memory.path,\n      reasonCode: \"explicit_capture_review\" as const,\n      severity: \"medium\" as const,\n      suggestedAction: \"set_status\" as const,\n      suggestedStatus: \"pending_review\" as const,\n      relatedMemoryIds: [],\n    }));\n}\n\n/**\n * List every `*.md` under `root`, refusing to follow symlinked directories or\n * entries that resolve outside `containmentRoot` (a realpath-resolved memory\n * store root). Mirrors the containment guard in consolidation-provenance's\n * walkMarkdownFiles / the CLI walker, reusing the shared assertPathInsideRoot\n * (rule 22). Without this, a symlinked category dir (e.g. decisions/ → outside\n * memoryDir) would be walked and its files surfaced by the malformed-import\n * governance sweep — an out-of-store info leak.\n */\nasync function listMarkdownFiles(root: string, containmentRoot: string): Promise<string[]> {\n  const files: string[] = [];\n  const walk = async (dir: string) => {\n    try {\n      const dirStat = await lstat(dir);\n      if (dirStat.isSymbolicLink() || !dirStat.isDirectory()) return;\n      assertPathInsideRoot(containmentRoot, await realpath(dir), dir);\n      const entries = await readdir(dir, { withFileTypes: true });\n      for (const entry of entries) {\n        if (entry.isSymbolicLink()) continue; // never follow symlinked entries\n        if (isMacOsReplicationJunkBasename(entry.name)) continue;\n        const fullPath = path.join(dir, entry.name);\n        if (entry.isDirectory()) {\n          await walk(fullPath);\n          continue;\n        }\n        if (entry.isFile() && entry.name.endsWith(\".md\")) {\n          try {\n            assertPathInsideRoot(containmentRoot, await realpath(fullPath), fullPath);\n          } catch {\n            continue; // poisoned entry escaping the root — skip it.\n          }\n          files.push(fullPath);\n        }\n      }\n    } catch {\n      // Absent dir (ENOENT), symlinked/out-of-root dir, or containment\n      // violation — skip this subtree without aborting the sweep.\n    }\n  };\n\n  await walk(root);\n  return files;\n}\n\nfunction malformedMemoryId(memoryDir: string, filePath: string): string {\n  return `malformed:${path.relative(memoryDir, filePath).replaceAll(path.sep, \"/\")}`;\n}\n\nasync function buildMalformedImportEntries(\n  memoryDir: string,\n  storage: StorageManager,\n  parsedMemories: MemoryFile[],\n  candidateFiles?: string[],\n): Promise<MemoryGovernanceReviewQueueEntry[]> {\n  const parsedPaths = new Set(parsedMemories.map((memory) => memory.path));\n  // Inspect every recall category directory (RECALL_FALLBACK_DIRS — the single\n  // source of truth) so malformed files under newly-routed categories\n  // (decisions/, preferences/, ...) are surfaced too, not just facts/ (#1546).\n  // Resolve the containment root (realpath) once and thread it into the walker\n  // so a symlinked category dir can't escape memoryDir. If memoryDir itself\n  // can't be resolved, there is nothing valid to inspect.\n  let containmentRoot: string | null = null;\n  try {\n    containmentRoot = await realpath(memoryDir);\n  } catch {\n    containmentRoot = null;\n  }\n  const filesToInspect =\n    candidateFiles ??\n    (containmentRoot === null\n      ? []\n      : (\n          await Promise.all(\n            RECALL_FALLBACK_DIRS.map((dir) =>\n              listMarkdownFiles(path.join(memoryDir, dir), containmentRoot as string),\n            ),\n          )\n        ).flat());\n  const entries: MemoryGovernanceReviewQueueEntry[] = [];\n\n  for (const filePath of filesToInspect) {\n    if (parsedPaths.has(filePath)) continue;\n    const parsed = await storage.readMemoryByPath(filePath);\n    if (parsed) continue;\n    entries.push({\n      entryId: `review:${malformedMemoryId(memoryDir, filePath)}:malformed_import`,\n      memoryId: malformedMemoryId(memoryDir, filePath),\n      path: filePath,\n      reasonCode: \"malformed_import\",\n      severity: \"high\",\n      suggestedAction: \"set_status\",\n      suggestedStatus: \"quarantined\",\n      relatedMemoryIds: [],\n    });\n  }\n\n  return entries;\n}\n\nasync function buildReviewQueue(\n  memoryDir: string,\n  storage: StorageManager,\n  memories: MemoryFile[],\n  now: Date,\n  options: {\n    malformedCandidateFiles?: string[];\n  } = {},\n): Promise<MemoryGovernanceReviewQueueEntry[]> {\n  const reviewQueue: MemoryGovernanceReviewQueueEntry[] = [];\n  const activeMemories = memories.filter((memory) => statusOf(memory) === \"active\");\n  const duplicateBuckets = new Map<string, MemoryFile[]>();\n\n  for (const memory of activeMemories) {\n    const key = `${memory.frontmatter.category}:${normalizeContent(memory.content)}`;\n    const bucket = duplicateBuckets.get(key) ?? [];\n    bucket.push(memory);\n    duplicateBuckets.set(key, bucket);\n  }\n\n  for (const bucket of duplicateBuckets.values()) {\n    if (bucket.length < 2) continue;\n    const ordered = [...bucket].sort(compareCanonicalPreference);\n    const canonical = ordered[0];\n    for (const duplicate of ordered.slice(1)) {\n      reviewQueue.push({\n        entryId: `review:${duplicate.frontmatter.id}:exact_duplicate`,\n        memoryId: duplicate.frontmatter.id,\n        path: duplicate.path,\n        reasonCode: \"exact_duplicate\",\n        severity: \"medium\",\n        suggestedAction: \"set_status\",\n        suggestedStatus: \"pending_review\",\n        relatedMemoryIds: canonical ? [canonical.frontmatter.id] : [],\n      });\n    }\n  }\n\n  reviewQueue.push(...buildSemanticDuplicateEntries(activeMemories));\n\n  for (const memory of activeMemories) {\n    if (memory.frontmatter.verificationState === \"disputed\") {\n      reviewQueue.push({\n        entryId: `review:${memory.frontmatter.id}:disputed_memory`,\n        memoryId: memory.frontmatter.id,\n        path: memory.path,\n        reasonCode: \"disputed_memory\",\n        severity: \"high\",\n        suggestedAction: \"set_status\",\n        suggestedStatus: \"quarantined\",\n        relatedMemoryIds: [],\n      });\n    }\n\n    if (\n      memory.frontmatter.confidenceTier === \"speculative\"\n      && (memory.frontmatter.confidence ?? 0) <= 0.25\n    ) {\n      reviewQueue.push({\n        entryId: `review:${memory.frontmatter.id}:speculative_low_confidence`,\n        memoryId: memory.frontmatter.id,\n        path: memory.path,\n        reasonCode: \"speculative_low_confidence\",\n        severity: \"medium\",\n        suggestedAction: \"set_status\",\n        suggestedStatus: \"pending_review\",\n        relatedMemoryIds: [],\n      });\n    }\n\n    const lifecycle = decideLifecycleTransition(memory, {}, now);\n    const staleForArchive = memory.frontmatter.lifecycleState === \"stale\"\n      && daysSince(memory.frontmatter.updated ?? memory.frontmatter.created, now) >= 180;\n    if ((lifecycle.nextState === \"archived\" && lifecycle.changed) || staleForArchive) {\n      reviewQueue.push({\n        entryId: `review:${memory.frontmatter.id}:archive_candidate`,\n        memoryId: memory.frontmatter.id,\n        path: memory.path,\n        reasonCode: \"archive_candidate\",\n        severity: \"low\",\n        suggestedAction: \"archive\",\n        relatedMemoryIds: [],\n      });\n    }\n  }\n\n  const lifecycleEvents = await storage.readMemoryLifecycleEvents(Number.MAX_SAFE_INTEGER);\n  reviewQueue.push(...buildExplicitCaptureReviewEntries(memories, lifecycleEvents));\n  reviewQueue.push(...await buildMalformedImportEntries(\n    memoryDir,\n    storage,\n    memories,\n    options.malformedCandidateFiles,\n  ));\n\n  return reviewQueue;\n}\n\nexport function buildProposedActions(\n  reviewQueue: MemoryGovernanceReviewQueueEntry[],\n  memories: MemoryFile[],\n): MemoryGovernanceAppliedAction[] {\n  const byMemory = new Map(memories.map((memory) => [memory.frontmatter.id, memory]));\n  const selected = new Map<string, MemoryGovernanceAppliedAction>();\n\n  for (const entry of reviewQueue) {\n    const memory = byMemory.get(entry.memoryId);\n    if (!memory) continue;\n    const currentStatus = statusOf(memory);\n    if (\n      entry.suggestedAction === \"set_status\"\n      && entry.suggestedStatus\n      && entry.suggestedStatus === currentStatus\n    ) {\n      continue;\n    }\n    const candidate: MemoryGovernanceAppliedAction = {\n      action: entry.suggestedAction,\n      memoryId: entry.memoryId,\n      reasonCode: entry.reasonCode,\n      beforeStatus: currentStatus,\n      afterStatus: entry.suggestedStatus,\n      originalPath: memory.path,\n      currentPath: memory.path,\n    };\n\n    const existing = selected.get(entry.memoryId);\n    if (!existing) {\n      selected.set(entry.memoryId, candidate);\n      continue;\n    }\n\n    const existingPriority = proposedActionPriority(existing);\n    const candidatePriority = proposedActionPriority(candidate);\n    if (candidatePriority > existingPriority) {\n      selected.set(entry.memoryId, candidate);\n    }\n  }\n\n  return [...selected.values()];\n}\n\nfunction buildMetrics(\n  reviewQueue: MemoryGovernanceReviewQueueEntry[],\n  proposedActions: MemoryGovernanceAppliedAction[],\n  scannedMemories: number,\n): MemoryGovernanceMetrics {\n  const reviewReasons: MemoryGovernanceMetrics[\"reviewReasons\"] = {\n    exact_duplicate: 0,\n    semantic_duplicate_candidate: 0,\n    disputed_memory: 0,\n    speculative_low_confidence: 0,\n    archive_candidate: 0,\n    explicit_capture_review: 0,\n    malformed_import: 0,\n  };\n  const proposedStatuses: Record<string, number> = {};\n\n  for (const entry of reviewQueue) {\n    reviewReasons[entry.reasonCode] += 1;\n  }\n\n  for (const action of proposedActions) {\n    const effectiveStatus = action.afterStatus ?? (action.action === \"archive\" ? \"archived\" : undefined);\n    if (!effectiveStatus) continue;\n    proposedStatuses[effectiveStatus] = (proposedStatuses[effectiveStatus] ?? 0) + 1;\n  }\n\n  return {\n    reviewReasons,\n    proposedStatuses,\n    keptMemoryCount: Math.max(0, scannedMemories - proposedActions.length),\n    qualityScore: buildQualityScore(reviewReasons),\n  };\n}\n\nexport function buildQualityScore(\n  reviewReasons: Record<MemoryGovernanceReasonCode, number>,\n): MemoryGovernanceQualityScore {\n  const deductions = Object.entries(reviewReasons)\n    .map(([reasonCode, count]) => ({\n      reasonCode: reasonCode as MemoryGovernanceReasonCode,\n      count,\n      pointsLost: count * QUALITY_SCORE_WEIGHTS[reasonCode as MemoryGovernanceReasonCode],\n    }))\n    .filter((entry) => entry.count > 0)\n    .sort((left, right) => right.pointsLost - left.pointsLost);\n  const totalPointsLost = deductions.reduce((sum, entry) => sum + entry.pointsLost, 0);\n  const score = Math.max(0, 100 - totalPointsLost);\n  const grade = score >= 90 ? \"excellent\"\n    : score >= 75 ? \"good\"\n      : score >= 50 ? \"fair\"\n        : \"poor\";\n  return {\n    score,\n    maxScore: 100,\n    grade,\n    deductions,\n  };\n}\n\nexport function groupActionsByStatus(\n  actions: MemoryGovernanceAppliedAction[],\n): Record<string, MemoryGovernanceAppliedAction[]> {\n  const grouped: Record<string, MemoryGovernanceAppliedAction[]> = {};\n  for (const action of actions) {\n    const status = action.afterStatus ?? (action.action === \"archive\" ? \"archived\" : \"unchanged\");\n    const bucket = grouped[status] ?? [];\n    bucket.push(action);\n    grouped[status] = bucket;\n  }\n  return grouped;\n}\n\nasync function safeRead(filePath: string): Promise<string | null> {\n  try {\n    return await readFile(filePath, \"utf-8\");\n  } catch {\n    return null;\n  }\n}\n\nasync function persistRestoreManifest(\n  memoryDir: string,\n  manifest: MemoryGovernanceRestoreManifest,\n): Promise<string> {\n  const restorePath = governanceRestorePath(memoryDir, manifest.runId);\n  await mkdir(path.dirname(restorePath), { recursive: true });\n  await writeFile(restorePath, JSON.stringify(manifest, null, 2), \"utf-8\");\n  return restorePath;\n}\n\nasync function writeGovernanceArtifacts(options: {\n  memoryDir: string;\n  runId: string;\n  traceId: string;\n  summary: MemoryGovernanceSummary;\n  metrics: MemoryGovernanceMetrics;\n  qualityScore: MemoryGovernanceQualityScore;\n  transitionReport: MemoryGovernanceTransitionReport;\n  keptMemoryIds: string[];\n  reviewQueue: MemoryGovernanceReviewQueueEntry[];\n  proposedActions: MemoryGovernanceAppliedAction[];\n  appliedActions: MemoryGovernanceAppliedAction[];\n  restoreManifest?: MemoryGovernanceRestoreManifest;\n}): Promise<\n  Pick<\n    MemoryGovernanceRunResult,\n    | \"summaryPath\"\n    | \"reviewQueuePath\"\n    | \"qualityScorePath\"\n    | \"transitionReportPath\"\n    | \"reportPath\"\n    | \"keptMemoriesPath\"\n    | \"appliedActionsPath\"\n    | \"metricsPath\"\n    | \"manifestPath\"\n    | \"restorePath\"\n  >\n> {\n  const runDir = governanceRunDir(options.memoryDir, options.runId);\n  await mkdir(runDir, { recursive: true });\n\n  const summaryPath = path.join(runDir, \"summary.json\");\n  const reviewQueuePath = path.join(runDir, \"review-queue.json\");\n  const qualityScorePath = path.join(runDir, \"quality-score.json\");\n  const transitionReportPath = path.join(runDir, \"status-transitions.json\");\n  const reportPath = path.join(runDir, \"report.md\");\n  const keptMemoriesPath = path.join(runDir, \"kept-memories.json\");\n  const appliedActionsPath = path.join(runDir, \"applied-actions.json\");\n  const metricsPath = path.join(runDir, \"metrics.json\");\n  const manifestPath = path.join(runDir, \"manifest.json\");\n  const restorePath = options.restoreManifest ? governanceRestorePath(options.memoryDir, options.runId) : undefined;\n\n  await writeFile(summaryPath, JSON.stringify(options.summary, null, 2), \"utf-8\");\n  await writeFile(reviewQueuePath, JSON.stringify(options.reviewQueue, null, 2), \"utf-8\");\n  await writeFile(qualityScorePath, JSON.stringify(options.qualityScore, null, 2), \"utf-8\");\n  await writeFile(transitionReportPath, JSON.stringify(options.transitionReport, null, 2), \"utf-8\");\n  await writeFile(keptMemoriesPath, JSON.stringify(options.keptMemoryIds, null, 2), \"utf-8\");\n  await writeFile(appliedActionsPath, JSON.stringify(options.appliedActions, null, 2), \"utf-8\");\n  await writeFile(metricsPath, JSON.stringify(options.metrics, null, 2), \"utf-8\");\n  await writeFile(\n    reportPath,\n    [\n      `# Memory Governance Run ${options.runId}`,\n      \"\",\n      `- Trace ID: ${options.traceId}`,\n      `- Mode: ${options.summary.mode}`,\n      `- Scanned memories: ${options.summary.scannedMemories}`,\n      `- Kept memories: ${options.metrics.keptMemoryCount}`,\n      `- Review queue entries: ${options.summary.reviewQueueCount}`,\n      `- Proposed actions: ${options.summary.proposedActionCount}`,\n      `- Applied actions: ${options.summary.appliedActionCount}`,\n      `- Quality score: ${options.qualityScore.score}/${options.qualityScore.maxScore} (${options.qualityScore.grade})`,\n      \"\",\n      \"## Metrics\",\n      ...Object.entries(options.metrics.reviewReasons).map(([reason, count]) => `- ${reason}: ${count}`),\n      ...(Object.entries(options.metrics.proposedStatuses).length > 0\n        ? Object.entries(options.metrics.proposedStatuses).map(([status, count]) => `- proposed ${status}: ${count}`)\n        : [\"- proposed statuses: (none)\"]),\n      \"\",\n      \"## Quality Score\",\n      ...(options.qualityScore.deductions.length > 0\n        ? options.qualityScore.deductions.map((entry) => `- ${entry.reasonCode}: ${entry.count} -> -${entry.pointsLost}`)\n        : [\"- no deductions\"]),\n      \"\",\n      \"## Proposed Actions\",\n      ...(options.proposedActions.length > 0\n        ? options.proposedActions.map((action) =>\n            `- ${action.memoryId}: ${action.action}${action.afterStatus ? ` -> ${action.afterStatus}` : \"\"} [${action.reasonCode}]`,\n          )\n        : [\"- (empty)\"]),\n      \"\",\n      \"## Applied Actions\",\n      ...(options.appliedActions.length > 0\n        ? options.appliedActions.map((action) =>\n            `- ${action.memoryId}: ${action.action}${action.afterStatus ? ` -> ${action.afterStatus}` : \"\"} [${action.reasonCode}]`,\n          )\n        : [\"- (empty)\"]),\n      \"\",\n      \"## Review Queue\",\n      ...(options.reviewQueue.length > 0\n        ? options.reviewQueue.map((entry) =>\n            `- ${entry.memoryId}: ${entry.reasonCode} -> ${entry.suggestedAction}${entry.suggestedStatus ? ` (${entry.suggestedStatus})` : \"\"}`,\n          )\n        : [\"- (empty)\"]),\n    ].join(\"\\n\"),\n    \"utf-8\",\n  );\n  const manifest: MemoryGovernanceManifest = {\n    schemaVersion: 1,\n    runId: options.runId,\n    traceId: options.traceId,\n    mode: options.summary.mode,\n    createdAt: options.summary.createdAt,\n    ruleVersion: options.summary.ruleVersion,\n    artifacts: {\n      summary: summaryPath,\n      reviewQueue: reviewQueuePath,\n      qualityScore: qualityScorePath,\n      transitionReport: transitionReportPath,\n      report: reportPath,\n      keptMemories: keptMemoriesPath,\n      appliedActions: appliedActionsPath,\n      metrics: metricsPath,\n      ...(restorePath ? { restore: restorePath } : {}),\n    },\n  };\n  await writeFile(manifestPath, JSON.stringify(manifest, null, 2), \"utf-8\");\n  if (restorePath && options.restoreManifest && await safeRead(restorePath) === null) {\n    await writeFile(restorePath, JSON.stringify(options.restoreManifest, null, 2), \"utf-8\");\n  }\n\n  return {\n    summaryPath,\n    reviewQueuePath,\n    qualityScorePath,\n    transitionReportPath,\n    reportPath,\n    keptMemoriesPath,\n    appliedActionsPath,\n    metricsPath,\n    manifestPath,\n    restorePath,\n  };\n}\n\nexport async function runMemoryGovernance(\n  options: RunMemoryGovernanceOptions,\n): Promise<MemoryGovernanceRunResult> {\n  const now = options.now ?? new Date();\n  const runId = buildRunId(now);\n  const traceId = runId;\n  const storage = new StorageManager(options.memoryDir);\n  const boundedScan =\n    options.maxMemories !== undefined ||\n    options.recentDays !== undefined ||\n    options.batchSize !== undefined;\n  const normalizedRecentDays = typeof options.recentDays === \"number\" && Number.isFinite(options.recentDays)\n    ? Math.max(1, Math.floor(options.recentDays))\n    : undefined;\n  const updatedAfter = normalizedRecentDays !== undefined\n    ? new Date(now.getTime() - normalizedRecentDays * 86_400_000)\n    : undefined;\n  const memoryWindow = boundedScan\n    ? await storage.readMemoriesWindow({\n        maxMemories: options.maxMemories,\n        batchSize: options.batchSize,\n        updatedAfter,\n        includeMalformedPaths: true,\n      })\n    : undefined;\n  const memories = excludeSupportPassportPrivateMemories(\n    memoryWindow?.memories ?? await storage.readAllMemories(),\n  );\n  const reviewQueue = await buildReviewQueue(options.memoryDir, storage, memories, now, {\n    malformedCandidateFiles: memoryWindow?.filePaths,\n  });\n  const proposedActions = buildProposedActions(reviewQueue, memories);\n  const reviewEntryByActionKey = new Map(\n    reviewQueue.map((entry) => [`${entry.memoryId}:${entry.reasonCode}`, entry] as const),\n  );\n  const metrics = buildMetrics(reviewQueue, proposedActions, memories.length);\n  const transitionReport: MemoryGovernanceTransitionReport = {\n    proposed: groupActionsByStatus(proposedActions),\n    applied: {},\n  };\n  const memoryPathById = new Map(memories.map((memory) => [memory.frontmatter.id, memory.path] as const));\n  const targetedMemoryIds = new Set(proposedActions.map((action) => action.memoryId));\n  const keptMemoryIds = memories\n    .map((memory) => memory.frontmatter.id)\n    .filter((memoryId) => !targetedMemoryIds.has(memoryId));\n  const appliedActions: MemoryGovernanceAppliedAction[] = [];\n  const restoreEntries: MemoryGovernanceRestoreEntry[] = [];\n  const restoreEntryByMemoryId = new Map<string, MemoryGovernanceRestoreEntry>();\n\n  if (options.mode === \"apply\") {\n    for (const action of proposedActions) {\n      const memoryPath = memoryPathById.get(action.memoryId) ?? null;\n      if (!memoryPath) continue;\n      const memory = await storage.readMemoryByPath(memoryPath);\n      if (!memory) continue;\n      if (memory.frontmatter.id !== action.memoryId) continue;\n      const beforeRaw = await safeRead(memory.path);\n      if (!beforeRaw) continue;\n      const entry: MemoryGovernanceRestoreEntry = {\n        action: action.action,\n        memoryId: action.memoryId,\n        reasonCode: action.reasonCode,\n        originalPath: memory.path,\n        currentPath: action.action === \"archive\"\n          ? plannedArchivePath(options.memoryDir, memory.path, now)\n          : memory.path,\n        beforeRaw,\n        applied: false,\n      };\n      restoreEntries.push(entry);\n      restoreEntryByMemoryId.set(action.memoryId, entry);\n    }\n\n    const restoreManifest: MemoryGovernanceRestoreManifest = {\n      runId,\n      createdAt: now.toISOString(),\n      entries: restoreEntries,\n    };\n    await persistRestoreManifest(options.memoryDir, restoreManifest);\n\n    for (const action of proposedActions) {\n      const memoryPath = memoryPathById.get(action.memoryId) ?? null;\n      if (!memoryPath) continue;\n      const memory = await storage.readMemoryByPath(memoryPath);\n      if (!memory) continue;\n      if (memory.frontmatter.id !== action.memoryId) continue;\n      const restoreEntry = restoreEntryByMemoryId.get(action.memoryId);\n      if (!restoreEntry) continue;\n\n      if (action.action === \"archive\") {\n        const reviewEntry = reviewEntryByActionKey.get(`${action.memoryId}:${action.reasonCode}`);\n        restoreEntry.applied = true;\n        await persistRestoreManifest(options.memoryDir, restoreManifest);\n        const archivedPath = await storage.archiveMemory(memory, {\n          at: now,\n          actor: \"memory-governance.apply\",\n          reasonCode: action.reasonCode,\n          ruleVersion: RULE_VERSION,\n          relatedMemoryIds: reviewEntry?.relatedMemoryIds ?? [],\n          correlationId: traceId,\n        });\n        if (!archivedPath) {\n          restoreEntry.applied = false;\n          await persistRestoreManifest(options.memoryDir, restoreManifest);\n          continue;\n        }\n        restoreEntry.currentPath = archivedPath;\n        restoreEntry.expectedCurrentRaw = await safeRead(archivedPath) ?? undefined;\n        await persistRestoreManifest(options.memoryDir, restoreManifest);\n        appliedActions.push({\n          ...action,\n          currentPath: archivedPath,\n          afterStatus: \"archived\",\n        });\n        continue;\n      }\n\n      if (!action.afterStatus || action.beforeStatus === action.afterStatus) continue;\n      const reviewEntry = reviewEntryByActionKey.get(`${action.memoryId}:${action.reasonCode}`);\n      restoreEntry.applied = true;\n      await persistRestoreManifest(options.memoryDir, restoreManifest);\n      const updated = await storage.writeMemoryFrontmatter(memory, {\n        status: action.afterStatus,\n        updated: now.toISOString(),\n      }, {\n        actor: \"memory-governance.apply\",\n        reasonCode: action.reasonCode,\n        ruleVersion: RULE_VERSION,\n        relatedMemoryIds: reviewEntry?.relatedMemoryIds ?? [],\n        correlationId: traceId,\n      });\n      if (!updated) {\n        restoreEntry.applied = false;\n        await persistRestoreManifest(options.memoryDir, restoreManifest);\n        continue;\n      }\n      restoreEntry.expectedCurrentRaw = await safeRead(memory.path) ?? undefined;\n      await persistRestoreManifest(options.memoryDir, restoreManifest);\n      appliedActions.push({\n        ...action,\n        currentPath: memory.path,\n      });\n    }\n  }\n\n  const summary: MemoryGovernanceSummary = {\n    schemaVersion: 1,\n    runId,\n    traceId,\n    mode: options.mode,\n    createdAt: now.toISOString(),\n    scannedMemories: memories.length,\n    reviewQueueCount: reviewQueue.length,\n    proposedActionCount: proposedActions.length,\n    appliedActionCount: appliedActions.length,\n    ruleVersion: RULE_VERSION,\n  };\n  const restoreManifest = options.mode === \"apply\"\n    ? {\n        runId,\n        createdAt: now.toISOString(),\n        entries: restoreEntries,\n      }\n    : undefined;\n  transitionReport.applied = groupActionsByStatus(appliedActions);\n  const paths = await writeGovernanceArtifacts({\n    memoryDir: options.memoryDir,\n    runId,\n    traceId,\n    summary,\n    metrics,\n    qualityScore: metrics.qualityScore,\n    transitionReport,\n    keptMemoryIds,\n    reviewQueue,\n    proposedActions,\n    appliedActions,\n    restoreManifest,\n  });\n\n  return {\n    runId,\n    traceId,\n    mode: options.mode,\n    summary,\n    ...paths,\n    reviewQueue,\n    proposedActions,\n    appliedActions,\n  };\n}\n\nexport async function restoreMemoryGovernanceRun(\n  options: RestoreMemoryGovernanceRunOptions,\n): Promise<RestoreMemoryGovernanceRunResult> {\n  void options.now;\n  const restorePath = governanceRestorePath(options.memoryDir, options.runId);\n  const raw = JSON.parse(await readFile(restorePath, \"utf-8\")) as MemoryGovernanceRestoreManifest;\n  let restoredActions = 0;\n\n  for (const entry of [...raw.entries].reverse()) {\n    if (!entry.applied) {\n      continue;\n    }\n    const currentRaw = await safeRead(entry.currentPath);\n    if (entry.expectedCurrentRaw && currentRaw !== entry.expectedCurrentRaw) {\n      throw new Error(`restore conflict for ${entry.memoryId}: current contents diverged from governance run`);\n    }\n    if (entry.action === \"archive\") {\n      await rm(entry.currentPath, { force: true });\n    }\n    await mkdir(path.dirname(entry.originalPath), { recursive: true });\n    await writeFile(entry.originalPath, entry.beforeRaw, \"utf-8\");\n    restoredActions += 1;\n    // Restore writes/removes memory files directly (out-of-band — not through a\n    // StorageManager mutation). Bump the corpus sentinel PER entry so a\n    // same-process or peer readAllMemories rescans mid-batch and never serves a\n    // partially-restored corpus (Cursor Medium, #1902).\n    bumpMemoryCorpusVersionForDir(options.memoryDir);\n    // Restored bytes predate the current migration journal and can carry\n    // legacy entity references (issue #2213) — request one reconcile pass.\n    await requestEntityCanonicalIdReconcile(path.join(options.memoryDir, \"state\"));\n  }\n\n  return {\n    runId: raw.runId,\n    restoredActions,\n    restorePath,\n  };\n}\n\nexport async function listMemoryGovernanceRuns(memoryDir: string): Promise<string[]> {\n  try {\n    return (await readdir(governanceRunsDir(memoryDir))).sort().reverse();\n  } catch {\n    return [];\n  }\n}\n\nexport async function readMemoryGovernanceRunArtifact(\n  memoryDir: string,\n  runId: string,\n): Promise<{\n  summary: MemoryGovernanceSummary;\n  metrics: MemoryGovernanceMetrics;\n  qualityScore: MemoryGovernanceQualityScore;\n  keptMemoryIds: string[];\n  reviewQueue: MemoryGovernanceReviewQueueEntry[];\n  appliedActions: MemoryGovernanceAppliedAction[];\n  transitionReport: MemoryGovernanceTransitionReport;\n  report: string;\n  manifest: MemoryGovernanceManifest;\n  restore?: MemoryGovernanceRestoreManifest;\n}> {\n  const runDir = governanceRunDir(memoryDir, runId);\n  const summary = JSON.parse(await readFile(path.join(runDir, \"summary.json\"), \"utf-8\")) as MemoryGovernanceSummary;\n  const metrics = JSON.parse(await readFile(path.join(runDir, \"metrics.json\"), \"utf-8\")) as MemoryGovernanceMetrics;\n  metrics.qualityScore ??= buildQualityScore(metrics.reviewReasons);\n  const keptMemoryIds = JSON.parse(await readFile(path.join(runDir, \"kept-memories.json\"), \"utf-8\")) as string[];\n  const reviewQueue = JSON.parse(\n    await readFile(path.join(runDir, \"review-queue.json\"), \"utf-8\"),\n  ) as MemoryGovernanceReviewQueueEntry[];\n  const appliedActions = JSON.parse(\n    await readFile(path.join(runDir, \"applied-actions.json\"), \"utf-8\"),\n  ) as MemoryGovernanceAppliedAction[];\n  const qualityScoreRaw = await safeRead(path.join(runDir, \"quality-score.json\"));\n  const transitionReportRaw = await safeRead(path.join(runDir, \"status-transitions.json\"));\n  const manifest = JSON.parse(\n    await readFile(path.join(runDir, \"manifest.json\"), \"utf-8\"),\n  ) as MemoryGovernanceManifest;\n  const report = await readFile(path.join(runDir, \"report.md\"), \"utf-8\");\n  const restoreRaw = await safeRead(path.join(runDir, \"restore.json\"));\n  const qualityScore = qualityScoreRaw\n    ? JSON.parse(qualityScoreRaw) as MemoryGovernanceQualityScore\n    : metrics.qualityScore ?? buildQualityScore(metrics.reviewReasons);\n  const transitionReport = transitionReportRaw\n    ? JSON.parse(transitionReportRaw) as MemoryGovernanceTransitionReport\n    : {\n        proposed: {},\n        applied: groupActionsByStatus(appliedActions),\n      };\n  return {\n    summary,\n    metrics,\n    qualityScore,\n    keptMemoryIds,\n    reviewQueue,\n    appliedActions,\n    transitionReport,\n    report,\n    manifest,\n    restore: restoreRaw ? JSON.parse(restoreRaw) as MemoryGovernanceRestoreManifest : undefined,\n  };\n}\n"],"mappings":"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","names":["restoreManifest","reviewEntry"]}

package/dist/{chunk-6LG7BWKW.js → chunk-CFZ4SXXH.js}

@@ -1,7 +1,7 @@
 import {
   canonicalCategoryForAlias,
   categoryAliasCoercion
-} from "./chunk-W5MCEVUS.js";
+} from "./chunk-RYYVMZBR.js";
 
 // src/access-observe-write-category.ts
 function splitCanonicalWriteRequest(request) {
@@ -22,4 +22,4 @@ function splitCanonicalWriteRequest(request) {
 export {
   splitCanonicalWriteRequest
 };
-//# sourceMappingURL=chunk-6LG7BWKW.js.map
+//# sourceMappingURL=chunk-CFZ4SXXH.js.map

package/dist/{chunk-BLVHDY2U.js → chunk-DOWACHYO.js}

@@ -1,3 +1,6 @@
+import {
+  isMacOsReplicationJunkBasename
+} from "./chunk-QUIRIG2P.js";
 import {
   log
 } from "./chunk-3WCASNQZ.js";
@@ -232,7 +235,7 @@ var ProfilingCollector = class {
     try {
       const dir = this.storageDir;
       const entries = await fsp.readdir(dir);
-      const jsonlFiles = entries.filter((f) => f.endsWith(".jsonl"));
+      const jsonlFiles = entries.filter((f) => !isMacOsReplicationJunkBasename(f) && f.endsWith(".jsonl"));
       const withMtime = await Promise.all(
         jsonlFiles.map(async (f) => ({
           name: f,
@@ -306,4 +309,4 @@ export {
   ProfilingCollector,
   formatProfileTraceAscii
 };
-//# sourceMappingURL=chunk-BLVHDY2U.js.map
+//# sourceMappingURL=chunk-DOWACHYO.js.map

package/dist/chunk-DOWACHYO.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/profiling.ts"],"sourcesContent":["// Performance profiling collector for recall and extraction traces.\n// Zero external dependencies — uses only node:fs and node:path.\n\nimport {\n  existsSync,\n  mkdirSync,\n  writeFileSync,\n  promises as fsp,\n} from \"node:fs\";\nimport { join } from \"node:path\";\n\nimport { log } from \"./logger.js\";\nimport { isMacOsReplicationJunkBasename } from \"./utils/macos-replication-junk.js\";\n\n// ---------------------------------------------------------------------------\n// Types\n// ---------------------------------------------------------------------------\n\nexport interface ProfileSpan {\n  name: string;\n  startOffsetMs: number;\n  durationMs: number;\n}\n\nexport interface ProfileParallelGroupMember {\n  name: string;\n  durationMs: number;\n  resolvedIndex: number;\n}\n\nexport interface ProfileParallelGroup {\n  name: string;\n  startOffsetMs: number;\n  wallMs: number;\n  members: ProfileParallelGroupMember[];\n}\n\nexport interface ProfileTrace {\n  ts: string;\n  kind: \"recall\" | \"extraction\";\n  traceId: string;\n  sessionKey?: string;\n  totalMs: number;\n  spans: ProfileSpan[];\n  parallelGroups?: ProfileParallelGroup[];\n  configSnapshot?: Record<string, unknown>;\n}\n\nexport interface ProfilingConfig {\n  enabled: boolean;\n  storageDir: string;\n  maxTraces: number;\n}\n\nexport interface ParallelGroupHandle {\n  name: string;\n  startOffsetMs: number;\n  traceId?: string;\n}\n\nexport interface ProfilingStats {\n  byKind: Record<string, { count: number; avgMs: number; p50Ms: number; p95Ms: number; maxMs: number }>;\n  bySpan: Record<string, { count: number; avgMs: number; p50Ms: number; p95Ms: number; maxMs: number }>;\n}\n\n// ---------------------------------------------------------------------------\n// Helpers\n// ---------------------------------------------------------------------------\n\nfunction percentile(sorted: number[], p: number): number {\n  if (sorted.length === 0) return 0;\n  const idx = Math.ceil((p / 100) * sorted.length) - 1;\n  return sorted[Math.max(0, Math.min(idx, sorted.length - 1))];\n}\n\nfunction aggregateStats(values: number[]): { count: number; avgMs: number; p50Ms: number; p95Ms: number; maxMs: number } {\n  const count = values.length;\n  if (count === 0) return { count: 0, avgMs: 0, p50Ms: 0, p95Ms: 0, maxMs: 0 };\n  const sorted = [...values].sort((a, b) => a - b);\n  const sum = sorted.reduce((s, v) => s + v, 0);\n  return {\n    count,\n    avgMs: Math.round(sum / count),\n    p50Ms: Math.round(percentile(sorted, 50)),\n    p95Ms: Math.round(percentile(sorted, 95)),\n    maxMs: sorted[sorted.length - 1],\n  };\n}\n\nlet traceCounter = 0;\n\n// ---------------------------------------------------------------------------\n// ProfilingCollector\n// ---------------------------------------------------------------------------\n\nexport class ProfilingCollector {\n  private enabled: boolean;\n  private storageDir: string;\n  private maxTraces: number;\n  private traces: ProfileTrace[] = [];\n  private prunePromise: Promise<void> | null = null;\n\n  // Active trace state — keyed by traceId so concurrent pipelines are isolated.\n  private activeTraces = new Map<\n    string,\n    {\n      kind: \"recall\" | \"extraction\";\n      start: number;\n      sessionKey?: string;\n      configSnapshot?: Record<string, unknown>;\n      spans: ProfileSpan[];\n      spanStarts: Map<string, number>;\n      parallelGroups: ProfileParallelGroup[];\n    }\n  >();\n  private latestTraceId = \"\";\n\n  constructor(config: ProfilingConfig) {\n    this.enabled = config.enabled;\n    this.storageDir = config.storageDir;\n    this.maxTraces = Math.max(0, config.maxTraces);\n  }\n\n  get isEnabled(): boolean {\n    return this.enabled;\n  }\n\n  // ---- Trace lifecycle ---------------------------------------------------\n\n  startTrace(kind: \"recall\" | \"extraction\", sessionKey?: string, configSnapshot?: Record<string, unknown>): string {\n    if (!this.enabled) return \"\";\n    traceCounter++;\n    const traceId = `t${traceCounter}-${Date.now().toString(36)}`;\n    this.activeTraces.set(traceId, {\n      kind,\n      start: Date.now(),\n      sessionKey,\n      configSnapshot,\n      spans: [],\n      spanStarts: new Map(),\n      parallelGroups: [],\n    });\n    this.latestTraceId = traceId;\n    log.debug(`profiling: started trace ${traceId} kind=${kind}`);\n    return traceId;\n  }\n\n  startSpan(name: string, traceId?: string): void {\n    const tid = traceId ?? this.latestTraceId;\n    const t = tid ? this.activeTraces.get(tid) : undefined;\n    if (!t) return;\n    const offset = Date.now() - t.start;\n    t.spanStarts.set(name, Date.now());\n    log.debug(`profiling: span ${name} started at +${offset}ms (trace=${tid})`);\n  }\n\n  endSpan(name: string, traceId?: string): void {\n    const tid = traceId ?? this.latestTraceId;\n    const t = tid ? this.activeTraces.get(tid) : undefined;\n    if (!t) return;\n    const start = t.spanStarts.get(name);\n    if (start === undefined) return;\n    const duration = Date.now() - start;\n    const startOffset = start - t.start;\n    t.spans.push({ name, startOffsetMs: startOffset, durationMs: duration });\n    t.spanStarts.delete(name);\n    log.debug(`profiling: span ${name} ended ${duration}ms (trace=${tid})`);\n  }\n\n  endTrace(traceId?: string): ProfileTrace | null {\n    const tid = traceId ?? this.latestTraceId;\n    const t = tid ? this.activeTraces.get(tid) : undefined;\n    if (!t) return null;\n\n    // Auto-close any spans still open when the trace finalizes.\n    const now = Date.now();\n    for (const [name, start] of t.spanStarts) {\n      const duration = now - start;\n      const startOffset = start - t.start;\n      t.spans.push({ name, startOffsetMs: startOffset, durationMs: duration });\n      log.debug(`profiling: auto-closed span ${name} at trace end (${duration}ms, trace=${tid})`);\n    }\n    t.spanStarts.clear();\n\n    const trace: ProfileTrace = {\n      ts: new Date().toISOString(),\n      kind: t.kind,\n      traceId: tid,\n      totalMs: Date.now() - t.start,\n      spans: t.spans,\n      configSnapshot: t.configSnapshot,\n    };\n\n    if (t.sessionKey) {\n      trace.sessionKey = t.sessionKey;\n    }\n    if (t.parallelGroups.length > 0) {\n      trace.parallelGroups = t.parallelGroups;\n    }\n\n    // Remove from active map.\n    this.activeTraces.delete(tid);\n\n    if (!this.enabled) {\n      log.debug(\"profiling: trace discarded (disabled)\");\n      return null;\n    }\n\n    // Persist.\n    this.persistTrace(trace);\n\n    // Buffer in memory (FIFO).\n    this.traces.push(trace);\n    if (this.traces.length > this.maxTraces) {\n      this.traces.shift();\n    }\n\n    // Single-flight: if a prune is already running, piggyback on it;\n    // otherwise start one.  This prevents concurrent prunes from racing\n    // on stale directory snapshots.\n    if (!this.prunePromise) {\n      this.prunePromise = this.pruneFiles().finally(() => {\n        this.prunePromise = null;\n      });\n    }\n    log.debug(`profiling: trace ${trace.traceId} finalized totalMs=${trace.totalMs}`);\n    return trace;\n  }\n\n  // ---- Parallel group tracking -------------------------------------------\n\n  startParallelGroup(name: string, traceId?: string): ParallelGroupHandle {\n    const tid = traceId ?? this.latestTraceId;\n    const t = tid ? this.activeTraces.get(tid) : undefined;\n    const startOffsetMs = t ? Date.now() - t.start : 0;\n    return { name, startOffsetMs, traceId: tid };\n  }\n\n  async endParallelGroup(\n    handle: ParallelGroupHandle,\n    members: Array<{ name: string; promise: Promise<unknown> }>,\n  ): Promise<void> {\n    const wallStart = Date.now();\n\n    let nextResolvedIndex = 0;\n    const resolutionOrder = new Map<string, number>();\n\n    const timed = members.map(async (m) => {\n      const t0 = Date.now();\n      try {\n        await m.promise;\n      } catch {\n        // settled — still record order\n      }\n      resolutionOrder.set(m.name, nextResolvedIndex++);\n      return { name: m.name, durationMs: Date.now() - t0 };\n    });\n    const timedResults = await Promise.allSettled(timed);\n\n    const tid = handle.traceId ?? this.latestTraceId;\n    const t = tid ? this.activeTraces.get(tid) : undefined;\n    if (!t) return;\n\n    const wallMs = Date.now() - wallStart;\n\n    const groupMembers: ProfileParallelGroupMember[] = members.map((m, i) => {\n      const timedResult = timedResults[i].status === \"fulfilled\"\n        ? timedResults[i].value\n        : { name: m.name, durationMs: wallMs };\n      return {\n        name: timedResult.name,\n        durationMs: timedResult.durationMs,\n        resolvedIndex: resolutionOrder.get(m.name) ?? i,\n      };\n    });\n\n    t.parallelGroups.push({\n      name: handle.name,\n      startOffsetMs: handle.startOffsetMs,\n      wallMs,\n      members: groupMembers,\n    });\n\n    log.debug(`profiling: parallel group ${handle.name} wallMs=${wallMs} (trace=${tid})`);\n  }\n\n  // ---- Query methods -----------------------------------------------------\n\n  getRecentTraces(limit?: number): ProfileTrace[] {\n    if (limit === undefined || limit === Infinity) {\n      return [...this.traces];\n    }\n    if (!Number.isFinite(limit)) {\n      return [];\n    }\n    const n = Math.floor(limit);\n    if (n <= 0) {\n      return [];\n    }\n    return this.traces.slice(-n);\n  }\n\n  getStats(): ProfilingStats {\n    const byKind: Record<string, number[]> = {};\n    const bySpan: Record<string, number[]> = {};\n\n    for (const trace of this.traces) {\n      if (!byKind[trace.kind]) byKind[trace.kind] = [];\n      byKind[trace.kind].push(trace.totalMs);\n\n      for (const span of trace.spans) {\n        if (!bySpan[span.name]) bySpan[span.name] = [];\n        bySpan[span.name].push(span.durationMs);\n      }\n    }\n\n    const result: ProfilingStats = { byKind: {}, bySpan: {} };\n    for (const [k, v] of Object.entries(byKind)) {\n      result.byKind[k] = aggregateStats(v);\n    }\n    for (const [k, v] of Object.entries(bySpan)) {\n      result.bySpan[k] = aggregateStats(v);\n    }\n    return result;\n  }\n\n  identifyBottleneck(): string | null {\n    if (this.traces.length === 0) return null;\n    const latest = this.traces[this.traces.length - 1];\n    if (latest.spans.length === 0) return null;\n    let slowest = latest.spans[0];\n    for (const span of latest.spans) {\n      if (span.durationMs > slowest.durationMs) slowest = span;\n    }\n    return slowest.name;\n  }\n\n  // ---- Persistence -------------------------------------------------------\n\n  private persistTrace(trace: ProfileTrace): void {\n    const filename = `${trace.kind}-${trace.traceId}.jsonl`;\n    const filepath = join(this.storageDir, filename);\n    try {\n      // Created on first persist, never at construction: constructing a\n      // collector (plugin registration, a discovery pass, CLI metadata) must\n      // not touch the operator's memory dir when no trace is ever written.\n      if (!existsSync(this.storageDir)) {\n        mkdirSync(this.storageDir, { recursive: true });\n        log.debug(`profiling: created storage dir ${this.storageDir}`);\n      }\n      writeFileSync(filepath, JSON.stringify(trace) + \"\\n\", \"utf-8\");\n      log.debug(`profiling: persisted ${filename}`);\n    } catch (err) {\n      log.warn(`profiling: failed to persist ${filename}`, err);\n    }\n  }\n\n  async pruneFiles(): Promise<void> {\n    try {\n      const dir = this.storageDir;\n      const entries = await fsp.readdir(dir);\n      const jsonlFiles = entries.filter((f) => !isMacOsReplicationJunkBasename(f) && f.endsWith(\".jsonl\"));\n      const withMtime = await Promise.all(\n        jsonlFiles.map(async (f) => ({\n          name: f,\n          mtime: (await fsp.stat(join(dir, f))).mtimeMs,\n        })),\n      );\n      const files = withMtime.sort((a, b) => a.mtime - b.mtime).map((f) => f.name);\n\n      while (files.length > this.maxTraces) {\n        const oldest = files.shift()!;\n        await fsp.unlink(join(dir, oldest));\n        log.debug(`profiling: pruned ${oldest}`);\n      }\n    } catch (err) {\n      log.warn(\"profiling: prune failed\", err);\n    }\n  }\n}\n\n// ---------------------------------------------------------------------------\n// ASCII formatter\n// ---------------------------------------------------------------------------\n\nexport function formatProfileTraceAscii(trace: ProfileTrace): string {\n  const lines: string[] = [];\n  const BAR_WIDTH = 40;\n\n  lines.push(`=== Profile: ${trace.kind} ===`);\n  lines.push(`Trace ID : ${trace.traceId}`);\n  lines.push(`Total    : ${trace.totalMs}ms`);\n  if (trace.sessionKey) lines.push(`Session  : ${trace.sessionKey}`);\n  lines.push(\"\");\n\n  // Identify bottleneck.\n  let bottleneckName: string | null = null;\n  if (trace.spans.length > 0) {\n    let slowest = trace.spans[0];\n    for (const s of trace.spans) {\n      if (s.durationMs > slowest.durationMs) slowest = s;\n    }\n    bottleneckName = slowest.name;\n  }\n\n  // Spans.\n  if (trace.spans.length > 0) {\n    const maxDuration = Math.max(...trace.spans.map((s) => s.durationMs), 1);\n    lines.push(\"Spans:\");\n    for (const span of trace.spans) {\n      const barLen = Math.max(1, Math.round((span.durationMs / maxDuration) * BAR_WIDTH));\n      const bar = \"\\u2588\".repeat(barLen);\n      const suffix = span.name === bottleneckName ? \" \\u2190 bottleneck\" : \"\";\n      lines.push(`  ${span.name.padEnd(30)} ${String(span.durationMs).padStart(6)}ms ${bar}${suffix}`);\n    }\n    lines.push(\"\");\n  }\n\n  // Parallel groups.\n  if (trace.parallelGroups && trace.parallelGroups.length > 0) {\n    lines.push(\"Parallel Groups:\");\n    for (const group of trace.parallelGroups) {\n      lines.push(`  ${group.name}:`);\n      lines.push(`    Wall time    : ${group.wallMs}ms`);\n      const efficiency = parallelEfficiency(group);\n      if (efficiency !== null) {\n        lines.push(`    Efficiency   : ${efficiency}%`);\n      }\n      for (const member of group.members) {\n        lines.push(`    [${String(member.resolvedIndex).padStart(2)}] ${member.name.padEnd(28)} ${String(member.durationMs).padStart(6)}ms`);\n      }\n    }\n    lines.push(\"\");\n  }\n\n  lines.push(\"---\");\n  return lines.join(\"\\n\");\n}\n\nfunction parallelEfficiency(group: ProfileParallelGroup): number | null {\n  if (group.members.length <= 1) return null;\n  const idealMs = Math.max(...group.members.map((m) => m.durationMs));\n  if (group.wallMs === 0) return null;\n  return Math.round((idealMs / group.wallMs) * 100);\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-4OSG5Y6M.js → chunk-DPSOFK4D.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-7T4TOGMS.js";
 import {
   defineOperation
-} from "./chunk-ZV65I6ME.js";
+} from "./chunk-XLBFX63V.js";
 
 // src/external-wiki-access.ts
 import { z } from "zod";
@@ -26,4 +26,4 @@ var externalWikiSearchOperation = defineOperation({
 export {
   externalWikiSearchOperation
 };
-//# sourceMappingURL=chunk-4OSG5Y6M.js.map
+//# sourceMappingURL=chunk-DPSOFK4D.js.map