@remnic/core 1.1.2 → 1.1.4

package/dist/{chunk-GA5P7RST.js → chunk-VTJVUHRK.js}

@@ -1,9 +1,6 @@
 import {
   validateRouteTarget
 } from "./chunk-2LGMW3DJ.js";
-import {
-  resolveHomeDir
-} from "./chunk-MARWOCVP.js";
 import {
   log
 } from "./chunk-2ODBA7MQ.js";
@@ -139,19 +136,9 @@ function validateReplayTurn(turn, index) {
   return issues;
 }
 
-// src/utils/path.ts
-import path from "path";
-function expandTildePath(p) {
-  if (p === "~") return resolveHomeDir();
-  if (p.startsWith("~/") || p.startsWith("~\\")) {
-    return path.join(resolveHomeDir(), p.slice(2));
-  }
-  return p;
-}
-
 // src/routing/store.ts
 import { lstat, mkdir, readFile, realpath, rename, rm, stat, writeFile } from "fs/promises";
-import path2 from "path";
+import path from "path";
 import { createHash } from "crypto";
 function defaultState() {
   return {
@@ -170,14 +157,14 @@ function stableRuleId(rule) {
   return `route-${createHash("sha256").update(seed).digest("hex").slice(0, 12)}`;
 }
 function resolveStatePath(memoryDir, stateFile) {
-  const root = path2.resolve(memoryDir);
-  const defaultPath = path2.join(root, "state", "routing-rules.json");
-  if (path2.isAbsolute(stateFile)) {
-    const absolute = path2.resolve(stateFile);
-    return absolute.startsWith(root + path2.sep) ? absolute : defaultPath;
+  const root = path.resolve(memoryDir);
+  const defaultPath = path.join(root, "state", "routing-rules.json");
+  if (path.isAbsolute(stateFile)) {
+    const absolute = path.resolve(stateFile);
+    return absolute.startsWith(root + path.sep) ? absolute : defaultPath;
   }
-  const resolved = path2.resolve(root, stateFile);
-  return resolved.startsWith(root + path2.sep) ? resolved : defaultPath;
+  const resolved = path.resolve(root, stateFile);
+  return resolved.startsWith(root + path.sep) ? resolved : defaultPath;
 }
 function normalizeRule(rule, options) {
   if (!rule || typeof rule !== "object") return null;
@@ -210,7 +197,7 @@ var RoutingRulesStore = class {
   lockPath;
   writeQueue = Promise.resolve();
   constructor(memoryDir, stateFile = "state/routing-rules.json") {
-    this.memoryRoot = path2.resolve(memoryDir);
+    this.memoryRoot = path.resolve(memoryDir);
     this.statePath = resolveStatePath(memoryDir, stateFile);
     this.lockPath = `${this.statePath}.lock`;
   }
@@ -316,7 +303,7 @@ var RoutingRulesStore = class {
     const timeoutMs = 5e3;
     let unexpectedLockError = null;
     await this.assertStatePathScoped();
-    await mkdir(path2.dirname(this.lockPath), { recursive: true });
+    await mkdir(path.dirname(this.lockPath), { recursive: true });
     while (Date.now() - start < timeoutMs) {
       try {
         await mkdir(this.lockPath);
@@ -351,12 +338,12 @@ var RoutingRulesStore = class {
   async assertStatePathScoped() {
     await mkdir(this.memoryRoot, { recursive: true });
     const canonicalRoot = await realpath(this.memoryRoot);
-    const canonicalParent = await this.canonicalizePathWithoutCreating(path2.dirname(this.statePath));
-    const canonicalStatePath = path2.join(canonicalParent, path2.basename(this.statePath));
+    const canonicalParent = await this.canonicalizePathWithoutCreating(path.dirname(this.statePath));
+    const canonicalStatePath = path.join(canonicalParent, path.basename(this.statePath));
     if (!this.isPathInside(canonicalRoot, canonicalStatePath)) {
       throw new Error(`routing rules state path escaped memoryDir: ${canonicalStatePath}`);
     }
-    await mkdir(path2.dirname(this.statePath), { recursive: true });
+    await mkdir(path.dirname(this.statePath), { recursive: true });
     try {
       const stateStats = await lstat(this.statePath);
       if (stateStats.isSymbolicLink()) {
@@ -373,28 +360,28 @@ var RoutingRulesStore = class {
     }
   }
   isPathInside(root, candidate) {
-    const normalizedRoot = path2.resolve(root);
-    const normalizedCandidate = path2.resolve(candidate);
+    const normalizedRoot = path.resolve(root);
+    const normalizedCandidate = path.resolve(candidate);
     if (normalizedCandidate === normalizedRoot) return true;
-    if (normalizedRoot === path2.parse(normalizedRoot).root) {
+    if (normalizedRoot === path.parse(normalizedRoot).root) {
       return normalizedCandidate.startsWith(normalizedRoot);
     }
-    return normalizedCandidate.startsWith(`${normalizedRoot}${path2.sep}`);
+    return normalizedCandidate.startsWith(`${normalizedRoot}${path.sep}`);
   }
   async canonicalizePathWithoutCreating(targetPath) {
-    const absoluteTarget = path2.resolve(targetPath);
+    const absoluteTarget = path.resolve(targetPath);
     let probe = absoluteTarget;
     while (true) {
       try {
         const canonicalProbe = await realpath(probe);
-        const remainder = path2.relative(probe, absoluteTarget);
-        return path2.resolve(canonicalProbe, remainder);
+        const remainder = path.relative(probe, absoluteTarget);
+        return path.resolve(canonicalProbe, remainder);
       } catch (err) {
         const code = err.code;
         if (code !== "ENOENT") {
           throw err;
         }
-        const parent = path2.dirname(probe);
+        const parent = path.dirname(probe);
         if (parent === probe) {
           return absoluteTarget;
         }
@@ -411,7 +398,6 @@ export {
   normalizeReplaySessionKey,
   parseIsoTimestamp,
   validateReplayTurn,
-  expandTildePath,
   RoutingRulesStore
 };
-//# sourceMappingURL=chunk-GA5P7RST.js.map
+//# sourceMappingURL=chunk-VTJVUHRK.js.map

package/dist/chunk-VTJVUHRK.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/iso-timestamp.ts","../src/replay/types.ts","../src/routing/store.ts"],"sourcesContent":["// ---------------------------------------------------------------------------\n// Shared ISO-8601 / RFC 3339 timestamp validation helpers.\n//\n// Two public entry points — a strict UTC-only parser used by the replay\n// pipeline, and a more permissive parser used by bulk-import adapters that\n// need to preserve source timezone offsets. Both share date-component,\n// offset-range, and round-trip validation so they cannot silently diverge.\n// ---------------------------------------------------------------------------\n\n// UTC-only: `...Z`, 0 or 3 fractional digits (replay canonical form).\nconst ISO_UTC_TIMESTAMP_RE =\n  /^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d{3})?Z$/;\n\n// Lenient: variable-precision fractional seconds and `Z` or `[+-]HH:MM` offset.\nconst ISO_OFFSET_TIMESTAMP_RE =\n  /^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d+)?(?:Z|[+-]\\d{2}:\\d{2})$/;\n\n/**\n * Validate the date/time components of an ISO timestamp string.\n * Catches overflowed dates like Feb 31 that `Date.parse` silently normalizes.\n */\nfunction validateDateComponents(isoString: string): boolean {\n  const match = isoString.match(\n    /^(\\d{4})-(\\d{2})-(\\d{2})T(\\d{2}):(\\d{2}):(\\d{2})/,\n  );\n  if (!match) return false;\n  const [, yStr, mStr, dStr, hStr, minStr, sStr] = match;\n  const y = Number(yStr);\n  const m = Number(mStr);\n  const d = Number(dStr);\n  const h = Number(hStr);\n  const min = Number(minStr);\n  const s = Number(sStr);\n  if (m < 1 || m > 12) return false;\n  if (d < 1 || d > 31) return false;\n  if (h > 23 || min > 59 || s > 59) return false;\n  // Validate day for the specific month (using Date(y, m, 0) to get days).\n  const daysInMonth = new Date(y, m, 0).getDate();\n  if (d > daysInMonth) return false;\n  return true;\n}\n\n/**\n * Validate the timezone offset range if present.\n * Max offset is +/-14:00 per ISO 8601; minute part must be 0-59.\n */\nfunction validateOffset(isoString: string): boolean {\n  const offsetMatch = isoString.match(/([+-])(\\d{2}):(\\d{2})$/);\n  if (!offsetMatch) return true; // `Z` form, no offset to validate.\n  const oh = Number(offsetMatch[2]);\n  const om = Number(offsetMatch[3]);\n  if (oh > 14 || om > 59) return false;\n  // +14:00 is max; offsets like +14:30 are invalid.\n  if (oh === 14 && om > 0) return false;\n  return true;\n}\n\n/**\n * Normalize a `Z`-suffixed ISO timestamp to exactly three fractional digits so\n * the round-trip comparison against `Date.prototype.toISOString()` succeeds\n * regardless of input precision (or absence of a fractional part).\n */\nfunction normalizeUtcForComparison(value: string): string {\n  const fracMatch = value.match(/\\.(\\d+)Z$/);\n  if (fracMatch) {\n    const ms = (fracMatch[1] + \"000\").slice(0, 3);\n    return value.replace(/\\.\\d+Z$/, `.${ms}Z`);\n  }\n  return value.replace(/Z$/, \".000Z\");\n}\n\n/**\n * Strict UTC-only parser — accepts `YYYY-MM-DDTHH:MM:SS[.sss]Z`.\n * Returns milliseconds since epoch, or `null` if invalid.\n */\nexport function parseIsoUtcTimestamp(value: string): number | null {\n  if (typeof value !== \"string\" || !ISO_UTC_TIMESTAMP_RE.test(value)) {\n    return null;\n  }\n  const ts = Date.parse(value);\n  if (!Number.isFinite(ts)) return null;\n  if (!validateDateComponents(value)) return null;\n  const roundTrip = new Date(ts).toISOString();\n  if (roundTrip !== normalizeUtcForComparison(value)) return null;\n  return ts;\n}\n\n/**\n * Lenient parser — accepts variable-precision fractional seconds and either\n * a `Z` suffix or a `[+-]HH:MM` offset. Returns milliseconds since epoch, or\n * `null` if the string is not a well-formed RFC 3339 timestamp.\n */\nexport function parseIsoOffsetTimestamp(value: string): number | null {\n  if (typeof value !== \"string\" || !ISO_OFFSET_TIMESTAMP_RE.test(value)) {\n    return null;\n  }\n  const ts = Date.parse(value);\n  if (!Number.isFinite(ts)) return null;\n  if (!validateDateComponents(value)) return null;\n  if (!validateOffset(value)) return null;\n  // For UTC timestamps (ending in `Z`), verify with a round-trip so that\n  // overflowed UTC calendar dates cannot slip through.\n  if (value.endsWith(\"Z\")) {\n    const roundTrip = new Date(ts).toISOString();\n    if (roundTrip !== normalizeUtcForComparison(value)) return null;\n  }\n  return ts;\n}\n","import { parseIsoUtcTimestamp } from \"../utils/iso-timestamp.js\";\n\nexport type ReplaySource = \"openclaw\" | \"claude\" | \"chatgpt\";\nexport type ReplayRole = \"user\" | \"assistant\";\n\nexport interface ReplayTurn {\n  source: ReplaySource;\n  sessionKey: string;\n  role: ReplayRole;\n  content: string;\n  timestamp: string;\n  externalId?: string;\n  metadata?: Record<string, unknown>;\n}\n\nexport interface ReplayWarning {\n  code: string;\n  message: string;\n  index?: number;\n}\n\nexport interface ReplayValidationIssue {\n  code: string;\n  message: string;\n  index?: number;\n}\n\nexport interface ReplayParseOptions {\n  from?: string;\n  to?: string;\n  defaultSessionKey?: string;\n  strict?: boolean;\n}\n\nexport interface ReplayParseResult {\n  turns: ReplayTurn[];\n  warnings: ReplayWarning[];\n}\n\nexport interface ReplayNormalizer {\n  source: ReplaySource;\n  parse(input: unknown, options?: ReplayParseOptions): Promise<ReplayParseResult> | ReplayParseResult;\n}\n\nconst VALID_SOURCES: ReadonlySet<string> = new Set([\"openclaw\", \"claude\", \"chatgpt\"]);\nconst VALID_ROLES: ReadonlySet<string> = new Set([\"user\", \"assistant\"]);\nexport const REPLAY_UNKNOWN_SESSION_KEY = \"replay:unknown\";\n\nexport function isReplaySource(value: unknown): value is ReplaySource {\n  return typeof value === \"string\" && VALID_SOURCES.has(value);\n}\n\nexport function isReplayRole(value: unknown): value is ReplayRole {\n  return typeof value === \"string\" && VALID_ROLES.has(value);\n}\n\nexport function normalizeReplaySessionKey(value: unknown): string {\n  if (typeof value !== \"string\") return REPLAY_UNKNOWN_SESSION_KEY;\n  const trimmed = value.trim();\n  return trimmed.length > 0 ? trimmed : REPLAY_UNKNOWN_SESSION_KEY;\n}\n\n/**\n * Strict UTC-only ISO-8601 parser used by the replay pipeline.\n *\n * Delegates to the shared parser in `utils/iso-timestamp.ts` — do not\n * reimplement locally; extend that helper instead. Replay intentionally\n * rejects timezone-offset timestamps to keep canonical form consistent\n * across recorded transcripts.\n */\nexport function parseIsoTimestamp(value: string): number | null {\n  return parseIsoUtcTimestamp(value);\n}\n\nexport function validateReplayTurn(turn: ReplayTurn, index?: number): ReplayValidationIssue[] {\n  const issues: ReplayValidationIssue[] = [];\n  if (!turn || typeof turn !== \"object\") {\n    issues.push({\n      code: \"turn.invalid\",\n      message: \"Replay turn must be an object.\",\n      index,\n    });\n    return issues;\n  }\n\n  if (!isReplayRole(turn.role)) {\n    issues.push({\n      code: \"turn.role.invalid\",\n      message: `Replay role must be 'user' or 'assistant', received '${String(turn.role)}'.`,\n      index,\n    });\n  }\n\n  if (!isReplaySource(turn.source)) {\n    issues.push({\n      code: \"turn.source.invalid\",\n      message: `Replay source must be 'openclaw', 'claude', or 'chatgpt', received '${String(turn.source)}'.`,\n      index,\n    });\n  }\n\n  if (!turn.sessionKey || typeof turn.sessionKey !== \"string\" || turn.sessionKey.trim().length === 0) {\n    issues.push({\n      code: \"turn.sessionKey.invalid\",\n      message: \"Replay sessionKey is required.\",\n      index,\n    });\n  }\n\n  if (!turn.content || typeof turn.content !== \"string\" || turn.content.trim().length === 0) {\n    issues.push({\n      code: \"turn.content.invalid\",\n      message: \"Replay content must be a non-empty string.\",\n      index,\n    });\n  }\n\n  if (!turn.timestamp || typeof turn.timestamp !== \"string\" || parseIsoTimestamp(turn.timestamp) === null) {\n    issues.push({\n      code: \"turn.timestamp.invalid\",\n      message: `Replay timestamp must be a valid ISO timestamp, received '${String(turn.timestamp)}'.`,\n      index,\n    });\n  }\n\n  return issues;\n}\n","import { lstat, mkdir, readFile, realpath, rename, rm, stat, writeFile } from \"node:fs/promises\";\nimport path from \"node:path\";\nimport { createHash } from \"node:crypto\";\nimport { log } from \"../logger.js\";\nimport { validateRouteTarget, type RouteRule, type RoutingEngineOptions } from \"./engine.js\";\n\ntype RoutingRulesState = {\n  version: 1;\n  updatedAt: string;\n  rules: RouteRule[];\n};\n\nfunction defaultState(): RoutingRulesState {\n  return {\n    version: 1,\n    updatedAt: new Date(0).toISOString(),\n    rules: [],\n  };\n}\n\nfunction stableRuleId(rule: Pick<RouteRule, \"patternType\" | \"pattern\" | \"priority\" | \"target\">): string {\n  const seed = JSON.stringify({\n    patternType: rule.patternType,\n    pattern: rule.pattern.trim(),\n    priority: rule.priority,\n    target: rule.target,\n  });\n  return `route-${createHash(\"sha256\").update(seed).digest(\"hex\").slice(0, 12)}`;\n}\n\nfunction resolveStatePath(memoryDir: string, stateFile: string): string {\n  const root = path.resolve(memoryDir);\n  const defaultPath = path.join(root, \"state\", \"routing-rules.json\");\n  if (path.isAbsolute(stateFile)) {\n    const absolute = path.resolve(stateFile);\n    return absolute.startsWith(root + path.sep) ? absolute : defaultPath;\n  }\n  const resolved = path.resolve(root, stateFile);\n  return resolved.startsWith(root + path.sep) ? resolved : defaultPath;\n}\n\nfunction normalizeRule(rule: RouteRule, options?: RoutingEngineOptions): RouteRule | null {\n  if (!rule || typeof rule !== \"object\") return null;\n  if (rule.enabled === false) return null;\n  if (rule.patternType !== \"keyword\" && rule.patternType !== \"regex\") return null;\n  if (typeof rule.pattern !== \"string\" || rule.pattern.trim().length === 0) return null;\n  if (typeof rule.priority !== \"number\" || !Number.isFinite(rule.priority)) return null;\n\n  const targetValidation = validateRouteTarget(rule.target, options);\n  if (!targetValidation.ok || !targetValidation.target) return null;\n\n  const normalizedPriority = Math.trunc(rule.priority);\n  const normalizedTarget = targetValidation.target;\n  const id = typeof rule.id === \"string\" && rule.id.trim().length > 0\n    ? rule.id.trim()\n    : stableRuleId({\n      patternType: rule.patternType,\n      pattern: rule.pattern.trim(),\n      priority: normalizedPriority,\n      target: normalizedTarget,\n    });\n  return {\n    id,\n    patternType: rule.patternType,\n    pattern: rule.pattern.trim(),\n    priority: normalizedPriority,\n    target: normalizedTarget,\n    enabled: true,\n  };\n}\n\nexport class RoutingRulesStore {\n  private readonly memoryRoot: string;\n  private readonly statePath: string;\n  private readonly lockPath: string;\n  private writeQueue: Promise<void> = Promise.resolve();\n\n  constructor(memoryDir: string, stateFile = \"state/routing-rules.json\") {\n    this.memoryRoot = path.resolve(memoryDir);\n    this.statePath = resolveStatePath(memoryDir, stateFile);\n    this.lockPath = `${this.statePath}.lock`;\n  }\n\n  async read(options?: RoutingEngineOptions): Promise<RouteRule[]> {\n    try {\n      const persisted = await this.readPersistedRules();\n      return persisted\n        .map((rule) => normalizeRule(rule, options))\n        .filter((rule): rule is RouteRule => rule !== null);\n    } catch {\n      return [];\n    }\n  }\n\n  async write(rules: RouteRule[], options?: RoutingEngineOptions): Promise<RouteRule[]> {\n    return this.withWriteLock(async () => this.writeNormalized(rules, options));\n  }\n\n  async upsert(rule: RouteRule, options?: RoutingEngineOptions): Promise<RouteRule[]> {\n    return this.withWriteLock(async () => {\n      const existing = await this.readPersistedRules();\n      const normalized = normalizeRule(rule, options);\n      if (!normalized) return existing;\n\n      const next = existing.filter((entry) => entry.id !== normalized.id);\n      next.push(normalized);\n      return this.writeNormalized(next);\n    });\n  }\n\n  async removeByPattern(pattern: string): Promise<RouteRule[]> {\n    return this.withWriteLock(async () => {\n      const trimmed = pattern.trim();\n      const existing = await this.readPersistedRules();\n      const next = existing.filter((entry) => entry.pattern !== trimmed);\n      if (next.length === existing.length) return existing;\n      return this.writeNormalized(next);\n    });\n  }\n\n  async reset(): Promise<void> {\n    await this.withWriteLock(async () => {\n      const payload = defaultState();\n      await this.assertStatePathScoped();\n      await writeFile(this.statePath, JSON.stringify(payload, null, 2), \"utf-8\");\n    });\n  }\n\n  private dedupeById(rules: RouteRule[]): RouteRule[] {\n    const byId = new Map<string, RouteRule>();\n    for (const rule of rules) {\n      byId.set(rule.id, rule);\n    }\n    return Array.from(byId.values());\n  }\n\n  private async readPersistedRules(): Promise<RouteRule[]> {\n    try {\n      await this.assertStatePathScoped();\n      const raw = await readFile(this.statePath, \"utf-8\");\n      const parsed = JSON.parse(raw) as Partial<RoutingRulesState>;\n      if (!parsed || typeof parsed !== \"object\" || !Array.isArray(parsed.rules)) return [];\n      const normalized = parsed.rules\n        .map((rule) => normalizeRule(rule))\n        .filter((rule): rule is RouteRule => rule !== null);\n      return this.dedupeById(normalized);\n    } catch {\n      return [];\n    }\n  }\n\n  private async writeNormalized(rules: RouteRule[], options?: RoutingEngineOptions): Promise<RouteRule[]> {\n    const normalized = this.dedupeById(\n      rules\n        .map((rule) => normalizeRule(rule, options))\n        .filter((rule): rule is RouteRule => rule !== null),\n    );\n\n    const payload: RoutingRulesState = {\n      version: 1,\n      updatedAt: new Date().toISOString(),\n      rules: normalized,\n    };\n\n    const tmpPath = `${this.statePath}.tmp-${process.pid}-${Date.now()}`;\n    try {\n      await this.assertStatePathScoped();\n      await writeFile(tmpPath, JSON.stringify(payload, null, 2), \"utf-8\");\n      await rename(tmpPath, this.statePath);\n    } catch (err) {\n      log.debug(`routing rules write failed: ${err}`);\n      throw err;\n    } finally {\n      await rm(tmpPath, { force: true }).catch(() => {});\n    }\n\n    return normalized;\n  }\n\n  private async withWriteLock<T>(op: () => Promise<T>): Promise<T> {\n    const previous = this.writeQueue;\n    let release: () => void = () => {};\n    this.writeQueue = new Promise<void>((resolve) => {\n      release = resolve;\n    });\n    await previous;\n    let unlock: (() => Promise<void>) | null = null;\n    try {\n      unlock = await this.acquireFileLock();\n      return await op();\n    } finally {\n      if (unlock) await unlock();\n      release();\n    }\n  }\n\n  private async acquireFileLock(): Promise<() => Promise<void>> {\n    const start = Date.now();\n    const staleMs = 30_000;\n    const timeoutMs = 5_000;\n    let unexpectedLockError: unknown = null;\n    await this.assertStatePathScoped();\n    await mkdir(path.dirname(this.lockPath), { recursive: true });\n\n    while (Date.now() - start < timeoutMs) {\n      try {\n        await mkdir(this.lockPath);\n        return async () => {\n          try {\n            await rm(this.lockPath, { recursive: true, force: true });\n          } catch {\n            // Fail-open: lock cleanup should not fail writes.\n          }\n        };\n      } catch (err) {\n        const code = (err as NodeJS.ErrnoException).code;\n        if (code !== \"EEXIST\") {\n          unexpectedLockError = err;\n          break;\n        }\n        try {\n          const lockStat = await stat(this.lockPath);\n          if (Date.now() - lockStat.mtimeMs > staleMs) {\n            await rm(this.lockPath, { recursive: true, force: true });\n            continue;\n          }\n        } catch {\n          // Lock may have been released between stat/rm attempts.\n        }\n        await new Promise((resolve) => setTimeout(resolve, 25));\n      }\n    }\n\n    if (unexpectedLockError) {\n      throw unexpectedLockError;\n    }\n    throw new Error(`routing rules lock acquisition timed out after ${timeoutMs}ms`);\n  }\n\n  private async assertStatePathScoped(): Promise<void> {\n    await mkdir(this.memoryRoot, { recursive: true });\n    const canonicalRoot = await realpath(this.memoryRoot);\n    const canonicalParent = await this.canonicalizePathWithoutCreating(path.dirname(this.statePath));\n    const canonicalStatePath = path.join(canonicalParent, path.basename(this.statePath));\n    if (!this.isPathInside(canonicalRoot, canonicalStatePath)) {\n      throw new Error(`routing rules state path escaped memoryDir: ${canonicalStatePath}`);\n    }\n    await mkdir(path.dirname(this.statePath), { recursive: true });\n    try {\n      const stateStats = await lstat(this.statePath);\n      if (stateStats.isSymbolicLink()) {\n        const canonicalFile = await realpath(this.statePath);\n        if (!this.isPathInside(canonicalRoot, canonicalFile)) {\n          throw new Error(`routing rules state symlink escaped memoryDir: ${canonicalFile}`);\n        }\n      }\n    } catch (err) {\n      const code = (err as NodeJS.ErrnoException).code;\n      if (code !== \"ENOENT\") {\n        throw err;\n      }\n    }\n  }\n\n  private isPathInside(root: string, candidate: string): boolean {\n    const normalizedRoot = path.resolve(root);\n    const normalizedCandidate = path.resolve(candidate);\n    if (normalizedCandidate === normalizedRoot) return true;\n    if (normalizedRoot === path.parse(normalizedRoot).root) {\n      return normalizedCandidate.startsWith(normalizedRoot);\n    }\n    return normalizedCandidate.startsWith(`${normalizedRoot}${path.sep}`);\n  }\n\n  private async canonicalizePathWithoutCreating(targetPath: string): Promise<string> {\n    const absoluteTarget = path.resolve(targetPath);\n    let probe = absoluteTarget;\n    while (true) {\n      try {\n        const canonicalProbe = await realpath(probe);\n        const remainder = path.relative(probe, absoluteTarget);\n        return path.resolve(canonicalProbe, remainder);\n      } catch (err) {\n        const code = (err as NodeJS.ErrnoException).code;\n        if (code !== \"ENOENT\") {\n          throw err;\n        }\n        const parent = path.dirname(probe);\n        if (parent === probe) {\n          return absoluteTarget;\n        }\n        probe = parent;\n      }\n    }\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-SPI27QT6.js → chunk-W7WWT4FJ.js}

@@ -4,11 +4,11 @@ import {
 } from "./chunk-DT5TVLJE.js";
 import {
   StorageManager
-} from "./chunk-F5VP6YCB.js";
+} from "./chunk-Y4A6M3B6.js";
 import {
   getCachedRuleMemories,
   setCachedRuleMemories
-} from "./chunk-6PFRXT4K.js";
+} from "./chunk-PFV5C235.js";
 
 // src/semantic-rule-verifier.ts
 var DEFAULT_MIN_EFFECTIVE_CONFIDENCE = 0.45;
@@ -20,6 +20,8 @@ function verificationConfidenceMultiplier(status) {
       return 0.45;
     case "source-memory-archived":
       return 0.4;
+    case "source-memory-forgotten":
+      return 0.3;
     case "source-memory-missing":
       return 0.35;
     default:
@@ -28,7 +30,10 @@ function verificationConfidenceMultiplier(status) {
 }
 function resolveVerificationStatus(sourceMemory) {
   if (!sourceMemory) return "source-memory-missing";
-  if (sourceMemory.frontmatter.status === "archived") return "source-memory-archived";
+  if (sourceMemory.frontmatter.status === "archived") {
+    return "source-memory-archived";
+  }
+  if (sourceMemory.frontmatter.status === "forgotten") return "source-memory-forgotten";
   if (sourceMemory.frontmatter.memoryKind !== "episode") return "source-memory-not-episode";
   return "verified";
 }
@@ -110,4 +115,4 @@ async function searchVerifiedSemanticRules(options) {
 export {
   searchVerifiedSemanticRules
 };
-//# sourceMappingURL=chunk-SPI27QT6.js.map
+//# sourceMappingURL=chunk-W7WWT4FJ.js.map

package/dist/chunk-W7WWT4FJ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/semantic-rule-verifier.ts"],"sourcesContent":["import { getCachedRuleMemories, setCachedRuleMemories } from \"./memory-cache.js\";\nimport { StorageManager } from \"./storage.js\";\nimport type { MemoryFile } from \"./types.js\";\nimport { countRecallTokenOverlap, normalizeRecallTokens } from \"./recall-tokenization.js\";\n\nexport type SemanticRuleVerificationStatus =\n  | \"verified\"\n  | \"source-memory-missing\"\n  | \"source-memory-archived\"\n  | \"source-memory-forgotten\"\n  | \"source-memory-not-episode\";\n\nexport interface VerifiedSemanticRuleResult {\n  rule: MemoryFile;\n  score: number;\n  sourceMemoryId: string;\n  verificationStatus: SemanticRuleVerificationStatus;\n  effectiveConfidence: number;\n  matchedFields: string[];\n}\n\nconst DEFAULT_MIN_EFFECTIVE_CONFIDENCE = 0.45;\n\nfunction verificationConfidenceMultiplier(status: SemanticRuleVerificationStatus): number {\n  switch (status) {\n    case \"verified\":\n      return 1;\n    case \"source-memory-not-episode\":\n      return 0.45;\n    case \"source-memory-archived\":\n      return 0.4;\n    case \"source-memory-forgotten\":\n      return 0.3;\n    case \"source-memory-missing\":\n      return 0.35;\n    default:\n      return 0.35;\n  }\n}\n\nfunction resolveVerificationStatus(sourceMemory: MemoryFile | undefined): SemanticRuleVerificationStatus {\n  if (!sourceMemory) return \"source-memory-missing\";\n  if (sourceMemory.frontmatter.status === \"archived\") {\n    return \"source-memory-archived\";\n  }\n  if (sourceMemory.frontmatter.status === \"forgotten\") return \"source-memory-forgotten\";\n  if (sourceMemory.frontmatter.memoryKind !== \"episode\") return \"source-memory-not-episode\";\n  return \"verified\";\n}\n\nfunction resolveEffectiveConfidence(rule: MemoryFile, sourceMemory: MemoryFile | undefined): {\n  status: SemanticRuleVerificationStatus;\n  effectiveConfidence: number;\n} {\n  const status = resolveVerificationStatus(sourceMemory);\n  const ruleConfidence = Number.isFinite(rule.frontmatter.confidence) ? rule.frontmatter.confidence : 0.8;\n  const sourceConfidence = Number.isFinite(sourceMemory?.frontmatter.confidence)\n    ? sourceMemory!.frontmatter.confidence\n    : ruleConfidence;\n  const anchoredConfidence = Math.min(ruleConfidence, sourceConfidence);\n  const effectiveConfidence = Math.max(\n    0,\n    Math.min(1, anchoredConfidence * verificationConfidenceMultiplier(status)),\n  );\n  return { status, effectiveConfidence };\n}\n\nfunction scoreVerifiedSemanticRuleCandidate(\n  rule: MemoryFile,\n  sourceMemory: MemoryFile | undefined,\n  queryTokens: Set<string>,\n  effectiveConfidence: number,\n): { score: number; matchedFields: Set<string> } {\n  const matchedFields = new Set<string>();\n  let score = 0;\n\n  const ruleContentMatches = countRecallTokenOverlap(queryTokens, rule.content);\n  if (ruleContentMatches > 0) {\n    score += ruleContentMatches * 5;\n    matchedFields.add(\"ruleContent\");\n  }\n\n  const tagMatches = countRecallTokenOverlap(queryTokens, rule.frontmatter.tags?.join(\" \"));\n  if (tagMatches > 0) {\n    score += tagMatches * 2;\n    matchedFields.add(\"tags\");\n  }\n\n  const sourceContentMatches = countRecallTokenOverlap(queryTokens, sourceMemory?.content);\n  if (sourceContentMatches > 0) {\n    score += sourceContentMatches * 2;\n    matchedFields.add(\"sourceContent\");\n  }\n\n  if (score > 0) {\n    score += effectiveConfidence;\n  }\n\n  return { score, matchedFields };\n}\n\nexport async function searchVerifiedSemanticRules(options: {\n  memoryDir: string;\n  query: string;\n  maxResults: number;\n  minEffectiveConfidence?: number;\n}): Promise<VerifiedSemanticRuleResult[]> {\n  const queryTokens = new Set(normalizeRecallTokens(options.query, [\"what\", \"which\"]));\n  if (queryTokens.size === 0 || options.maxResults <= 0) return [];\n\n  const storage = new StorageManager(options.memoryDir);\n  const version = storage.getMemoryStatusVersion();\n\n  // Use derived rule cache to avoid O(146K) iteration on every call.\n  let cachedRules = getCachedRuleMemories(storage.dir, version);\n  if (!cachedRules) {\n    const allMems = await storage.readAllMemories();\n    cachedRules = setCachedRuleMemories(storage.dir, allMems, version);\n  }\n  const { all: ruleMemories, byId: memoryById } = cachedRules;\n  const minEffectiveConfidence = options.minEffectiveConfidence ?? DEFAULT_MIN_EFFECTIVE_CONFIDENCE;\n\n  const candidates: VerifiedSemanticRuleResult[] = [];\n  // ruleMemories is pre-filtered to category=rule and recall-hidden statuses.\n  for (const memory of ruleMemories) {\n    if (memory.frontmatter.source !== \"semantic-rule-promotion\") continue;\n    const sourceMemoryId = memory.frontmatter.sourceMemoryId;\n    if (!sourceMemoryId) continue;\n\n    const sourceMemory = memoryById.get(sourceMemoryId);\n    const { status, effectiveConfidence } = resolveEffectiveConfidence(memory, sourceMemory);\n    if (effectiveConfidence < minEffectiveConfidence) continue;\n\n    const { score, matchedFields } = scoreVerifiedSemanticRuleCandidate(\n      memory,\n      sourceMemory,\n      queryTokens,\n      effectiveConfidence,\n    );\n    if (score <= 0) continue;\n\n    candidates.push({\n      rule: memory,\n      score,\n      sourceMemoryId,\n      verificationStatus: status,\n      effectiveConfidence,\n      matchedFields: [...matchedFields].sort(),\n    });\n  }\n\n  return candidates\n    .sort(\n      (left, right) =>\n        right.score - left.score\n        || right.effectiveConfidence - left.effectiveConfidence\n        || right.rule.frontmatter.updated.localeCompare(left.rule.frontmatter.updated),\n    )\n    .slice(0, options.maxResults);\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-WIICJPET.js

@@ -0,0 +1,45 @@
+// src/graph-events.ts
+import { EventEmitter } from "events";
+var buses = /* @__PURE__ */ new Map();
+function getGraphEventBus(memoryDir) {
+  let bus = buses.get(memoryDir);
+  if (!bus) {
+    bus = new EventEmitter();
+    bus.setMaxListeners(200);
+    buses.set(memoryDir, bus);
+  }
+  return bus;
+}
+function emitGraphEvent(memoryDir, type, payload) {
+  const event = {
+    type,
+    memoryDir,
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    payload
+  };
+  const bus = getGraphEventBus(memoryDir);
+  try {
+    bus.emit("graph-event", event);
+  } catch {
+  }
+}
+function subscribeGraphEvents(memoryDir, listener) {
+  const bus = getGraphEventBus(memoryDir);
+  bus.on("graph-event", listener);
+  return () => bus.off("graph-event", listener);
+}
+function destroyGraphEventBus(memoryDir) {
+  const bus = buses.get(memoryDir);
+  if (bus) {
+    bus.removeAllListeners();
+    buses.delete(memoryDir);
+  }
+}
+
+export {
+  getGraphEventBus,
+  emitGraphEvent,
+  subscribeGraphEvents,
+  destroyGraphEventBus
+};
+//# sourceMappingURL=chunk-WIICJPET.js.map

package/dist/chunk-WIICJPET.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/graph-events.ts"],"sourcesContent":["/**\n * In-process EventEmitter for graph mutation events (issue #691 PR 5/5).\n *\n * The singleton is keyed by memoryDir so multiple orchestrator instances in\n * the same process get distinct event buses (CLAUDE.md rule 11: scope globals\n * per service).  The SSE handler in access-http.ts subscribes to the bus for\n * the resolved namespace and fans out to connected clients.\n *\n * Event types mirror the five mutations the graph layer can produce:\n *   node-added    — a memory file was referenced for the first time\n *   node-updated  — a memory file's metadata changed\n *   edge-added    — a new edge was appended\n *   edge-updated  — an existing edge's confidence/weight was modified\n *   edge-removed  — an edge was pruned (e.g. by decay maintenance)\n *\n * The `GraphEventBus` interface is intentionally narrow so nothing outside\n * this module needs to import Node.js EventEmitter directly.\n */\n\nimport { EventEmitter } from \"node:events\";\n\n// ---------------------------------------------------------------------------\n// Public types\n// ---------------------------------------------------------------------------\n\nexport type GraphEventType =\n  | \"node-added\"\n  | \"node-updated\"\n  | \"edge-added\"\n  | \"edge-updated\"\n  | \"edge-removed\";\n\nexport interface GraphEvent {\n  type: GraphEventType;\n  /** Memory dir that owns this event (absolute path). */\n  memoryDir: string;\n  /** ISO timestamp of the event. */\n  ts: string;\n  /** Payload depends on event type — always serialisable to JSON. */\n  payload: Record<string, unknown>;\n}\n\nexport interface NodeAddedPayload {\n  nodeId: string;   // relative memory path\n  kind: string;\n  label: string;\n  lastUpdated: string;\n}\n\nexport interface NodeUpdatedPayload {\n  nodeId: string;\n  kind: string;\n  label: string;\n  lastUpdated: string;\n}\n\nexport interface EdgeAddedPayload {\n  source: string;\n  target: string;\n  kind: string;\n  weight: number;\n  label: string;\n  confidence: number;\n}\n\nexport interface EdgeUpdatedPayload {\n  source: string;\n  target: string;\n  kind: string;\n  weight: number;\n  confidence: number;\n}\n\nexport interface EdgeRemovedPayload {\n  source: string;\n  target: string;\n  kind: string;\n}\n\n// ---------------------------------------------------------------------------\n// Per-memoryDir singleton bus\n// ---------------------------------------------------------------------------\n\nconst buses = new Map<string, EventEmitter>();\n\n/**\n * Return (or lazily create) the event bus for the given memoryDir.\n * The same bus is shared by the write side (graph.ts → appendEdge hooks) and\n * the read side (EngramAccessHttpServer SSE handler).\n */\nexport function getGraphEventBus(memoryDir: string): EventEmitter {\n  let bus = buses.get(memoryDir);\n  if (!bus) {\n    bus = new EventEmitter();\n    // Remove the default listener-count warning — SSE clients may hold many\n    // concurrent connections. Each SSE client registers one \"graph-event\"\n    // listener; warn only when an unreasonably high count suggests a leak.\n    bus.setMaxListeners(200);\n    buses.set(memoryDir, bus);\n  }\n  return bus;\n}\n\n/**\n * Emit a single graph event onto the bus for memoryDir.\n * Fails open: any listener that throws is caught so one bad client can't\n * crash the extraction pipeline.\n */\nexport function emitGraphEvent(\n  memoryDir: string,\n  type: GraphEventType,\n  payload: Record<string, unknown>,\n): void {\n  const event: GraphEvent = {\n    type,\n    memoryDir,\n    ts: new Date().toISOString(),\n    payload,\n  };\n  const bus = getGraphEventBus(memoryDir);\n  try {\n    bus.emit(\"graph-event\", event);\n  } catch {\n    // fail-open: never propagate listener errors to the write path\n  }\n}\n\n/**\n * Subscribe to graph events for a given memoryDir.\n * Returns an unsubscribe function.\n */\nexport function subscribeGraphEvents(\n  memoryDir: string,\n  listener: (event: GraphEvent) => void,\n): () => void {\n  const bus = getGraphEventBus(memoryDir);\n  bus.on(\"graph-event\", listener);\n  return () => bus.off(\"graph-event\", listener);\n}\n\n/**\n * Remove all listeners and the bus entry for a memoryDir.\n * Useful for tests that spin up isolated memory dirs.\n */\nexport function destroyGraphEventBus(memoryDir: string): void {\n  const bus = buses.get(memoryDir);\n  if (bus) {\n    bus.removeAllListeners();\n    buses.delete(memoryDir);\n  }\n}\n"],"mappings":";AAmBA,SAAS,oBAAoB;AAgE7B,IAAM,QAAQ,oBAAI,IAA0B;AAOrC,SAAS,iBAAiB,WAAiC;AAChE,MAAI,MAAM,MAAM,IAAI,SAAS;AAC7B,MAAI,CAAC,KAAK;AACR,UAAM,IAAI,aAAa;AAIvB,QAAI,gBAAgB,GAAG;AACvB,UAAM,IAAI,WAAW,GAAG;AAAA,EAC1B;AACA,SAAO;AACT;AAOO,SAAS,eACd,WACA,MACA,SACM;AACN,QAAM,QAAoB;AAAA,IACxB;AAAA,IACA;AAAA,IACA,KAAI,oBAAI,KAAK,GAAE,YAAY;AAAA,IAC3B;AAAA,EACF;AACA,QAAM,MAAM,iBAAiB,SAAS;AACtC,MAAI;AACF,QAAI,KAAK,eAAe,KAAK;AAAA,EAC/B,QAAQ;AAAA,EAER;AACF;AAMO,SAAS,qBACd,WACA,UACY;AACZ,QAAM,MAAM,iBAAiB,SAAS;AACtC,MAAI,GAAG,eAAe,QAAQ;AAC9B,SAAO,MAAM,IAAI,IAAI,eAAe,QAAQ;AAC9C;AAMO,SAAS,qBAAqB,WAAyB;AAC5D,QAAM,MAAM,MAAM,IAAI,SAAS;AAC/B,MAAI,KAAK;AACP,QAAI,mBAAmB;AACvB,UAAM,OAAO,SAAS;AAAA,EACxB;AACF;","names":[]}

package/dist/{chunk-VBVG2M5G.js → chunk-WPGJYVUH.js}

@@ -11,7 +11,7 @@ function clampGraphRecallExpandedEntries(entries, maxEntries = 64) {
   if (!Array.isArray(entries)) return [];
   return entries.filter((item) => !!item && typeof item === "object").map((item) => {
     const graphType = item.graphType === "entity" || item.graphType === "time" || item.graphType === "causal" ? item.graphType : "entity";
-    return {
+    const out = {
       path: typeof item.path === "string" ? item.path : "",
       score: typeof item.score === "number" && Number.isFinite(item.score) ? item.score : 0,
       namespace: typeof item.namespace === "string" ? item.namespace : "",
@@ -20,6 +20,10 @@ function clampGraphRecallExpandedEntries(entries, maxEntries = 64) {
       decayedWeight: typeof item.decayedWeight === "number" && Number.isFinite(item.decayedWeight) ? Math.max(0, item.decayedWeight) : 0,
       graphType
     };
+    if (typeof item.edgeConfidence === "number" && Number.isFinite(item.edgeConfidence)) {
+      out.edgeConfidence = Math.min(1, Math.max(0, item.edgeConfidence));
+    }
+    return out;
   }).filter((item) => item.path.length > 0 && item.namespace.length > 0).slice(0, limit);
 }
 function cloneTierExplain(tierExplain) {
@@ -236,4 +240,4 @@ export {
   LastRecallStore,
   TierMigrationStatusStore
 };
-//# sourceMappingURL=chunk-VBVG2M5G.js.map
+//# sourceMappingURL=chunk-WPGJYVUH.js.map

package/dist/chunk-WPGJYVUH.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/recall-state.ts"],"sourcesContent":["import { appendFile, mkdir, readFile, writeFile } from \"node:fs/promises\";\nimport path from \"node:path\";\nimport { createHash, randomUUID } from \"node:crypto\";\nimport { log } from \"./logger.js\";\nimport type {\n  IdentityInjectionMode,\n  RecallPlanMode,\n  RecallTierExplain,\n} from \"./types.js\";\n\nexport interface LastRecallBudgetSummary {\n  requestedTopK?: number;\n  appliedTopK: number;\n  recallBudgetChars: number;\n  maxMemoryTokens: number;\n  qmdFetchLimit?: number;\n  qmdHybridFetchLimit?: number;\n  finalContextChars?: number;\n  truncated?: boolean;\n  includedSections?: string[];\n  omittedSections?: string[];\n}\n\nexport interface LastRecallSnapshot {\n  sessionKey: string;\n  recordedAt: string;\n  queryHash: string;\n  queryLen: number;\n  memoryIds: string[];\n  namespace?: string;\n  traceId?: string;\n  plannerMode?: RecallPlanMode;\n  requestedMode?: RecallPlanMode;\n  source?: string;\n  fallbackUsed?: boolean;\n  sourcesUsed?: string[];\n  budgetsApplied?: LastRecallBudgetSummary;\n  latencyMs?: number;\n  resultPaths?: string[];\n  policyVersion?: string;\n  identityInjectionMode?: IdentityInjectionMode | \"none\";\n  identityInjectedChars?: number;\n  identityInjectionTruncated?: boolean;\n  /**\n   * Collision-safe write nonce.  Random UUID set on every `record()`\n   * call so the observation-mode direct-answer hook can detect stale\n   * snapshots and avoid annotating a snapshot that a subsequent recall\n   * already replaced (issue #518).\n   */\n  writeNonce?: string;\n  /**\n   * Optional tier-level explanation of how recall was served\n   * (issue #518).  Populated by orchestrator call sites that can\n   * identify a concrete tier; surfaces expose the block via\n   * `engram query --explain`, the `?explain=1` HTTP flag, and the\n   * `remnic_recall_explain` MCP tool.  Orthogonal to the existing\n   * graph-path `recallExplain` operation.\n   */\n  tierExplain?: RecallTierExplain;\n}\n\nexport interface GraphRecallExpandedEntry {\n  path: string;\n  score: number;\n  namespace: string;\n  seed: string;\n  hopDepth: number;\n  decayedWeight: number;\n  graphType: \"entity\" | \"time\" | \"causal\";\n  /**\n   * Issue #681 PR 3/3 — confidence of the edge that produced this entry's\n   * recorded provenance (strongest edge along the chosen entry path).\n   * Range `[0, 1]`. Optional so persisted snapshots from older builds\n   * round-trip through `clampGraphRecallExpandedEntries` without dropping.\n   */\n  edgeConfidence?: number;\n}\n\nexport function clampGraphRecallExpandedEntries(\n  entries: unknown,\n  maxEntries: number = 64,\n): GraphRecallExpandedEntry[] {\n  const limit = Math.max(1, Math.floor(maxEntries));\n  if (!Array.isArray(entries)) return [];\n  return entries\n    .filter((item): item is Record<string, unknown> => !!item && typeof item === \"object\")\n    .map((item) => {\n      const graphType: \"entity\" | \"time\" | \"causal\" =\n        item.graphType === \"entity\" || item.graphType === \"time\" || item.graphType === \"causal\"\n          ? item.graphType\n          : \"entity\";\n      const out: GraphRecallExpandedEntry = {\n        path: typeof item.path === \"string\" ? item.path : \"\",\n        score: typeof item.score === \"number\" && Number.isFinite(item.score) ? item.score : 0,\n        namespace: typeof item.namespace === \"string\" ? item.namespace : \"\",\n        seed: typeof item.seed === \"string\" ? item.seed : \"\",\n        hopDepth:\n          typeof item.hopDepth === \"number\" && Number.isFinite(item.hopDepth)\n            ? Math.max(0, Math.floor(item.hopDepth))\n            : 0,\n        decayedWeight:\n          typeof item.decayedWeight === \"number\" && Number.isFinite(item.decayedWeight)\n            ? Math.max(0, item.decayedWeight)\n            : 0,\n        graphType,\n      };\n      // Issue #681 PR 3/3: clamp `edgeConfidence` into [0, 1] when present.\n      // Older snapshots without the field round-trip cleanly via the\n      // optional shape; legacy callers always rendered as 1.0.\n      if (\n        typeof item.edgeConfidence === \"number\" &&\n        Number.isFinite(item.edgeConfidence)\n      ) {\n        out.edgeConfidence = Math.min(1, Math.max(0, item.edgeConfidence));\n      }\n      return out;\n    })\n    .filter((item) => item.path.length > 0 && item.namespace.length > 0)\n    .slice(0, limit);\n}\n\ntype LastRecallState = Record<string, LastRecallSnapshot>;\n\n/**\n * Deep-copy a RecallTierExplain block.  Used by both the write path\n * (so caller mutation after `record()` cannot tear the persisted\n * snapshot) and the read path (so caller mutation after `get()` /\n * `getMostRecent()` cannot tear the in-memory store).\n *\n * Uses structuredClone so future additions to RecallTierExplain do\n * not silently share references through hand-enumerated fields —\n * matching the pattern used elsewhere in the codebase (e.g.,\n * qmd-recall-cache.ts).  The payload is pure JSON-shaped data, so\n * structuredClone is both safe and complete here.\n */\nfunction cloneTierExplain(\n  tierExplain: RecallTierExplain | undefined,\n): RecallTierExplain | undefined {\n  if (!tierExplain) return undefined;\n  return structuredClone(tierExplain);\n}\n\n/**\n * Deep-copy a LastRecallSnapshot so callers that receive it cannot\n * mutate the store's internal state through mutable array/object\n * fields.  Same structuredClone rationale as cloneTierExplain above.\n */\nfunction cloneLastRecallSnapshot(\n  snapshot: LastRecallSnapshot | null,\n): LastRecallSnapshot | null {\n  if (!snapshot) return null;\n  return structuredClone(snapshot);\n}\n\nexport interface TierMigrationCycleSummary {\n  trigger: \"extraction\" | \"maintenance\" | \"manual\";\n  scanned: number;\n  migrated: number;\n  promoted: number;\n  demoted: number;\n  limit: number;\n  dryRun: boolean;\n  skipped?: string;\n  errorCount?: number;\n}\n\nexport interface TierMigrationStatusSnapshot {\n  updatedAt: string;\n  lastCycle: TierMigrationCycleSummary | null;\n  totals: {\n    cycles: number;\n    scanned: number;\n    migrated: number;\n    promoted: number;\n    demoted: number;\n    errors: number;\n  };\n}\n\nconst DEFAULT_TIER_MIGRATION_STATUS: TierMigrationStatusSnapshot = {\n  updatedAt: new Date(0).toISOString(),\n  lastCycle: null,\n  totals: {\n    cycles: 0,\n    scanned: 0,\n    migrated: 0,\n    promoted: 0,\n    demoted: 0,\n    errors: 0,\n  },\n};\n\nexport class LastRecallStore {\n  private readonly statePath: string;\n  private readonly impressionsPath: string;\n  private state: LastRecallState = {};\n\n  constructor(memoryDir: string) {\n    this.statePath = path.join(memoryDir, \"state\", \"last_recall.json\");\n    this.impressionsPath = path.join(memoryDir, \"state\", \"recall_impressions.jsonl\");\n  }\n\n  async load(): Promise<void> {\n    try {\n      const raw = await readFile(this.statePath, \"utf-8\");\n      const parsed = JSON.parse(raw) as LastRecallState;\n      if (parsed && typeof parsed === \"object\") this.state = parsed;\n    } catch {\n      this.state = {};\n    }\n  }\n\n  get(sessionKey: string): LastRecallSnapshot | null {\n    // Defensive copy: callers must not be able to mutate internal state\n    // by reaching into array/object fields on the returned snapshot.\n    return cloneLastRecallSnapshot(this.state[sessionKey] ?? null);\n  }\n\n  getMostRecent(): LastRecallSnapshot | null {\n    const snapshots = Object.values(this.state);\n    if (snapshots.length === 0) return null;\n    // Secondary key on sessionKey keeps the sort stable when two\n    // snapshots share a recordedAt timestamp (CLAUDE.md rule 19).\n    snapshots.sort((a, b) => {\n      const byTime = b.recordedAt.localeCompare(a.recordedAt);\n      if (byTime !== 0) return byTime;\n      return a.sessionKey.localeCompare(b.sessionKey);\n    });\n    return cloneLastRecallSnapshot(snapshots[0] ?? null);\n  }\n\n  /**\n   * Persist last-recall snapshot and append an impression log entry.\n   * Does not store raw query text; uses a stable hash for correlation.\n   */\n  async record(opts: {\n    sessionKey: string;\n    query: string;\n    memoryIds: string[];\n    namespace?: string;\n    traceId?: string;\n    plannerMode?: RecallPlanMode;\n    requestedMode?: RecallPlanMode;\n    source?: string;\n    fallbackUsed?: boolean;\n    sourcesUsed?: string[];\n    budgetsApplied?: LastRecallBudgetSummary;\n    latencyMs?: number;\n    resultPaths?: string[];\n    policyVersion?: string;\n    appendImpression?: boolean;\n    identityInjection?: {\n      mode: IdentityInjectionMode | \"none\";\n      injectedChars: number;\n      truncated: boolean;\n    };\n    /**\n     * Per-tier explain annotation (issue #518).  When supplied, the\n     * snapshot carries it so downstream surfaces (CLI / HTTP / MCP)\n     * can render which retrieval tier served the query.\n     */\n    tierExplain?: RecallTierExplain;\n  }): Promise<void> {\n    const now = new Date().toISOString();\n    const queryHash = createHash(\"sha256\").update(opts.query).digest(\"hex\");\n\n    // Build the snapshot from opts, then deep-copy it via\n    // cloneLastRecallSnapshot so caller arrays/objects passed in\n    // `opts` cannot retain a live reference to the persisted state\n    // and tear it after record() returns.\n    const liveSnapshot: LastRecallSnapshot = {\n      sessionKey: opts.sessionKey,\n      recordedAt: now,\n      queryHash,\n      writeNonce: randomUUID(),\n      queryLen: opts.query.length,\n      memoryIds: opts.memoryIds,\n      namespace: opts.namespace,\n      traceId: opts.traceId,\n      plannerMode: opts.plannerMode,\n      requestedMode: opts.requestedMode,\n      source: opts.source,\n      fallbackUsed: opts.fallbackUsed,\n      sourcesUsed: opts.sourcesUsed,\n      budgetsApplied: opts.budgetsApplied,\n      latencyMs: opts.latencyMs,\n      resultPaths: opts.resultPaths,\n      policyVersion: opts.policyVersion,\n      identityInjectionMode: opts.identityInjection?.mode,\n      identityInjectedChars: opts.identityInjection?.injectedChars,\n      identityInjectionTruncated: opts.identityInjection?.truncated,\n      tierExplain: opts.tierExplain,\n    };\n    // `cloneLastRecallSnapshot` handles `null` but that never applies\n    // at this call site — the non-null assertion keeps the type\n    // checker honest.\n    const snapshot = cloneLastRecallSnapshot(liveSnapshot)!;\n\n    this.state[opts.sessionKey] = snapshot;\n\n    // Keep the state bounded; the impression log is append-only.\n    const keys = Object.keys(this.state);\n    if (keys.length > 50) {\n      const ordered = keys\n        .map((k) => ({ k, at: this.state[k]?.recordedAt ?? \"\" }))\n        .sort((a, b) => b.at.localeCompare(a.at));\n      for (const doomed of ordered.slice(50)) {\n        delete this.state[doomed.k];\n      }\n    }\n\n    try {\n      await mkdir(path.dirname(this.statePath), { recursive: true });\n      await writeFile(this.statePath, JSON.stringify(this.state, null, 2), \"utf-8\");\n    } catch (err) {\n      log.debug(`last recall store write failed: ${err}`);\n    }\n\n    if (opts.appendImpression !== false) {\n      try {\n        await mkdir(path.dirname(this.impressionsPath), { recursive: true });\n        await appendFile(this.impressionsPath, JSON.stringify(snapshot) + \"\\n\", \"utf-8\");\n      } catch (err) {\n        log.debug(`recall impressions append failed: ${err}`);\n      }\n    }\n  }\n\n  /**\n   * Attach a RecallTierExplain block to the existing snapshot for a\n   * session without rewriting the entire snapshot.  Used by the\n   * post-recall direct-answer annotation path (issue #518 slice 3c):\n   * recallInternal records the snapshot first, then the orchestrator\n   * fires the direct-answer tier in observation mode and annotates\n   * the stored snapshot with whichever tier served the query.\n   *\n   * No-op when no snapshot exists for the given session; callers do\n   * not need to guard on existence.\n   */\n  async annotateTierExplain(\n    sessionKey: string,\n    tierExplain: RecallTierExplain,\n    expected?: { writeNonce?: string; traceId?: string; recordedAt?: string },\n  ): Promise<void> {\n    const current = this.state[sessionKey];\n    if (!current) return;\n    if (expected) {\n      if (\n        typeof expected.writeNonce === \"string\" &&\n        expected.writeNonce.length > 0\n      ) {\n        if (current.writeNonce !== expected.writeNonce) return;\n      } else {\n        const hasExpectedTraceId =\n          typeof expected.traceId === \"string\" && expected.traceId.length > 0;\n        const traceIdMatches =\n          hasExpectedTraceId && current.traceId === expected.traceId;\n        const recordedAtMatches =\n          expected.recordedAt !== undefined &&\n          current.recordedAt === expected.recordedAt;\n        if (hasExpectedTraceId) {\n          if (!traceIdMatches) return;\n        } else if (expected.recordedAt !== undefined && !recordedAtMatches) {\n          return;\n        }\n      }\n    }\n    this.state[sessionKey] = {\n      ...current,\n      tierExplain: cloneTierExplain(tierExplain),\n    };\n    try {\n      await mkdir(path.dirname(this.statePath), { recursive: true });\n      await writeFile(this.statePath, JSON.stringify(this.state, null, 2), \"utf-8\");\n    } catch (err) {\n      log.debug(`last recall tier-explain annotate failed: ${err}`);\n    }\n  }\n}\n\nexport class TierMigrationStatusStore {\n  private readonly statePath: string;\n  private state: TierMigrationStatusSnapshot = structuredClone(DEFAULT_TIER_MIGRATION_STATUS);\n\n  constructor(memoryDir: string) {\n    this.statePath = path.join(memoryDir, \"state\", \"tier-migration-status.json\");\n  }\n\n  async load(): Promise<void> {\n    try {\n      const raw = await readFile(this.statePath, \"utf-8\");\n      const parsed = JSON.parse(raw) as Partial<TierMigrationStatusSnapshot> | null;\n      if (!parsed || typeof parsed !== \"object\") {\n        this.state = structuredClone(DEFAULT_TIER_MIGRATION_STATUS);\n        return;\n      }\n      const totals = parsed.totals && typeof parsed.totals === \"object\"\n        ? parsed.totals\n        : DEFAULT_TIER_MIGRATION_STATUS.totals;\n      this.state = {\n        updatedAt:\n          typeof parsed.updatedAt === \"string\" && parsed.updatedAt.length > 0\n            ? parsed.updatedAt\n            : DEFAULT_TIER_MIGRATION_STATUS.updatedAt,\n        lastCycle:\n          parsed.lastCycle && typeof parsed.lastCycle === \"object\"\n            ? (parsed.lastCycle as TierMigrationCycleSummary)\n            : null,\n        totals: {\n          cycles: typeof totals.cycles === \"number\" && Number.isFinite(totals.cycles) ? totals.cycles : 0,\n          scanned: typeof totals.scanned === \"number\" && Number.isFinite(totals.scanned) ? totals.scanned : 0,\n          migrated: typeof totals.migrated === \"number\" && Number.isFinite(totals.migrated) ? totals.migrated : 0,\n          promoted: typeof totals.promoted === \"number\" && Number.isFinite(totals.promoted) ? totals.promoted : 0,\n          demoted: typeof totals.demoted === \"number\" && Number.isFinite(totals.demoted) ? totals.demoted : 0,\n          errors: typeof totals.errors === \"number\" && Number.isFinite(totals.errors) ? totals.errors : 0,\n        },\n      };\n    } catch {\n      this.state = structuredClone(DEFAULT_TIER_MIGRATION_STATUS);\n    }\n  }\n\n  get(): TierMigrationStatusSnapshot {\n    return {\n      updatedAt: this.state.updatedAt,\n      lastCycle: this.state.lastCycle ? { ...this.state.lastCycle } : null,\n      totals: { ...this.state.totals },\n    };\n  }\n\n  async recordCycle(summary: TierMigrationCycleSummary): Promise<void> {\n    const now = new Date().toISOString();\n    const migratedDelta = summary.dryRun ? 0 : Math.max(0, summary.migrated);\n    const promotedDelta = summary.dryRun ? 0 : Math.max(0, summary.promoted);\n    const demotedDelta = summary.dryRun ? 0 : Math.max(0, summary.demoted);\n    const next: TierMigrationStatusSnapshot = {\n      updatedAt: now,\n      lastCycle: { ...summary },\n      totals: {\n        cycles: this.state.totals.cycles + 1,\n        scanned: this.state.totals.scanned + Math.max(0, summary.scanned),\n        migrated: this.state.totals.migrated + migratedDelta,\n        promoted: this.state.totals.promoted + promotedDelta,\n        demoted: this.state.totals.demoted + demotedDelta,\n        errors: this.state.totals.errors + Math.max(0, summary.errorCount ?? 0),\n      },\n    };\n    this.state = next;\n    try {\n      await mkdir(path.dirname(this.statePath), { recursive: true });\n      await writeFile(this.statePath, JSON.stringify(next, null, 2), \"utf-8\");\n    } catch (err) {\n      log.debug(`tier migration status write failed: ${err}`);\n    }\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-4HQS2HPX.js → chunk-WSZIHQBK.js}

@@ -1,15 +1,15 @@
-import {
-  launchProcess
-} from "./chunk-OR64ZGRZ.js";
 import {
   abortError,
   isAbortError,
   throwIfAborted
 } from "./chunk-PVGDJXVK.js";
+import {
+  launchProcess
+} from "./chunk-OR64ZGRZ.js";
 import {
   getCachedQmdSearch,
   setCachedQmdSearch
-} from "./chunk-6PFRXT4K.js";
+} from "./chunk-PFV5C235.js";
 import {
   mergeEnv
 } from "./chunk-MARWOCVP.js";
@@ -1293,13 +1293,30 @@ ${stderr}`.split("\n").map((s) => s.trim()).filter((s) => s.length > 0);
       execution?.signal
     );
   }
+  async updateCollectionStrict(collection, execution) {
+    await this.runUpdateForCollection(
+      collection,
+      { perCollectionThrottle: true, strict: true },
+      execution?.signal
+    );
+  }
   async runUpdateForCollection(collection, options, signal) {
-    if (this.available === false) return;
+    if (this.available === false) {
+      if (options.strict) {
+        throw new Error("QMD unavailable");
+      }
+      return;
+    }
     const name = collection.trim();
-    if (!name) return;
+    if (!name) {
+      if (options.strict) {
+        throw new Error("QMD collection name is required");
+      }
+      return;
+    }
     const globalState = getGlobalQmdState();
     const now = Date.now();
-    if (options.perCollectionThrottle) {
+    if (!options.strict && options.perCollectionThrottle) {
       if (globalState.lastGlobalUpdateFailAtMs && now - globalState.lastGlobalUpdateFailAtMs < QMD_UPDATE_BACKOFF_MS) {
         log.debug("QMD update: suppressed by global failure backoff");
         return;
@@ -1314,7 +1331,7 @@ ${stderr}`.split("\n").map((s) => s.trim()).filter((s) => s.length > 0);
         log.debug(`QMD update: suppressed by per-collection failure backoff (${name})`);
         return;
       }
-    } else {
+    } else if (!options.strict) {
       if (this.lastUpdateRunAtMs && now - this.lastUpdateRunAtMs < this.updateMinIntervalMs) {
         log.debug("QMD update: suppressed due to min-interval gate");
         return;
@@ -1365,6 +1382,9 @@ ${stderr}`.split("\n").map((s) => s.trim()).filter((s) => s.length > 0);
       }
       const msg = err instanceof Error ? err.message : String(err);
       log.warn(`QMD update failed for collection ${name}: ${msg}`);
+      if (options.strict) {
+        throw err;
+      }
     }
   }
   async embed() {
@@ -1495,4 +1515,4 @@ export {
   parseQmdExplain,
   QmdClient
 };
-//# sourceMappingURL=chunk-4HQS2HPX.js.map
+//# sourceMappingURL=chunk-WSZIHQBK.js.map